solargraph 0.56.0 → 0.58.1

data/lib/solargraph/parser/region.rb

@@ -23,8 +23,10 @@ module Solargraph
 
       # @param source [Source]
       # @param namespace [String]
+      # @param closure [Pin::Closure, nil]
       # @param scope [Symbol, nil]
       # @param visibility [Symbol]
+      # @param lvars [Array<Symbol>]
       def initialize source: Solargraph::Source.load_string(''), closure: nil,
                      scope: nil, visibility: :public, lvars: []
         @source = source
@@ -45,6 +47,7 @@ module Solargraph
       # @param closure [Pin::Closure, nil]
       # @param scope [Symbol, nil]
       # @param visibility [Symbol, nil]
+      # @param lvars [Array<Symbol>, nil]
       # @return [Region]
       def update closure: nil, scope: nil, visibility: nil, lvars: nil
         Region.new(

data/lib/solargraph/parser/snippet.rb

@@ -6,6 +6,8 @@ module Solargraph
       # @return [String]
       attr_reader :text
 
+      # @param range [Solargraph::Range]
+      # @param text [String]
       def initialize range, text
         @range = range
         @text = text

data/lib/solargraph/pin/base.rb

@@ -13,10 +13,10 @@ module Solargraph
       # @return [YARD::CodeObjects::Base]
       attr_reader :code_object
 
-      # @return [Solargraph::Location]
+      # @return [Solargraph::Location, nil]
       attr_reader :location
 
-      # @return [Solargraph::Location]
+      # @return [Solargraph::Location, nil]
       attr_reader :type_location
 
       # @return [String]
@@ -28,6 +28,11 @@ module Solargraph
       # @return [::Symbol]
       attr_accessor :source
 
+      # @type [::Numeric, nil] A priority for determining if pins should be combined or not
+      #   A nil priority is considered the be the lowest. All code, yard & rbs pins have nil priority
+      #   Between 2 pins, the one with the higher priority gets chosen. If the priorities are equal, they are combined.
+      attr_reader :combine_priority
+
       def presence_certain?
         true
       end
@@ -40,7 +45,8 @@ module Solargraph
       # @param source [Symbol, nil]
       # @param docstring [YARD::Docstring, nil]
       # @param directives [::Array<YARD::Tags::Directive>, nil]
-      def initialize location: nil, type_location: nil, closure: nil, source: nil, name: '', comments: '', docstring: nil, directives: nil
+      # @param combine_priority [::Numeric, nil] See attr_reader for combine_priority
+      def initialize location: nil, type_location: nil, closure: nil, source: nil, name: '', comments: '', docstring: nil, directives: nil, combine_priority: nil
         @location = location
         @type_location = type_location
         @closure = closure
@@ -50,15 +56,35 @@ module Solargraph
         @identity = nil
         @docstring = docstring
         @directives = directives
+        @combine_priority = combine_priority
+
         assert_source_provided
+        assert_location_provided
+      end
+
+      # @return [void]
+      def assert_location_provided
+        return unless best_location.nil? && %i[yardoc source rbs].include?(source)
+
+        Solargraph.assert_or_log(:best_location, "Neither location nor type_location provided - #{path} #{source} #{self.class}")
+      end
+
+      # @return [Pin::Closure, nil]
+      def closure
+        Solargraph.assert_or_log(:closure, "Closure not set on #{self.class} #{name.inspect} from #{source.inspect}") unless @closure
+        # @type [Pin::Closure, nil]
+        @closure
       end
 
       # @param other [self]
-      # @param attrs [Hash{Symbol => Object}]
+      # @param attrs [Hash{::Symbol => Object}]
       #
       # @return [self]
       def combine_with(other, attrs={})
         raise "tried to combine #{other.class} with #{self.class}" unless other.class == self.class
+        priority_choice = choose_priority(other)
+        return priority_choice unless priority_choice.nil?
+
         type_location = choose(other, :type_location)
         location = choose(other, :location)
         combined_name = combine_name(other)
@@ -71,6 +97,7 @@ module Solargraph
           source: :combined,
           docstring: choose(other, :docstring),
           directives: combine_directives(other),
+          combine_priority: combine_priority
         }.merge(attrs)
         assert_same_macros(other)
         logger.debug { "Base#combine_with(path=#{path}) - other.comments=#{other.comments.inspect}, self.comments = #{self.comments}" }
@@ -79,6 +106,25 @@ module Solargraph
         out
       end
 
+      # @param other [self]
+      # @return [self, nil] Returns either the pin chosen based on priority or nil
+      #   A nil return means that the combination process must proceed
+      def choose_priority(other)
+        if combine_priority.nil? && !other.combine_priority.nil?
+          return other
+        elsif other.combine_priority.nil? && !combine_priority.nil?
+          return self
+        elsif !combine_priority.nil? && !other.combine_priority.nil?
+          if combine_priority > other.combine_priority
+            return self
+          elsif combine_priority < other.combine_priority
+            return other
+          end
+        end
+
+        nil
+      end
+
       # @param other [self]
       # @param attr [::Symbol]
       # @sg-ignore
