Module: Solargraph::Parser::ParserGem::NodeMethods

Included in:
FlowSensitiveTyping, NodeChainer, Solargraph::Parser::ParserGem::NodeProcessors::AndNode, Solargraph::Parser::ParserGem::NodeProcessors::BlockNode, Solargraph::Parser::ParserGem::NodeProcessors::CasgnNode, Solargraph::Parser::ParserGem::NodeProcessors::DefsNode, Solargraph::Parser::ParserGem::NodeProcessors::IfNode, Solargraph::Parser::ParserGem::NodeProcessors::IvasgnNode, Solargraph::Parser::ParserGem::NodeProcessors::LvasgnNode, Solargraph::Parser::ParserGem::NodeProcessors::MasgnNode, Solargraph::Parser::ParserGem::NodeProcessors::NamespaceNode, Solargraph::Parser::ParserGem::NodeProcessors::OrNode, Solargraph::Parser::ParserGem::NodeProcessors::ResbodyNode, Solargraph::Parser::ParserGem::NodeProcessors::SendNode, Solargraph::Parser::ParserGem::NodeProcessors::UntilNode, Solargraph::Parser::ParserGem::NodeProcessors::WhenNode, Solargraph::Parser::ParserGem::NodeProcessors::WhileNode
Defined in:
lib/solargraph/parser/parser_gem/node_methods.rb

Defined Under Namespace

Modules: DeepInference

Constant Summary collapse

NIL_NODE = 
::Parser::AST::Node.new(:nil)

Class Method Summary collapse

Class Method Details

.any_splatted_call?(nodes) ⇒ Boolean

Parameters:

  • nodes (Enumerable<Parser::AST::Node>)

Returns:

  • (Boolean) 


154
155
156
 
# File 'lib/solargraph/parser/parser_gem/node_methods.rb', line 154

def any_splatted_call? nodes
  nodes.any? { |n| splatted_call?(n) }
end

.call_nodes_from(node) ⇒ Array<Parser::AST::Node>

TODO:

Temporarily here for testing. Move to Solargraph::Parser.

Parameters:

  • node (Parser::AST::Node)

Returns:

  • (Array<Parser::AST::Node>) 


161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
 
# File 'lib/solargraph/parser/parser_gem/node_methods.rb', line 161

def call_nodes_from node
  return [] unless node.is_a?(::Parser::AST::Node)
  result = []
  if node.type == :block
    result.push node
    if Parser.is_ast_node?(node.children[0]) && node.children[0].children.length > 2
      # @sg-ignore Need to add nil check here
      node.children[0].children[2..].each { |child| result.concat call_nodes_from(child) }
    end
    # @sg-ignore Need to add nil check here
    node.children[1..].each { |child| result.concat call_nodes_from(child) }
  elsif node.type == :send
    result.push node
    result.concat call_nodes_from(node.children.first)
    # @sg-ignore Need to add nil check here
    node.children[2..].each { |child| result.concat call_nodes_from(child) }
  elsif %i[super zsuper].include?(node.type)
    result.push node
    node.children.each { |child| result.concat call_nodes_from(child) }
  else
    node.children.each { |child| result.concat call_nodes_from(child) }
  end
  result
end

.const_nodes_from(node) ⇒ Array<Parser::AST::Node>

Parameters:

  • node (Parser::AST::Node)

Returns:

  • (Array<Parser::AST::Node>) 


131
132
133
134
135
136
137
138
139
140
 
# File 'lib/solargraph/parser/parser_gem/node_methods.rb', line 131

def const_nodes_from node
  return [] unless Parser.is_ast_node?(node)
  result = []
  if node.type == :const
    result.push node
  else
    node.children.each { |child| result.concat const_nodes_from(child) }
  end
  result
end

.convert_hash(node) ⇒ Hash{Symbol => Chain}

Parameters:

  • node (Parser::AST::Node, nil)

