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) 


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

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>) 


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

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>) 


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

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}) 


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

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) 


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

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) 


213
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
 
# File 'lib/solargraph/parser/parser_gem/node_methods.rb', line 213

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
  nil
end

.get_node_end_position(node) ⇒ Position

Parameters:

  • node (Parser::AST::Node)

Returns:



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

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:



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

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) 


42
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
 
# File 'lib/solargraph/parser/parser_gem/node_methods.rb', line 42

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>) 


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

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) 


254
255
256
257
258
 
# File 'lib/solargraph/parser/parser_gem/node_methods.rb', line 254

def repaired_find_recipient_node cursor
  cursor = cursor.source.cursor_at([cursor.position.line, cursor.position.column - 1])
  node = cursor.source.tree_at(cursor.position.line, cursor.position.column).first
  node if node && node.type == :send
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>) 


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

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) 


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

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) 


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

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) 


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

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



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

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