solargraph 0.54.0 → 0.54.1

data/lib/solargraph/source/chain/call.rb

@@ -3,7 +3,9 @@
 module Solargraph
   class Source
     class Chain
-      class Call < Link
+      class Call < Chain::Link
+        include Solargraph::Parser::NodeMethods
+
         # @return [String]
         attr_reader :word
 
@@ -28,7 +30,7 @@ module Solargraph
         end
 
         # @param api_map [ApiMap]
-        # @param name_pin [Pin::Base]
+        # @param name_pin [Pin::Closure] name_pin.binder should give us the object on which 'word' will be invoked
         # @param locals [::Array<Pin::LocalVariable>]
         def resolve api_map, name_pin, locals
           return super_pins(api_map, name_pin) if word == 'super'
@@ -38,23 +40,23 @@ module Solargraph
           else
             []
           end
-          return inferred_pins(found, api_map, name_pin.context, locals) unless found.empty?
-          # @param [ComplexType::UniqueType]
+          return inferred_pins(found, api_map, name_pin, locals) unless found.empty?
           pins = name_pin.binder.each_unique_type.flat_map do |context|
-            api_map.get_method_stack(context.namespace == '' ? '' : context.tag, word, scope: context.scope)
+            method_context = context.namespace == '' ? '' : context.tag
+            api_map.get_method_stack(method_context, word, scope: context.scope)
           end
           return [] if pins.empty?
-          inferred_pins(pins, api_map, name_pin.context, locals)
+          inferred_pins(pins, api_map, name_pin, locals)
         end
 
         private
 
         # @param pins [::Enumerable<Pin::Method>]
         # @param api_map [ApiMap]
-        # @param context [ComplexType]
+        # @param name_pin [Pin::Base]
         # @param locals [::Array<Pin::LocalVariable>]
         # @return [::Array<Pin::Base>]
-        def inferred_pins pins, api_map, context, locals
+        def inferred_pins pins, api_map, name_pin, locals
           result = pins.map do |p|
             next p unless p.is_a?(Pin::Method)
             overloads = p.signatures
@@ -68,7 +70,7 @@ module Solargraph
             sorted_overloads = overloads.sort { |ol| ol.block? ? -1 : 1 }
             new_signature_pin = nil
             sorted_overloads.each do |ol|
-              next unless arity_matches?(arguments, ol)
+              next unless ol.arity_matches?(arguments, with_block?)
               match = true
 
               atypes = []
@@ -78,7 +80,8 @@ module Solargraph
                   match = ol.parameters.any?(&:restarg?)
                   break
                 end
-                atype = atypes[idx] ||= arg.infer(api_map, Pin::ProxyType.anonymous(context), locals)
+                atype = atypes[idx] ||= arg.infer(api_map, Pin::ProxyType.anonymous(name_pin.context), locals)
+                ptype = param.return_type
                 # @todo Weak type comparison
                 # unless atype.tag == param.return_type.tag || api_map.super_and_sub?(param.return_type.tag, atype.tag)
                 unless param.return_type.undefined? || atype.name == param.return_type.name || api_map.super_and_sub?(param.return_type.name, atype.name) || param.return_type.generic?
@@ -89,11 +92,16 @@ module Solargraph
               if match
                 if ol.block && with_block?
                   block_atypes = ol.block.parameters.map(&:return_type)
-                  blocktype = block_call_type(api_map, context, block_atypes, locals)
+                  if block.links.map(&:class) == [BlockSymbol]
+                    # like the bar in foo(&:bar)
+                    blocktype = block_symbol_call_type(api_map, name_pin.context, block_atypes, locals)
+                  else
+                    blocktype = block_call_type(api_map, name_pin, locals)
+                  end
                 end
                 new_signature_pin = ol.resolve_generics_from_context_until_complete(ol.generics, atypes, nil, nil, blocktype)
                 new_return_type = new_signature_pin.return_type
-                type = with_params(new_return_type.self_to(context.to_s), context).qualify(api_map, context.namespace) if new_return_type.defined?
+                type = with_params(new_return_type.self_to_type(name_pin.context), name_pin.context).qualify(api_map, name_pin.context.namespace) if new_return_type.defined?
                 type ||= ComplexType::UNDEFINED
               end
               break if type.defined?
