solargraph 0.57.0 → 0.58.1

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

@@ -2,15 +2,6 @@
 
 require 'prism'
 
-# Awaiting ability to use a version containing https://github.com/whitequark/parser/pull/1076
-#
-# @!parse
-#   class ::Parser::Base < ::Parser::Builder
-#     # @return [Integer]
-#     def version; end
-#   end
-#   class ::Parser::CurrentRuby < ::Parser::Base; end
-
 module Solargraph
   module Parser
     module ParserGem
@@ -84,6 +75,7 @@ module Solargraph
         # @param top [AST::Node]
         # @return [Array<AST::Node>]
         def inner_node_references name, top
+          # @type [Array<AST::Node>]
           result = []
           if top.is_a?(AST::Node) && top.to_s.include?(":#{name}")
             result.push top if top.children.any? { |c| c.to_s == name }
@@ -137,9 +129,7 @@ module Solargraph
         def string_ranges node
           return [] unless is_ast_node?(node)
           result = []
-          if node.type == :str
-            result.push Range.from_node(node)
-          end
+          result.push Range.from_node(node) if node.type == :str
           node.children.each do |child|
             result.concat string_ranges(child)
           end

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

@@ -3,20 +3,6 @@
 require 'parser'
 require 'ast'
 
-# Teach AST::Node#children about its generic type
-#
-# @todo contribute back to https://github.com/ruby/gem_rbs_collection/blob/main/gems/ast/2.4/ast.rbs
-#
-# @!parse
-#   module ::AST
-#     class Node
-#       # New children
-#
-#       # @return [Array<self, Integer, String, Symbol, nil>]
-#       attr_reader :children
-#     end
-#   end
-
 # https://github.com/whitequark/parser
 module Solargraph
   module Parser
@@ -133,6 +119,7 @@ module Solargraph
           result
         end
 
+        # @sg-ignore Wrong argument type for AST::Node.new: type expected AST::_ToSym, received :nil
         NIL_NODE = ::Parser::AST::Node.new(:nil)
 
         # @param node [Parser::AST::Node]

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

@@ -11,6 +11,7 @@ module Solargraph
             process_children
 
             position = get_node_start_position(node)
+            # @sg-ignore https://github.com/castwide/solargraph/pull/1114
             enclosing_breakable_pin = pins.select{|pin| pin.is_a?(Pin::Breakable) && pin.location.range.contain?(position)}.last
             FlowSensitiveTyping.new(locals, enclosing_breakable_pin).process_and(node)
           end

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

@@ -9,14 +9,70 @@ module Solargraph
         class OpasgnNode < Parser::NodeProcessor::Base
           # @return [void]
           def process
-            # Parser::CurrentRuby.parse("a += 2")
-            # => s(:op_asgn,
-            #      s(:lvasgn, :a), :+,
-            #      s(:int, 2))
-            asgn = node.children[0]
-            variable_name = asgn.children[0]
+            target = node.children[0]
             operator = node.children[1]
             argument = node.children[2]
+            if target.type == :send
+              # @sg-ignore Need a downcast here
+              process_send_target(target, operator, argument)
+            elsif target.type.to_s.end_with?('vasgn')
+              # @sg-ignore Need a downcast here
+              process_vasgn_target(target, operator, argument)
+            else
+              Solargraph.assert_or_log(:opasgn_unknown_target,
+                                       "Unexpected op_asgn target type: #{target.type}")
+            end
+          end
+
+          # @param call [Parser::AST::Node] the target of the assignment
+          # @param operator [Symbol] the operator, e.g. :+
+          # @param argument [Parser::AST::Node] the argument of the operation
+          #
+          # @return [void]
+          def process_send_target call, operator, argument
+            # if target is a call:
+            # [10] pry(main)> Parser::CurrentRuby.parse("Foo.bar += baz")
+            # => s(:op_asgn,
+            #      s(:send, # call
+            #        s(:const, nil, :Foo), # calee
+            #        :bar), # call_method
+            #      :+, # operator
+            #      s(:send, nil, :baz)) # argument
+            # [11] pry(main)>
+            callee = call.children[0]
+            call_method = call.children[1]
+            asgn_method = :"#{call_method}="
+
+            # [8] pry(main)> Parser::CurrentRuby.parse("Foo.bar = Foo.bar + baz")
+            # => s(:send,
+            #       s(:const, nil, :Foo), # callee
+            #       :bar=, # asgn_method
+            #        s(:send,
+            #          s(:send,
+            #             s(:const, nil, :Foo), # callee
+            #             :bar), # call_method
+            #          :+, # operator
+            #          s(:send, nil, :baz))) # argument
+            new_send = node.updated(:send,
+                                    [callee,
+                                     asgn_method,
+                                     node.updated(:send, [call, operator, argument])])
+            NodeProcessor.process(new_send, region, pins, locals)
+          end
+
+          # @param asgn [Parser::AST::Node] the target of the assignment
+          # @param operator [Symbol] the operator, e.g. :+
+          # @param argument [Parser::AST::Node] the argument of the operation
+          #
+          # @return [void]
+          def process_vasgn_target asgn, operator, argument
+            # => s(:op_asgn,
+            #      s(:lvasgn, :a), # asgn
+            #      :+, # operator
+            #      s(:int, 2)) # argument
+
+            # @type [Parser::AST::Node]
+            variable_name = asgn.children[0]
             # for lvasgn, gvasgn, cvasgn, convert to lvar, gvar, cvar
             # [6] pry(main)> Parser::CurrentRuby.parse("a = a + 1")
             # => s(:lvasgn, :a,