Returns:

  • (Hash{Symbol => Chain}) 


107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/solargraph/parser/parser_gem/node_methods.rb', line 107

def convert_hash node
  return {} unless Parser.is_ast_node?(node)
  # @sg-ignore Translate to something flow sensitive typing understands
  return convert_hash(node.children[0]) if node.type == :kwsplat
  # @sg-ignore Translate to something flow sensitive typing understands
  if Parser.is_ast_node?(node.children[0]) && node.children[0].type == :kwsplat
    # @sg-ignore Translate to something flow sensitive typing understands
    return convert_hash(node.children[0])
  end
  # @sg-ignore Translate to something flow sensitive typing understands
  return {} unless node.type == :hash
  result = {}
  # @sg-ignore Translate to something flow sensitive typing understands
  node.children.each do |pair|
    result[pair.children[0].children[0]] = Solargraph::Parser.chain(pair.children[1])
  end
  result
end

.drill_signature(node, signature) ⇒ String

Parameters:

  • node (Parser::AST::Node)
  • signature (String)

Returns:

  • (String) 


88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/solargraph/parser/parser_gem/node_methods.rb', line 88

def drill_signature node, signature
  return signature unless node.is_a?(AST::Node)
  if %i[const cbase].include?(node.type)
    signature += drill_signature(node.children[0], signature) unless node.children[0].nil?
    signature += '::' unless signature.empty?
    signature += node.children[1].to_s
  elsif %i[lvar ivar cvar].include?(node.type)
    signature += '.' unless signature.empty?
    signature += node.children[0].to_s
  elsif node.type == :send
    signature += drill_signature(node.children[0], signature) unless node.children[0].nil?
    signature += '.' unless signature.empty?
    signature += node.children[1].to_s
  end
  signature
end

.find_recipient_node(cursor) ⇒ Parser::AST::Node?

Parameters:

Returns:

  • (Parser::AST::Node, nil) 


214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
 
# File 'lib/solargraph/parser/parser_gem/node_methods.rb', line 214