@@ -101,20 +109,21 @@ module Solargraph
             p = p.with_single_signature(new_signature_pin) unless new_signature_pin.nil?
             next p.proxy(type) if type.defined?
             if !p.macros.empty?
-              result = process_macro(p, api_map, context, locals)
+              result = process_macro(p, api_map, name_pin.context, locals)
               next result unless result.return_type.undefined?
             elsif !p.directives.empty?
-              result = process_directive(p, api_map, context, locals)
+              result = process_directive(p, api_map, name_pin.context, locals)
               next result unless result.return_type.undefined?
             end
             p
           end
           result.map do |pin|
-            if pin.path == 'Class#new' && context.tag != 'Class'
-              pin.proxy(ComplexType.try_parse(context.namespace))
+            if pin.path == 'Class#new' && name_pin.context.tag != 'Class'
+              reduced_context = name_pin.context.reduce_class_type
+              pin.proxy(reduced_context)
             else
               next pin if pin.return_type.undefined?
-              selfy = pin.return_type.self_to(context.tag)
+              selfy = pin.return_type.self_to_type(name_pin.context)
               selfy == pin.return_type ? pin : pin.proxy(selfy)
             end
           end
@@ -192,24 +201,24 @@ module Solargraph
           nil
         end
 
-        # @param arguments [::Array<Chain>]
-        # @param signature [Pin::Signature]
-        # @return [Boolean]
-        def arity_matches? arguments, signature
-          parameters = signature.parameters
-          argcount = arguments.length
-          parcount = parameters.length
-          parcount -= 1 if !parameters.empty? && parameters.last.block?
-          return false if signature.block? && !with_block?
-          return false if argcount < parcount && !(argcount == parcount - 1 && parameters.last.restarg?)
-          true
+        # @param name_pin [Pin::Base]
+        # @return [Pin::Method, nil]
+        def find_method_pin(name_pin)
+          method_pin = name_pin
+          until method_pin.is_a?(Pin::Method)
+            method_pin = method_pin.closure
+            return if method_pin.nil?
+          end
+          method_pin
         end
 
         # @param api_map [ApiMap]
         # @param name_pin [Pin::Base]
         # @return [::Array<Pin::Base>]
         def super_pins api_map, name_pin
-          pins = api_map.get_method_stack(name_pin.namespace, name_pin.name, scope: name_pin.context.scope)
+          method_pin = find_method_pin(name_pin)
+          return [] if method_pin.nil?
+          pins = api_map.get_method_stack(method_pin.namespace, method_pin.name, scope: method_pin.context.scope)
           pins.reject{|p| p.path == name_pin.path}
         end
 
@@ -217,10 +226,13 @@ module Solargraph
         # @param name_pin [Pin::Base]
         # @return [::Array<Pin::Base>]
         def yield_pins api_map, name_pin
-          method_pin = api_map.get_method_stack(name_pin.namespace, name_pin.name, scope: name_pin.context.scope).first
-          return [] if method_pin.nil?
+          method_pin = find_method_pin(name_pin)
+          return [] unless method_pin
 
-          method_pin.signatures.map(&:block).compact
+          method_pin.signatures.map(&:block).compact.map do |signature_pin|
+            return_type = signature_pin.return_type.qualify(api_map, name_pin.namespace)
+            signature_pin.proxy(return_type)
+          end
         end
 
         # @param type [ComplexType]
@@ -228,7 +240,7 @@ module Solargraph
         # @return [ComplexType]
         def with_params type, context
           return type unless type.to_s.include?('$')
-          ComplexType.try_parse(type.to_s.gsub('$', context.value_types.map(&:tag).join(', ')).gsub('<>', ''))
+          ComplexType.try_parse(type.to_s.gsub('$', context.value_types.map(&:rooted_tag).join(', ')).gsub('<>', ''))
         end
 
         # @return [void]
@@ -242,25 +254,41 @@ module Solargraph
         # @param block_parameter_types [::Array<ComplexType>]
         # @param locals [::Array<Pin::LocalVariable>]
         # @return [ComplexType, nil]
