solargraph 0.54.1 → 0.56.0

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'parser'
+
 module Solargraph
   class Source
     class Chain
@@ -8,14 +10,37 @@ module Solargraph
           @word ||= "<#{@type}>"
         end
 
+        attr_reader :value
+
         # @param type [String]
-        def initialize type
+        # @param node [Parser::AST::Node, Object]
+        def initialize type, node
+          if node.is_a?(::Parser::AST::Node)
+            if node.type == :true
+              @value = true
+            elsif node.type == :false
+              @value = false
+            elsif [:int, :sym].include?(node.type)
+              @value = node.children.first
+            end
+          end
           @type = type
+          @literal_type = ComplexType.try_parse(@value.inspect)
           @complex_type = ComplexType.try_parse(type)
         end
 
+        # @sg-ignore Fix "Not enough arguments to Module#protected"
+        protected def equality_fields
+          super + [@value, @type, @literal_type, @complex_type]
+        end
+
         def resolve api_map, name_pin, locals
-          [Pin::ProxyType.anonymous(@complex_type)]
+          if api_map.super_and_sub?(@complex_type.name, @literal_type.name)
+            [Pin::ProxyType.anonymous(@literal_type, source: :chain)]
+          else
+            # we don't support this value as a literal type
+            [Pin::ProxyType.anonymous(@complex_type, source: :chain)]
+          end
         end
       end
     end

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.new(types.uniq))]
+          [Solargraph::Pin::ProxyType.anonymous(Solargraph::ComplexType.new(types.uniq), source: :chain)]
         end
       end
     end

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

@@ -15,7 +15,7 @@ module Solargraph
         # @param with_block [Boolean] True if the chain is inside a block
         # @param head [Boolean] True if the call is the start of its chain
         def initialize word, with_block = false
-          super(word, [], with_block)
+          super(word, nil, [], with_block)
         end
 
         # @param api_map [ApiMap]

data/lib/solargraph/source/chain.rb

@@ -14,10 +14,8 @@ module Solargraph
     # expression.
     #
     class Chain
-      #
-      # A chain of constants, variables, and method calls for inferring types of
-      # values.
-      #
+      include Equality
+
       autoload :Link,             'solargraph/source/chain/link'
       autoload :Call,             'solargraph/source/chain/call'
       autoload :QCall,            'solargraph/source/chain/q_call'
@@ -41,7 +39,7 @@ module Solargraph
       @@inference_invalidation_key = nil
       @@inference_cache = {}
 
-      UNDEFINED_CALL = Chain::Call.new('<undefined>')
+      UNDEFINED_CALL = Chain::Call.new('<undefined>', nil)
       UNDEFINED_CONSTANT = Chain::Constant.new('<undefined>')
 
       # @return [::Array<Source::Chain::Link>]
@@ -49,6 +47,11 @@ module Solargraph
 
       attr_reader :node
 
+      # @sg-ignore Fix "Not enough arguments to Module#protected"
+      protected def equality_fields
+        [links, node]
+      end
+
       # @param node [Parser::AST::Node, nil]
       # @param links [::Array<Chain::Link>]
       # @param splat [Boolean]
@@ -72,16 +75,27 @@ module Solargraph
 
       # Determine potential Pins returned by this chain of words
       #
-      # @param api_map [ApiMap]
-      # @param name_pin [Pin::Closure] the surrounding closure pin for
-      #   the statement represented by this chain for type resolution
-      #   and method pin lookup.
+      # @param api_map [ApiMap] @param name_pin [Pin::Base] A pin
+      # representing the place in which expression is evaluated (e.g.,
+      # a Method pin, or a Module or Class pin if not run within a
+      # method - both in terms of the closure around the chain, as well
+      # as the self type used for any method calls in head position.
+      #
+      #   Requirements for name_pin:
       #
-      #   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.
+      #     * name_pin.context: This should be a type representing the
+      #       namespace where we can look up non-local variables and
+      #       method names.  If it is a Class<X>, we will look up
+      #       :class scoped methods/variables.
       #
