solargraph 0.54.0 → 0.54.2

data/lib/solargraph/pin/block.rb

@@ -2,7 +2,7 @@
 
 module Solargraph
   module Pin
-    class Block < Closure
+    class Block < Callable
       # @return [Parser::AST::Node]
       attr_reader :receiver
 
@@ -14,10 +14,9 @@ module Solargraph
       # @param context [ComplexType, nil]
       # @param args [::Array<Parameter>]
       def initialize receiver: nil, args: [], context: nil, node: nil, **splat
-        super(**splat)
+        super(**splat, parameters: args)
         @receiver = receiver
         @context = context
-        @parameters = args
         @return_type = ComplexType.parse('::Proc')
         @node = node
       end
@@ -32,38 +31,19 @@ module Solargraph
         @rebind&.defined? ? @rebind : closure.binder
       end
 
-      # @return [::Array<Parameter>]
-      def parameters
-        @parameters ||= []
-      end
-
-      # @return [::Array<String>]
-      def parameter_names
-        @parameter_names ||= parameters.map(&:name)
-      end
-
       # @param yield_types [::Array<ComplexType>]
       # @param parameters [::Array<Parameter>]
       #
       # @return [::Array<ComplexType>]
       def destructure_yield_types(yield_types, parameters)
-        return yield_types if yield_types.length == parameters.length
-
         # yielding a tuple into a block will destructure the tuple
         if yield_types.length == 1
           yield_type = yield_types.first
           return yield_type.all_params if yield_type.tuple? && yield_type.all_params.length == parameters.length
         end
-        parameters.map { ComplexType::UNDEFINED }
+        parameters.map.with_index { |_, idx| yield_types[idx] || ComplexType::UNDEFINED }
       end
 
-      # @todo the next step with parameters, arguments, destructuring,
-      #   kwargs, etc logic is probably either creating a Parameters
-      #   or Callable pin that encapsulates and shares the logic
-      #   between methods, blocks and signatures.  It could live in
-      #   Signature if Method didn't also own potentially different
-      #   set of parameters, generics and return types.
-
       # @param api_map [ApiMap]
       # @return [::Array<ComplexType>]
       def typify_parameters(api_map)
@@ -87,7 +67,7 @@ module Solargraph
                 namespace_pin = api_map.get_namespace_pins(meth.namespace, closure.namespace).first
                 arg_type.resolve_generics(namespace_pin, param_type)
               else
-                arg_type.self_to(chain.base.infer(api_map, self, locals).namespace).qualify(api_map, meth.context.namespace)
+                arg_type.self_to_type(chain.base.infer(api_map, self, locals)).qualify(api_map, meth.context.namespace)
               end
             end
           end
@@ -105,7 +85,7 @@ module Solargraph
 
         chain = Parser.chain(receiver, location.filename)
         locals = api_map.source_map(location.filename).locals_at(location)
-        receiver_pin = chain.define(api_map, self, locals).first
+        receiver_pin = chain.define(api_map, closure, locals).first
         return ComplexType::UNDEFINED unless receiver_pin
 
         types = receiver_pin.docstring.tag(:yieldreceiver)&.types
@@ -114,7 +94,7 @@ module Solargraph
         target = chain.base.infer(api_map, receiver_pin, locals)
         target = full_context unless target.defined?
 
-        ComplexType.try_parse(*types).qualify(api_map, receiver_pin.context.namespace).self_to(target.to_s)
+        ComplexType.try_parse(*types).qualify(api_map, receiver_pin.context.namespace).self_to_type(target)
       end
     end
   end