-        def block_call_type(api_map, context, block_parameter_types, locals)
+        def block_symbol_call_type(api_map, context, block_parameter_types, locals)
+          # Ruby's shorthand for sending the passed in method name
+          # to the first yield parameter with no arguments
+          block_symbol_name = block.links.first.word
+          block_symbol_call_path = "#{block_parameter_types.first}##{block_symbol_name}"
+          callee = api_map.get_path_pins(block_symbol_call_path).first
+          return_type = callee&.return_type
+          # @todo: Figure out why we get unresolved generics at
+          #   this point and need to assume method return types
+          #   based on the generic type
+          return_type ||= api_map.get_path_pins("#{context.subtypes.first}##{block.links.first.word}").first&.return_type
+          return_type || ComplexType::UNDEFINED
+        end
+
+        # @param api_map [ApiMap]
+        # @return [Pin::Block, nil]
+        def find_block_pin(api_map)
+          node_location = Solargraph::Location.from_node(block.node)
+          return if  node_location.nil?
+          block_pins = api_map.get_block_pins
+          block_pins.find { |pin| pin.location.contain?(node_location) }
+        end
+
+        # @param api_map [ApiMap]
+        # @param name_pin [Pin::Base]
+        # @param block_parameter_types [::Array<ComplexType>]
+        # @param locals [::Array<Pin::LocalVariable>]
+        # @return [ComplexType, nil]
+        def block_call_type(api_map, name_pin, locals)
           return nil unless with_block?
 
-          # @todo Handle BlockVariable
-          if block.links.map(&:class) == [BlockSymbol]
-            # Ruby's shorthand for sending the passed in method name
-            # to the first yield parameter with no arguments
-            block_symbol_name = block.links.first.word
-            block_symbol_call_path = "#{block_parameter_types.first}##{block_symbol_name}"
-            callee = api_map.get_path_pins(block_symbol_call_path).first
-            return_type = callee&.return_type
-            # @todo: Figure out why we get unresolved generics at
-            #   this point and need to assume method return types
-            #   based on the generic type
-            return_type ||= api_map.get_path_pins("#{context.subtypes.first}##{block.links.first.word}").first&.return_type
-            return_type || ComplexType::UNDEFINED
-          else
-            block.infer(api_map, Pin::ProxyType.anonymous(context), locals)
-          end
+          block_context_pin = name_pin
+          block_pin = find_block_pin(api_map)
+          block_context_pin = block_pin.closure if block_pin
+          block.infer(api_map, block_context_pin, locals)
         end
       end
     end

data/lib/solargraph/source/chain/link.rb

@@ -61,6 +61,15 @@ module Solargraph
           false
         end
 
+        # debugging description of contents; not for machine use
+        def desc
+          word
+        end
+
+        def inspect
+          "#<#{self.class} - `#{self.desc}`>"
+        end
+
         protected
 
         # Mark whether this link is the head of a chain

data/lib/solargraph/source/chain/or.rb

@@ -15,7 +15,7 @@ module Solargraph
 
         def resolve api_map, name_pin, locals
           types = @links.map { |link| link.infer(api_map, name_pin, locals) }
-          [Solargraph::Pin::ProxyType.anonymous(Solargraph::ComplexType.try_parse(types.map(&:tag).uniq.join(', ')))]
+          [Solargraph::Pin::ProxyType.anonymous(Solargraph::ComplexType.new(types.uniq))]
         end
       end
     end

data/lib/solargraph/source/chain.rb

@@ -5,10 +5,19 @@ require 'solargraph/source/chain/link'
 
 module Solargraph
   class Source
-    # A chain of constants, variables, and method calls for inferring types of
-    # values.
+    #
+    # Represents an expression as a single call chain at the parse
+    # tree level, made up of constants, variables, and method calls,
+    # each represented as a Link object.
+    #
+    # Computes Pins and/or ComplexTypes representing the interpreted
+    # expression.
     #
     class Chain
+      #
+      # A chain of constants, variables, and method calls for inferring types of
+      # values.
+      #
       autoload :Link,             'solargraph/source/chain/link'
       autoload :Call,             'solargraph/source/chain/call'
       autoload :QCall,            'solargraph/source/chain/q_call'
@@ -61,13 +70,31 @@ module Solargraph
         @base ||= Chain.new(links[0..-2])
       end
 
+      # Determine potential Pins returned by this chain of words
+      #
       # @param api_map [ApiMap]
-      # @param name_pin [Pin::Base]
-      # @param locals [::Enumerable<Pin::LocalVariable>]
+      # @param name_pin [Pin::Closure] the surrounding closure pin for
+      #   the statement represented by this chain for type resolution
+      #   and method pin lookup.
+      #
+      #   For method calls (Chain::Call objects) as the first element
+      #   in the chain, 'name_pin.binder' should return the
+      #   ComplexType representing the LHS / "self type" of the call.
+      #
+      # @param locals [::Enumerable<Pin::LocalVariable>] Any local
+      #   variables / method parameters etc visible by the statement
       #