-      # @param locals [::Enumerable<Pin::LocalVariable>] Any local
+      #     * name_pin.binder: Used for method call lookups only
+      #       (Chain::Call links).  For method calls as the first
+      #       element in the chain, 'name_pin.binder' should be the
+      #       same as name_pin.context above.  For method calls later
+      #       in the chain (e.g., 'b' in a.b.c), it should represent
+      #       'a'.
+      #
+      # @param locals [::Array<Pin::LocalVariable>] Any local
       #   variables / method parameters etc visible by the statement
       #
       # @return [::Array<Pin::Base>] Pins representing possible return
@@ -98,9 +112,18 @@ module Solargraph
         working_pin = name_pin
         links[0..-2].each do |link|
           pins = link.resolve(api_map, working_pin, locals)
-          type = infer_first_defined(pins, working_pin, api_map, locals)
-          return [] if type.undefined?
-          working_pin = Pin::ProxyType.anonymous(type)
+          type = infer_from_definitions(pins, working_pin, api_map, locals)
+          if type.undefined?
+            logger.debug { "Chain#define(links=#{links.map(&:desc)}, name_pin=#{name_pin.inspect}, locals=#{locals}) => [] - undefined type from #{link.desc}" }
+            return []
+          end
+          # We continue to use the context from the head pin, in case
+          # we need it to, for instance, provide context for a block
+          # evaluation.  However, we use the last link's return type
+          # for the binder, as this is chaining off of it, and the
+          # binder is now the lhs of the rhs we are evaluating.
+          working_pin = Pin::ProxyType.anonymous(name_pin.context, binder: type, closure: name_pin, source: :chain)
+          logger.debug { "Chain#define(links=#{links.map(&:desc)}, name_pin=#{name_pin.inspect}, locals=#{locals}) - after processing #{link.desc}, new working_pin=#{working_pin} with binder #{working_pin.binder}" }
         end
         links.last.last_context = working_pin
         links.last.resolve(api_map, working_pin, locals)
@@ -108,30 +131,37 @@ module Solargraph
 
       # @param api_map [ApiMap]
       # @param name_pin [Pin::Base] The pin for the closure in which this code runs
-      # @param locals [::Enumerable<Pin::LocalVariable>]
+      # @param locals [::Array<Pin::LocalVariable>]
       # @return [ComplexType]
       # @sg-ignore
       def infer api_map, name_pin, locals
-        out = nil
-        cached = @@inference_cache[[node, node.location, links.map(&:word), name_pin&.return_type, locals]] unless node.nil?
-        return cached if cached && @@inference_invalidation_key == api_map.hash
-        out = infer_uncached api_map, name_pin, locals
-        if @@inference_invalidation_key != api_map.hash
-          @@inference_cache = {}
+        cache_key = [node, node&.location, links, name_pin&.return_type, locals]
+        if @@inference_invalidation_key == api_map.hash
+          cached = @@inference_cache[cache_key]
+          return cached if cached
+        else
           @@inference_invalidation_key = api_map.hash
+          @@inference_cache = {}
         end
-        @@inference_cache[[node, node.location, links.map(&:word), name_pin&.return_type, locals]] = out unless node.nil?
-        out
+        out = infer_uncached(api_map, name_pin, locals).downcast_to_literal_if_possible
+        logger.debug { "Chain#infer() - caching result - cache_key_hash=#{cache_key.hash}, links.map(&:hash)=#{links.map(&:hash)}, links=#{links}, cache_key.map(&:hash) = #{cache_key.map(&:hash)}, cache_key=#{cache_key}" }
+        @@inference_cache[cache_key] = out
       end
 
       # @param api_map [ApiMap]
       # @param name_pin [Pin::Base]
-      # @param locals [::Enumerable<Pin::LocalVariable>]
+      # @param locals [::Array<Pin::LocalVariable>]
       # @return [ComplexType]
       def infer_uncached api_map, name_pin, locals
         pins = define(api_map, name_pin, locals)
