solargraph 0.46.0 → 0.54.5

data/lib/solargraph/pin/base_variable.rb

@@ -1,84 +1,118 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class BaseVariable < Base
-      include Solargraph::Parser::NodeMethods
-      # include Solargraph::Source::NodeMethods
-
-      # @return [Parser::AST::Node, nil]
-      attr_reader :assignment
-
-      # @param assignment [Parser::AST::Node, nil]
-      def initialize assignment: nil, **splat
-        super(**splat)
-        @assignment = assignment
-      end
-
-      def completion_item_kind
-        Solargraph::LanguageServer::CompletionItemKinds::VARIABLE
-      end
-
-      # @return [Integer]
-      def symbol_kind
-        Solargraph::LanguageServer::SymbolKinds::VARIABLE
-      end
-
-      def return_type
-        @return_type ||= generate_complex_type
-      end
-
-      def nil_assignment?
-        return_type.nil?
-      end
-
-      def variable?
-        true
-      end
-
-      def probe api_map
-        return ComplexType::UNDEFINED if @assignment.nil?
-        types = []
-        returns_from(@assignment).each do |node|
-          # Nil nodes may not have a location
-          if node.nil? || node.type == :NIL || node.type == :nil
-            types.push ComplexType::NIL
-          else
-            rng = Range.from_node(node)
-            next if rng.nil?
-            pos = rng.ending
-            clip = api_map.clip_at(location.filename, pos)
-            # Use the return node for inference. The clip might infer from the
-            # first node in a method call instead of the entire call.
-            chain = Parser.chain(node, nil, clip.in_block?)
-            result = chain.infer(api_map, closure, clip.locals)
-            types.push result unless result.undefined?
-          end
-        end
-        return ComplexType::UNDEFINED if types.empty?
-        ComplexType.try_parse(*types.map(&:tag))
-      end
-
-      def == other
-        return false unless super
-        assignment == other.assignment
-      end
-
-      def try_merge! pin
-        return false unless super
-        @assignment = pin.assignment
-        @return_type = pin.return_type
-        true
-      end
-
-      private
-
-      # @return [ComplexType]
-      def generate_complex_type
-        tag = docstring.tag(:type)
-        return ComplexType.try_parse(*tag.types) unless tag.nil? || tag.types.nil? || tag.types.empty?
-        ComplexType.new
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class BaseVariable < Base
+      include Solargraph::Parser::NodeMethods
+      # include Solargraph::Source::NodeMethods
+
+      # @return [Parser::AST::Node, nil]
+      attr_reader :assignment
+
+      attr_accessor :mass_assignment
+
+      # @param assignment [Parser::AST::Node, nil]
+      def initialize assignment: nil, **splat
+        super(**splat)
+        @assignment = assignment
+        # @type [nil, ::Array(Parser::AST::Node, Integer)]
+        @mass_assignment = nil
+      end
+
+      def completion_item_kind
+        Solargraph::LanguageServer::CompletionItemKinds::VARIABLE
+      end
+
+      # @return [Integer]
+      def symbol_kind
+        Solargraph::LanguageServer::SymbolKinds::VARIABLE
+      end
+
+      def return_type
+        @return_type ||= generate_complex_type
+      end
+
+      def nil_assignment?
+        return_type.nil?
+      end
+
+      def variable?
+        true
+      end
+
+      # @param parent_node [Parser::AST::Node]
+      # @param api_map [ApiMap]
+      # @return [::Array<ComplexType>]
+      def return_types_from_node(parent_node, api_map)
+        types = []
+        value_position_nodes_only(parent_node).each do |node|
+          # Nil nodes may not have a location
+          if node.nil? || node.type == :NIL || node.type == :nil
+            types.push ComplexType::NIL
+          else
+            rng = Range.from_node(node)
+            next if rng.nil?
+            pos = rng.ending
+            clip = api_map.clip_at(location.filename, pos)
+            # Use the return node for inference. The clip might infer from the
+            # first node in a method call instead of the entire call.
+            chain = Parser.chain(node, nil, nil)
+            result = chain.infer(api_map, closure, clip.locals).self_to_type(closure.context)
+            types.push result unless result.undefined?
+          end
+        end
+        types
+      end
+
+      # @param api_map [ApiMap]
+      # @return [ComplexType]
+      def probe api_map
+        unless @assignment.nil?
+          types = return_types_from_node(@assignment, api_map)
+          return ComplexType.new(types.uniq) unless types.empty?
+        end
+
+        unless @mass_assignment.nil?
+          mass_node, index = @mass_assignment
+          types = return_types_from_node(mass_node, api_map)
+          types.map! do |type|
+            if type.tuple?
+              type.all_params[index]
+            elsif ['::Array', '::Set', '::Enumerable'].include?(type.rooted_name)
+              type.all_params.first
+            end
+          end.compact!
+          return ComplexType.new(types.uniq) unless types.empty?
+        end
+
+        ComplexType::UNDEFINED
+      end
+
+      def == other
+        return false unless super
+        assignment == other.assignment
+      end
+
+      # @param pin [self]
+      def try_merge! pin
+        return false unless super
+        @assignment = pin.assignment
+        @return_type = pin.return_type
+        true
+      end
+
+      def type_desc
+        "#{super} = #{assignment&.type.inspect}"
+      end
+
+      private
+
+      # @return [ComplexType]
+      def generate_complex_type
+        tag = docstring.tag(:type)
+        return ComplexType.try_parse(*tag.types) unless tag.nil? || tag.types.nil? || tag.types.empty?
+        ComplexType.new
+      end
+    end
+  end
+end

