solargraph 0.61.0 → 0.62.0

data/lib/solargraph/rbs_translator.rb

@@ -10,36 +10,43 @@ module Solargraph
       'int' => 'Integer',
       'untyped' => '',
       'NilClass' => 'nil'
-    }
+    }.freeze
 
-    # @param type [RBS::Types::Bases::Base]
+    # Relative type names (e.g. `Bar` in an inline `#: () -> Bar`) stay
+    # unrooted so they resolve against the pin's namespace like YARD tags
+    # do. Absolute names (`::Bar`, or any name from an RBS environment
+    # after `resolve_type_names`) and RBS builtins stay rooted.
+    #
+    # @param type [RBS::Types::t]
+    # @param type_alias_decls [Hash{String => RBS::AST::Declarations::TypeAlias}]
     # @return [ComplexType]
-    def self.to_complex_type(type)
-      tag = type_to_tag(type)
-      ComplexType.try_parse(tag).force_rooted
+    def self.to_complex_type type, type_alias_decls: {}
+      ComplexType.try_parse(type_to_tag(type, type_alias_decls))
     end
 
     # @param param_type [RBS::Types::Function::Param]
     # @param name [String]
     # @param decl [Symbol]
     # @param closure [Pin::Closure]
+    # @param type_alias_decls [Hash{String => RBS::AST::Declarations::TypeAlias}]
     # @return [Pin::Parameter]
-    def self.to_parameter_pin(param_type, name, decl, closure)
+    def self.to_parameter_pin param_type, name, decl, closure, type_alias_decls: {}
       return_type = if decl == :restarg
-        ComplexType.parse('Array')
-      elsif decl == :kwrestarg
-        ComplexType.parse('Hash{Symbol => Object}')
-      else
-        RbsTranslator.to_complex_type(param_type.type)
-      end
+                      ComplexType.parse('Array')
+                    elsif decl == :kwrestarg
+                      ComplexType.parse('Hash{Symbol => Object}')
+                    else
+                      RbsTranslator.to_complex_type(param_type.type, type_alias_decls: type_alias_decls)
+                    end
       Solargraph::Pin::Parameter.new(decl: decl, name: name, closure: closure, return_type: return_type, source: :rbs, type_location: to_sg_location(param_type.location) || closure.type_location)
     end
 
-    # @param method_type [RBS::MethodType]
+    # @param method_type [RBS::MethodType, RBS::Types::Block]
     # @param closure [Pin::Closure]
     # @param parameter_names [Array<String>]
+    # @param type_alias_decls [Hash{String => RBS::AST::Declarations::TypeAlias}]
     # @return [Array<Pin::Parameter>]