-        type = infer_first_defined(pins, links.last.last_context, api_map, locals)
-        maybe_nil(type)
+        if pins.empty?
+          logger.debug { "Chain#infer_uncached(links=#{links.map(&:desc)}, locals=#{locals.map(&:desc)}) => undefined - no pins" }
+          return ComplexType::UNDEFINED
+        end
+        type = infer_from_definitions(pins, links.last.last_context, api_map, locals)
+        out = maybe_nil(type)
+        logger.debug { "Chain#infer_uncached(links=#{self.links.map(&:desc)}, locals=#{locals.map(&:desc)}, name_pin=#{name_pin}, name_pin.closure=#{name_pin.closure.inspect}, name_pin.binder=#{name_pin.binder}) => #{out.rooted_tags.inspect}" }
+        out
       end
 
       # @return [Boolean]
@@ -160,6 +190,18 @@ module Solargraph
         links.any?(&:nullable?)
       end
 
+      include Logging
+
+      def desc
+        links.map(&:desc).to_s
+      end
+
+      def to_s
+        desc
+      end
+
+      include Logging
+
       private
 
       # @param pins [::Array<Pin::Base>]
@@ -167,16 +209,18 @@ module Solargraph
       # @param api_map [ApiMap]
       # @param locals [::Enumerable<Pin::LocalVariable>]
       # @return [ComplexType]
-      def infer_first_defined pins, context, api_map, locals
-        possibles = []
+      def infer_from_definitions pins, context, api_map, locals
+        # @type [::Array<ComplexType>]
+        types = []
+        unresolved_pins = []
         # @todo this param tag shouldn't be needed to probe the type
         # @todo ...but given it is needed, typecheck should complain that it is needed
         # @param pin [Pin::Base]
         pins.each do |pin|
           # Avoid infinite recursion
-          next if @@inference_stack.include?(pin.identity)
+          next if @@inference_stack.include?(pin)
 
-          @@inference_stack.push pin.identity
+          @@inference_stack.push pin
           type = pin.typify(api_map)
           @@inference_stack.pop
           if type.defined?
@@ -186,41 +230,41 @@ module Solargraph
               #   that accepts only [Pin::Namespace] as an argument
               type = type.resolve_generics(pin.closure, context.binder)
             end
-            if type.defined?
-              possibles.push type
-              break if pin.is_a?(Pin::Method)
-            end
+            types << type
+          else
+            unresolved_pins << pin
           end
         end
-        if possibles.empty?
-          # Limit method inference recursion
-          return ComplexType::UNDEFINED if @@inference_depth >= 10 && pins.first.is_a?(Pin::Method)
-
-          @@inference_depth += 1
-          # @param pin [Pin::Base]
-          pins.each do |pin|
-            # Avoid infinite recursion
-            next if @@inference_stack.include?(pin.identity)
-
-            @@inference_stack.push pin.identity
-            type = pin.probe(api_map)
-            @@inference_stack.pop
-            if type.defined?
-              possibles.push type
-              break if pin.is_a?(Pin::Method)
-            end
-          end
-          @@inference_depth -= 1
+
+        # Limit method inference recursion
+        if @@inference_depth >= 10 && pins.first.is_a?(Pin::Method)
+          return ComplexType::UNDEFINED
         end
-        return ComplexType::UNDEFINED if possibles.empty?
 
-        type = if possibles.length > 1
-          # Move nil to the end by convention
-          sorted = possibles.sort { |a, _| a.tag == 'nil' ? 1 : 0 }
-          ComplexType.new(sorted.uniq)
-        else
-          ComplexType.new(possibles)
+        @@inference_depth += 1
+        # @param pin [Pin::Base]
+        unresolved_pins.each do |pin|
+          # Avoid infinite recursion
+          if @@inference_stack.include?(pin.identity)
+            next
+          end
+
+          @@inference_stack.push(pin.identity)
+          type = pin.probe(api_map)
+          @@inference_stack.pop
+          types.push type if type
         end
