solargraph 0.53.4 → 0.54.1

data/lib/solargraph/parser/parser_gem/node_processors/args_node.rb

@@ -6,22 +6,25 @@ module Solargraph
       module NodeProcessors
         class ArgsNode < Parser::NodeProcessor::Base
           def process
-            if node.type == :forward_args
-              forward
-            else
-              node.children.each do |u|
-                loc = get_node_location(u)
-                locals.push Solargraph::Pin::Parameter.new(
-                  location: loc,
-                  closure: region.closure,
-                  comments: comments_for(node),
-                  name: u.children[0].to_s,
-                  assignment: u.children[1],
-                  asgn_code: u.children[1] ? region.code_for(u.children[1]) : nil,
-                  presence: region.closure.location.range,
-                  decl: get_decl(u)
-                )
-                region.closure.parameters.push locals.last
+            callable = region.closure
+            if callable.is_a? Pin::Callable
+              if node.type == :forward_args
+                forward(callable)
+              else
+                node.children.each do |u|
+                  loc = get_node_location(u)
+                  locals.push Solargraph::Pin::Parameter.new(
+                                location: loc,
+                                closure: callable,
+                                comments: comments_for(node),
+                                name: u.children[0].to_s,
+                                assignment: u.children[1],
+                                asgn_code: u.children[1] ? region.code_for(u.children[1]) : nil,
+                                presence: callable.location.range,
+                                decl: get_decl(u)
+                              )
+                  callable.parameters.push locals.last
+                end
               end
             end
             process_children
@@ -29,16 +32,17 @@ module Solargraph
 
           private
 
+          # @param callable [Pin::Callable]
           # @return [void]
-          def forward
+          def forward(callable)
             loc = get_node_location(node)
             locals.push Solargraph::Pin::Parameter.new(
               location: loc,
-              closure: region.closure,
+              closure: callable,
               presence: region.closure.location.range,
               decl: get_decl(node)
             )
-            region.closure.parameters.push locals.last
+            callable.parameters.push locals.last
           end
 
           # @param node [AST::Node]

data/lib/solargraph/parser/parser_gem/node_processors/lvasgn_node.rb

@@ -8,8 +8,8 @@ module Solargraph
           include ParserGem::NodeMethods
 
           def process
-            here = get_node_start_position(node)
-            presence = Range.new(here, region.closure.location.range.ending)
+            # variable not visible until next statement
+            presence = Range.new(get_node_end_position(node), region.closure.location.range.ending)
             loc = get_node_location(node)
             locals.push Solargraph::Pin::LocalVariable.new(
               location: loc,

data/lib/solargraph/parser/parser_gem/node_processors/masgn_node.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class MasgnNode < Parser::NodeProcessor::Base
+          include ParserGem::NodeMethods
+
+          def process
+            # Example:
+            #
+            # s(:masgn,
+            #   s(:mlhs,
+            #     s(:send,
+            #       s(:send, nil, :a), :b=),
+            #     s(:lvasgn, :b),
+            #     s(:ivasgn, :@c)),
+            #   s(:array,
+            #     s(:int, 1),
+            #     s(:int, 2),
+            #     s(:int, 3)))
+            masgn = node
+            mlhs = masgn.children.fetch(0)
+            lhs_arr = mlhs.children
+            mass_rhs = node.children.fetch(1)
+
+            # Get pins created for the mlhs node
+            process_children
+
+            lhs_arr.each_with_index do |lhs, i|
+              location = get_node_location(lhs)
+              pin = if lhs.type == :lvasgn
+                      # lvasgn is a local variable
+                      locals.find { |l| l.location == location }
+                    else
+                      # e.g., ivasgn is an instance variable, etc
+                      pins.find { |iv| iv.location == location && iv.is_a?(Pin::BaseVariable) }
+                    end
+              # @todo in line below, nothing in typechecking alerts
+              #   when a non-existant method is called on 'l'
+              if pin.nil?
+                Solargraph.logger.debug { "Could not find local for masgn= value in location #{location.inspect} in #{lhs_arr} - masgn = #{masgn}, lhs.type = #{lhs.type}" }
+                next
+              end
+              pin.mass_assignment = [mass_rhs, i]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/parser_gem/node_processors/send_node.rb

@@ -80,7 +80,7 @@ module Solargraph
                 )
               end
               if node.children[1] == :attr_writer || node.children[1] == :attr_accessor
-                pins.push Solargraph::Pin::Method.new(
+                method_pin = Solargraph::Pin::Method.new(
                   location: loc,
                   closure: clos,
                   name: "#{a.children[0]}=",
@@ -89,9 +89,10 @@ module Solargraph
                   visibility: region.visibility,
                   attribute: true
                 )
-                pins.last.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last)
-                if pins.last.return_type.defined?
-                  pins.last.docstring.add_tag YARD::Tags::Tag.new(:param, '', pins.last.return_type.to_s.split(', '), 'value')
+                pins.push method_pin
+                method_pin.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last)
+                if method_pin.return_type.defined?
+                  pins.last.docstring.add_tag YARD::Tags::Tag.new(:param, '', pins.last.return_type.items.map(&:rooted_tags), 'value')
                 end
               end
             end
@@ -112,6 +113,7 @@ module Solargraph
             end
           end
 
+          # @return [void]
           def process_prepend
             if node.children[2].is_a?(AST::Node) && node.children[2].type == :const
               cp = region.closure

