solargraph 0.47.2 → 0.53.3

data/lib/solargraph/pin/signature.rb

@@ -0,0 +1,143 @@
+module Solargraph
+  module Pin
+    class Signature < Base
+      # @return [::Array<Parameter>]
+      attr_reader :parameters
+
+      # @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
+      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
+      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
+
+      # @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
+      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
+
+      def identity
+        @identity ||= "signature#{object_id}"
+      end
+
+      def block?
+        !!@block
+      end
+
+      protected
+
+      attr_writer :block
+
+      attr_writer :parameters
+    end
+  end
+end

data/lib/solargraph/pin.rb

@@ -10,7 +10,9 @@ module Solargraph
     autoload :Conversions,      'solargraph/pin/conversions'
     autoload :Base,             'solargraph/pin/base'
     autoload :Method,           'solargraph/pin/method'
+    autoload :Signature,        'solargraph/pin/signature'
     autoload :MethodAlias,      'solargraph/pin/method_alias'
+    autoload :DelegatedMethod,  'solargraph/pin/delegated_method'
     autoload :BaseVariable,     'solargraph/pin/base_variable'
     autoload :InstanceVariable, 'solargraph/pin/instance_variable'
     autoload :ClassVariable,    'solargraph/pin/class_variable'
@@ -25,7 +27,6 @@ module Solargraph
     autoload :Reference,        'solargraph/pin/reference'
     autoload :Documenting,      'solargraph/pin/documenting'
     autoload :Block,            'solargraph/pin/block'
-    autoload :Localized,        'solargraph/pin/localized'
     autoload :ProxyType,        'solargraph/pin/proxy_type'
     autoload :DuckMethod,       'solargraph/pin/duck_method'
     autoload :Singleton,        'solargraph/pin/singleton'

data/lib/solargraph/range.rb

@@ -62,13 +62,11 @@ module Solargraph
 
     # Get a range from a node.
     #
-    # @param node [RubyVM::AbstractSyntaxTree::Node, Parser::AST::Node]
-    # @return [Range]
+    # @param node [Parser::AST::Node]
+    # @return [Range, nil]
     def self.from_node node
-      if defined?(RubyVM::AbstractSyntaxTree::Node)
-        if node.is_a?(RubyVM::AbstractSyntaxTree::Node)
-          Solargraph::Range.from_to(node.first_lineno - 1, node.first_column, node.last_lineno - 1, node.last_column)
-        end
+      if Parser.rubyvm? && node.is_a?(RubyVM::AbstractSyntaxTree::Node)
+        Solargraph::Range.from_to(node.first_lineno - 1, node.first_column, node.last_lineno - 1, node.last_column)
       elsif node&.loc && node.loc.expression
         from_expr(node.loc.expression)
       end