solargraph 0.54.0 → 0.58.0

data/lib/solargraph/pin/parameter.rb

@@ -3,20 +3,39 @@
 module Solargraph
   module Pin
     class Parameter < LocalVariable
-      # @return [Symbol]
+      # @return [::Symbol]
       attr_reader :decl
 
       # @return [String]
       attr_reader :asgn_code
 
+      # allow this to be set to the method after the method itself has
+      # been created
+      attr_writer :closure
+
       # @param decl [::Symbol] :arg, :optarg, :kwarg, :kwoptarg, :restarg, :kwrestarg, :block, :blockarg
       # @param asgn_code [String, nil]
-      # @param return_type [ComplexType, nil]
-      def initialize decl: :arg, asgn_code: nil, return_type: nil, **splat
+      def initialize decl: :arg, asgn_code: nil, **splat
         super(**splat)
         @asgn_code = asgn_code
         @decl = decl
-        @return_type = return_type
+      end
+
+      def type_location
+        super || closure&.type_location
+      end
+
+      def location
+        super || closure&.type_location
+      end
+
+      def combine_with(other, attrs={})
+        new_attrs = {
+          decl: assert_same(other, :decl),
+          presence: choose(other, :presence),
+          asgn_code: choose(other, :asgn_code),
+        }.merge(attrs)
+        super(other, new_attrs)
       end
 
       def keyword?
@@ -27,6 +46,36 @@ module Solargraph
         decl == :kwrestarg || (assignment && [:HASH, :hash].include?(assignment.type))
       end
 
+      def needs_consistent_name?
+        keyword?
+      end
+
+      # @return [String]
+      def arity_decl
+        name = (self.name || '(anon)')
+        type = (return_type&.to_rbs || 'untyped')
+        case decl
+        when :arg
+          ""
+        when :optarg
+          "?"
+        when :kwarg
+          "#{name}:"
+        when :kwoptarg
+          "?#{name}:"
+        when :restarg
+          "*"
+        when :kwrestarg
+          "**"
+        else
+          "(unknown decl: #{decl})"
+        end
+      end
+
+      def arg?
+        decl == :arg
+      end
+
       def restarg?
         decl == :restarg
       end
@@ -56,15 +105,13 @@ module Solargraph
         end
       end
 
-      # @return [String]
-      def full
+      # @return [String] the full name of the parameter, including any
+      #   declarative symbols such as `*` or `:` indicating type of
+      #   parameter. This is used in method signatures.
+      def full_name
         case decl
-        when :optarg
-          "#{name} = #{asgn_code || '?'}"
-        when :kwarg
+        when :kwarg, :kwoptarg
           "#{name}:"
-        when :kwoptarg
-          "#{name}: #{asgn_code || '?'}"
         when :restarg
           "*#{name}"
         when :kwrestarg
@@ -76,6 +123,18 @@ module Solargraph
         end
       end
 
+      # @return [String]
+      def full
+        full_name + case decl
+                    when :optarg
+                      " = #{asgn_code || '?'}"
+                    when :kwoptarg
+                      " #{asgn_code || '?'}"
+                    else
+                      ''
+                    end
+      end
+
       # @return [ComplexType]
       def return_type
         if @return_type.nil?
@@ -84,11 +143,11 @@ module Solargraph
           @return_type = ComplexType.try_parse(*found.types) unless found.nil? or found.types.nil?
           if @return_type.undefined?
             if decl == :restarg
-              @return_type = ComplexType.try_parse('Array')
+              @return_type = ComplexType.try_parse('::Array')
             elsif decl == :kwrestarg
-              @return_type = ComplexType.try_parse('Hash')
+              @return_type = ComplexType.try_parse('::Hash')
             elsif decl == :blockarg
-              @return_type = ComplexType.try_parse('Proc')
+              @return_type = ComplexType.try_parse('::Proc')
             end
           end
         end
@@ -107,43 +166,42 @@ module Solargraph
 
       # @param api_map [ApiMap]
       def typify api_map
-        return return_type.qualify(api_map, closure.context.namespace) unless return_type.undefined?
+        return return_type.qualify(api_map, *closure.gates) unless return_type.undefined?
         closure.is_a?(Pin::Block) ? typify_block_param(api_map) : typify_method_param(api_map)
       end
 
+      # @param atype [ComplexType]
+      # @param api_map [ApiMap]
+      def compatible_arg?(atype, api_map)
+        # make sure we get types from up the method
+        # inheritance chain if we don't have them on this pin
+        ptype = typify api_map
+        ptype.undefined? || ptype.can_assign?(api_map, atype) || ptype.generic?
+      end
+
       def documentation
         tag = param_tag
         return '' if tag.nil? || tag.text.nil?
         tag.text
       end
 
