solargraph 0.58.2 → 0.59.0.dev.2

data/lib/solargraph/parser/parser_gem/node_methods.rb

@@ -12,17 +12,17 @@ module Solargraph
 
         # @param node [Parser::AST::Node]
         # @return [String]
-        def unpack_name(node)
-          pack_name(node).join("::")
+        def unpack_name node
+          pack_name(node).join('::')
         end
 
         # @param node [Parser::AST::Node]
         # @return [Array<String>]
-        def pack_name(node)
+        def pack_name node
           # @type [Array<String>]
           parts = []
           if node.is_a?(AST::Node)
-            node.children.each { |n|
+            node.children.each do |n|
               if n.is_a?(AST::Node)
                 if n.type == :cbase
                   parts = [''] + pack_name(n)
@@ -32,16 +32,16 @@ module Solargraph
               else
                 parts.push n unless n.nil?
               end
-            }
+            end
           end
           parts
         end
 
-        # @param node [Parser::AST::Node]
+        # @param node [Parser::AST::Node, nil]
         # @return [String, nil]
         def infer_literal_node_type node
           return nil unless node.is_a?(AST::Node)
-          if node.type == :str || node.type == :dstr
+          if %i[str dstr].include?(node.type)
             return '::String'
           elsif node.type == :array
             return '::Array'
@@ -53,30 +53,30 @@ module Solargraph
             return '::Integer'
           elsif node.type == :float
             return '::Float'
-          elsif node.type == :sym || node.type == :dsym
+          elsif %i[sym dsym].include?(node.type)
             return '::Symbol'
           elsif node.type == :regexp
             return '::Regexp'
           elsif node.type == :irange
             return '::Range'
-          elsif node.type == :true || node.type == :false
+          elsif %i[true false].include?(node.type)
             return '::Boolean'
             # @todo Support `nil` keyword in types
-          # elsif node.type == :nil
-          #   return 'NilClass'
+            # elsif node.type == :nil
+            #   return 'NilClass'
           end
           nil
         end
 
         # @param node [Parser::AST::Node]
         # @return [Position]
-        def get_node_start_position(node)
+        def get_node_start_position node
           Position.new(node.loc.line, node.loc.column)
         end
 
         # @param node [Parser::AST::Node]
         # @return [Position]
-        def get_node_end_position(node)
+        def get_node_end_position node
           Position.new(node.loc.last_line, node.loc.last_column)
         end
 
@@ -86,40 +86,42 @@ module Solargraph
         # @return [String]
         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
+          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 node.type == :lvar or node.type == :ivar or node.type == :cvar
+          elsif %i[lvar ivar cvar].include?(node.type)
             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 += drill_signature(node.children[0], signature) unless node.children[0].nil?
             signature += '.' unless signature.empty?
             signature += node.children[1].to_s
           end
           signature
         end
 
-        # @param node [Parser::AST::Node]
+        # @param node [Parser::AST::Node, nil]
         # @return [Hash{Symbol => Chain}]
         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
-          return convert_hash(node.children[0]) if Parser.is_ast_node?(node.children[0]) && node.children[0].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
 
-        # @sg-ignore Wrong argument type for AST::Node.new: type expected AST::_ToSym, received :nil
         NIL_NODE = ::Parser::AST::Node.new(:nil)
 
         # @param node [Parser::AST::Node]
@@ -148,7 +150,7 @@ module Solargraph
         end
 
         # @param nodes [Enumerable<Parser::AST::Node>]
-        def any_splatted_call?(nodes)
+        def any_splatted_call? nodes
           nodes.any? { |n| splatted_call?(n) }
         end
 
@@ -161,14 +163,17 @@ module Solargraph
           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) }
+              # @sg-ignore Need to add nil check here
+              node.children[0].children[2..].each { |child| result.concat call_nodes_from(child) }
             end
-            node.children[1..-1].each { |child| result.concat call_nodes_from(child) }
+            # @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)
-            node.children[2..-1].each { |child| result.concat call_nodes_from(child) }
-          elsif [:super, :zsuper].include?(node.type)
+            # @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
@@ -199,40 +204,44 @@ module Solargraph
         # @return [Array<AST::Node>] low-level value nodes in
         #   value position.  Does not include explicit return
         #   statements