@@ -90,7 +136,6 @@ module Solargraph
         val2 = other.send(attr)
         return val1 if val1 == val2
         return val2 if val1.nil?
-        # @sg-ignore
         val1.length > val2.length ? val1 : val2
       end
 
@@ -150,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
@@ -180,7 +225,7 @@ module Solargraph
       end
 
       # @param other [self]
-      # @param attr [Symbol]
+      # @param attr [::Symbol]
       # @sg-ignore
       # @return [undefined]
       def choose_node(other, attr)
@@ -214,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
 
@@ -229,7 +275,6 @@ module Solargraph
         raise "Expected #{attr} on #{other} to be an Enumerable, got #{arr2.class}" unless arr2.is_a?(::Enumerable)
         # @type arr2 [::Enumerable]
 
-        # @sg-ignore
         # @type [undefined]
         values1 = arr1.map(&block)
         # @type [undefined]
@@ -261,7 +306,8 @@ module Solargraph
       # @param other [self]
       # @param attr [::Symbol]
       #
-      # @return [Object, nil]
+      # @sg-ignore
+      # @return [undefined]
       def assert_same(other, attr)
         return false if other.nil?
         val1 = send(attr)
@@ -290,20 +336,36 @@ module Solargraph
         choose_pin_attr(other, attr)
       end
 
+      # @param other [self]
+      # @param attr [::Symbol]
+      #
+      # @sg-ignore Missing @return tag for Solargraph::Pin::Base#choose_pin_attr
+      # @return [undefined]
       def choose_pin_attr(other, attr)
         # @type [Pin::Base, nil]
         val1 = send(attr)
         # @type [Pin::Base, nil]
         val2 = other.send(attr)
         if val1.class != val2.class
+          # :nocov:
           Solargraph.assert_or_log("combine_with_#{attr}_class".to_sym,
                                    "Inconsistent #{attr.inspect} class values between \nself =#{inspect} and \nother=#{other.inspect}:\n\n self.#{attr} = #{val1.inspect}\nother.#{attr} = #{val2.inspect}")
           return val1
+          # :nocov:
         end
         # arbitrary way of choosing a pin
-        [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]
       def assert_source_provided
         Solargraph.assert_or_log(:source, "source not provided - #{@path} #{@source} #{self.class}") if source.nil?
       end
@@ -402,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
 
@@ -459,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.
@@ -520,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
@@ -548,6 +623,7 @@ module Solargraph
         "name=#{name.inspect} return_type=#{type_desc}, context=#{context.rooted_tags}, closure=#{closure_info}, binder=#{binder_info}"
       end
 
+      # @return [String]
       def desc
         "[#{inner_desc}]"
       end
@@ -557,6 +633,7 @@ module Solargraph
         "#<#{self.class} `#{self.inner_desc}`#{all_location_text} via #{source.inspect}>"
       end
 
+      # @return [String]
       def all_location_text
         if location.nil? && type_location.nil?
           ''
@@ -569,6 +646,7 @@ module Solargraph
         end
       end
 
+      # @return [void]
       def reset_generated!
       end
 

data/lib/solargraph/pin/base_variable.rb

@@ -3,8 +3,8 @@
 module Solargraph
   module Pin
     class BaseVariable < Base
-      include Solargraph::Parser::NodeMethods
       # include Solargraph::Source::NodeMethods
+      include Solargraph::Parser::NodeMethods
 
       # @return [Parser::AST::Node, nil]
       attr_reader :assignment
@@ -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
@@ -43,7 +44,6 @@ module Solargraph
         @return_type ||= generate_complex_type
       end
 
-      # @sg-ignore
       def nil_assignment?
         # this will always be false - should it be return_type ==
         #   ComplexType::NIL or somesuch?
@@ -105,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

@@ -21,16 +21,21 @@ module Solargraph
         @parameters = parameters
       end
 
+      # @return [String]
       def method_namespace
         closure.namespace
       end
 
+      # @param other [self]
+      #
+      # @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
@@ -57,8 +62,13 @@ 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
@@ -70,6 +80,7 @@ module Solargraph
         end
       end
 
+      # @return [Array<Pin::Parameter>]
       def blockless_parameters
         if parameters.last&.block?
           parameters[0..-2]
@@ -78,6 +89,7 @@ module Solargraph
         end
       end
 
+      # @return [Array]
       def arity
         [generics, blockless_parameters.map(&:arity_decl), block&.arity]
       end
@@ -125,6 +137,7 @@ module Solargraph
         end
       end
 
+      # @return [String]
       def method_name
         raise "closure was nil in #{self.inspect}" if closure.nil?
         @method_name ||= closure.name
@@ -197,11 +210,11 @@ module Solargraph
         true
       end
 
+      # @return [Integer]
       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

data/lib/solargraph/pin/closure.rb