def find_recipient_node cursor
  if cursor.source.repaired? && cursor.source.code[cursor.offset - 1] == '('
    return repaired_find_recipient_node(cursor)
  end
  source = cursor.source
  position = cursor.position
  offset = cursor.offset
  tree = if source.synchronized?
           # @sg-ignore Need to add nil check here
           match = source.code[0..(offset - 1)].match(/,\s*\z/)
           if match
             # @sg-ignore Need to add nil check here
             source.tree_at(position.line, position.column - match[0].length)
           else
             source.tree_at(position.line, position.column)
           end
         else
           source.tree_at(position.line, position.column - 1)
         end
  # @type [AST::Node, nil]
  prev = nil
  tree.each do |node|
    if node.type == :send
      args = node.children[2..]
      # @sg-ignore Need to add nil check here
      if !args.empty?
        # @sg-ignore Need to add nil check here
        return node if prev && args.include?(prev)
      elsif source.synchronized?
        return node if source.code[0..(offset - 1)] =~ /\(\s*\z/ && source.code[offset..] =~ /^\s*\)/
      elsif source.code[0..(offset - 1)] =~ /\([^(]*\z/
        return node
      end
    end
    prev = node
  end
  find_recipient_node_by_text(source, offset)
end

.find_recipient_node_by_text(source, offset) ⇒ Parser::AST::Node?

Text-based fallback for finding a method call recipient when the AST is unavailable (e.g., unparseable source with syntax errors).

Scans backward from cursor offset to find ‘(’ and the method name before it, then creates a minimal :send node.

Parameters:

Returns:

  • (Parser::AST::Node, nil) 


262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
 
# File 'lib/solargraph/parser/parser_gem/node_methods.rb', line 262

def find_recipient_node_by_text source, offset
  code = source.code
  return nil if offset.nil? || offset <= 0 || offset > code.length

  # The '(' could be at offset-1 (cursor after '(') or at offset (cursor on '(')
  start_pos = offset - 1
  if start_pos.positive? && code[start_pos] != '(' && code[offset] == '('
    start_pos = offset
  end

  # Scan backward to find the matching '(' (handle nested parens)
  depth = 0
  paren_pos = nil
  pos = start_pos
  while pos >= 0
    case code[pos]
    when ')'
      depth += 1
    when '('
      if depth.zero?
        paren_pos = pos
        break
      end
      depth -= 1
    end
    pos -= 1
  end
  return nil if paren_pos.nil?

  # Skip whitespace before '(' to find method name
  idx = paren_pos - 1
  idx -= 1 while idx >= 0 && code[idx] =~ /\s/
  return nil if idx.negative?

  # Read method name (including ? and !)
  name_end = idx + 1
  idx -= 1 while idx >= 0 && code[idx] =~ /[a-zA-Z0-9_?!]/
  name_start = idx + 1
  return nil if name_start >= name_end
  method_name = code[name_start...name_end]
  return nil if method_name.empty?

  # Check for receiver pattern: receiver.method( or receiver::method(
  idx = name_start - 1
  idx -= 1 while idx >= 0 && code[idx] =~ /\s/
  if idx >= 0 && code[idx] == '.'
    idx -= 1
    idx -= 1 while idx >= 0 && code[idx] =~ /\s/
    recv_end = idx + 1
    idx -= 1 while idx >= 0 && code[idx] =~ /[a-zA-Z0-9_@$]/
    recv_start = idx + 1
    if recv_start < recv_end
      recv_name = code[recv_start...recv_end]
      unless recv_name.empty?
        receiver_node = ::Parser::AST::Node.new(:send, [nil, recv_name.to_sym])
        return ::Parser::AST::Node.new(:send, [receiver_node, method_name.to_sym])
      end
    end
  elsif idx >= 0 && idx.positive? && code[idx - 1] == ':' && code[idx] == ':'
    const_end = idx - 1
    const_start = const_end
    const_start -= 1 while const_start.positive? && code[const_start - 1] =~ /[a-zA-Z0-9_]/
    const_name = code[const_start...const_end]
    unless const_name.empty? || method_name.empty?
      const_node = ::Parser::AST::Node.new(:const, [nil, const_name.to_sym])
      return ::Parser::AST::Node.new(:send, [const_node, method_name.to_sym])
    end
  end

  # Simple method call without receiver
  ::Parser::AST::Node.new(:send, [nil, method_name.to_sym])
end

.get_node_end_position(node) ⇒ Position

Parameters:

  • node (Parser::AST::Node)

Returns:



80
81
82
 
# File 'lib/solargraph/parser/parser_gem/node_methods.rb', line 80

def get_node_end_position node
  Position.new(node.loc.last_line, node.loc.last_column)
end

.get_node_start_position(node) ⇒ Position

Parameters:

  • node (Parser::AST::Node)

Returns:



74
75
76
 
# File 'lib/solargraph/parser/parser_gem/node_methods.rb', line 74

def get_node_start_position node
  Position.new(node.loc.line, node.loc.column)
end

.infer_literal_node_type(node) ⇒ String?

Parameters:

  • node (Parser::AST::Node, nil)

Returns:

  • (String, nil) 


43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/solargraph/parser/parser_gem/node_methods.rb', line 43

def infer_literal_node_type node
  return nil unless node.is_a?(AST::Node)
  if %i[str dstr].include?(node.type)
    return '::String'
  elsif node.type == :array
    return '::Array'
  elsif node.type == :nil
    return '::NilClass'
  elsif node.type == :hash
    return '::Hash'
  elsif node.type == :int
    return '::Integer'
  elsif node.type == :float
    return '::Float'
  elsif %i[sym dsym].include?(node.type)
    return '::Symbol'
  elsif node.type == :regexp
    return '::Regexp'
  elsif node.type == :irange
    return '::Range'
  elsif %i[true false].include?(node.type)
    return '::Boolean'
    # @todo Support `nil` keyword in types
    # elsif node.type == :nil
    #   return 'NilClass'
  end
  nil
end

.pack_name(node) ⇒ Array<String>

Parameters:

  • node (Parser::AST::Node)

Returns:

  • (Array<String>) 


22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/solargraph/parser/parser_gem/node_methods.rb', line 22

def pack_name node
  # @type [Array<String>]
  parts = []
  if node.is_a?(AST::Node)
    node.children.each do |n|
      if n.is_a?(AST::Node)
        if n.type == :cbase
          parts = [''] + pack_name(n)
        elsif n.type == :const
          parts += pack_name(n)
        end
      else
        parts.push n unless n.nil?
      end
    end
  end
  parts
end

.repaired_find_recipient_node(cursor) ⇒ Parser::AST::Node?

Parameters:

Returns:

  • (Parser::AST::Node, nil) 


337
338
339
340
341
342
343
344
 
# File 'lib/solargraph/parser/parser_gem/node_methods.rb', line 337

def repaired_find_recipient_node cursor
  c = cursor.source.cursor_at([cursor.position.line, cursor.position.column - 1])
  tree = c.source.tree_at(c.position.line, c.position.column)
  tree.each do |node|
    return node if node.type == :send
  end
  find_recipient_node_by_text(cursor.source, cursor.offset)
end

.returns_from_method_body(node) ⇒ Array<Parser::AST::Node>

Find all the nodes within the provided node that potentially return a value.

The node parameter typically represents a method’s logic, e.g., the second child (after the :args node) of a :def node. A simple one-line method would typically return itself, while a node with conditions would return the resulting node from each conditional branch. Nodes that follow a :return node are assumed to be unreachable. Nil values are converted to nil node types.

Parameters:

  • node (Parser::AST::Node)

Returns:

  • (Array<Parser::AST::Node>) 


198
199
200
201
202
 
# File 'lib/solargraph/parser/parser_gem/node_methods.rb', line 198

def returns_from_method_body node
  # @todo is the || NIL_NODE necessary?
  # STDERR.puts("Evaluating expression: #{node.inspect}")
  DeepInference.from_method_body(node).map { |n| n || NIL_NODE }
end

.splatted_call?(node) ⇒ Boolean

Parameters:

  • node (Parser::AST::Node)

Returns:

  • (Boolean) 


148
149
150
151
 
# File 'lib/solargraph/parser/parser_gem/node_methods.rb', line 148

def splatted_call? node
  return false unless Parser.is_ast_node?(node)
  Parser.is_ast_node?(node.children[0]) && node.children[0].type == :kwsplat && node.children[0].children[0].type != :hash
end

.splatted_hash?(node) ⇒ Boolean

Parameters:

  • node (Parser::AST::Node)

Returns:

  • (Boolean) 


143
144
145
 
# File 'lib/solargraph/parser/parser_gem/node_methods.rb', line 143

def splatted_hash? node
  Parser.is_ast_node?(node.children[0]) && node.children[0].type == :kwsplat
end

.unpack_name(node) ⇒ String

Parameters:

  • node (Parser::AST::Node)

Returns:

  • (String) 


16
17
18
 
# File 'lib/solargraph/parser/parser_gem/node_methods.rb', line 16

def unpack_name node
  pack_name(node).join('::')
end

.value_position_nodes_only(node) ⇒ Array<AST::Node>

Returns low-level value nodes in value position. Does not include explicit return statements.

Parameters:

  • node (Parser::AST::Node)

Returns:

  • (Array<AST::Node>) —

    low-level value nodes in value position. Does not include explicit return statements



208
209
210
 
# File 'lib/solargraph/parser/parser_gem/node_methods.rb', line 208

def value_position_nodes_only node
  DeepInference.value_position_nodes_only(node).map { |n| n || NIL_NODE }
end