data/lib/solargraph/parser/parser_gem/node_processors.rb

@@ -17,6 +17,7 @@ module Solargraph
         autoload :LvasgnNode,    'solargraph/parser/parser_gem/node_processors/lvasgn_node'
         autoload :GvasgnNode,    'solargraph/parser/parser_gem/node_processors/gvasgn_node'
         autoload :CasgnNode,     'solargraph/parser/parser_gem/node_processors/casgn_node'
+        autoload :MasgnNode,     'solargraph/parser/parser_gem/node_processors/masgn_node'
         autoload :AliasNode,     'solargraph/parser/parser_gem/node_processors/alias_node'
         autoload :ArgsNode,      'solargraph/parser/parser_gem/node_processors/args_node'
         autoload :BlockNode,     'solargraph/parser/parser_gem/node_processors/block_node'
@@ -43,6 +44,7 @@ module Solargraph
       register :lvasgn,       ParserGem::NodeProcessors::LvasgnNode
       register :gvasgn,       ParserGem::NodeProcessors::GvasgnNode
       register :casgn,        ParserGem::NodeProcessors::CasgnNode
+      register :masgn,        ParserGem::NodeProcessors::MasgnNode
       register :alias,        ParserGem::NodeProcessors::AliasNode
       register :args,         ParserGem::NodeProcessors::ArgsNode
       register :forward_args, ParserGem::NodeProcessors::ArgsNode

data/lib/solargraph/parser.rb

@@ -9,15 +9,12 @@ module Solargraph
     class SyntaxError < StandardError
     end
 
-    def self.rubyvm?
-      false
-    end
-
     # @deprecated
     Legacy = ParserGem
 
     ClassMethods = ParserGem::ClassMethods
-
+    # @todo should be able to just 'extend ClassMethods' here and
+    #   typecheck things off it in strict mode
     extend ParserGem::ClassMethods
 
     NodeMethods = ParserGem::NodeMethods

data/lib/solargraph/pin/base.rb

@@ -15,6 +15,9 @@ module Solargraph
       # @return [Solargraph::Location]
       attr_reader :location
 
+      # @return [Solargraph::Location]
+      attr_reader :type_location
+
       # @return [String]
       attr_reader :name
 
@@ -25,11 +28,13 @@ module Solargraph
       attr_accessor :source
 
       # @param location [Solargraph::Location, nil]
+      # @param type_location [Solargraph::Location, nil]
       # @param closure [Solargraph::Pin::Closure, nil]
       # @param name [String]
       # @param comments [String]
-      def initialize location: nil, closure: nil, name: '', comments: ''
+      def initialize location: nil, type_location: nil, closure: nil, name: '', comments: ''
         @location = location
+        @type_location = type_location
         @closure = closure
         @name = name
         @comments = comments
@@ -70,6 +75,10 @@ module Solargraph
         transformed.erase_generics(definitions.generics)
       end
 
+      def all_rooted?
+        !return_type || return_type.all_rooted?
+      end
+
       # @param generics_to_erase [Enumerable<String>]
       # @return [self]
       def erase_generics(generics_to_erase)
@@ -102,6 +111,11 @@ module Solargraph
         false
       end
 
+      # @return [Location, nil]
+      def best_location
+        location || type_location
+      end
+
       # Pin equality is determined using the #nearly? method and also
       # requiring both pins to have the same location.
       #

data/lib/solargraph/pin/base_variable.rb

@@ -9,10 +9,14 @@ module Solargraph
       # @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
@@ -36,10 +40,12 @@ module Solargraph
         true
       end
 
-      def probe api_map
-        return ComplexType::UNDEFINED if @assignment.nil?
+      # @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(@assignment).each do |node|
+        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
@@ -51,12 +57,35 @@ module Solargraph
             # 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(closure.context.tag)
+            result = chain.infer(api_map, closure, clip.locals).self_to_type(closure.context)
             types.push result unless result.undefined?
           end
         end
-        return ComplexType::UNDEFINED if types.empty?
-        ComplexType.try_parse(*types.map(&:to_s))
+        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

data/lib/solargraph/pin/block.rb

@@ -2,7 +2,7 @@
 
 module Solargraph
   module Pin
-    class Block < Closure
+    class Block < Callable
       # @return [Parser::AST::Node]
       attr_reader :receiver
 
@@ -14,10 +14,10 @@ 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
 
@@ -31,14 +31,51 @@ module Solargraph
         @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)
+        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 }
       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
@@ -50,7 +87,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
@@ -59,7 +96,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.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

@@ -18,7 +18,7 @@ module Solargraph
         @context ||= begin
           result = super
           if scope == :instance
-            Solargraph::ComplexType.parse(result.namespace)
+            result.reduce_class_type
           else
             result
           end
@@ -42,10 +42,15 @@ module Solargraph
       end
 
       # @return [String]
-      def generics_as_rbs
+      def to_rbs
+        rbs_generics + return_type.to_rbs
+      end
+
+      # @return [String]
+      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

@@ -19,7 +19,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 +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.tag)
-            else
-              return here.context
-            end
+            return here.context
           end
           here = here.closure
         end

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

@@ -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 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

@@ -76,6 +76,8 @@ module Solargraph
         end
       end
 
+      # @param text [String]
+      # @return [String]
       def self.strip_html_comments text
         text.gsub(/<!--([\s\S]*?)-->/, '').strip
       end