@@ -25,9 +81,9 @@ module Solargraph
             #     s(:int, 1)))
             # [7] pry(main)>
             variable_reference_type = asgn.type.to_s.sub(/vasgn$/, 'var').to_sym
-            variable_reference = node.updated(variable_reference_type, asgn.children)
+            target_reference = node.updated(variable_reference_type, asgn.children)
             send_children = [
-              variable_reference,
+              target_reference,
               operator,
               argument
             ]

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

@@ -7,9 +7,18 @@ module Solargraph
         class SclassNode < Parser::NodeProcessor::Base
           def process
             sclass = node.children[0]
-            if sclass.is_a?(AST::Node) && sclass.type == :self
+            # @todo Changing Parser::AST::Node to AST::Node below will
+            #   cause type errors at strong level because the combined
+            #   pin for AST::Node#children has return type
+            #   "Array<AST::Node>, Array".  YARD annotations in AST
+            #   provided the Array, RBS for Array<AST::Node>.  We
+            #   should probably have a rule to combine "A, A<T>""
+            #   types to "A<T>" if the "A" comes from YARD, with the
+            #   rationale that folks tend to be less formal with types in
+            #   YARD.
+            if sclass.is_a?(::Parser::AST::Node) && sclass.type == :self
               closure = region.closure
-            elsif sclass.is_a?(AST::Node) && sclass.type == :casgn
+            elsif sclass.is_a?(::Parser::AST::Node) && sclass.type == :casgn
               names = [region.closure.namespace, region.closure.name]
               if sclass.children[0].nil? && names.last != sclass.children[1].to_s
                 names << sclass.children[1].to_s
@@ -18,7 +27,7 @@ module Solargraph
               end
               name = names.reject(&:empty?).join('::')
               closure = Solargraph::Pin::Namespace.new(name: name, location: region.closure.location, source: :parser)
-            elsif sclass.is_a?(AST::Node) && sclass.type == :const
+            elsif sclass.is_a?(::Parser::AST::Node) && sclass.type == :const
               names = [region.closure.namespace, region.closure.name]
               also = NodeMethods.unpack_name(sclass)
               if also != region.closure.name

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

@@ -36,15 +36,12 @@ module Solargraph
                 process_autoload
               elsif method_name == :private_constant
                 process_private_constant
-              # @sg-ignore
               elsif method_name == :alias_method && node.children[2] && node.children[2] && node.children[2].type == :sym && node.children[3] && node.children[3].type == :sym
                 process_alias_method
-              # @sg-ignore
               elsif method_name == :private_class_method && node.children[2].is_a?(AST::Node)
                 # Processing a private class can potentially handle children on its own
                 return if process_private_class_method
               end
-            # @sg-ignore
             elsif method_name == :require && node.children[0].to_s == '(const nil :Bundler)'
               pins.push Pin::Reference::Require.new(Solargraph::Location.new(region.filename, Solargraph::Range.from_to(0, 0, 0, 0)), 'bundler/require', source: :parser)
             end
@@ -66,7 +63,7 @@ module Solargraph
                   return process_children
                 end
                 # :nocov:
