solargraph 0.51.2 → 0.54.2

data/lib/solargraph/pin/block.rb

@@ -2,76 +2,99 @@
 
 module Solargraph
   module Pin
-    class Block < Closure
-      # The signature of the method that receives this block.
-      #
+    class Block < Callable
       # @return [Parser::AST::Node]
       attr_reader :receiver
 
-      # @param args [Array<Parameter>]
-      def initialize receiver: nil, args: [], context: nil, **splat
-        super(**splat)
+      # @return [Parser::AST::Node]
+      attr_reader :node
+
+      # @param receiver [Parser::AST::Node, nil]
+      # @param node [Parser::AST::Node, nil]
+      # @param context [ComplexType, nil]
+      # @param args [::Array<Parameter>]
+      def initialize receiver: nil, args: [], context: nil, node: nil, **splat
+        super(**splat, parameters: args)
         @receiver = receiver
         @context = context
-        @parameters = args
+        @return_type = ComplexType.parse('::Proc')
+        @node = node
       end
 
       # @param api_map [ApiMap]
       # @return [void]
       def rebind api_map
-        @binder ||= binder_or_nil(api_map)
+        @rebind ||= maybe_rebind(api_map)
       end
 
       def binder
-        @binder || closure.binder
+        @rebind&.defined? ? @rebind : closure.binder
       end
 
-      # @return [Array<Parameter>]
-      def parameters
-        @parameters ||= []
+      # @param yield_types [::Array<ComplexType>]
+      # @param parameters [::Array<Parameter>]
+      #
+      # @return [::Array<ComplexType>]
+      def destructure_yield_types(yield_types, parameters)
+        # 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.with_index { |_, idx| yield_types[idx] || ComplexType::UNDEFINED }
       end
 
-      # @return [Array<String>]
-      def parameter_names
-        @parameter_names ||= parameters.map(&:name)
+      # @param api_map [ApiMap]
+      # @return [::Array<ComplexType>]
+      def typify_parameters(api_map)
+        chain = Parser.chain(receiver, filename, node)
+        clip = api_map.clip_at(location.filename, location.range.start)
+        locals = clip.locals - [self]
+        meths = chain.define(api_map, closure, locals)
+        # @todo Convert logic to use signatures
+        meths.each do |meth|
+          next if meth.block.nil?
+
+          yield_types = meth.block.parameters.map(&:return_type)
+          # 'arguments' is what the method says it will yield to the
+          # block; 'parameters' is what the block accepts
+          argument_types = destructure_yield_types(yield_types, parameters)
+          param_types = argument_types.each_with_index.map do |arg_type, idx|
+            param = parameters[idx]
+            param_type = chain.base.infer(api_map, param, locals)
+            unless arg_type.nil?
+              if arg_type.generic? && param_type.defined?
+                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_type(chain.base.infer(api_map, self, locals)).qualify(api_map, meth.context.namespace)
+              end
+            end
+          end
+          return param_types if param_types.all?(&:defined?)
+        end
+        parameters.map { ComplexType::UNDEFINED }
       end
 
       private
 
       # @param api_map [ApiMap]
-      # @return [ComplexType, nil]
-      def binder_or_nil api_map
-        return nil unless receiver
-        word = receiver.children.find { |c| c.is_a?(::Symbol) }.to_s
-        return nil unless api_map.rebindable_method_names.include?(word)
+      # @return [ComplexType]
+      def maybe_rebind api_map
+        return ComplexType::UNDEFINED unless receiver
+
         chain = Parser.chain(receiver, location.filename)
         locals = api_map.source_map(location.filename).locals_at(location)
-        links_last_word = chain.links.last.word
-        if %w[instance_eval instance_exec class_eval class_exec module_eval module_exec].include?(links_last_word)
-          return chain.base.infer(api_map, self, locals)
-        end
-        if 'define_method' == links_last_word and chain.define(api_map, self, locals).first&.path == 'Module#define_method' # change class type to instance type
-          if chain.links.size > 1 # Class.define_method
-            ty = chain.base.infer(api_map, self, locals)
-            return Solargraph::ComplexType.parse(ty.namespace)
-          else # define_method without self
-            return Solargraph::ComplexType.parse(closure.binder.namespace)
-          end
-        end
-        # other case without early return, read block yieldself tags
-        receiver_pin = chain.define(api_map, self, locals).first
-        if receiver_pin && receiver_pin.docstring
-          ys = receiver_pin.docstring.tag(:yieldself)
-          if ys && ys.types && !ys.types.empty?
-            target = if chain.links.first.is_a?(Source::Chain::Constant)
-              receiver_pin.full_context.namespace
-            else
-              full_context.namespace
-            end
-            return ComplexType.try_parse(*ys.types).qualify(api_map, receiver_pin.context.namespace).self_to(target)
-          end
-        end
-        nil
+        receiver_pin = chain.define(api_map, closure, locals).first
+        return ComplexType::UNDEFINED unless receiver_pin
+
+        types = receiver_pin.docstring.tag(:yieldreceiver)&.types
+        return ComplexType::UNDEFINED unless types&.any?
+
+        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_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