-      def try_merge! pin
-        return false unless super && closure == pin.closure
-        true
-      end
-
       private
 
       # @return [YARD::Tags::Tag, nil]
       def param_tag
-        found = nil
         params = closure.docstring.tags(:param)
         params.each do |p|
-          next unless p.name == name
-          found = p
-          break
-        end
-        if found.nil? and !index.nil?
-          found = params[index] if params[index] && (params[index].name.nil? || params[index].name.empty?)
+          return p if p.name == name
         end
-        found
+        params[index] if index && params[index] && (params[index].name.nil? || params[index].name.empty?)
       end
 
       # @param api_map [ApiMap]
       # @return [ComplexType]
       def typify_block_param api_map
-        if closure.is_a?(Pin::Block) && closure.receiver
-          return closure.typify_parameters(api_map)[index]
+        block_pin = closure
+        if block_pin.is_a?(Pin::Block) && block_pin.receiver
+          return block_pin.typify_parameters(api_map)[index]
         end
         ComplexType::UNDEFINED
       end
@@ -164,7 +222,7 @@ module Solargraph
           if found.nil? and !index.nil?
             found = params[index] if params[index] && (params[index].name.nil? || params[index].name.empty?)
           end
-          return ComplexType.try_parse(*found.types).qualify(api_map, meth.context.namespace) unless found.nil? || found.types.nil?
+          return ComplexType.try_parse(*found.types).qualify(api_map, *meth.closure.gates) unless found.nil? || found.types.nil?
         end
         ComplexType::UNDEFINED
       end
@@ -174,8 +232,12 @@ module Solargraph
       # @param skip [::Array]
       # @return [::Array<YARD::Tags::Tag>]
       def see_reference heredoc, api_map, skip = []
+        # This should actually be an intersection type
+        # @param ref [YARD::Tags::Tag, Solargraph::Yard::Tags::RefTag]
         heredoc.ref_tags.each do |ref|
+          # @sg-ignore ref should actually be an intersection type
           next unless ref.tag_name == 'param' && ref.owner
+          # @sg-ignore ref should actually be an intersection type
           result = resolve_reference(ref.owner.to_s, api_map, skip)
           return result unless result.nil?
         end
@@ -189,7 +251,7 @@ module Solargraph
       def resolve_reference ref, api_map, skip
         return nil if skip.include?(ref)
         skip.push ref