data/lib/solargraph/pin/callable.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Callable < Closure
+      # @return [self]
+      attr_reader :block
+
+      attr_reader :parameters
+
+      # @return [ComplexType, nil]
+      attr_reader :return_type
+
+      # @param block [Signature, nil]
+      # @param return_type [ComplexType, nil]
+      # @param parameters [::Array<Pin::Parameter>]
+      def initialize block: nil, return_type: nil, parameters: [], **splat
+        super(**splat)
+        @block = block
+        @return_type = return_type
+        @parameters = parameters
+      end
+
+      # @return [::Array<String>]
+      def parameter_names
+        @parameter_names ||= parameters.map(&:name)
+      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(generics_to_resolve,
+                                        arg_types = nil,
+                                        return_type_context = nil,
+                                        yield_arg_types = nil,
+                                        yield_return_type_context = nil,
+                                        resolved_generic_values: {})
+        callable = super(generics_to_resolve, return_type_context, resolved_generic_values: resolved_generic_values)
+        callable.parameters = callable.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
+        callable.block = block.resolve_generics_from_context(generics_to_resolve,
+                                                              yield_arg_types,
+                                                              yield_return_type_context,
+                                                              resolved_generic_values: resolved_generic_values) if callable.block?
+        callable
+      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)
+      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
+        callable = super(&transform)
+        callable.block = block.transform_types(&transform) if block?
+        callable.parameters = parameters.map do |param|
+          param.transform_types(&transform)
+        end
+        callable
+      end
+
+      # @param arguments [::Array<Chain>]
+      # @param signature [Pin::Signature]
+      # @return [Boolean]
+      def arity_matches? arguments, with_block
+        argcount = arguments.length
+        parcount = mandatory_positional_param_count
+        parcount -= 1 if !parameters.empty? && parameters.last.block?
+        return false if block? && !with_block
+        return false if argcount < parcount && !(argcount == parcount - 1 && parameters.last.restarg?)
+        true
+      end
+
+      def mandatory_positional_param_count
+        parameters.count(&:arg?)
+      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
+
+      def block?
+        !!@block
+      end
+
+      protected
+
+      attr_writer :block
+
+      attr_writer :parameters
+    end
+  end
+end

data/lib/solargraph/pin/closure.rb

@@ -18,7 +18,7 @@ module Solargraph
         @context ||= begin
           result = super
           if scope == :instance
-            Solargraph::ComplexType.parse(result.namespace)
+            result.reduce_class_type
           else
             result
           end
@@ -42,10 +42,15 @@ module Solargraph
       end
 
       # @return [String]
-      def generics_as_rbs
+      def to_rbs
+        rbs_generics + return_type.to_rbs
+      end
+
+      # @return [String]
+      def rbs_generics
         return '' if generics.empty?
 
-        generics.join(', ') + ' '
+        '[' + generics.map { |gen| gen.to_s }.join(', ') + '] '
       end
     end
   end

data/lib/solargraph/pin/common.rb

@@ -19,7 +19,7 @@ module Solargraph
         @return_type ||= ComplexType::UNDEFINED
       end
 
-      # @return [ComplexType, Array<UniqueType>]
+      # @return [ComplexType]
       def context
         # Get the static context from the nearest namespace
         @context ||= find_context
@@ -59,11 +59,7 @@ module Solargraph
           if here.is_a?(Pin::Namespace)
             return here.return_type
           elsif here.is_a?(Pin::Method)
-            if here.scope == :instance
-              return ComplexType.try_parse(here.context.tag)
-            else
-              return here.context
-            end
+            return here.context
           end
           here = here.closure
         end

data/lib/solargraph/pin/conversions.rb

@@ -87,7 +87,7 @@ module Solargraph
 
       # @return [String, nil]
       def text_documentation
-        this_path = path || return_type.tag
+        this_path = path || name || return_type.tag
         return nil if this_path == 'undefined'
         escape_brackets this_path
       end
@@ -105,9 +105,10 @@ module Solargraph
 
       # @return [String, nil]
       def generate_link
-        this_path = path || return_type.tag
+        this_path = path || name || return_type.tag
         return nil if this_path == 'undefined'
         return nil if this_path.nil? || this_path == 'undefined'
+        return this_path if path.nil?
         "[#{escape_brackets(this_path).gsub('_', '\\\\_')}](solargraph:/document?query=#{CGI.escape(this_path)})"
       end
 

data/lib/solargraph/pin/instance_variable.rb

@@ -18,9 +18,9 @@ module Solargraph
         @context ||= begin
           result = super
           if scope == :class
-            ComplexType.parse("Class<#{result.namespace}>")
+            ComplexType.parse("::Class<#{result.rooted_namespace}>")
           else
-            ComplexType.parse("#{result.namespace}")
+            result.reduce_class_type
           end
         end
       end

data/lib/solargraph/pin/method.rb

@@ -4,12 +4,9 @@ module Solargraph
   module Pin
     # The base class for method and attribute pins.
     #