-    def self.to_parameter_pins method_type, closure, parameter_names = []
+    def self.to_parameter_pins method_type, closure, parameter_names = [], type_alias_decls: {}
       if defined?(RBS::Types::UntypedFunction) && method_type.type.is_a?(RBS::Types::UntypedFunction)
         return [
           Solargraph::Pin::Parameter.new(decl: :restarg, name: 'arg', closure: closure, source: :rbs)
@@ -49,27 +56,37 @@ module Solargraph
       arg_num = 0
       params = []
       method_type.type.required_positionals.each do |param|
-        params.push RbsTranslator.to_parameter_pin(param, param.name&.to_s || parameter_names[arg_num] || "arg_#{arg_num}", :arg, closure)
+        # @sg-ignore Unresolved call to name on RBS::Types::Function::Param
+        params.push RbsTranslator.to_parameter_pin(param, param.name&.to_s || parameter_names[arg_num] || "arg_#{arg_num}", :arg, closure, type_alias_decls: type_alias_decls)
         arg_num += 1
       end
       method_type.type.optional_positionals.each do |param|
-        params.push RbsTranslator.to_parameter_pin(param, param.name&.to_s || parameter_names[arg_num] || "arg_#{arg_num}", :optarg, closure)
+        # @sg-ignore Unresolved call to name on RBS::Types::Function::Param
+        params.push RbsTranslator.to_parameter_pin(param, param.name&.to_s || parameter_names[arg_num] || "arg_#{arg_num}", :optarg, closure, type_alias_decls: type_alias_decls)
         arg_num += 1
       end
       if method_type.type.rest_positionals
-        params.push RbsTranslator.to_parameter_pin(method_type.type.rest_positionals, method_type.type.rest_positionals.name&.to_s || parameter_names[arg_num] || "arg_#{arg_num}", :restarg, closure)
+        rest_positionals = method_type.type.rest_positionals
+        # @sg-ignore Unresolved call to name on RBS::Types::Function::Param
+        rest_name = rest_positionals.name&.to_s || parameter_names[arg_num] || "arg_#{arg_num}"
+        params.push RbsTranslator.to_parameter_pin(rest_positionals, rest_name, :restarg, closure, type_alias_decls: type_alias_decls)
         arg_num += 1
       end
       method_type.type.required_keywords.each do |param|
-        params.push RbsTranslator.to_parameter_pin(param.last, param.first.to_s, :kwarg, closure)
+        # @sg-ignore Unresolved calls to last, first on generic<D>
+        params.push RbsTranslator.to_parameter_pin(param.last, param.first.to_s, :kwarg, closure, type_alias_decls: type_alias_decls)
         arg_num += 1
       end
       method_type.type.optional_keywords.each do |param|
-        params.push RbsTranslator.to_parameter_pin(param.last, param.first.to_s, :kwoptarg, closure)
+        # @sg-ignore Unresolved calls to last, first on generic<D>
+        params.push RbsTranslator.to_parameter_pin(param.last, param.first.to_s, :kwoptarg, closure, type_alias_decls: type_alias_decls)
         arg_num += 1
       end
       if method_type.type.rest_keywords
-        params.push RbsTranslator.to_parameter_pin(method_type.type.rest_keywords, method_type.type.rest_keywords.name&.to_s || parameter_names[arg_num] || "arg_#{arg_num}", :kwrestarg, closure)
+        rest_keywords = method_type.type.rest_keywords
+        # @sg-ignore Unresolved call to name on RBS::Types::Function::Param
+        rest_keywords_name = rest_keywords.name&.to_s || parameter_names[arg_num] || "arg_#{arg_num}"
+        params.push RbsTranslator.to_parameter_pin(rest_keywords, rest_keywords_name, :kwrestarg, closure, type_alias_decls: type_alias_decls)
       end
       params
     end
@@ -77,41 +94,29 @@ module Solargraph
     # @param method_type [RBS::MethodType]
     # @param closure [Pin::Closure]
     # @param parameter_names [Array<String>]
+    # @param type_alias_decls [Hash{String => RBS::AST::Declarations::TypeAlias}]
     # @return [Pin::Signature]
-    def self.to_signature method_type, closure, parameter_names = []
+    def self.to_signature method_type, closure, parameter_names = [], type_alias_decls: {}
       # There may be edge cases here around different signatures
       # having different type params / orders - we may need to match
       # this data model and have generics live in signatures to
       # handle those correctly
       generics = method_type.type_params.map(&:name).map(&:to_s).uniq
-      parameters = to_parameter_pins(method_type, closure, parameter_names)
-      return_type = to_complex_type(method_type.type.return_type)
+      parameters = to_parameter_pins(method_type, closure, parameter_names, type_alias_decls: type_alias_decls)
+      return_type = to_complex_type(method_type.type.return_type, type_alias_decls: type_alias_decls)
       block = if method_type.block
-        block_parameters = to_parameter_pins(method_type.block, closure)
-        block_return_type = to_complex_type(method_type.block.type.return_type)
-        Pin::Signature.new(generics: generics, parameters: block_parameters, return_type: block_return_type, source: :rbs, type_location: closure.location, closure: closure)
-      end
-      Pin::Signature.new(generics: generics, parameters: parameters, return_type: return_type, block: block, source: :rbs, type_location: closure.location, closure: closure)
-    end
-
-    # @param type_name [RBS::TypeName]
-    # @param type_args [Enumerable<RBS::Types::Bases::Base>]
-    # @return [ComplexType::UniqueType]
-    def self.build_unique_type(type_name, type_args = [])
-      base = RBS_TO_YARD_TYPE[type_name.relative!.to_s] || type_name.relative!.to_s
-      params = type_args.map do |a|
-        RbsTranslator.to_complex_type(a)
-      end
-      if base == 'Hash' && params.length == 2
-        ComplexType::UniqueType.new(base, [params.first], [params.last], rooted: true, parameters_type: :hash)
-      else
-        ComplexType::UniqueType.new(base, [], params.reject(&:undefined?), rooted: true, parameters_type: :list)
-      end
+                # @sg-ignore https://github.com/castwide/solargraph/issues/1249
+                block_parameters = to_parameter_pins(method_type.block, closure, type_alias_decls: type_alias_decls)
+                block_return_type = to_complex_type(method_type.block.type.return_type, type_alias_decls: type_alias_decls)
+                Pin::Signature.new(generics: generics, parameters: block_parameters, return_type: block_return_type, source: :rbs, type_location: closure.location, closure: closure)
+              end
+      Pin::Signature.new(generics: generics, parameters: parameters, return_type: return_type, block: block,
+                         block_required: method_type.block&.required || false, source: :rbs, type_location: closure.location, closure: closure)
     end
 
     # @param location [RBS::Location, nil]
     # @return [Solargraph::Location, nil]
-    def self.to_sg_location(location)
+    def self.to_sg_location location
       return nil if location&.name.nil?
 
       start_pos = Position.new(location.start_line - 1, location.start_column)
@@ -123,50 +128,74 @@ module Solargraph
     class << self
       private
 
-      # @param type [RBS::Types::Bases::Base]
+      # @param type [RBS::Types::t]
+      # @param type_alias_decls [Hash{String => RBS::AST::Declarations::TypeAlias}]
+      # @param expanding_aliases [Array<String>] Names of aliases already
+      #   being expanded in this call chain, to detect recursive aliases
       # @return [String]
-      def type_to_tag type
+      def type_to_tag type, type_alias_decls = {}, expanding_aliases = []
         case type
         when RBS::Types::Optional
-          "#{type_to_tag(type.type)}, nil"
+          # @sg-ignore flow sensitive typing should support case/when
+          "#{type_to_tag(type.type, type_alias_decls, expanding_aliases)}, nil"
         when RBS::Types::Bases::Bool
-          'Boolean'
+          '::Boolean'
         when RBS::Types::Tuple
-          "Array(#{type.types.map { |t| type_to_tag(t) }.join(', ')})"
+          # @sg-ignore flow sensitive typing should support case/when
+          "::Array(#{type.types.map { |t| type_to_tag(t, type_alias_decls, expanding_aliases) }.join(', ')})"
         when RBS::Types::Literal
+          # @sg-ignore flow sensitive typing should support case/when
           type.literal.inspect
         when RBS::Types::Union
-          type.types.map { |t| type_to_tag(t) }.join(', ')
+          # @sg-ignore flow sensitive typing should support case/when
+          type.types.map { |t| type_to_tag(t, type_alias_decls, expanding_aliases) }.join(', ')
         when RBS::Types::Record
           # @todo Better record support
-          'Hash'
+          '::Hash'
         when RBS::Types::Bases::Nil
           'nil'
         when RBS::Types::Bases::Void
           'void'
         when RBS::Types::Variable
+          # @sg-ignore flow sensitive typing should support case/when
           "#{Solargraph::ComplexType::GENERIC_TAG_NAME}<#{type.name}>"
         when RBS::Types::Bases::Self, RBS::Types::Bases::Instance
           'self'
         when RBS::Types::Bases::Top
           # `Top` is the most super superclass
-          'BasicObject'
+          '::BasicObject'
         when RBS::Types::Intersection
-          type.types.map { |member| type_to_tag(member) }.join(', ')
+          # @sg-ignore flow sensitive typing should support case/when
+          type.types.map { |member| type_to_tag(member, type_alias_decls, expanding_aliases) }.join(', ')
         when RBS::Types::Proc
-          'Proc'
-        when RBS::Types::ClassInstance, RBS::Types::Alias, RBS::Types::Interface
-          # `Alias` is a top-level type alias, e.g., 'bool' in "type bool = true | false"
-          # @todo ensure these get resolved after processing all aliases
-          # @todo handle recursive aliases
-          #
-          # `Interface represents a mix-in module which can be considered a
+          '::Proc'
+        when RBS::Types::Alias
+          # Expand so conformance checks see the members, not the name. A
+          # generic alias falls back: args are not substituted, so expanding
+          # would leak an unbound generic<T>.
+          # @sg-ignore flow sensitive typing should support case/when
+          alias_name = type.name.to_s
+          alias_decl = type_alias_decls[alias_name]
+          # @sg-ignore flow sensitive typing should support case/when
+          if alias_decl.nil? || expanding_aliases.include?(alias_name) || !type.args.empty?
+            # @sg-ignore flow sensitive typing should support case/when
+            type_tag(type.name, type.args, type_alias_decls, expanding_aliases)
+          else
+            # The alias body belongs to the alias's declaration, not the
+            # use site, so its names stay rooted even when a core-less
+            # environment left them relative.
+            expanded = type_to_tag(alias_decl.type, type_alias_decls, expanding_aliases + [alias_name])
+            ComplexType.try_parse(expanded).force_rooted.rooted_tags
+          end
+        when RBS::Types::ClassInstance, RBS::Types::Interface
+          # `Interface` represents a mix-in module which can be considered a
           # subtype of a consumer of it
-          #
-          type_tag(type.name, type.args)
+          # @sg-ignore flow sensitive typing should support case/when
+          type_tag(type.name, type.args, type_alias_decls, expanding_aliases)
         when RBS::Types::ClassSingleton
           # e.g., singleton(String)
-          type_tag(type.name)
+          # @sg-ignore flow sensitive typing should support case/when
+          type_tag(type.name, [], type_alias_decls, expanding_aliases)
         when RBS::Types::Bases::Any, RBS::Types::Bases::Bottom
           # `Bottom`` is used in contexts where nothing will ever return
           # - e.g., it could be the return type of 'exit()' or 'raise'
@@ -182,23 +211,29 @@ module Solargraph
 
       # @param type_name [RBS::TypeName]
       # @param type_args [Enumerable<RBS::Types::Bases::Base>]
+      # @param type_alias_decls [Hash{String => RBS::AST::Declarations::TypeAlias}]
+      # @param expanding_aliases [Array<String>]
       # @return [String]
-      def type_tag(type_name, type_args = [])
-        build_type(type_name, type_args).tags
+      def type_tag type_name, type_args = [], type_alias_decls = {}, expanding_aliases = []
+        build_type(type_name, type_args, type_alias_decls, expanding_aliases).rooted_tags
       end
 
       # @param type_name [RBS::TypeName]
       # @param type_args [Enumerable<RBS::Types::Bases::Base>]
+      # @param type_alias_decls [Hash{String => RBS::AST::Declarations::TypeAlias}]
+      # @param expanding_aliases [Array<String>]
       # @return [ComplexType::UniqueType]
-      def build_type(type_name, type_args = [])
-        base = RBS_TO_YARD_TYPE[type_name.relative!.to_s] || type_name.relative!.to_s
-        params = type_args.map { |a| type_to_tag(a) }.map do |t|
+      def build_type type_name, type_args = [], type_alias_decls = {}, expanding_aliases = []
+        yard_base = RBS_TO_YARD_TYPE[type_name.relative!.to_s]
+        base = yard_base || type_name.relative!.to_s
+        rooted = !yard_base.nil? || type_name.absolute?
+        params = type_args.map { |a| type_to_tag(a, type_alias_decls, expanding_aliases) }.map do |t|
           ComplexType.try_parse(t)
         end
         if base == 'Hash' && params.length == 2
-          ComplexType::UniqueType.new(base, [params.first], [params.last], rooted: true, parameters_type: :hash)
+          ComplexType::UniqueType.new(base, [params.first], [params.last], rooted: rooted, parameters_type: :hash)
         else
-          ComplexType::UniqueType.new(base, [], params.reject(&:undefined?), rooted: true, parameters_type: :list)
+          ComplexType::UniqueType.new(base, [], params.reject(&:undefined?), rooted: rooted, parameters_type: :list)
         end
       end
     end

data/lib/solargraph/repo.rb

@@ -122,7 +122,7 @@ module Solargraph
             source: spec.source.to_s,
             version: spec.version,
             require_paths: spec.require_paths,
-            dependencies: spec.dependencies.map(&:name)
+            dependencies: spec.runtime_dependencies.map(&:name)
           }
         end
         groups = Bundler.definition.groups.to_h do |group|

