solargraph 0.50.0 → 0.53.0

data/lib/solargraph/pin/reference.rb

@@ -9,6 +9,14 @@ module Solargraph
       autoload :Prepend,    'solargraph/pin/reference/prepend'
       autoload :Extend,     'solargraph/pin/reference/extend'
       autoload :Override,   'solargraph/pin/reference/override'
+
+      attr_reader :generic_values
+
+      # @param generic_values [Array<String>]
+      def initialize generic_values: [], **splat
+        super(**splat)
+        @generic_values = generic_values
+      end
     end
   end
 end

data/lib/solargraph/pin/search.rb

@@ -18,21 +18,21 @@ module Solargraph
         end
       end
 
-      # @param pins [Array<Pin::Base>]
+      # @param pins [::Array<Pin::Base>]
       # @param query [String]
       def initialize pins, query
         @pins = pins
         @query = query
       end
 
-      # @return [Array<Pin::Base>]
+      # @return [::Array<Pin::Base>]
       def results
         @results ||= do_query
       end
 
       private
 
-      # @return [Array<Pin::Base>]
+      # @return [::Array<Pin::Base>]
       def do_query
         return @pins if @query.nil? || @query.empty?
         @pins.map do |pin|
@@ -49,7 +49,7 @@ module Solargraph
       # @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)
-        JaroWinkler.distance(str1, str2, ignore_case: true)
+        JaroWinkler.similarity(str1, str2, ignore_case: true)
       end
     end
   end

data/lib/solargraph/pin/signature.rb

@@ -1,23 +1,143 @@
 module Solargraph
   module Pin
-    class Signature
-      # @return [Array<Parameter>]
+    class Signature < Base
+      # @return [::Array<Parameter>]
       attr_reader :parameters
 
       # @return [ComplexType]
       attr_reader :return_type
 
+      # @return [self]
       attr_reader :block
 
-      def initialize parameters, return_type, block = nil
+      # @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

@@ -12,6 +12,7 @@ module Solargraph
     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'
@@ -26,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