-        def value_position_nodes_only(node)
+        def value_position_nodes_only node
           DeepInference.value_position_nodes_only(node).map { |n| n || NIL_NODE }
         end
 
         # @param cursor [Solargraph::Source::Cursor]
         # @return [Parser::AST::Node, nil]
         def find_recipient_node cursor
-          return repaired_find_recipient_node(cursor) if cursor.source.repaired? && cursor.source.code[cursor.offset - 1] == '('
+          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?
-            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
+                   # @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..-1]
+              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)
-              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
+              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
@@ -245,7 +254,7 @@ module Solargraph
         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
+          node if node && node.type == :send
         end
 
         #
@@ -302,19 +311,15 @@ module Solargraph
         #    statements in value positions.
         module DeepInference
           class << self
-            CONDITIONAL_ALL_BUT_FIRST = [:if, :unless]
-            CONDITIONAL_ALL = [:or]
-            ONLY_ONE_CHILD = [:return]
-            FIRST_TWO_CHILDREN = [:rescue]
-            COMPOUND_STATEMENTS = [:begin, :kwbegin]
-            SKIPPABLE = [:def, :defs, :class, :sclass, :module]
-            FUNCTION_VALUE = [:block]
-            CASE_STATEMENT = [:case]
+            CONDITIONAL_ALL_BUT_FIRST = %i[if unless].freeze
+            ONLY_ONE_CHILD = [:return].freeze
+            FIRST_TWO_CHILDREN = [:rescue].freeze
+            COMPOUND_STATEMENTS = %i[begin kwbegin].freeze
+            SKIPPABLE = %i[def defs class sclass module].freeze
+            FUNCTION_VALUE = [:block].freeze
+            CASE_STATEMENT = [:case].freeze
 
             # @param node [AST::Node] a method body compound statement
-            # @param include_explicit_returns [Boolean] If true,
-            #    include the value nodes of the parameter of the
-            #    'return' statements in the type returned.
             # @return [Array<AST::Node>] low-level value nodes from
             #   both nodes in value position as well as explicit
             #   return statements in the method's closure.
@@ -327,14 +332,14 @@ module Solargraph
             # @return [Array<AST::Node>] low-level value nodes in
             #   value position.  Does not include explicit return
             #   statements
-            def value_position_nodes_only(node)
+            def value_position_nodes_only node
               from_value_position_statement(node, include_explicit_returns: false)
             end
 
             # Look at known control statements and use them to find
             # more specific return nodes.
             #
-            # @param node [Parser::AST::Node] Statement which is in
+            # @param node [AST::Node] Statement which is in
             #    value position for a method body
             # @param include_explicit_returns [Boolean] If true,
             #    include the value nodes of the parameter of the
@@ -348,10 +353,9 @@ module Solargraph
               if COMPOUND_STATEMENTS.include?(node.type)
                 result.concat from_value_position_compound_statement node
               elsif CONDITIONAL_ALL_BUT_FIRST.include?(node.type)
-                result.concat reduce_to_value_nodes(node.children[1..-1])
+                # @sg-ignore Need to add nil check here
+                result.concat reduce_to_value_nodes(node.children[1..])
                 # result.push NIL_NODE unless node.children[2]
-              elsif CONDITIONAL_ALL.include?(node.type)
-                result.concat reduce_to_value_nodes(node.children)
               elsif ONLY_ONE_CHILD.include?(node.type)
                 result.concat reduce_to_value_nodes([node.children[0]])
               elsif FIRST_TWO_CHILDREN.include?(node.type)
@@ -362,9 +366,12 @@ module Solargraph
                 # @todo any explicit returns actually return from
                 #   scope in which the proc is run.  This asssumes
                 #   that the function is executed here.
-                result.concat explicit_return_values_from_compound_statement(node.children[2]) if include_explicit_returns
+                if include_explicit_returns
+                  result.concat explicit_return_values_from_compound_statement(node.children[2])
+                end
               elsif CASE_STATEMENT.include?(node.type)
