solargraph 0.54.0 → 0.58.0

data/lib/solargraph/pin/block.rb

@@ -2,7 +2,9 @@
 
 module Solargraph
   module Pin
-    class Block < Closure
+    class Block < Callable
+      include Breakable
+
       # @return [Parser::AST::Node]
       attr_reader :receiver
 
@@ -14,10 +16,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 +33,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)
@@ -72,6 +54,7 @@ module Solargraph
         locals = clip.locals - [self]
         meths = chain.define(api_map, closure, locals)
         # @todo Convert logic to use signatures
+        # @param meth [Pin::Method]
         meths.each do |meth|
           next if meth.block.nil?
 
@@ -87,7 +70,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.gates)
               end
             end
           end
@@ -105,7 +88,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 +97,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.gates).self_to_type(target)
       end
     end
   end

data/lib/solargraph/pin/breakable.rb

@@ -0,0 +1,9 @@
+module Solargraph
+  module Pin
+    # Mix-in for pins which enclose code which the 'break' statement works with-in - e.g., blocks, when, until, ...
+    module Breakable
+      # @return [Parser::AST::Node]
+      attr_reader :node
+    end
+  end
+end

data/lib/solargraph/pin/callable.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Callable < Closure
+      # @return [Signature]
+      attr_reader :block
+
+      attr_accessor :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 [String]
+      def method_namespace
+        closure.namespace
+      end
+
+      # @param other [self]
+      #
+      # @return [Pin::Signature, nil]
+      def combine_blocks(other)
+        if block.nil?
+          other.block
+        elsif other.block.nil?
+          block
+        else
+          # @type [Pin::Signature, nil]
+          choose_pin_attr(other, :block)
+        end
+      end
+
+      # @param other [self]
+      # @param attrs [Hash{Symbol => Object}]
+      #
+      # @return [self]
+      def combine_with(other, attrs={})
+        new_attrs = {
+          block: combine_blocks(other),
+          return_type: combine_return_type(other),
+        }.merge(attrs)
+        new_attrs[:parameters] = choose_parameters(other).clone.freeze unless new_attrs.key?(:parameters)
+        super(other, new_attrs)
+      end
+
+      # @return [::Array<String>]
+      def parameter_names
+        @parameter_names ||= parameters.map(&:name)
+      end
+
+      def generics
+        []
+      end
+
+      # @param other [self]
+      #
+      # @return [Array<Pin::Parameter>]
+      def choose_parameters(other)
+        raise "Trying to combine two pins with different arities - \nself =#{inspect}, \nother=#{other.inspect}, \n\n self.arity=#{self.arity}, \nother.arity=#{other.arity}" if other.arity != arity
+        # @param param [Pin::Parameter]
+        # @param other_param [Pin::Parameter]
+        parameters.zip(other.parameters).map do |param, other_param|
+          if param.nil? && other_param.block?
+            other_param
+          elsif other_param.nil? && param.block?
+            param
+          else
+            param.combine_with(other_param)
+          end
+        end
+      end
+
+      # @return [Array<Pin::Parameter>]
+      def blockless_parameters
+        if parameters.last&.block?
+          parameters[0..-2]
+        else
+          parameters
+        end
+      end
+
+      # @return [Array]
+      def arity
+        [generics, blockless_parameters.map(&:arity_decl), block&.arity]
+      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
+
+      def typify api_map
+        type = super
+        return type if type.defined?
+        if method_name.end_with?('?')
+          logger.debug { "Callable#typify(self=#{self}) => Boolean (? suffix)" }
+          ComplexType::BOOLEAN
+        else
+          logger.debug { "Callable#typify(self=#{self}) => undefined" }
+          ComplexType::UNDEFINED
+        end
+      end
+
+      # @return [String]
+      def method_name
+        raise "closure was nil in #{self.inspect}" if closure.nil?
+        @method_name ||= closure.name
+      end
+
+      # @param generics_to_resolve [::Array<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 with_block [Boolean]
+      # @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
+
+      # @return [Integer]
+      def mandatory_positional_param_count
+        parameters.count(&:arg?)
+      end
+
+      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
+    end
+  end
+end

data/lib/solargraph/pin/closure.rb

@@ -8,17 +8,36 @@ module Solargraph
 
       # @param scope [::Symbol] :class or :instance
       # @param generics [::Array<Pin::Parameter>, nil]
-      def initialize scope: :class, generics: nil, **splat
+      # @param generic_defaults [Hash{String => ComplexType}]
+      def initialize scope: :class, generics: nil, generic_defaults: {},  **splat
         super(**splat)
         @scope = scope
         @generics = generics
+        @generic_defaults = generic_defaults
+      end
+
+      # @return [Hash{String => ComplexType}]
+      def generic_defaults
+        @generic_defaults ||= {}
+      end
+
+      # @param other [self]
+      # @param attrs [Hash{Symbol => Object}]
+      #
+      # @return [self]
+      def combine_with(other, attrs={})
+        new_attrs = {
+          scope: assert_same(other, :scope),
+          generics: generics.empty? ? other.generics : generics,
+        }.merge(attrs)
+        super(other, new_attrs)
       end
 
       def context
         @context ||= begin
           result = super
           if scope == :instance
-            Solargraph::ComplexType.parse(result.namespace)
+            result.reduce_class_type
           else
             result
           end