data/lib/solargraph/source/chain/call.rb

@@ -55,20 +55,39 @@ module Solargraph
           # chain.rb#maybe_nil will add the nil type later, we just
           # need to worry about the not-nil case
 
-          # @sg-ignore Need to handle duck-typed method calls on union types
           binder = binder.without_nil if nullable?
-          # @sg-ignore Need to handle duck-typed method calls on union types
-          pin_groups = binder.each_unique_type.map do |context|
-            ns_tag = context.namespace == '' ? '' : context.namespace_type.tag
-            stack = api_map.get_method_stack(ns_tag, word, scope: context.scope)
-            [stack.first].compact
+          # Resolve one unique type at a time, so a `self` return type narrows to the one that supplied the pin.
+          # @type [::Array<Pin::Base>]
+          resolved = []
+          unresolved_type = false
+          binder.each_unique_type do |context|
+            if context.duck_type? && context.name[1..] == word
+              # explicit: false skips arity checking; the duck type
+              # only tells us the method exists, not its signature
+              pin = Pin::DuckMethod.new(name: word, source: :chain, explicit: false)
+            else
+              ns_tag = context.namespace == '' ? '' : context.namespace_type.tag
+              stack = api_map.get_method_stack(ns_tag, word, scope: context.scope)
+              pin = stack.first
+            end
+            if pin.nil?
+              unresolved_type = true
+              next
+            end
+            # Bind name_pin to this type alone, so #inferred_pins (incl. Class#new) cannot see the others.
+            type_name_pin = Pin::ProxyType.anonymous(name_pin.context,
+                                                     closure: name_pin.closure,
+                                                     gates: name_pin.gates,
+                                                     binder: context,
+                                                     source: :chain)
+            resolved.concat inferred_pins([pin], api_map, type_name_pin, locals)
           end