-                if child.is_a?(AST::Node) && (child.type == :sym || child.type == :str)
+                if child.is_a?(::Parser::AST::Node) && (child.type == :sym || child.type == :str)
                   name = child.children[0].to_s
                   matches = pins.select{ |pin| pin.is_a?(Pin::Method) && pin.name == name && pin.namespace == region.closure.full_context.namespace && pin.context.scope == (region.scope || :instance)}
                   matches.each do |pin|
@@ -198,7 +195,7 @@ module Solargraph
             elsif node.children[2].type == :sym || node.children[2].type == :str
               node.children[2..-1].each do |x|
                 cn = x.children[0].to_s
-                # @type [Pin::Method]
+                # @type [Pin::Method, nil]
                 ref = pins.find { |p| p.is_a?(Pin::Method) && p.namespace == region.closure.full_context.namespace && p.name == cn }
                 unless ref.nil?
                   pins.delete ref
@@ -231,6 +228,7 @@ module Solargraph
                       closure: cm,
                       name: ivar.name,
                       comments: ivar.comments,
+                      # @sg-ignore https://github.com/castwide/solargraph/pull/1114
                       assignment: ivar.assignment,
                       source: :parser
                     )
@@ -239,6 +237,7 @@ module Solargraph
                       closure: mm,
                       name: ivar.name,
                       comments: ivar.comments,
+                      # @sg-ignore https://github.com/castwide/solargraph/pull/1114
                       assignment: ivar.assignment,
                       source: :parser
                     )

data/lib/solargraph/pin/base.rb

@@ -195,9 +195,9 @@ module Solargraph
           return_type
         else
           all_items = return_type.items + other.return_type.items
-          if all_items.any? { |item| item.selfy? } && all_items.any? { |item| item.rooted_tag == context.rooted_tag }
+          if all_items.any? { |item| item.selfy? } && all_items.any? { |item| item.rooted_tag == context.reduce_class_type.rooted_tag }
             # assume this was a declaration that should have said 'self'
-            all_items.delete_if { |item| item.rooted_tag == context.rooted_tag }
+            all_items.delete_if { |item| item.rooted_tag == context.reduce_class_type.rooted_tag }
           end
           ComplexType.new(all_items)
         end
@@ -259,6 +259,7 @@ module Solargraph
       def assert_same_macros(other)
         return unless self.source == :yardoc && other.source == :yardoc
         assert_same_count(other, :macros)
+        # @param [YARD::Tags::MacroDirective]
         assert_same_array_content(other, :macros) { |macro| macro.tag.name }
       end
 
@@ -338,7 +339,7 @@ module Solargraph
       # @param other [self]
       # @param attr [::Symbol]
       #
-      # @sg-ignore
+      # @sg-ignore Missing @return tag for Solargraph::Pin::Base#choose_pin_attr
       # @return [undefined]
       def choose_pin_attr(other, attr)
         # @type [Pin::Base, nil]
@@ -353,8 +354,15 @@ module Solargraph
           # :nocov:
         end
         # arbitrary way of choosing a pin
-        # @sg-ignore Need _1 support
-        [val1, val2].compact.min_by { _1.best_location.to_s }
+        [val1, val2].compact.max_by do |closure|
+          [
+            # maximize number of gates, as types in other combined pins may
+            # depend on those gates
+            closure.gates.length,
+            # use basename so that results don't vary system to system
+            File.basename(closure.best_location.to_s)
+          ]
+        end
       end
 
       # @return [void]
@@ -456,9 +464,10 @@ module Solargraph
       # Pin equality is determined using the #nearly? method and also
       # requiring both pins to have the same location.
       #
-      # @param other [self]
+      # @param other [Object]
       def == other
         return false unless nearly? other
+        # @sg-ignore Should add more explicit type check on other
         comments == other.comments && location == other.location
       end
 
@@ -513,7 +522,7 @@ module Solargraph
       # @param api_map [ApiMap]
       # @return [ComplexType]
       def typify api_map
-        return_type.qualify(api_map, namespace)
+        return_type.qualify(api_map, *(closure&.gates || ['']))
       end
 
       # Infer the pin's return type via static code analysis.
@@ -574,12 +583,24 @@ module Solargraph
         @identity ||= "#{closure&.path}|#{name}|#{location}"
       end
 