-    class Method < Closure
+    class Method < Callable
       include Solargraph::Parser::NodeMethods
 
-      # @return [::Array<Pin::Parameter>]
-      attr_reader :parameters
-
       # @return [::Symbol] :public, :private, or :protected
       attr_reader :visibility
 
@@ -18,24 +15,20 @@ module Solargraph
 
       # @param visibility [::Symbol] :public, :protected, or :private
       # @param explicit [Boolean]
-      # @param parameters [::Array<Pin::Parameter>]
       # @param block [Pin::Signature, nil, ::Symbol]
-      # @param node [Parser::AST::Node, RubyVM::AbstractSyntaxTree::Node, nil]
+      # @param node [Parser::AST::Node, nil]
       # @param attribute [Boolean]
       # @param signatures [::Array<Signature>, nil]
       # @param anon_splat [Boolean]
-      # @param return_type [ComplexType, nil]
-      def initialize visibility: :public, explicit: true, parameters: [], block: :undefined, node: nil, attribute: false, signatures: nil, anon_splat: false, return_type: nil, **splat
+      def initialize visibility: :public, explicit: true, block: :undefined, node: nil, attribute: false, signatures: nil, anon_splat: false, **splat
         super(**splat)
         @visibility = visibility
         @explicit = explicit
-        @parameters = parameters
         @block = block
         @node = node
         @attribute = attribute
         @signatures = signatures
         @anon_splat = anon_splat
-        @return_type = return_type
       end
 
       def transform_types(&transform)
@@ -44,15 +37,16 @@ module Solargraph
         m.signatures = m.signatures.map do |sig|
           sig.transform_types(&transform)
         end
-        m.parameters = m.parameters.map do |param|
-          param.transform_types(&transform)
-        end
         m.block = block&.transform_types(&transform)
         m.signature_help = nil
         m.documentation = nil
         m
       end
 
+      def all_rooted?
+        super && parameters.all?(&:all_rooted?) && (!block || block&.all_rooted?) && signatures.all?(&:all_rooted?)
+      end
+
       # @param signature [Pin::Signature]
       # @return [Pin::Method]
       def with_single_signature(signature)
@@ -71,15 +65,14 @@ module Solargraph
         m
       end
 
+      def block?
+        !block.nil?
+      end
+
       # @return [Pin::Signature, nil]
       def block
         return @block unless @block == :undefined
-        @block = signatures.first.block
-      end
-
-      # @return [::Array<String>]
-      def parameter_names
-        @parameter_names ||= parameters.map(&:name)
+        @block = signatures.first&.block
       end
 
       def completion_item_kind
@@ -123,9 +116,9 @@ module Solargraph
             )
           end
           yield_return_type = ComplexType.try_parse(*yieldreturn_tags.flat_map(&:types))
-          block = Signature.new(generics, yield_parameters, yield_return_type)
+          block = Signature.new(generics: generics, parameters: yield_parameters, return_type: yield_return_type)
         end
-        Signature.new(generics, parameters, return_type, block)
+        Signature.new(generics: generics, parameters: parameters, return_type: return_type, block: block)
       end
 
       # @return [::Array<Signature>]
@@ -270,9 +263,9 @@ module Solargraph
       end
 
       def nearly? other
-        return false unless super
-        parameters == other.parameters and
-          scope == other.scope and
+        super &&
+          parameters == other.parameters &&
+          scope == other.scope &&
           visibility == other.visibility
       end
 
@@ -283,6 +276,7 @@ module Solargraph
       def try_merge! pin
         return false unless super
         @node = pin.node
+        @resolved_ref_tag = false
         true
       end
 
@@ -292,8 +286,8 @@ module Solargraph
         # tag's source is likely malformed.
         @overloads ||= docstring.tags(:overload).select(&:parameters).map do |tag|
           Pin::Signature.new(
-            generics,
-            tag.parameters.map do |src|
+            generics: generics,
+            parameters: tag.parameters.map do |src|
               name, decl = parse_overload_param(src.first)
               Pin::Parameter.new(
                 location: location,
@@ -305,7 +299,7 @@ module Solargraph
                 return_type: param_type_from_name(tag, src.first)
               )
             end,
-            ComplexType.try_parse(*tag.docstring.tags(:return).flat_map(&:types))
+            return_type: ComplexType.try_parse(*tag.docstring.tags(:return).flat_map(&:types))
           )
         end
         @overloads