@@ -6,16 +6,19 @@ module Solargraph
       # @return [::Symbol] :class or :instance
       attr_reader :scope
 
-      def initialize scope: :class, **splat
+      # @param scope [::Symbol] :class or :instance
+      # @param generics [::Array<Pin::Parameter>, nil]
+      def initialize scope: :class, generics: nil, **splat
         super(**splat)
         @scope = scope
+        @generics = generics
       end
 
       def context
         @context ||= begin
           result = super
           if scope == :instance
-            Solargraph::ComplexType.parse(result.namespace)
+            result.reduce_class_type
           else
             result
           end
@@ -26,12 +29,29 @@ module Solargraph
         @binder || context
       end
 
-      # @return [Array<String>]
+      # @return [::Array<String>]
       def gates
         # @todo This check might not be necessary. There should always be a
         #   root pin
         closure ? closure.gates : ['']
       end
+
+      # @return [::Array<String>]
+      def generics
+        @generics ||= docstring.tags(:generic).map(&:name)
+      end
+
+      # @return [String]
+      def to_rbs
+        rbs_generics + return_type.to_rbs
+      end
+
+      # @return [String]
+      def rbs_generics
+        return '' if generics.empty?
+
+        '[' + generics.map { |gen| gen.to_s }.join(', ') + '] '
+      end
     end
   end
 end

data/lib/solargraph/pin/common.rb

@@ -6,7 +6,7 @@ module Solargraph
       # @return [Location]
       attr_reader :location
 
-      # @return [Pin::Base, nil]
+      # @return [Pin::Closure, nil]
       attr_reader :closure
 
       # @return [String]
@@ -46,6 +46,10 @@ module Solargraph
         @path ||= name.empty? ? context.namespace : "#{context.namespace}::#{name}"
       end
 
+      protected
+
+      attr_writer :context
+
       private
 
       # @return [ComplexType]
@@ -55,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.namespace)
-            else
-              return here.context
-            end
+            return here.context
           end
           here = here.closure
         end

data/lib/solargraph/pin/conversions.rb

@@ -5,7 +5,35 @@ require 'cgi'
 module Solargraph
   module Pin
     # @todo Move this stuff. It should be the responsibility of the language server.
+    # @todo abstract methods below should be verified to be overridden
+    #   by type checker when mixin included by non-abstract class
     module Conversions