data/lib/solargraph/pin/block.rb

@@ -1,72 +1,101 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class Block < Closure
-      # The signature of the method that receives this block.
-      #
-      # @return [Parser::AST::Node]
-      attr_reader :receiver
-
-      def initialize receiver: nil, args: [], context: nil, **splat
-        super(**splat)
-        @receiver = receiver
-        @context = context
-        @parameters = args
-      end
-
-      # @param api_map [ApiMap]
-      # @return [void]
-      def rebind api_map
-        @binder ||= binder_or_nil(api_map)
-      end
-
-      def binder
-        @binder || closure.binder
-      end
-
-      # @return [Array<String>]
-      def parameters
-        @parameters ||= []
-      end
-
-      # @return [Array<String>]
-      def parameter_names
-        @parameter_names ||= parameters.map(&:name)
-      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)
-        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?
-            return ComplexType.try_parse(*ys.types).qualify(api_map, receiver_pin.context.namespace)
-          end
-        end
-        nil
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Block < Callable
+      # @return [Parser::AST::Node]
+      attr_reader :receiver
+
+      # @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
+        @return_type = ComplexType.parse('::Proc')
+        @node = node
+      end
+
+      # @param api_map [ApiMap]
+      # @return [void]
+      def rebind api_map
+        @rebind ||= maybe_rebind(api_map)
+      end
+
+      def binder
+        @rebind&.defined? ? @rebind : closure.binder
+      end
+
+      # @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
+
+      # @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]
+      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)
+        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
+end

data/lib/solargraph/pin/callable.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Callable < Closure
+      # @return [Signature]
+      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 [::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
+
+      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/class_variable.rb

@@ -1,8 +1,8 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class ClassVariable < BaseVariable
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class ClassVariable < BaseVariable
+    end
+  end
+end

data/lib/solargraph/pin/closure.rb

@@ -1,37 +1,57 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class Closure < Base
-      # @return [::Symbol] :class or :instance
-      attr_reader :scope
-
-      def initialize scope: :class, **splat
-        super(**splat)
-        @scope = scope
-      end
-
-      def context
-        @context ||= begin
-          result = super
-          if scope == :instance
-            Solargraph::ComplexType.parse(result.namespace)
-          else
-            result
-          end
-        end
-      end
-
-      def binder
-        @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
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Closure < Base
+      # @return [::Symbol] :class or :instance
+      attr_reader :scope
+
+      # @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
+            result.reduce_class_type
+          else
+            result
+          end
+        end
+      end
+
+      def binder
+        @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
+
+      # @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