-        parts = ref.split(/[\.#]/)
+        parts = ref.split(/[.#]/)
         if parts.first.empty?
           path = "#{namespace}#{ref}"
         else

data/lib/solargraph/pin/proxy_type.rb

@@ -4,24 +4,34 @@ module Solargraph
   module Pin
     class ProxyType < Base
       # @param return_type [ComplexType]
-      def initialize return_type: ComplexType::UNDEFINED, **splat
+      # @param gates [Array<String>, nil] Namespaces to try while resolving non-rooted types
+      # @param binder [ComplexType, ComplexType::UniqueType, nil]
+      # @param gates [Array<String>, nil]
+      def initialize return_type: ComplexType::UNDEFINED, binder: nil, gates: nil, **splat
         super(**splat)
+        @gates = gates
         @return_type = return_type
+        @binder = binder if binder
       end
 
       def context
         @return_type
       end
 
-      # @param return_type [ComplexType]
+      # @param context [ComplexType, ComplexType::UniqueType] Used as context for this pin
+      # @param closure [Pin::Namespace, nil] Used as the closure for this pin
+      # @param binder [ComplexType, ComplexType::UniqueType, nil]
       # @return [ProxyType]
-      def self.anonymous return_type
-        parts = return_type.namespace.split('::')
-        namespace = parts[0..-2].join('::').to_s
-        name = parts.last.to_s
+      def self.anonymous context, closure: nil, binder: nil, **kwargs
+        unless closure
+          parts = context.namespace.split('::')
+          namespace = parts[0..-2].join('::').to_s
+          closure = Solargraph::Pin::Namespace.new(name: namespace, source: :proxy_type)
+        end
+        # name = parts.last.to_s
         # ProxyType.new(nil, namespace, name, return_type)
         ProxyType.new(
-          closure: Solargraph::Pin::Namespace.new(name: namespace), return_type: return_type
+          closure: closure, return_type: context, binder: binder || context, **kwargs
         )
       end
     end

data/lib/solargraph/pin/reference/override.rb

@@ -10,18 +10,36 @@ module Solargraph
         # @return [::Array<Symbol>]
         attr_reader :delete
 
-        def initialize location, name, tags, delete = []
-          super(location: location, name: name)
+        def closure
+          nil
+        end
+
+        # @param location [Location, nil]
+        # @param name [String]
+        # @param tags [::Array<YARD::Tags::Tag>]
+        # @param delete [::Array<Symbol>]
+        # @param splat [Hash]
+        def initialize location, name, tags, delete = [], **splat
+          super(location: location, name: name, **splat)
           @tags = tags
           @delete = delete
         end
 
-        def self.method_return name, *tags, delete: []
-          new(nil, name, [YARD::Tags::Tag.new('return', nil, tags)], delete)
+        # @param name [String]
+        # @param tags [::Array<String>]
+        # @param delete [::Array<Symbol>]
+        # @param splat [Hash]
+        # @return [Solargraph::Pin::Reference::Override]
+        def self.method_return name, *tags, delete: [], **splat
+          new(nil, name, [YARD::Tags::Tag.new('return', '', tags)], delete, **splat)
         end
 
-        def self.from_comment name, comment
-          new(nil, name, Solargraph::Source.parse_docstring(comment).to_docstring.tags)
+        # @param name [String]
+        # @param comment [String]
+        # @param splat [Hash]
+        # @return [Solargraph::Pin::Reference::Override]
+        def self.from_comment name, comment, **splat
+          new(nil, name, Solargraph::Source.parse_docstring(comment).to_docstring.tags, **splat)
         end
       end
     end

data/lib/solargraph/pin/reference/require.rb

@@ -4,9 +4,9 @@ module Solargraph
   module Pin
     class Reference
       class Require < Reference
-        def initialize location, name
+        def initialize location, name, **splat
           # super(location, '', name)
-          super(location: location, name: name)
+          super(location: location, name: name, closure: Pin::ROOT_PIN, **splat)
         end
       end
     end

data/lib/solargraph/pin/reference/superclass.rb

@@ -3,7 +3,12 @@
 module Solargraph
   module Pin
     class Reference
+      # A Superclass reference pin.
+      #
       class Superclass < Reference
+        def reference_gates
+          @reference_gates ||= closure.gates - [closure.path]
+        end
       end
     end
   end

data/lib/solargraph/pin/reference.rb

@@ -17,6 +17,23 @@ module Solargraph
         super(**splat)
         @generic_values = generic_values
       end
+
+      # @return [ComplexType]
+      def type
+        @type ||= ComplexType.try_parse(
+          name +
+          if generic_values&.length&.> 0
+            "<#{generic_values.join(', ')}>"
+          else
+            ''
+          end
+        )
+      end
+
+      # @return [Array<String>]
+      def reference_gates
+        closure.gates
+      end
     end
   end
 end

data/lib/solargraph/pin/search.rb

@@ -12,6 +12,8 @@ module Solargraph
         # @return [Pin::Base]
         attr_reader :pin
 
+        # @param match [Float] The match score for the pin
+        # @param pin [Pin::Base]
         def initialize match, pin
           @match = match
           @pin = pin
@@ -40,6 +42,9 @@ module Solargraph
           Result.new(match, pin) if match > 0.7
         end
           .compact
+          # @param a [self]
+          # @param b [self]
+          # @sg-ignore https://github.com/castwide/solargraph/pull/1050
           .sort { |a, b| b.match <=> a.match }
           .map(&:pin)
       end
@@ -48,7 +53,7 @@ module Solargraph
       # @param str2 [String]
       # @return [Float]
       def fuzzy_string_match str1, str2
-        return (1.0 + (str2.length.to_f / str1.length.to_f)) if str1.downcase.include?(str2.downcase)
+        return 1.0 + (str2.length.to_f / str1.length.to_f) if str1.downcase.include?(str2.downcase)
         JaroWinkler.similarity(str1, str2, ignore_case: true)
       end
     end

data/lib/solargraph/pin/signature.rb

@@ -1,143 +1,61 @@
 module Solargraph
   module Pin
-    class Signature < Base
-      # @return [::Array<Parameter>]
-      attr_reader :parameters
+    class Signature < Callable
+      # allow signature to be created before method pin, then set this
+      # to the method pin
+      attr_writer :closure
 
-      # @return [ComplexType]
-      attr_reader :return_type
-
-      # @return [self]
-      attr_reader :block
-
-      # @param generics [Array<String>]
-      # @param parameters [Array<Parameter>]
-      # @param return_type [ComplexType]
-      # @param block [Signature, nil]
-      def initialize generics, parameters, return_type, block = nil
-        @generics = generics
-        @parameters = parameters
-        @return_type = return_type
-        @block = block
+      def initialize **splat
+        super(**splat)
       end
 
       def generics
         @generics ||= [].freeze
       end
 
-      # @return [String]
-      def to_rbs
-        rbs_generics + '(' + parameters.map { |param| param.to_rbs }.join(', ') + ') ' + (block.nil? ? '' : '{ ' + block.to_rbs + ' } ') + '-> ' + return_type.to_rbs
-      end
-
-      # @return [String]
-      def rbs_generics
-        if generics.empty?
-          return ''
-        else
-          return '[' + generics.map { |gen| gen.to_s }.join(', ') + '] '
-        end
+      def identity
+        @identity ||= "signature#{object_id}"
       end
 
-      # @return [Array<String>]
-      # @yieldparam [ComplexType]
-      # @yieldreturn [ComplexType]
-      # @return [self]
-      def transform_types(&transform)
-        # @todo 'super' alone should work here I think, but doesn't typecheck at level typed
-        signature = super(&transform)
-        signature.parameters = signature.parameters.map do |param|
-          param.transform_types(&transform)
-        end
-        signature.block = block.transform_types(&transform) if signature.block?
-        signature
-      end
+      attr_writer :closure
 
-      # @param generics_to_resolve [Enumerable<String>]
-      # @param arg_types [Array<ComplexType>, nil]
-      # @param return_type_context [ComplexType, nil]
-      # @param yield_arg_types [Array<ComplexType>, nil]
-      # @param yield_return_type_context [ComplexType, nil]
-      # @param context [ComplexType, nil]
-      # @param resolved_generic_values [Hash{String => ComplexType}]
-      # @return [self]
-      def resolve_generics_from_context(generics_to_resolve,
-                                        arg_types = nil,
-                                        return_type_context = nil,
-                                        yield_arg_types = nil,
-                                        yield_return_type_context = nil,
-                                        resolved_generic_values: {})
-        signature = super(generics_to_resolve, return_type_context, resolved_generic_values: resolved_generic_values)
-        signature.parameters = signature.parameters.each_with_index.map do |param, i|
-          if arg_types.nil?
-            param.dup
-          else
-            param.resolve_generics_from_context(generics_to_resolve,
-                                                arg_types[i],
-                                                resolved_generic_values: resolved_generic_values)
-          end
-        end
-        signature.block = block.resolve_generics_from_context(generics_to_resolve,
-                                                              yield_arg_types,
-                                                              yield_return_type_context,
-                                                              resolved_generic_values: resolved_generic_values) if signature.block?
-        signature
+      def dodgy_return_type_source?
+        super || closure&.dodgy_return_type_source?
       end
 
-      # @param generics_to_resolve [Enumerable<String>]
-      # @param arg_types [Array<ComplexType>, nil]
-      # @param return_type_context [ComplexType, nil]
-      # @param yield_arg_types [Array<ComplexType>, nil]
-      # @param yield_return_type_context [ComplexType, nil]
-      # @param context [ComplexType, nil]
-      # @param resolved_generic_values [Hash{String => ComplexType}]
-      # @return [self]
-      def resolve_generics_from_context_until_complete(generics_to_resolve,
-                                                       arg_types = nil,
-                                                       return_type_context = nil,
-                                                       yield_arg_types = nil,
-                                                       yield_return_type_context = nil,
-                                                       resolved_generic_values: {})
-        # See
-        # https://github.com/soutaro/steep/tree/master/lib/steep/type_inference
-        # and
-        # https://github.com/sorbet/sorbet/blob/master/infer/inference.cc
-        # for other implementations
-
-        return self if generics_to_resolve.empty?
-
-        last_resolved_generic_values = resolved_generic_values.dup
-        new_pin = resolve_generics_from_context(generics_to_resolve,
-                                                arg_types,
-                                                return_type_context,
-                                                yield_arg_types,
-                                                yield_return_type_context,
-                                                resolved_generic_values: resolved_generic_values)
-        if last_resolved_generic_values == resolved_generic_values
-          # erase anything unresolved
-          return new_pin.erase_generics(self.generics)
-        end
-        new_pin.resolve_generics_from_context_until_complete(generics_to_resolve,
-                                                             arg_types,
-                                                             return_type_context,
-                                                             yield_arg_types,
-                                                             yield_return_type_context,
-                                                             resolved_generic_values: resolved_generic_values)
+      def type_location
+        super || closure&.type_location
       end
 
-      def identity
-        @identity ||= "signature#{object_id}"
+      def location
+        super || closure&.location
       end
 
-      def block?
-        !!@block
+      def typify api_map
+        if return_type.defined?
+          qualified = return_type.qualify(api_map, closure.namespace)
+          logger.debug { "Signature#typify(self=#{self}) => #{qualified.rooted_tags.inspect}" }
+          return qualified
+        end
+        return ComplexType::UNDEFINED if closure.nil?
+        return ComplexType::UNDEFINED unless closure.is_a?(Pin::Method)
+        # @sg-ignore need is_a? support
+        # @type [Array<Pin::Method>]
+        method_stack = closure.rest_of_stack api_map
+        logger.debug { "Signature#typify(self=#{self}) - method_stack: #{method_stack}" }
+        method_stack.each do |pin|
+          sig = pin.signatures.find { |s| s.arity == self.arity }
+          next unless sig
+          unless sig.return_type.undefined?
+            qualified = sig.return_type.qualify(api_map, closure.namespace)
+            logger.debug { "Signature#typify(self=#{self}) => #{qualified.rooted_tags.inspect}" }
+            return qualified
+          end
+        end
+        out = super
+        logger.debug { "Signature#typify(self=#{self}) => #{out}" }
+        out
       end
-
-      protected
-
-      attr_writer :block
-
-      attr_writer :parameters
     end
   end
 end

data/lib/solargraph/pin/singleton.rb

@@ -3,7 +3,7 @@
 module Solargraph
   module Pin
     class Singleton < Closure
-      def initialize name: '', location: nil, closure: nil
+      def initialize name: '', location: nil, closure: nil, **splat
         super
       end
     end

data/lib/solargraph/pin/symbol.rb

@@ -5,8 +5,9 @@ module Solargraph
     class Symbol < Base
       # @param location [Solargraph::Location]
       # @param name [String]
-      def initialize location, name
-        super(location: location, name: name)
+      def initialize(location, name, **kwargs)
+        # @sg-ignore "Unrecognized keyword argument kwargs to Solargraph::Pin::Base#initialize"
+        super(location: location, name: name, **kwargs)
         # @name = name
         # @location = location
       end
@@ -19,6 +20,10 @@ module Solargraph
         ''
       end
 
+      def closure
+        @closure ||= Pin::ROOT_PIN
+      end
+
       def completion_item_kind
         Solargraph::LanguageServer::CompletionItemKinds::KEYWORD
       end
@@ -35,6 +40,7 @@ module Solargraph
         []
       end
 
+      # @return [::Symbol]
       def visibility
         :public
       end

data/lib/solargraph/pin/until.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Until < Base
+      include Breakable
+
+      # @param receiver [Parser::AST::Node, nil]
+      # @param node [Parser::AST::Node, nil]
+      # @param context [ComplexType, nil]
+      # @param args [::Array<Parameter>]
+      def initialize node: nil, **splat
+        super(**splat)
+        @node = node
+      end
+    end
+  end
+end

data/lib/solargraph/pin/while.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class While < Base
+      include Breakable
+
+      # @param receiver [Parser::AST::Node, nil]
+      # @param node [Parser::AST::Node, nil]
+      # @param context [ComplexType, nil]
+      # @param args [::Array<Parameter>]
+      def initialize node: nil, **splat
+        super(**splat)
+        @node = node
+      end
+    end
+  end
+end

data/lib/solargraph/pin.rb

@@ -3,7 +3,9 @@
 require 'yard'
 
 module Solargraph
-  # The namespace for pins used in maps.
+  # The namespace for Pins used in SourceMaps.
+  #
+  # Pins represent declarations, from gems, Sources, and the Ruby core.
   #
   module Pin
     autoload :Common,           'solargraph/pin/common'
@@ -32,7 +34,11 @@ module Solargraph
     autoload :Singleton,        'solargraph/pin/singleton'
     autoload :KeywordParam,     'solargraph/pin/keyword_param'
     autoload :Search,           'solargraph/pin/search'
+    autoload :Breakable,        'solargraph/pin/breakable'
+    autoload :Until,            'solargraph/pin/until'
+    autoload :While,            'solargraph/pin/while'
+    autoload :Callable,         'solargraph/pin/callable'
 
-    ROOT_PIN = Pin::Namespace.new(type: :class, name: '', closure: nil)
+    ROOT_PIN = Pin::Namespace.new(type: :class, name: '', closure: nil, source: :pin_rb)
   end
 end