-          pin_groups = [] if !api_map.loose_unions && pin_groups.any?(&:empty?)
-          # Several union members can end up with the same pin and return type.
-          # @sg-ignore Array#flatten returns a bare Array
-          pins = pin_groups.flatten.uniq { |p| [p.path, p.return_type.rooted_tags] }
-          return [] if pins.empty?
-          inferred_pins(pins, api_map, name_pin, locals)
+          return [] if unresolved_type && !api_map.loose_unions
+          return [] if resolved.empty?
+          # Accumulating every type's result treats the binder as a union, which is the only
+          # multi-type binder ComplexType builds; dedup on rooted_tags rather than #tag, which
+          # reports only the first member and so collapses two distinct unions.
+          resolved.uniq { |pin| [pin.path, pin.return_type.rooted_tags] }
         end
 
         private
@@ -166,7 +185,7 @@ module Solargraph
 
         # @param pins [::Enumerable<Pin::Base>]
         # @param api_map [ApiMap]
-        # @param name_pin [Pin::Base]
+        # @param name_pin [Pin::Base] its #binder resolves `self` in the declarations of `pins`
         # @param locals [::Array<Solargraph::Pin::LocalVariable, Solargraph::Pin::Parameter>]
         # @return [::Array<Pin::Base>]
         def inferred_pins pins, api_map, name_pin, locals