+        @@inference_depth -= 1
+
+        type = if types.empty?
+                 ComplexType::UNDEFINED
+               elsif types.length > 1
+                 # Move nil to the end by convention
+                 sorted = types.flat_map(&:items).sort { |a, _| a.tag == 'nil' ? 1 : 0 }
+                 ComplexType.new(sorted.uniq)
+               else
+                 ComplexType.new(types)
+               end
         return type if context.nil? || context.return_type.undefined?
 
         type.self_to_type(context.return_type)

data/lib/solargraph/source/cursor.rb

@@ -35,6 +35,7 @@ module Solargraph
       # The part of the word before the current position. Given the text
       # `foo.bar`, the start_of_word at position(0, 6) is `ba`.
       #
+      # @sg-ignore Improve resolution of String#match below
       # @return [String]
       def start_of_word
         @start_of_word ||= begin
@@ -103,17 +104,6 @@ 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.
       #

data/lib/solargraph/source/source_chainer.rb

@@ -32,8 +32,8 @@ module Solargraph
       # @return [Source::Chain]
       def chain
         # Special handling for files that end with an integer and a period
-        return Chain.new([Chain::Literal.new('Integer'), Chain::UNDEFINED_CALL]) if phrase =~ /^[0-9]+\.$/
-        return Chain.new([Chain::Literal.new('Symbol')]) if phrase.start_with?(':') && !phrase.start_with?('::')
+        return Chain.new([Chain::Literal.new('Integer', Integer(phrase[0..-2])), Chain::UNDEFINED_CALL]) if phrase =~ /^[0-9]+\.$/
+        return Chain.new([Chain::Literal.new('Symbol', phrase[1..].to_sym)]) if phrase.start_with?(':') && !phrase.start_with?('::')
         return SourceChainer.chain(source, Position.new(position.line, position.character + 1)) if end_of_phrase.strip == '::' && source.code[Position.to_offset(source.code, position)].to_s.match?(/[a-z]/i)
         begin
           return Chain.new([]) if phrase.end_with?('..')

data/lib/solargraph/source.rb

@@ -307,7 +307,7 @@ module Solargraph
 
     # A hash of line numbers and their associated comments.
     #
-    # @return [Hash{Integer => Array<String>}]
+    # @return [Hash{Integer => Array<String>, nil}]
     def stringified_comments
       @stringified_comments ||= {}
     end
@@ -375,6 +375,7 @@ module Solargraph
 
     protected
 
+    # @return [Array<Change>]
     def changes
       @changes ||= []
     end

data/lib/solargraph/source_map/clip.rb

@@ -11,7 +11,9 @@ module Solargraph
       def initialize api_map, cursor
         @api_map = api_map
         @cursor = cursor
-        block.rebind(api_map) if block.is_a?(Pin::Block)
+        block_pin = block
+        block_pin.rebind(api_map) if block_pin.is_a?(Pin::Block) && !Solargraph::Range.from_node(block_pin.receiver).contain?(cursor.range.start)
+        @in_block = nil
       end
 
       # @return [Array<Pin::Base>] Relevant pins for infering the type of the Cursor's position
@@ -40,7 +42,7 @@ module Solargraph
         end
       end
 
-      # @return [Array<Pin::Base>]
+      # @return [Array<Pin::Method>]
       def signify
         return [] unless cursor.argument?
         chain = Parser.chain(cursor.recipient_node, cursor.filename)

data/lib/solargraph/source_map/mapper.rb

@@ -41,7 +41,7 @@ module Solargraph
         s = Position.new(0, 0)
         e = Position.from_offset(code, code.length)
         location = Location.new(filename, Range.new(s, e))
-        [[Pin::Namespace.new(location: location, name: '')], []]
+        [[Pin::Namespace.new(location: location, name: '', source: :source_map)], []]
       end
 
       class << self
@@ -55,6 +55,7 @@ module Solargraph
 
       # @return [Array<Solargraph::Pin::Base>]
       def pins
+        # @type [Array<Solargraph::Pin::Base>]
         @pins ||= []
       end
 
@@ -140,7 +141,8 @@ module Solargraph
               scope: namespace.is_a?(Pin::Singleton) ? :class : :instance,
               visibility: :public,
               explicit: false,
