module Solargraph::Parser::Legacy::NodeMethods
Constants
- NIL_NODE
Public Instance Methods
# File lib/solargraph/parser/legacy/node_methods.rb, line 132 def any_splatted_call?(nodes) nodes.any? { |n| splatted_call?(n) } end
@todo Temporarily here for testing. Move to Solargraph::Parser.
# File lib/solargraph/parser/legacy/node_methods.rb, line 137 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
# File lib/solargraph/parser/legacy/node_methods.rb, line 112 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
# File lib/solargraph/parser/legacy/node_methods.rb, line 98 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
# File lib/solargraph/parser/legacy/node_methods.rb, line 77 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
@param cursor [Solargraph::Source::Cursor]
# File lib/solargraph/parser/legacy/node_methods.rb, line 179 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
@param node [Parser::AST::Node] @return [Position]
# File lib/solargraph/parser/legacy/node_methods.rb, line 73 def get_node_end_position(node) Position.new(node.loc.last_line, node.loc.last_column) end
@param node [Parser::AST::Node] @return [Position]
# File lib/solargraph/parser/legacy/node_methods.rb, line 67 def get_node_start_position(node) Position.new(node.loc.line, node.loc.column) end
@param node [Parser::AST::Node] @return [String, nil]
# File lib/solargraph/parser/legacy/node_methods.rb, line 38 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
@param node [Parser::AST::Node] @return [Array<String>]
# File lib/solargraph/parser/legacy/node_methods.rb, line 18 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
# File lib/solargraph/parser/legacy/node_methods.rb, line 213 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
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 174 def returns_from node DeepInference.get_return_nodes(node).map { |n| n || NIL_NODE } end
# File lib/solargraph/parser/legacy/node_methods.rb, line 127 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
# File lib/solargraph/parser/legacy/node_methods.rb, line 123 def splatted_hash? node Parser.is_ast_node?(node.children[0]) && node.children[0].type == :kwsplat end
@param node [Parser::AST::Node] @return [String]
# File lib/solargraph/parser/legacy/node_methods.rb, line 12 def unpack_name(node) pack_name(node).join("::") end