@@ -8,6 +8,7 @@ module Solargraph
 
       # @param scope [::Symbol] :class or :instance
       # @param generics [::Array<Pin::Parameter>, nil]
+      # @param generic_defaults [Hash{String => ComplexType}]
       def initialize scope: :class, generics: nil, generic_defaults: {},  **splat
         super(**splat)
         @scope = scope
@@ -15,6 +16,7 @@ module Solargraph
         @generic_defaults = generic_defaults
       end
 
+      # @return [Hash{String => ComplexType}]
       def generic_defaults
         @generic_defaults ||= {}
       end
@@ -46,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/common.rb

@@ -3,12 +3,16 @@
 module Solargraph
   module Pin
     module Common
+      # @!method source
+      #   @abstract
+      #   @return [Source, nil]
+      # @type @closure [Pin::Closure, nil]
+
       # @return [Location]
       attr_reader :location
 
+      # @sg-ignore Solargraph::Pin::Common#closure return type could not be inferred
       # @return [Pin::Closure, nil]
-      attr_reader :closure
-
       def closure
         Solargraph.assert_or_log(:closure, "Closure not set on #{self.class} #{name.inspect} from #{source.inspect}") unless @closure
         @closure

data/lib/solargraph/pin/constant.rb

@@ -5,6 +5,8 @@ module Solargraph
     class Constant < BaseVariable
       attr_reader :visibility
 
+      # @param visibility [::Symbol] The visibility of the constant (:public, :protected, or :private)
+      # @param splat [Hash] Additional options supported by superclasses
       def initialize visibility: :public, **splat
         super(**splat)
         @visibility = visibility

data/lib/solargraph/pin/local_variable.rb

@@ -26,7 +26,7 @@ module Solargraph
           assignment: assert_same(other, :assignment),
           presence_certain: assert_same(other, :presence_certain?),
         }.merge(attrs)
-        new_attrs[:presence] =  assert_same(other, :presence) unless attrs.key?(:presence)
+        new_attrs[:presence] = assert_same(other, :presence) unless attrs.key?(:presence)
 
         super(other, new_attrs)
       end
@@ -39,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,12 +17,13 @@ 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]
       # @param anon_splat [Boolean]
-      def initialize visibility: :public, explicit: true, block: :undefined, node: nil, attribute: false, signatures: nil, anon_splat: false, **splat
+      def initialize visibility: :public, explicit: true, block: :undefined, node: nil, attribute: false, signatures: nil, anon_splat: false,
+                     **splat
         super(**splat)
         @visibility = visibility
         @explicit = explicit
@@ -33,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)
@@ -50,7 +55,7 @@ module Solargraph
       end
 
       # @param other [Pin::Method]
-      # @return [Symbol]
+      # @return [::Symbol]
       def combine_visibility(other)
         if dodgy_visibility_source? && !other.dodgy_visibility_source?
           other.visibility
@@ -76,6 +81,9 @@ module Solargraph
       end
 
       def combine_with(other, attrs = {})
+        priority_choice = choose_priority(other)
+        return priority_choice unless priority_choice.nil?
+
         sigs = combine_signatures(other)
         parameters = if sigs.length > 0
           [].freeze
@@ -84,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),
@@ -199,9 +208,11 @@ module Solargraph
             )
           end
           yield_return_type = ComplexType.try_parse(*yieldreturn_tags.flat_map(&:types))
-          block = Signature.new(generics: generics, parameters: yield_parameters, return_type: yield_return_type, source: source, closure: self)
+          block = Signature.new(generics: generics, parameters: yield_parameters, return_type: yield_return_type, source: source,
+                                closure: self, location: location, type_location: type_location)
         end
-        signature = Signature.new(generics: generics, parameters: parameters, return_type: return_type, block: block, closure: self, source: source)
+        signature = Signature.new(generics: generics, parameters: parameters, return_type: return_type, block: block, closure: self, source: source,
+                                  location: location, type_location: type_location)
         block.closure = signature if block
         signature
       end
@@ -292,14 +303,13 @@ 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
         super
       end
 
-      # @sg-ignore
       def documentation
         if @documentation.nil?
           method_docs ||= super || ''
@@ -371,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
 
@@ -387,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(
@@ -423,7 +439,7 @@ module Solargraph
         @resolved_ref_tag = true
         return self unless docstring.ref_tags.any?
         docstring.ref_tags.each do |tag|
-          ref = if tag.owner.to_s.start_with?(/[#\.]/)
+          ref = if tag.owner.to_s.start_with?(/[#.]/)
             api_map.get_methods(namespace)
                    .select { |pin| pin.path.end_with?(tag.owner.to_s) }
                    .first
@@ -502,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)
@@ -517,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
@@ -547,11 +568,11 @@ module Solargraph
       # @param api_map [ApiMap]
       # @return [ComplexType, nil]
       def resolve_reference ref, api_map
-        parts = ref.split(/[\.#]/)
+        parts = ref.split(/[.#]/)
         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