-      # @return [::Array<Pin::Base>]
+      # @return [::Array<Pin::Base>] Pins representing possible return
+      #   types of this method.
       def define api_map, name_pin, locals
         return [] if undefined?
+
+        # working_pin is the surrounding closure pin for the link
+        # being processed, whose #binder method will provide the LHS /
+        # 'self type' of the next link (same as the  #return_type method
+        # --the type of the result so far).
+        #
+        # @todo ProxyType uses 'type' for the binder, but '
         working_pin = name_pin
         links[0..-2].each do |link|
           pins = link.resolve(api_map, working_pin, locals)
@@ -75,12 +102,12 @@ module Solargraph
           return [] if type.undefined?
           working_pin = Pin::ProxyType.anonymous(type)
         end
-        links.last.last_context = name_pin
+        links.last.last_context = working_pin
         links.last.resolve(api_map, working_pin, locals)
       end
 
       # @param api_map [ApiMap]
-      # @param name_pin [Pin::Base]
+      # @param name_pin [Pin::Base] The pin for the closure in which this code runs
       # @param locals [::Enumerable<Pin::LocalVariable>]
       # @return [ComplexType]
       # @sg-ignore
@@ -102,10 +129,6 @@ module Solargraph
       # @param locals [::Enumerable<Pin::LocalVariable>]
       # @return [ComplexType]
       def infer_uncached api_map, name_pin, locals
-        from_here = base.infer(api_map, name_pin, locals) unless links.length == 1
-        if from_here
-          name_pin = name_pin.proxy(from_here)
-        end
         pins = define(api_map, name_pin, locals)
         type = infer_first_defined(pins, links.last.last_context, api_map, locals)
         maybe_nil(type)
@@ -161,7 +184,7 @@ module Solargraph
               # @todo even at strong, no typechecking complaint
               #   happens when a [Pin::Base,nil] is passed into a method
               #   that accepts only [Pin::Namespace] as an argument
-              type = type.resolve_generics(pin.closure, context.return_type)
+              type = type.resolve_generics(pin.closure, context.binder)
             end
             if type.defined?
               possibles.push type
@@ -192,14 +215,15 @@ module Solargraph
         return ComplexType::UNDEFINED if possibles.empty?
 
         type = if possibles.length > 1
-          sorted = possibles.map { |t| t.rooted? ? "::#{t}" : t.to_s }.sort { |a, _| a == 'nil' ? 1 : 0 }
-          ComplexType.parse(*sorted)
+          # Move nil to the end by convention
+          sorted = possibles.sort { |a, _| a.tag == 'nil' ? 1 : 0 }
+          ComplexType.new(sorted.uniq)
         else
-          ComplexType.parse(possibles.map(&:to_s).join(', '))
+          ComplexType.new(possibles)
         end
         return type if context.nil? || context.return_type.undefined?
 
-        type.self_to(context.return_type.tag)
+        type.self_to_type(context.return_type)
       end
 
       # @param type [ComplexType]
@@ -207,7 +231,7 @@ module Solargraph
       def maybe_nil type
         return type if type.undefined? || type.void? || type.nullable?
         return type unless nullable?
-        ComplexType.try_parse("#{type}, nil")
+        ComplexType.new(type.items + [ComplexType::NIL])
       end
     end
   end

data/lib/solargraph/source/cursor.rb

@@ -2,8 +2,8 @@
 
 module Solargraph
   class Source
-    # Information about a position in a source, including the word located
-    # there.
+    # Information about a single Position in a Source, including the
+    # word located there.
     #
     class Cursor
       # @return [Position]
@@ -103,6 +103,17 @@ module Solargraph
         @string ||= source.string_at?(position)
       end
 
+
+      # True if the cursor's chain is an assignment to a variable.
+      #
+      # When the chain is an assignment, `Cursor#word` will contain the
+      # variable name.
+      #
+      # @return [Boolean]
+      def assign?
+        [:lvasgn, :ivasgn, :gvasgn, :cvasgn].include? chain&.node&.type
+      end
+
       # Get a cursor pointing to the method that receives the current statement
       # as an argument.
       #