+      # @!parse
+      #   include Documenting
+      #   include Common
+
+      # @return [Integer]
+      # @abstract
+      def completion_item_kind
+        raise NotImplementedError
+      end
+
+      # @abstract
+      # @return [Boolean]
+      def deprecated?
+        raise NotImplementedError
+      end
+
+      # @abstract
+      def probed?
+        raise NotImplementedError
+      end
+
+      # @abstract
+      def proxied?
+        raise NotImplementedError
+      end
+
       # @return [Hash]
       def completion_item
         @completion_item ||= {
@@ -34,12 +62,12 @@ module Solargraph
         end
       end
 
-      # @return [Array<Hash>]
+      # @return [::Array<Hash>]
       def signature_help
         []
       end
 
-      # @return [String]
+      # @return [String, nil]
       def detail
         # This property is not cached in an instance variable because it can
         # change when pins get proxied.
@@ -57,12 +85,14 @@ module Solargraph
         @link_documentation ||= generate_link
       end
 
+      # @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
 
+      # @return [void]
       def reset_conversions
         @completion_item = nil
         @resolve_completion_item = nil
@@ -73,11 +103,12 @@ module Solargraph
 
       private
 
-      # @return [String]
+      # @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

@@ -11,8 +11,9 @@ module Solargraph
       # given closure/scope, and the delegated method will then be resolved
       # to a method pin on that type.
       #
-      # @param resolved_method [Method] an already resolved method pin.
-      # @param receiver [Source::Chain] the source code used to resolve the receiver for this delegated method.
+      # @param method [Method, nil] an already resolved method pin.
+      # @param receiver [Source::Chain, nil] the source code used to resolve the receiver for this delegated method.
+      # @param name [String]
       # @param receiver_method_name [String] the method name that will be called on the receiver (defaults to :name).
       def initialize(method: nil, receiver: nil, name: method&.name, receiver_method_name: name, **splat)
         raise ArgumentError, 'either :method or :receiver is required' if (method && receiver) || (!method && !receiver)
@@ -37,6 +38,7 @@ module Solargraph
         end
       end
 
+      # @param api_map [ApiMap]
       def resolvable?(api_map)
         resolve_method(api_map)
         !!@resolved_method
@@ -79,6 +81,7 @@ module Solargraph
       # helper to print a source chain as code, probably not 100% correct.
       #
       # @param chain [Source::Chain]
+      # @return [String]
       def print_chain(chain)
         out = +''
         chain.links.each_with_index do |link, index|
@@ -91,6 +94,7 @@ module Solargraph
           end
           out << link.word
         end
+        out
       end
     end
   end

data/lib/solargraph/pin/documenting.rb

@@ -38,23 +38,20 @@ module Solargraph
         end
 
         def to_s
-          return "\n```ruby\n#{@plaintext}#{@plaintext.end_with?("\n") ? '' : "\n"}```\n\n" if code?
-          ReverseMarkdown.convert unescape_brackets(Kramdown::Document.new(escape_brackets(@plaintext), input: 'GFM').to_html)
+          return to_code if code?
+          to_markdown
         end
 
         private
 
-        # @param text [String]
         # @return [String]
-        def escape_brackets text
-          # text.gsub(/(\[[^\]]*\])([^\(]|\z)/, '!!!^\1^!!!\2')
-          text.gsub('[', '!!!!b').gsub(']', 'e!!!!')
+        def to_code
+          "\n```ruby\n#{Documenting.normalize_indentation(@plaintext)}#{@plaintext.end_with?("\n") ? '' : "\n"}```\n\n"
         end
 
-        # @param text [String]
         # @return [String]
-        def unescape_brackets text
-          text.gsub('!!!!b', '[').gsub('e!!!!', ']')
+        def to_markdown
+          ReverseMarkdown.convert Kramdown::Document.new(@plaintext, input: 'GFM').to_html
         end
       end
 
@@ -65,40 +62,36 @@ module Solargraph
           # line and at least two spaces of indentation. This is a common
           # convention in Ruby core documentation, e.g., String#split.
           sections = [DocSection.new(false)]
-          normalize_indentation(docstring.to_s).gsub(/\t/, '  ').lines.each do |l|
-            if l.strip.empty?
-              sections.last.concat l
-            else
-              if (l =~ /^  [^\s]/ && sections.last.plaintext =~ /(\r?\n[ \t]*?){2,}$/) || (l.start_with?('  ') && sections.last.code?)
-                # Code block
-                sections.push DocSection.new(true) unless sections.last.code?
-                sections.last.concat l[2..-1]
-              else
-                # Regular documentation
-                sections.push DocSection.new(false) if sections.last.code?
-                sections.last.concat l
-              end
+          Documenting.normalize_indentation(Documenting.strip_html_comments(docstring.to_s.gsub("\t", '  '))).lines.each do |l|
+            if l.start_with?('  ')
+              # Code block
+              sections.push DocSection.new(true) unless sections.last.code?
+            elsif sections.last.code?
+              # Regular documentation
+              sections.push DocSection.new(false)
             end
+            sections.last.concat l
           end
           sections.map(&:to_s).join.strip
         end
       end
 
-      private
-
       # @param text [String]
       # @return [String]
-      def normalize_indentation text
-        text.lines.map { |l| remove_odd_spaces(l) }.join
+      def self.strip_html_comments text
+        text.gsub(/<!--([\s\S]*?)-->/, '').strip
       end
 
-      # @param line [String]
+      # @param text [String]
       # @return [String]
-      def remove_odd_spaces line
-        return line unless line.start_with?(' ')
-        spaces = line.match(/^ +/)[0].length
-        return line unless spaces.odd?
-        line[1..-1]
+      def self.normalize_indentation text
+        left = text.lines.map do |line|
+          match = line.match(/^ +/)
+          next 0 unless match
+          match[0].length
+        end.min
+        return text if left.nil? || left.zero?
+        text.lines.map { |line| line[left..] }.join
       end
     end
   end

data/lib/solargraph/pin/instance_variable.rb

@@ -3,25 +3,29 @@
 module Solargraph
   module Pin
     class InstanceVariable < BaseVariable
+      # @return [ComplexType]
       def binder
         closure.binder
       end
 
+      # @return [::Symbol]
       def scope
         closure.binder.scope
       end
 
+      # @return [ComplexType]
       def context
         @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
 
+      # @param other [InstanceVariable]
       def nearly? other
         super && binder == other.binder
       end

data/lib/solargraph/pin/local_variable.rb

@@ -6,12 +6,16 @@ module Solargraph
       # @return [Range]
       attr_reader :presence
 
+      # @param assignment [AST::Node, nil]
+      # @param presence [Range, nil]
+      # @param splat [Hash]
       def initialize assignment: nil, presence: nil, **splat
         super(**splat)
         @assignment = assignment
         @presence = presence
       end
 
+      # @param pin [self]
       def try_merge! pin
         return false unless super
         @presence = pin.presence
@@ -21,11 +25,16 @@ module Solargraph
       # @param other_closure [Pin::Closure]
       # @param other_loc [Location]
       def visible_at?(other_closure, other_loc)
-        return true if location.filename == other_loc.filename &&
+        location.filename == other_loc.filename &&
           presence.include?(other_loc.range.start) &&
           match_named_closure(other_closure, closure)
       end
 
+      # @return [String]
+      def to_rbs
+        (name || '(anon)') + ' ' + (return_type&.to_rbs || 'untyped')
+      end
+
       private
 
       # @param tag1 [String]
@@ -40,6 +49,9 @@ module Solargraph
           (['', 'Class<>'].include?(tag1) && ['', 'Class<>'].include?(tag2))
       end
 
+      # @param needle [Pin::Base]
+      # @param haystack [Pin::Base]
+      # @return [Boolean]
       def match_named_closure needle, haystack
         return true if needle == haystack || haystack.is_a?(Pin::Block)
         cursor = haystack