+      # The namespaces available for resolving the current namespace. Each gate
+      # should be a fully qualified namespace or the root namespace (i.e., an
+      # empty string.)
+      #
+      # Example: Given the name 'Bar' and the gates ['Foo', ''],
+      # the fully qualified namespace should be 'Foo::Bar' or 'Bar'.
+      #
+      # @return [Array<String>]
+      def gates
+        @gates ||= closure&.gates || ['']
+      end
+
       # @return [String, nil]
       def to_rbs
         return_type.to_rbs
       end
 
-      # @return [String]
+      # @return [String, nil]
       def type_desc
         rbs = to_rbs
         # RBS doesn't have a way to represent a Class<x> type

data/lib/solargraph/pin/base_variable.rb

@@ -12,8 +12,9 @@ module Solargraph
       attr_accessor :mass_assignment
 
       # @param return_type [ComplexType, nil]
+      # @param mass_assignment [::Array(Parser::AST::Node, Integer), nil]
       # @param assignment [Parser::AST::Node, nil]
-      def initialize assignment: nil, return_type: nil, **splat
+      def initialize assignment: nil, return_type: nil, mass_assignment: nil, **splat
         super(**splat)
         @assignment = assignment
         # @type [nil, ::Array(Parser::AST::Node, Integer)]
@@ -22,12 +23,12 @@ module Solargraph
       end
 
       def combine_with(other, attrs={})
-        attrs.merge({
+        new_attrs = attrs.merge({
           assignment: assert_same(other, :assignment),
           mass_assignment: assert_same(other, :mass_assignment),
           return_type: combine_return_type(other),
         })
-        super(other, attrs)
+        super(other, new_attrs)
       end
 
       def completion_item_kind
@@ -104,6 +105,7 @@ module Solargraph
       # @param other [Object]
       def == other
         return false unless super
+        # @sg-ignore Should add type check on other
         assignment == other.assignment
       end
 

data/lib/solargraph/pin/block.rb

@@ -54,6 +54,7 @@ module Solargraph
         locals = clip.locals - [self]
         meths = chain.define(api_map, closure, locals)
         # @todo Convert logic to use signatures
+        # @param meth [Pin::Method]
         meths.each do |meth|
           next if meth.block.nil?
 
@@ -69,7 +70,7 @@ module Solargraph
                 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)
+                arg_type.self_to_type(chain.base.infer(api_map, self, locals)).qualify(api_map, *meth.gates)
               end
             end
           end
@@ -96,7 +97,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_type(target)
+        ComplexType.try_parse(*types).qualify(api_map, *receiver_pin.gates).self_to_type(target)
       end
     end
   end

data/lib/solargraph/pin/callable.rb

@@ -27,13 +27,15 @@ module Solargraph
       end
 
       # @param other [self]
-      # @return [Pin::Block, nil]
+      #
+      # @return [Pin::Signature, nil]
       def combine_blocks(other)
         if block.nil?
           other.block
         elsif other.block.nil?
           block
         else
+          # @type [Pin::Signature, nil]
           choose_pin_attr(other, :block)
         end
       end
@@ -61,9 +63,12 @@ module Solargraph
       end
 
       # @param other [self]
+      #
       # @return [Array<Pin::Parameter>]
       def choose_parameters(other)
         raise "Trying to combine two pins with different arities - \nself =#{inspect}, \nother=#{other.inspect}, \n\n self.arity=#{self.arity}, \nother.arity=#{other.arity}" if other.arity != arity
+        # @param param [Pin::Parameter]
+        # @param other_param [Pin::Parameter]
         parameters.zip(other.parameters).map do |param, other_param|
           if param.nil? && other_param.block?
             other_param
@@ -210,7 +215,6 @@ module Solargraph
         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

data/lib/solargraph/pin/closure.rb

@@ -48,19 +48,15 @@ module Solargraph
         @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
+      # @param api_map [Solargraph::ApiMap]
+      # @return [void]
+      def rebind api_map; 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

data/lib/solargraph/pin/delegated_method.rb

@@ -51,7 +51,6 @@ module Solargraph
       %i[typify realize infer probe].each do |method|
         # @param api_map [ApiMap]
         define_method(method) do |api_map|
-          # @sg-ignore Unresolved call to resolve_method
           resolve_method(api_map)
           # @sg-ignore Need to set context correctly in define_method blocks
           @resolved_method ? @resolved_method.send(method, api_map) : super(api_map)

data/lib/solargraph/pin/local_variable.rb

@@ -26,9 +26,6 @@ module Solargraph
           assignment: assert_same(other, :assignment),
           presence_certain: assert_same(other, :presence_certain?),
         }.merge(attrs)