@@ -29,23 +48,24 @@ module Solargraph
         @binder || context
       end
 
-      # @return [::Array<String>]
-      def gates
-        # @todo This check might not be necessary. There should always be a
-        #   root pin
-        closure ? closure.gates : ['']
-      end
+      # @param api_map [Solargraph::ApiMap]
+      # @return [void]
+      def rebind api_map; end
 
       # @return [::Array<String>]
       def generics
         @generics ||= docstring.tags(:generic).map(&:name)
       end
 
+      def to_rbs
+        rbs_generics + return_type.to_rbs
+      end
+
       # @return [String]
-      def generics_as_rbs
+      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

@@ -3,11 +3,20 @@
 module Solargraph
   module Pin
     module Common
+      # @!method source
+      #   @abstract
+      #   @return [Source, nil]
+      # @type @closure [Pin::Closure, nil]
+
       # @return [Location]
       attr_reader :location
 
+      # @sg-ignore Solargraph::Pin::Common#closure return type could not be inferred
       # @return [Pin::Closure, nil]
-      attr_reader :closure
+      def closure
+        Solargraph.assert_or_log(:closure, "Closure not set on #{self.class} #{name.inspect} from #{source.inspect}") unless @closure
+        @closure
+      end
 
       # @return [String]
       def name
@@ -19,7 +28,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 +68,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/constant.rb

@@ -5,6 +5,8 @@ module Solargraph
     class Constant < BaseVariable
       attr_reader :visibility
 
+      # @param visibility [::Symbol] The visibility of the constant (:public, :protected, or :private)
+      # @param splat [Hash] Additional options supported by superclasses
       def initialize visibility: :public, **splat
         super(**splat)
         @visibility = visibility

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/delegated_method.rb

@@ -24,8 +24,26 @@ module Solargraph
         @receiver_method_name = receiver_method_name
       end
 
-      %i[comments parameters return_type location].each do |method|
+      def inner_desc
+        "#{name} => #{@receiver_chain}##{@receiver_method_name}"
+      end
+
+      def location
+        return super if super
+
+        @resolved_method&.send(:location)
+      end
+
+
+      def type_location
+        return super if super
+
+        @resolved_method&.send(:type_location)
+      end
+
+      %i[comments parameters return_type signatures].each do |method|
         define_method(method) do
+          # @sg-ignore Need to set context correctly in define_method blocks
           @resolved_method ? @resolved_method.send(method) : super()
         end
       end
@@ -34,6 +52,7 @@ module Solargraph
         # @param api_map [ApiMap]
         define_method(method) do |api_map|
           resolve_method(api_map)
+          # @sg-ignore Need to set context correctly in define_method blocks
           @resolved_method ? @resolved_method.send(method, api_map) : super(api_map)
         end
       end

data/lib/solargraph/pin/documenting.rb

@@ -9,6 +9,22 @@ require 'solargraph/converters/dt'
 require 'solargraph/converters/dd'
 require 'solargraph/converters/misc'
 
+# @todo upstream this definition
+
+# @!parse
+#   module ::Kramdown
+#     class Document
+#       # @return [String]
+#       def to_html; end
+#     end
+#   end
+#   module ReverseMarkdown
+#     # @param input [String]
+#     # @param options [Hash]
+#     # @return [String]
+#     def self.convert(input, options = {}); end
+#   end
+
 module Solargraph
   module Pin
     # A module to add the Pin::Base#documentation method.

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/keyword.rb

@@ -3,8 +3,13 @@
 module Solargraph
   module Pin
     class Keyword < Base
-      def initialize name
-        super(name: name)
+      def initialize(name, **kwargs)
+        # @sg-ignore "Unrecognized keyword argument kwargs to Solargraph::Pin::Base#initialize"
+        super(name: name, **kwargs)
+      end
+
+      def closure
+        @closure ||= Pin::ROOT_PIN
       end
 
       def name

data/lib/solargraph/pin/local_variable.rb

@@ -6,20 +6,29 @@ module Solargraph
       # @return [Range]
       attr_reader :presence
 
+      def presence_certain?
+        @presence_certain
+      end
+
       # @param assignment [AST::Node, nil]
       # @param presence [Range, nil]
+      # @param presence_certain [Boolean]
       # @param splat [Hash]
-      def initialize assignment: nil, presence: nil, **splat
+      def initialize assignment: nil, presence: nil, presence_certain: false, **splat
         super(**splat)
         @assignment = assignment
         @presence = presence
+        @presence_certain = presence_certain
       end
 
-      # @param pin [self]
-      def try_merge! pin
-        return false unless super
-        @presence = pin.presence
-        true
+      def combine_with(other, attrs={})
+        new_attrs = {
+          assignment: assert_same(other, :assignment),
+          presence_certain: assert_same(other, :presence_certain?),
+        }.merge(attrs)
+        new_attrs[:presence] = assert_same(other, :presence) unless attrs.key?(:presence)
+
+        super(other, new_attrs)
       end
 
       # @param other_closure [Pin::Closure]
@@ -30,7 +39,6 @@ module Solargraph
           match_named_closure(other_closure, closure)
       end
 
-      # @return [String]
       def to_rbs
         (name || '(anon)') + ' ' + (return_type&.to_rbs || 'untyped')
       end