@@ -315,12 +309,33 @@ module Solargraph
         @anon_splat
       end
 
+      # @param [ApiMap]
+      # @return [self]
+      def resolve_ref_tag api_map
+        return self if @resolved_ref_tag
+
+        @resolved_ref_tag = true
+        return self unless docstring.ref_tags.any?
+        docstring.ref_tags.each do |tag|
+          ref = if tag.owner.to_s.start_with?(/[#\.]/)
+            api_map.get_methods(namespace)
+                   .select { |pin| pin.path.end_with?(tag.owner.to_s) }
+                   .first
+          else
+            # @todo Resolve relative namespaces
+            api_map.get_path_pins(tag.owner.to_s).first
+          end
+          next unless ref
+
+          docstring.add_tag(*ref.docstring.tags(:param))
+        end
+        self
+      end
+
       protected
 
       attr_writer :block
 
-      attr_writer :parameters
-
       attr_writer :signatures
 
       attr_writer :signature_help
@@ -452,7 +467,7 @@ module Solargraph
         end
         result.push ComplexType::NIL if has_nil
         return ComplexType::UNDEFINED if result.empty?
-        ComplexType.try_parse(*result.map(&:tag).uniq)
+        ComplexType.new(result.uniq)
       end
 
       # @param [ApiMap] api_map
@@ -467,7 +482,7 @@ module Solargraph
           types.push type if type.defined?
         end
         return ComplexType::UNDEFINED if types.empty?
-        ComplexType.try_parse(*types.map(&:tag).uniq)
+        ComplexType.new(types.uniq)
       end
 
       # When YARD parses an overload tag, it includes rest modifiers in the parameters names.
@@ -475,6 +490,7 @@ module Solargraph
       # @param name [String]
       # @return [::Array(String, ::Symbol)]
       def parse_overload_param(name)
+        # @todo this needs to handle mandatory vs not args, kwargs, blocks, etc
         if name.start_with?('**')
           [name[2..-1], :kwrestarg]
         elsif name.start_with?('*')
@@ -496,6 +512,10 @@ module Solargraph
         .join("\n")
         .concat("```\n")
       end
+
+      protected
+
+      attr_writer :signatures
     end
   end
 end

data/lib/solargraph/pin/namespace.rb

@@ -41,11 +41,11 @@ module Solargraph
       end
 
       def to_rbs
-        "#{@type.to_s} #{generics_as_rbs}#{return_type.to_rbs}"
+        "#{@type.to_s} #{return_type.all_params.first.to_rbs}#{rbs_generics}".strip
       end
 
       def desc
-        if name.nil?
+        if name.nil? || name.empty?
           '(top-level)'
         else
           to_rbs
@@ -57,7 +57,7 @@ module Solargraph
       end
 
       def full_context
-        @full_context ||= ComplexType.try_parse("#{type.to_s.capitalize}<#{path}>")
+        @full_context ||= ComplexType.try_parse("::#{type.to_s.capitalize}<#{path}>")
       end
 
       def binder
@@ -83,7 +83,7 @@ module Solargraph
       end
 
       def return_type
-        @return_type ||= ComplexType.try_parse( (type == :class ? 'Class' : 'Module') + "<#{path}>" )
+        @return_type ||= ComplexType.try_parse( (type == :class ? '::Class' : '::Module') + "<::#{path}>")
       end
 
       # @return [Array<String>]

data/lib/solargraph/pin/parameter.rb

@@ -27,6 +27,10 @@ module Solargraph
         decl == :kwrestarg || (assignment && [:HASH, :hash].include?(assignment.type))
       end
 
+      def arg?
+        decl == :arg
+      end
+
       def restarg?
         decl == :restarg
       end
@@ -84,11 +88,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
@@ -126,17 +130,11 @@ module Solargraph
 
       # @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]

data/lib/solargraph/pin/proxy_type.rb

@@ -18,7 +18,7 @@ module Solargraph
       def self.anonymous return_type
         parts = return_type.namespace.split('::')
         namespace = parts[0..-2].join('::').to_s
-        name = parts.last.to_s
+        # 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