-        # @sg-ignore Wrong argument type for
-        #   Solargraph::Pin::Base#assert_same: other expected
-        #   Solargraph::Pin::Base, received self
         new_attrs[:presence] = assert_same(other, :presence) unless attrs.key?(:presence)
 
         super(other, new_attrs)
@@ -42,7 +39,6 @@ module Solargraph
           match_named_closure(other_closure, closure)
       end
 
-      # @return [String]
       def to_rbs
         (name || '(anon)') + ' ' + (return_type&.to_rbs || 'untyped')
       end

data/lib/solargraph/pin/method.rb

@@ -17,7 +17,7 @@ module Solargraph
 
       # @param visibility [::Symbol] :public, :protected, or :private
       # @param explicit [Boolean]
-      # @param block [Pin::Signature, nil, ::Symbol]
+      # @param block [Pin::Signature, nil, :undefined]
       # @param node [Parser::AST::Node, nil]
       # @param attribute [Boolean]
       # @param signatures [::Array<Signature>, nil]
@@ -34,14 +34,18 @@ module Solargraph
         @anon_splat = anon_splat
       end
 
+      # @param signature_pins [Array<Pin::Signature>]
       # @return [Array<Pin::Signature>]
       def combine_all_signature_pins(*signature_pins)
+        # @type [Hash{Array => Array<Pin::Signature>}]
         by_arity = {}
         signature_pins.each do |signature_pin|
           by_arity[signature_pin.arity] ||= []
           by_arity[signature_pin.arity] << signature_pin
         end
         by_arity.transform_values! do |same_arity_pins|
+          # @param memo [Pin::Signature, nil]
+          # @param signature [Pin::Signature]
           same_arity_pins.reduce(nil) do |memo, signature|
             next signature if memo.nil?
             memo.combine_with(signature)