-                node.children[1..-1].each do |cc|
+                # @sg-ignore Need to add nil check here
+                node.children[1..].each do |cc|
                   if cc.nil?
                     result.push NIL_NODE
                   elsif cc.type == :when
@@ -397,7 +404,7 @@ module Solargraph
             # @return [Array<Parser::AST::Node>]
             def from_value_position_compound_statement parent
               result = []
-              nodes = parent.children.select{|n| n.is_a?(AST::Node)}
+              nodes = parent.children.select { |n| n.is_a?(AST::Node) }
               nodes.each_with_index do |node, idx|
                 if node.type == :block
                   result.concat explicit_return_values_from_compound_statement(node.children[2])
@@ -422,7 +429,10 @@ module Solargraph
                 # value position.  we already have the explicit values
                 # from above; now we need to also gather the value
                 # position nodes
-                result.concat from_value_position_statement(nodes.last, include_explicit_returns: false) if idx == nodes.length - 1
+                if idx == nodes.length - 1
+                  result.concat from_value_position_statement(nodes.last,
+                                                              include_explicit_returns: false)
+                end
               end
               result
             end
@@ -438,7 +448,7 @@ module Solargraph
             def explicit_return_values_from_compound_statement parent
               return [] unless parent.is_a?(::Parser::AST::Node)
               result = []
-              nodes = parent.children.select{|n| n.is_a?(::Parser::AST::Node)}
+              nodes = parent.children.select { |n| n.is_a?(::Parser::AST::Node) }
               nodes.each do |node|
                 next if SKIPPABLE.include?(node.type)
                 if node.type == :return
@@ -460,17 +470,28 @@ module Solargraph
               nodes.each do |node|
                 if !node.is_a?(::Parser::AST::Node)
                   result.push nil
+                # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
                 elsif COMPOUND_STATEMENTS.include?(node.type)
                   result.concat from_value_position_compound_statement(node)
+                # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
                 elsif CONDITIONAL_ALL_BUT_FIRST.include?(node.type)
-                  result.concat reduce_to_value_nodes(node.children[1..-1])
+                  # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
+                  result.concat reduce_to_value_nodes(node.children[1..])
+                # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
                 elsif node.type == :return
+                  # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
                   result.concat reduce_to_value_nodes([node.children[0]])
+                # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
                 elsif node.type == :or
+                  # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
                   result.concat reduce_to_value_nodes(node.children)
+                # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
                 elsif node.type == :block
+                  # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
                   result.concat explicit_return_values_from_compound_statement(node.children[2])
+                # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
                 elsif node.type == :resbody
+                  # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
                   result.concat reduce_to_value_nodes([node.children[2]])
                 else
                   result.push node

data/lib/solargraph/parser/parser_gem/node_processors/and_node.rb

@@ -10,10 +10,10 @@ module Solargraph
           def process
             process_children
 
-            position = get_node_start_position(node)
-            # @sg-ignore https://github.com/castwide/solargraph/pull/1114
-            enclosing_breakable_pin = pins.select{|pin| pin.is_a?(Pin::Breakable) && pin.location.range.contain?(position)}.last
-            FlowSensitiveTyping.new(locals, enclosing_breakable_pin).process_and(node)
+            FlowSensitiveTyping.new(locals,
+                                    ivars,
+                                    enclosing_breakable_pin,
+                                    enclosing_compound_statement_pin).process_and(node)
           end
         end
       end

data/lib/solargraph/parser/parser_gem/node_processors/args_node.rb

@@ -14,16 +14,17 @@ module Solargraph
                 node.children.each do |u|
                   loc = get_node_location(u)
                   locals.push Solargraph::Pin::Parameter.new(
-                                location: loc,
-                                closure: callable,
-                                comments: comments_for(node),
-                                name: u.children[0].to_s,
-                                assignment: u.children[1],
-                                asgn_code: u.children[1] ? region.code_for(u.children[1]) : nil,
-                                presence: callable.location.range,
-                                decl: get_decl(u),
-                                source: :parser
-                              )
+                    location: loc,
+                    closure: callable,
+                    comments: comments_for(node),
+                    name: u.children[0].to_s,
+                    assignment: u.children[1],
+                    asgn_code: u.children[1] ? region.code_for(u.children[1]) : nil,
+                    # @sg-ignore Need to add nil check here
+                    presence: callable.location.range,
+                    decl: get_decl(u),
+                    source: :parser
+                  )
                   callable.parameters.push locals.last
                 end
               end