data/lib/solargraph/source/node_map.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class NodeMap
+      # @param node [Parser::AST::Node]
+      def initialize node
+        @node = node
+      end
+
+      def find_by_type type
+        node_map[type] || []
+      end
+
+      private
+
+      def node_map
+        @node_map ||= flatten(@node).to_set.classify(&:type)
+      end
+
+      def flatten from
+        return [] unless from.is_a?(::Parser::AST::Node)
+        [from].concat(from.children.flat_map { |child| flatten child })
+      end
+    end
+  end
+end

data/lib/solargraph/source.rb

@@ -12,6 +12,7 @@ module Solargraph
     autoload :Cursor,        'solargraph/source/cursor'
     autoload :Chain,         'solargraph/source/chain'
     autoload :SourceChainer, 'solargraph/source/source_chainer'
+    autoload :NodeMap,       'solargraph/source/node_map'
 
     include EncodingFixes
 
@@ -213,6 +214,21 @@ module Solargraph
       end
     end
 
+    # The RBS type in an rbs-inline type assertion, i.e., a `#: TYPE`
+    # comment that trails the node on its last line.
+    #
+    # @example
+    #   x = [] #: Array[String]
+    #
+    # @param node [AST::Node]
+    # @return [String, nil]
+    def type_assertion_for node
+      rng = Range.from_node(node)
+      return nil if rng.nil?
+      rest = code_lines[rng.ending.line]&.[](rng.ending.column..)
+      rest&.[](/\A\s*#:(.*)$/, 1)&.strip
+    end
+
     # A location representing the file in its entirety.
     #
     # @return [Location]
@@ -457,6 +473,7 @@ module Solargraph
     # @return [String]
     def code= val
       @code_lines = nil
+      @node_map = nil
       @finalized = false
       @code = val
     end

data/lib/solargraph/source_map/call.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class SourceMap
+    class Call
+      attr_reader :source_map, :chain, :closure
+
+      # @param source_map [SourceMap]
+      # @param chain [Source::Chain]
+      # @param closure [Pin::Closure]
+      def initialize source_map, chain, closure
+        @source_map = source_map
+        @chain = chain
+        @closure = closure
+      end
+    end
+  end
+end

data/lib/solargraph/source_map/mapper.rb

@@ -12,7 +12,7 @@ module Solargraph
 
       private_class_method :new
 
-      DIRECTIVE_REGEXP = /(@!method|@!attribute|@!visibility|@!scope|@!domain|@!macro|@!parse|@!override)/
+      DIRECTIVE_REGEXP = /(@!method|@method|@!attribute|@!visibility|@!scope|@!domain|@!macro|@!parse|@!override)/
 
       # Generate the data.
       #

data/lib/solargraph/source_map.rb

@@ -12,6 +12,7 @@ module Solargraph
     autoload :Clip,          'solargraph/source_map/clip'
     autoload :Completion,    'solargraph/source_map/completion'
     autoload :Data,          'solargraph/source_map/data'
+    autoload :Call,          'solargraph/source_map/call'
 
     # @return [Source]
     attr_reader :source
@@ -82,6 +83,16 @@ module Solargraph
       pins_by_class(Pin::Reference::Require)
     end
 
+    def calls *method_names
+      symbolized = method_names.map(&:to_sym)
+      node_map.find_by_type(:send).select { |node| node.children[0].nil? && symbolized.include?(node.children[1].to_sym) }
+              .map { |node| Call.new(self, Parser.chain(node), locate_namespace_pin(node.loc.line, node.loc.column)) }
+    end
+
+    def node_map
+      @node_map ||= Source::NodeMap.new(source.node)
+    end
+
     # @return [Environ]
     def conventions_environ
       @conventions_environ ||= Environ.new
@@ -128,6 +139,10 @@ module Solargraph
       _locate_pin line, character, Pin::Namespace, Pin::Method
     end
 
+    def locate_namespace_pin line, character
+      _locate_pin line, character, Pin::Namespace, Pin::Singleton
+    end
+
     # @param line [Integer]
     # @param character [Integer]
     # @return [Pin::Closure]
@@ -197,7 +212,7 @@ module Solargraph
 
     private
 
-    # @return [Hash{Class<Pin::Base> => Array<Pin::Base>}]
+    # @return [Hash{Class, Pin::Base => Array<Pin::Base>}]
     def pin_class_hash
       # @todo Need to support generic resolution in classify and transform_values
       @pin_class_hash ||= pins.to_set.classify(&:class).transform_values(&:to_a)
@@ -226,9 +241,8 @@ module Solargraph
       position = Position.new(line, character)
       found = nil
       pins.each do |pin|
-        # @todo Attribute pins should not be treated like closures, but
-        #   there's probably a better way to handle it
-        next if pin.is_a?(Pin::Method) && pin.attribute?
+        # A bodyless method pin covers its declaring statement's range but isn't a closure.
+        next if pin.is_a?(Pin::Method) && !pin.body?
         found = pin if (klasses.empty? || klasses.any? do |kls|
           pin.is_a?(kls)
           # @sg-ignore Need to add nil check here

data/lib/solargraph/type_checker/rules.rb

@@ -75,11 +75,11 @@ module Solargraph
       # @todo 22: Translate to something flow sensitive typing understands
       # @todo 3: Need a downcast here
       #
-      # flow sensitive typing could handle (97):
+      # flow sensitive typing could handle (99):
       #
       # @todo 36: flow sensitive typing needs to handle attrs
       # @todo 29: flow sensitive typing should be able to handle redefinition
-      # @todo 19: flow sensitive typing needs to narrow down type with an if is_a? check
+      # @todo 21: flow sensitive typing needs to narrow down type with an if is_a? check
       # @todo 13: Need to validate config
       # @todo 8: flow sensitive typing should support .class == .class
       # @todo 6: need boolish support for ? methods

data/lib/solargraph/type_checker.rb

@@ -141,6 +141,8 @@ module Solargraph
     # @return [Array<Problem>]
     def method_return_type_problems_for pin
       return [] if pin.is_a?(Pin::MethodAlias)
+      # An unresolvable DelegatedMethod's type comes from its @!method directive, not a @return tag.
+      return [] if pin.is_a?(Pin::DelegatedMethod) && !pin.resolvable?(api_map)
       result = []
       declared = pin.typify(api_map).self_to_type(pin.full_context).qualify(api_map, *pin.gates)
       if declared.undefined?
@@ -219,7 +221,7 @@ module Solargraph
         params = param_details_from_stack(sig, stack)
         if rules.require_type_tags?
           sig.parameters.each do |par|
-            break if %i[restarg kwrestarg blockarg].include?(par.decl)
+            break if %i[restarg kwrestarg blockarg forward_args].include?(par.decl)
             unless params[par.name]
               if pin.attribute?
                 inferred = pin.probe(api_map).self_to_type(pin.full_context)
@@ -388,6 +390,7 @@ module Solargraph
       return [] unless last_base_link.is_a?(Solargraph::Source::Chain::Call)
 
       arguments = last_base_link.arguments
+      return [] if any_forwarded_args?(arguments.map(&:node))
 
       pins = base.define(api_map, closure_pin, locals)
 

data/lib/solargraph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Solargraph
-  VERSION = ENV.fetch('SOLARGRAPH_FORCE_VERSION', '0.61.0')
+  VERSION = ENV.fetch('SOLARGRAPH_FORCE_VERSION', '0.62.0')
 end

data/lib/solargraph/yard_map/macro.rb

@@ -11,6 +11,17 @@ module Solargraph
       # its content.
       VALUE_DIRECTIVES = %w[parse scope].freeze
 
+      # Directives that define an object capable of owning @overload tags.
+      OVERLOAD_OWNERS = %w[method attribute parse].freeze
+
+      # The directive used to generate a pin for the @overload tags a macro
+      # declares without an owning @!method directive. Its arguments are
+      # represented by (...) so that any of the overloads remains valid.
+      OVERLOAD_METHOD_DIRECTIVE = '@!method $1(...)'
+
+      # An @overload tag that starts a line of a macro's text.
+      OVERLOAD_TAG_LINE = /^\s*@overload(\s|$)/
+
       class << self
         # @param directive [YARD::Tags::Directive]
         # @param method_pin [Pin::Method]
@@ -123,9 +134,17 @@ module Solargraph
         code = source_map.source.code_for(chain.node)
         expanded_comment = macro_object.expand([name, *values], code)
                                        .gsub(/\n(?!@!|\s)/, "\n  ")
-        directives = Solargraph::Source.parse_docstring(expanded_comment).directives.select do |directive|
+        parsed_docstring = Solargraph::Source.parse_docstring(expanded_comment)
+        directives = parsed_docstring.directives.select do |directive|
           PROCESSABLE_DIRECTIVES.include?(directive.tag.tag_name)
         end
+        # A macro can document the methods it generates with bare @overload
+        # tags instead of wrapping them in a @!method directive. Those overloads
+        # have no pin to attach to and would otherwise be discarded, so
+        # generate the pin they describe.
+        if declares_overloads? && directives.none? { |directive| OVERLOAD_OWNERS.include?(directive.tag.tag_name) }
+          directives += generate_overload_directives([name, *values], code)
+        end
         directives.each do |directive|
           next if VALUE_DIRECTIVES.include? directive.tag.tag_name
 
@@ -137,6 +156,37 @@ module Solargraph
         end
         directives
       end
+
+      # True if the macro declares @overload tags. The tags are read from the
+      # macro's text and not from its parsed docstring because the indentation
+      # a macro's content ends up with can nest the tags inside other objects.
+      #
+      # @return [Boolean]
+      def declares_overloads?
+        text.match?(OVERLOAD_TAG_LINE)
+      end
+
+      # Generates the @!method directive for a macro's bare @overload tags. The
+      # pin takes the name the macro generates, that is, the pin a
+      # @!method $1(...) directive would produce, and keeps the overloads in
+      # its comments.
+      #
+      # The macro's unprocessed text is used here and not its macro data. The
+      # data is re-indented for @! directives, which flattens the nesting that
+      # keeps a @param attached to the @overload it describes.
+      #
+      # @param call_params [Array<String>]
+      # @param code [String]
+      # @return [Array<YARD::Tags::Directive>]
+      def generate_overload_directives call_params, code
+        body = text.each_line.map { |line| "  #{line}" }.join
+        expanded = YARD::CodeObjects::MacroObject.expand(
+          "#{OVERLOAD_METHOD_DIRECTIVE}\n#{body}", call_params, code
+        )
+        Solargraph::Source.parse_docstring(expanded).directives.select do |directive|
+          directive.tag.tag_name == 'method'
+        end
+      end
     end
   end
 end

data/lib/solargraph.rb

@@ -53,6 +53,8 @@ module Solargraph
   autoload :RbsMap,           'solargraph/rbs_map'
   autoload :CacheDir,         'solargraph/cache_dir'
   autoload :RbsTranslator,    'solargraph/rbs_translator'
+  autoload :RbsCollection,    'solargraph/rbs_collection'
+  autoload :Plugin,           'solargraph/plugin'
 
   dir = File.dirname(__FILE__)
   VIEWS_PATH = File.join(dir, 'solargraph', 'views')