-              attribute: true
+              attribute: true,
+              source: :source_map
             )
           end
           if t.nil? || t.include?('w')
@@ -151,10 +153,11 @@ module Solargraph
               comments: docstring.all.to_s,
               scope: namespace.is_a?(Pin::Singleton) ? :class : :instance,
               visibility: :public,
-              attribute: true
+              attribute: true,
+              source: :source_map
             )
             pins.push method_pin
-            method_pin.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last)
+            method_pin.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last, source: :source_map)
             if pins.last.return_type.defined?
               pins.last.docstring.add_tag YARD::Tags::Tag.new(:param, '', pins.last.return_type.to_s.split(', '), 'value')
             end
@@ -205,7 +208,8 @@ module Solargraph
           namespace = closure_at(source_position) || Pin::ROOT_PIN
           namespace.domains.concat directive.tag.types unless directive.tag.types.nil?
         when 'override'
-          pins.push Pin::Reference::Override.new(location, directive.tag.name, docstring.tags)
+          pins.push Pin::Reference::Override.new(location, directive.tag.name, docstring.tags,
+                                                 source: :source_map)
         when 'macro'
           # @todo Handle macros
         end

data/lib/solargraph/source_map.rb

@@ -118,23 +118,6 @@ module Solargraph
       _locate_pin line, character, Pin::Namespace, Pin::Method, Pin::Block
     end
 
-    # @todo Candidate for deprecation
-    #
-    # @param other_map [SourceMap]
-    # @return [Boolean]
-    def try_merge! other_map
-      return false if pins.length != other_map.pins.length || locals.length != other_map.locals.length || requires.map(&:name).uniq.sort != other_map.requires.map(&:name).uniq.sort
-
-      pins.each_index do |i|
-        return false unless pins[i].try_merge!(other_map.pins[i])
-      end
-      locals.each_index do |i|
-        return false unless locals[i].try_merge!(other_map.locals[i])
-      end
-      @source = other_map.source
-      true
-    end
-
     # @param name [String]
     # @return [Array<Location>]
     def references name

data/lib/solargraph/type_checker/checks.rb

@@ -50,6 +50,8 @@ module Solargraph
       # @param inferred [ComplexType]
       # @return [Boolean]
       def any_types_match? api_map, expected, inferred
+        expected = expected.downcast_to_literal_if_possible
+        inferred = inferred.downcast_to_literal_if_possible
         return duck_types_match?(api_map, expected, inferred) if expected.duck_type?
         # walk through the union expected type and see if any members
         # of the union match the inferred type
@@ -71,6 +73,8 @@ module Solargraph
       # @param expected [ComplexType]
       # @return [Boolean]
       def all_types_match? api_map, inferred, expected
+        expected = expected.downcast_to_literal_if_possible
+        inferred = inferred.downcast_to_literal_if_possible
         return duck_types_match?(api_map, expected, inferred) if expected.duck_type?
         inferred.each do |inf|
           next if inf.duck_type?

data/lib/solargraph/type_checker.rb

@@ -29,6 +29,7 @@ module Solargraph
       # @todo Smarter directory resolution
       @api_map = api_map || Solargraph::ApiMap.load(File.dirname(filename))
       @rules = Rules.new(level)
+      # @type [Array<Range>]
       @marked_ranges = []
     end
 
@@ -413,7 +414,7 @@ module Solargraph
     # @param locals [Array<Pin::LocalVariable>]
     # @param location [Location]
     # @param pin [Pin::Method]
-    # @param params [Hash{String => [nil, Hash]}]
+    # @param params [Hash{String => Hash{Symbol => String, Solargraph::ComplexType}}]
     # @param idx [Integer]
     #
     # @return [Array<Problem>]
@@ -467,13 +468,24 @@ module Solargraph
     end
 
     # @param pin [Pin::Method]
-    # @return [Hash{String => Hash{Symbol => BaseObject}}]
+    # @return [Hash{String => Hash{Symbol => String, ComplexType}}]
     def param_hash(pin)