@@ -35,11 +36,12 @@ module Solargraph
 
           # @param callable [Pin::Callable]
           # @return [void]
-          def forward(callable)
+          def forward callable
             loc = get_node_location(node)
             locals.push Solargraph::Pin::Parameter.new(
               location: loc,
               closure: callable,
+              # @sg-ignore Need to add nil check here
               presence: region.closure.location.range,
               decl: get_decl(node),
               source: :parser

data/lib/solargraph/parser/parser_gem/node_processors/begin_node.rb

@@ -6,6 +6,15 @@ module Solargraph
       module NodeProcessors
         class BeginNode < Parser::NodeProcessor::Base
           def process
+            # We intentionally don't create a CompoundStatement pin
+            # here, as this is not necessarily a control flow block -
+            # e.g., a begin...end without rescue or ensure should be
+            # treated by flow sensitive typing as if the begin and end
+            # didn't exist at all.  As such, we create the
+            # CompoundStatement pins around the things which actually
+            # result in control flow changes - like
+            # if/while/rescue/etc
+
             process_children
           end
         end

data/lib/solargraph/parser/parser_gem/node_processors/block_node.rb

@@ -9,23 +9,22 @@ module Solargraph
 
           def process
             location = get_node_location(node)
-            parent = if other_class_eval?
-              Solargraph::Pin::Namespace.new(
-                location: location,
-                type: :class,
-                name: unpack_name(node.children[0].children[0]),
-                source: :parser,
-              )
-            else
-              region.closure
+            scope = region.scope || region.closure.context.scope
+            if other_class_eval?
+              clazz_name = unpack_name(node.children[0].children[0])
+              # instance variables should come from the Class<T> type
+              # - i.e., treated as class instance variables
+              context = ComplexType.try_parse("Class<#{clazz_name}>")
+              scope = :class
             end
             block_pin = Solargraph::Pin::Block.new(
               location: location,
-              closure: parent,
+              closure: region.closure,
               node: node,
+              context: context,
               receiver: node.children[0],
               comments: comments_for(node),
-              scope: region.scope || region.closure.context.scope,
+              scope: scope,
               source: :parser
             )
             pins.push block_pin
@@ -37,7 +36,8 @@ module Solargraph
           def other_class_eval?
             node.children[0].type == :send &&
               node.children[0].children[1] == :class_eval &&
-              [:cbase, :const].include?(node.children[0].children[0]&.type)
+              # @sg-ignore Need to add nil check here
+              %i[cbase const].include?(node.children[0].children[0]&.type)
           end
         end
       end

data/lib/solargraph/parser/parser_gem/node_processors/def_node.rb

@@ -8,38 +8,45 @@ module Solargraph
           def process
             name = node.children[0].to_s
             scope = region.scope || (region.closure.is_a?(Pin::Singleton) ? :class : :instance)
+            # specify context explicitly instead of relying on
+            # closure, as they may differ (e.g., defs inside
+            # class_eval)
+            method_context = scope == :instance ? region.closure.binder.namespace_type : region.closure.binder
             methpin = Solargraph::Pin::Method.new(
               location: get_node_location(node),
               closure: region.closure,
               name: name,
+              context: method_context,
               comments: comments_for(node),
               scope: scope,
               visibility: scope == :instance && name == 'initialize' ? :private : region.visibility,
               node: node,
-              source: :parser,
+              source: :parser
             )
             if region.visibility == :module_function
               pins.push Solargraph::Pin::Method.new(
                 location: methpin.location,
                 closure: methpin.closure,
                 name: methpin.name,
+                context: method_context,
                 comments: methpin.comments,
                 scope: :class,
                 visibility: :public,
                 parameters: methpin.parameters,
                 node: methpin.node,
-                source: :parser,
+                source: :parser
               )
               pins.push Solargraph::Pin::Method.new(
                 location: methpin.location,
                 closure: methpin.closure,
                 name: methpin.name,
+                context: method_context,
                 comments: methpin.comments,
                 scope: :instance,
                 visibility: :private,
                 parameters: methpin.parameters,
                 node: methpin.node,
-                source: :parser,
+                source: :parser
               )
             else
               pins.push methpin

data/lib/solargraph/parser/parser_gem/node_processors/defs_node.rb

@@ -1,37 +1,38 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      module NodeProcessors
-        class DefsNode < DefNode
-          include ParserGem::NodeMethods
-
-          def process
-            s_visi = region.visibility
-            s_visi = :public if s_visi == :module_function || region.scope != :class
-            loc = get_node_location(node)
-            if node.children[0].is_a?(AST::Node) && node.children[0].type == :self
-              closure = region.closure
-            else
-              closure = Solargraph::Pin::Namespace.new(
-                name: unpack_name(node.children[0])
-              )
-            end
-            pins.push Solargraph::Pin::Method.new(
-              location: loc,
-              closure: closure,
-              name: node.children[1].to_s,
-              comments: comments_for(node),
-              scope: :class,
-              visibility: s_visi,
-              node: node,
-              source: :parser,
-            )
-            process_children region.update(closure: pins.last, scope: :class)
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class DefsNode < DefNode
+          include ParserGem::NodeMethods
+
+          def process
+            s_visi = region.visibility
+            s_visi = :public if s_visi == :module_function || region.scope != :class
+            loc = get_node_location(node)
+            closure = if node.children[0].is_a?(AST::Node) && node.children[0].type == :self
+                        region.closure
+                      else
+                        Solargraph::Pin::Namespace.new(
+                          name: unpack_name(node.children[0]),
+                          source: :parser
+                        )
+                      end
+            pins.push Solargraph::Pin::Method.new(
+              location: loc,
+              closure: closure,
+              name: node.children[1].to_s,
+              comments: comments_for(node),
+              scope: :class,
+              visibility: s_visi,
+              node: node,
+              source: :parser
+            )
+            process_children region.update(closure: pins.last, scope: :class)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/parser_gem/node_processors/if_node.rb

@@ -8,13 +8,43 @@ module Solargraph
           include ParserGem::NodeMethods
 
           def process
-            process_children
+            FlowSensitiveTyping.new(locals,
+                                    ivars,
+                                    enclosing_breakable_pin,
+                                    enclosing_compound_statement_pin).process_if(node)
+            condition_node = node.children[0]
+            if condition_node
+              pins.push Solargraph::Pin::CompoundStatement.new(
+                location: get_node_location(condition_node),
+                closure: region.closure,
+                node: condition_node,
+                source: :parser
+              )
+              NodeProcessor.process(condition_node, region, pins, locals, ivars)
+            end
+            then_node = node.children[1]
+            if then_node
+              pins.push Solargraph::Pin::CompoundStatement.new(
+                location: get_node_location(then_node),
+                closure: region.closure,
+                node: then_node,
+                source: :parser
+              )
+              NodeProcessor.process(then_node, region, pins, locals, ivars)
+            end
 
-            position = get_node_start_position(node)
-            # @sg-ignore
-            # @type [Solargraph::Pin::Breakable, nil]
-            enclosing_breakable_pin = pins.select{|pin| pin.is_a?(Pin::Breakable) && pin.location.range.contain?(position)}.last
-            FlowSensitiveTyping.new(locals, enclosing_breakable_pin).process_if(node)
+            else_node = node.children[2]
+            if else_node
+              pins.push Solargraph::Pin::CompoundStatement.new(
+                location: get_node_location(else_node),
+                closure: region.closure,
+                node: else_node,
+                source: :parser
+              )
+              NodeProcessor.process(else_node, region, pins, locals, ivars)
+            end
+
+            true
           end
         end
       end