@@ -88,6 +92,7 @@ module Solargraph
         end
         new_attrs = {
           visibility: combine_visibility(other),
+          # @sg-ignore https://github.com/castwide/solargraph/pull/1050
           explicit: explicit? || other.explicit?,
           block: combine_blocks(other),
           node: choose_node(other, :node),
@@ -298,7 +303,7 @@ module Solargraph
         type = see_reference(api_map) || typify_from_super(api_map)
         logger.debug { "Method#typify(self=#{self}) - type=#{type&.rooted_tags.inspect}" }
         unless type.nil?
-          qualified = type.qualify(api_map, namespace)
+          qualified = type.qualify(api_map, *closure.gates)
           logger.debug { "Method#typify(self=#{self}) => #{qualified.rooted_tags.inspect}" }
           return qualified
         end
@@ -376,11 +381,14 @@ module Solargraph
         @attribute
       end
 
-      # @parm other [Method]
+      # @parm other [self]
       def nearly? other
         super &&
+          # @sg-ignore https://github.com/castwide/solargraph/pull/1050
           parameters == other.parameters &&
+          # @sg-ignore https://github.com/castwide/solargraph/pull/1050
           scope == other.scope &&
+          # @sg-ignore https://github.com/castwide/solargraph/pull/1050
           visibility == other.visibility
       end
 
@@ -392,9 +400,12 @@ module Solargraph
       def overloads
         # Ignore overload tags with nil parameters. If it's not an array, the
         # tag's source is likely malformed.
+
+        # @param tag [YARD::Tags::OverloadTag]
         @overloads ||= docstring.tags(:overload).select(&:parameters).map do |tag|
           Pin::Signature.new(
             generics: generics,
+            # @param src [Array(String, String)]
             parameters: tag.parameters.map do |src|
               name, decl = parse_overload_param(src.first)
               Pin::Parameter.new(
@@ -507,6 +518,7 @@ module Solargraph
       #
       # @return [ComplexType]
       def param_type_from_name(tag, name)
+        # @param t [YARD::Tags::Tag]
         param = tag.tags(:param).select { |t| t.name == name }.first
         return ComplexType::UNDEFINED unless param
         ComplexType.try_parse(*param.types)
@@ -522,8 +534,12 @@ module Solargraph
       # @param api_map [ApiMap]
       # @return [ComplexType, nil]
       def see_reference api_map
+        # This should actually be an intersection type
+        # @param ref [YARD::Tags::Tag, Solargraph::Yard::Tags::RefTag]
         docstring.ref_tags.each do |ref|
+          # @sg-ignore ref should actually be an intersection type
           next unless ref.tag_name == 'return' && ref.owner
+          # @sg-ignore ref should actually be an intersection type
           result = resolve_reference(ref.owner.to_s, api_map)
           return result unless result.nil?
         end
@@ -556,7 +572,7 @@ module Solargraph
         if parts.first.empty? || parts.one?
           path = "#{namespace}#{ref}"
         else
-          fqns = api_map.qualify(parts.first, namespace)
+          fqns = api_map.qualify(parts.first, *gates)
           return ComplexType::UNDEFINED if fqns.nil?
           path = fqns + ref[parts.first.length] + parts.last
         end

data/lib/solargraph/pin/parameter.rb

@@ -166,7 +166,7 @@ module Solargraph
 
       # @param api_map [ApiMap]
       def typify api_map
-        return return_type.qualify(api_map, closure.context.namespace) unless return_type.undefined?
+        return return_type.qualify(api_map, *closure.gates) unless return_type.undefined?
         closure.is_a?(Pin::Block) ? typify_block_param(api_map) : typify_method_param(api_map)
       end
 
@@ -222,7 +222,7 @@ module Solargraph
           if found.nil? and !index.nil?
             found = params[index] if params[index] && (params[index].name.nil? || params[index].name.empty?)
           end
-          return ComplexType.try_parse(*found.types).qualify(api_map, meth.context.namespace) unless found.nil? || found.types.nil?
+          return ComplexType.try_parse(*found.types).qualify(api_map, *meth.closure.gates) unless found.nil? || found.types.nil?
         end
         ComplexType::UNDEFINED
       end
@@ -232,8 +232,12 @@ module Solargraph
       # @param skip [::Array]
       # @return [::Array<YARD::Tags::Tag>]
       def see_reference heredoc, api_map, skip = []
+        # This should actually be an intersection type
+        # @param ref [YARD::Tags::Tag, Solargraph::Yard::Tags::RefTag]
         heredoc.ref_tags.each do |ref|
+          # @sg-ignore ref should actually be an intersection type
           next unless ref.tag_name == 'param' && ref.owner
+          # @sg-ignore ref should actually be an intersection type
           result = resolve_reference(ref.owner.to_s, api_map, skip)
           return result unless result.nil?
         end

data/lib/solargraph/pin/proxy_type.rb

@@ -4,9 +4,12 @@ module Solargraph
   module Pin
     class ProxyType < Base
       # @param return_type [ComplexType]
+      # @param gates [Array<String>, nil] Namespaces to try while resolving non-rooted types
       # @param binder [ComplexType, ComplexType::UniqueType, nil]
-      def initialize return_type: ComplexType::UNDEFINED, binder: nil, **splat
+      # @param gates [Array<String>, nil]
+      def initialize return_type: ComplexType::UNDEFINED, binder: nil, gates: nil, **splat
         super(**splat)
+        @gates = gates
         @return_type = return_type
         @binder = binder if binder
       end

data/lib/solargraph/pin/reference.rb

@@ -18,18 +18,9 @@ module Solargraph
         @generic_values = generic_values
       end
 
-      # @return [String]
-      def parameter_tag
-        @parameter_tag ||= if generic_values&.any?
-                             "<#{generic_values.join(', ')}>"
-                           else
-                             ''
-                           end
-      end
-
       # @return [ComplexType]
-      def parametrized_tag
-        @parametrized_tag ||= ComplexType.try_parse(
+      def type
+        @type ||= ComplexType.try_parse(
           name +
           if generic_values&.length&.> 0
             "<#{generic_values.join(', ')}>"

data/lib/solargraph/pin/search.rb

@@ -42,6 +42,9 @@ module Solargraph
           Result.new(match, pin) if match > 0.7
         end
           .compact
+          # @param a [self]
+          # @param b [self]
+          # @sg-ignore https://github.com/castwide/solargraph/pull/1050
           .sort { |a, b| b.match <=> a.match }
           .map(&:pin)
       end