-      tags = pin.docstring.tags(:param)
-      return {} if tags.empty?
+      # @type [Hash{String => Hash{Symbol => String, ComplexType}}]
       result = {}
+      pin.parameters.each do |param|
+        type = param.typify(api_map)
+        next if type.nil? || type.undefined?
+        result[param.name.to_s] = {
+          tagged: type.tags,
+          qualified: type
+        }
+      end
+      # see if we have additional tags to pay attention to from YARD -
+      # e.g., kwargs in a **restkwargs splat
+      tags = pin.docstring.tags(:param)
       tags.each do |tag|
-        next if tag.types.nil? || tag.types.empty?
+        next if result.key? tag.name.to_s
+        next if tag.types.nil?
         result[tag.name.to_s] = {
           tagged: tag.types.join(', '),
           qualified: Solargraph::ComplexType.try_parse(*tag.types).qualify(api_map, pin.full_context.namespace)
@@ -483,15 +495,29 @@ module Solargraph
     end
 
     # @param pins [Array<Pin::Method>]
-    # @return [Hash{String => Hash{Symbol => BasicObject}}]
+    # @return [Hash{String => Hash{Symbol => String, ComplexType}}]
     def first_param_hash(pins)
-      pins.each do |pin|
+      return {} if pins.empty?
+      first_pin_type = pins.first.typify(api_map)
+      first_pin = pins.first.proxy first_pin_type
+      param_names = first_pin.parameter_names
+      results = param_hash(first_pin)
+      pins[1..].each do |pin|
         # @todo this assignment from parametric use of Hash should not lose its generic
         # @type [Hash{String => Hash{Symbol => BasicObject}}]
-        result = param_hash(pin)
-        return result unless result.empty?
+
+        # documentation of types in superclasses should fail back to
+        # subclasses if the subclass hasn't documented something
+        superclass_results = param_hash(pin)
+        superclass_results.each do |param_name, details|
+          next unless param_names.include?(param_name)
+
+          results[param_name] ||= {}
+          results[param_name][:tagged] ||= details[:tagged]
+          results[param_name][:qualified] ||= details[:qualified]
+        end
       end
-      {}
+      results
     end
 
     # @param pin [Pin::Base]
@@ -512,7 +538,7 @@ module Solargraph
       !internal? pin
     end
 
-    # @param pin [Pin::Base]
+    # @param pin [Pin::BaseVariable]
     def declared_externally? pin
       return true if pin.assignment.nil?
       chain = Solargraph::Parser.chain(pin.assignment, filename)
@@ -562,7 +588,7 @@ module Solargraph
       return [] unless pin.explicit?
       return [] if parameters.empty? && arguments.empty?
       return [] if pin.anon_splat?
-      unchecked = arguments.clone
+      unchecked = arguments.dup # creates copy of and unthaws array
       add_params = 0
       if unchecked.empty? && parameters.any? { |param| param.decl == :kwarg }
         return [Problem.new(location, "Missing keyword arguments to #{pin.path}")]
@@ -584,7 +610,8 @@ module Solargraph
                   kwargs.delete param.name.to_sym
                   settled_kwargs += 1
                 elsif param.decl == :kwarg
-                  return [] if arguments.last.links.last.is_a?(Solargraph::Source::Chain::Hash) && arguments.last.links.last.splatted?
+                  last_arg_last_link = arguments.last.links.last
+                  return [] if last_arg_last_link.is_a?(Solargraph::Source::Chain::Hash) && last_arg_last_link.splatted?
                   return [Problem.new(location, "Missing keyword argument #{param.name} to #{pin.path}")]
                 end
               end
@@ -638,7 +665,7 @@ module Solargraph
         (pin.closure && pin.closure.docstring.has_tag?('abstract'))
     end
 
-    # @param pin [Pin::Base]
+    # @param pin [Pin::Method]
     # @return [Array<Source::Chain>]
     def fake_args_for(pin)
       args = []

data/lib/solargraph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Solargraph
-  VERSION = '0.54.1'
+  VERSION = '0.56.0'
 end