module Solargraph::Parser::Legacy::NodeMethods

Constants

NIL_NODE

Public Instance Methods

any_splatted_call?(nodes) click to toggle source
# File lib/solargraph/parser/legacy/node_methods.rb, line 133
def any_splatted_call?(nodes)
  nodes.any? { |n| splatted_call?(n) }
end
call_nodes_from(node) click to toggle source

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

# File lib/solargraph/parser/legacy/node_methods.rb, line 138
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
      node.children[0].children[2..-1].each { |child| result.concat call_nodes_from(child) }
    end
    node.children[1..-1].each { |child| result.concat call_nodes_from(child) }
  elsif node.type == :send
    result.push node
    node.children[2..-1].each { |child| result.concat call_nodes_from(child) }
  elsif [:super, :zsuper].include?(node.type)
    result.push node
    node.children.each { |child| result.concat call_nodes_from(child) }
  elsif node.type == :masgn
    # @todo We're treating a mass assignment as a call node, but the
    #   type checker still needs the logic to handle it.
    result.push node
  else
    node.children.each { |child| result.concat call_nodes_from(child) }
  end
  result
end
const_nodes_from(node) click to toggle source
# File lib/solargraph/parser/legacy/node_methods.rb, line 113
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) click to toggle source
# File lib/solargraph/parser/legacy/node_methods.rb, line 99
def convert_hash node
  return {} unless Parser.is_ast_node?(node)
  return convert_hash(node.children[0]) if node.type == :kwsplat
  return convert_hash(node.children[0]) if Parser.is_ast_node?(node.children[0]) && node.children[0].type == :kwsplat
  return {} unless node.type == :hash
  result = {}
  node.children.each do |pair|
    result[pair.children[0].children[0]] = Solargraph::Parser.chain(pair.children[1])
  end
  result
end
drill_signature(node, signature) click to toggle source
# File lib/solargraph/parser/legacy/node_methods.rb, line 78
def drill_signature node, signature
  return signature unless node.is_a?(AST::Node)
  if node.type == :const or node.type == :cbase
    unless node.children[0].nil?
      signature += drill_signature(node.children[0], signature)
    end
    signature += '::' unless signature.empty?
    signature += node.children[1].to_s
  elsif node.type == :lvar or node.type == :ivar or node.type == :cvar
    signature += '.' unless signature.empty?
    signature += node.children[0].to_s
  elsif node.type == :send
    unless node.children[0].nil?
      signature += drill_signature(node.children[0], signature)
    end
    signature += '.' unless signature.empty?
    signature += node.children[1].to_s
  end
  signature
end
find_recipient_node(cursor) click to toggle source

@param cursor [Solargraph::Source::Cursor]

# File lib/solargraph/parser/legacy/node_methods.rb, line 180
def find_recipient_node cursor
  return repaired_find_recipient_node(cursor) if cursor.source.repaired? && cursor.source.code[cursor.offset - 1] == '('
  source = cursor.source
  position = cursor.position
  offset = cursor.offset
  tree = if source.synchronized?
    match = source.code[0..offset-1].match(/,\s*\z/)
    if match
      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
  prev = nil
  tree.each do |node|
    if node.type == :send
      args = node.children[2..-1]
      if !args.empty?
        return node if prev && args.include?(prev)
      else
        if source.synchronized?
          return node if source.code[0..offset-1] =~ /\(\s*\z/ && source.code[offset..-1] =~ /^\s*\)/
        else
          return node if source.code[0..offset-1] =~ /\([^\(]*\z/
        end
      end
    end
    prev = node
  end
  nil
end
get_node_end_position(node) click to toggle source

@param node [Parser::AST::Node] @return [Position]

# File lib/solargraph/parser/legacy/node_methods.rb, line 74
def get_node_end_position(node)
  Position.new(node.loc.last_line, node.loc.last_column)
end
get_node_start_position(node) click to toggle source

@param node [Parser::AST::Node] @return [Position]

# File lib/solargraph/parser/legacy/node_methods.rb, line 68
def get_node_start_position(node)
  Position.new(node.loc.line, node.loc.column)
end
infer_literal_node_type(node) click to toggle source

@param node [Parser::AST::Node] @return [String, nil]

# File lib/solargraph/parser/legacy/node_methods.rb, line 39
def infer_literal_node_type node
  return nil unless node.is_a?(AST::Node)
  if node.type == :str || node.type == :dstr
    return '::String'
  elsif node.type == :array
    return '::Array'
  elsif node.type == :hash
    return '::Hash'
  elsif node.type == :int
    return '::Integer'
  elsif node.type == :float
    return '::Float'
  elsif node.type == :sym
    return '::Symbol'
  elsif node.type == :regexp
    return '::Regexp'
  elsif node.type == :irange
    return '::Range'
  elsif node.type == :true || node.type == :false
    return '::Boolean'
    # @todo Support `nil` keyword in types
  # elsif node.type == :nil
  #   return 'NilClass'
  end
  nil
end
pack_name(node) click to toggle source

@param node [Parser::AST::Node] @return [Array<String>]

# File lib/solargraph/parser/legacy/node_methods.rb, line 19
def pack_name(node)
  parts = []
  if node.is_a?(AST::Node)
    node.children.each { |n|
      if n.is_a?(AST::Node)
        if n.type == :cbase
          parts = [''] + pack_name(n)
        else
          parts += pack_name(n)
        end
      else
        parts.push n unless n.nil?
      end
    }
  end
  parts
end
repaired_find_recipient_node(cursor) click to toggle source
# File lib/solargraph/parser/legacy/node_methods.rb, line 214
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
  return node if node && node.type == :send
end
returns_from(node) click to toggle source

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.

@param node [Parser::AST::Node] @return [Array<Parser::AST::Node>]

# File lib/solargraph/parser/legacy/node_methods.rb, line 175
def returns_from node
  DeepInference.get_return_nodes(node).map { |n| n || NIL_NODE }
end
splatted_call?(node) click to toggle source
# File lib/solargraph/parser/legacy/node_methods.rb, line 128
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) click to toggle source
# File lib/solargraph/parser/legacy/node_methods.rb, line 124
def splatted_hash? node
  Parser.is_ast_node?(node.children[0]) && node.children[0].type == :kwsplat
end
unpack_name(node) click to toggle source

@param node [Parser::AST::Node] @return [String]

# File lib/solargraph/parser/legacy/node_methods.rb, line 13
def unpack_name(node)
  pack_name(node).join("::")
end