solargraph 0.51.2 → 0.54.2

data/lib/solargraph/api_map.rb

@@ -1,22 +1,17 @@
 # frozen_string_literal: true
 
-require 'rubygems'
-require 'set'
 require 'pathname'
 require 'yard'
-require 'yard-solargraph'
+require 'solargraph/yard_tags'
 
 module Solargraph
-  # An aggregate provider for information about workspaces, sources, gems, and
+  # An aggregate provider for information about Workspaces, Sources, gems, and
   # the Ruby core.
   #
   class ApiMap
     autoload :Cache,          'solargraph/api_map/cache'
     autoload :SourceToYard,   'solargraph/api_map/source_to_yard'
     autoload :Store,          'solargraph/api_map/store'
-    autoload :BundlerMethods, 'solargraph/api_map/bundler_methods'
-
-    include SourceToYard
 
     # @return [Array<String>]
     attr_reader :unresolved_requires
@@ -34,6 +29,25 @@ module Solargraph
       index pins
     end
 
+    #
+    # This is a mutable object, which is cached in the Chain class -
+    # if you add any fields which change the results of calls (not
+    # just caches), please also change `equality_fields` below.
+    #
+
+    def eql?(other)
+      self.class == other.class &&
+        equality_fields == other.equality_fields
+    end
+
+    def ==(other)
+      self.eql?(other)
+    end
+
+    def hash
+      equality_fields.hash
+    end
+
     # @param pins [Array<Pin::Base>]
     # @return [self]
     def index pins
@@ -59,34 +73,44 @@ module Solargraph
     # Catalog a bench.
     #
     # @param bench [Bench]
+    # @return [self]
     def catalog bench
-      implicit.clear
-      @cache.clear
+      old_api_hash = @source_map_hash&.values&.map(&:api_hash)
+      need_to_uncache = (old_api_hash != bench.source_maps.map(&:api_hash))
       @source_map_hash = bench.source_maps.map { |s| [s.filename, s] }.to_h
-      pins = bench.source_maps.map(&:pins).flatten
-      external_requires = bench.external_requires
+      pins = bench.source_maps.flat_map(&:pins).flatten
+      implicit.clear
       source_map_hash.each_value do |map|
         implicit.merge map.environ
       end
-      external_requires.merge implicit.requires
-      external_requires.merge bench.workspace.config.required
-      @rbs_maps = external_requires.map { |r| load_rbs_map(r) }
-      unresolved_requires = @rbs_maps.reject(&:resolved?).map(&:library)
-      yard_map.change(unresolved_requires, bench.workspace.directory, bench.workspace.source_gems)
-      @store = Store.new(@@core_map.pins + @rbs_maps.flat_map(&:pins) + yard_map.pins + implicit.pins + pins)
-      @unresolved_requires = yard_map.unresolved_requires
-      @missing_docs = yard_map.missing_docs
-      @rebindable_method_names = nil
-      store.block_pins.each { |blk| blk.rebind(self) }
+      unresolved_requires = (bench.external_requires + implicit.requires + bench.workspace.config.required).to_a.compact.uniq
+      if @unresolved_requires != unresolved_requires || @doc_map&.uncached_gemspecs&.any?
+        @doc_map = DocMap.new(unresolved_requires, [], bench.workspace.rbs_collection_path) # @todo Implement gem preferences
+        @unresolved_requires = unresolved_requires
+        need_to_uncache = true
+      end
+      @store = Store.new(@@core_map.pins + @doc_map.pins + implicit.pins + pins)
+      @cache.clear if need_to_uncache
+
+      @missing_docs = [] # @todo Implement missing docs
       self
     end
 
-    def core_pins
-      @@core_map.pins
+    # @todo need to model type def statement in chains as a symbol so
+    #   that this overload of 'protected' will typecheck @sg-ignore
+    # @sg-ignore
+    protected def equality_fields
+      [self.class, @source_map_hash, implicit, @doc_map, @unresolved_requires, @missing_docs]
+    end
+
+    # @return [::Array<Gem::Specification>]
+    def uncached_gemspecs
+      @doc_map&.uncached_gemspecs || []
     end
 
-    def yard_map
-      @yard_map ||= YardMap.new
+    # @return [Array<Pin::Base>]
+    def core_pins
+      @@core_map.pins
     end
 
     # @param name [String]
@@ -95,6 +119,7 @@ module Solargraph
       store.named_macros[name]
     end
 
+    # @return [Set<String>]
     def required
       @required ||= Set.new
     end
@@ -120,7 +145,7 @@ module Solargraph
     # @return [SourceMap::Clip]
     def clip_at filename, position
       position = Position.normalize(position)
-      SourceMap::Clip.new(self, cursor_at(filename, position))
+      clip(cursor_at(filename, position))
     end
 
     # Create an ApiMap with a workspace in the specified directory.
@@ -137,22 +162,33 @@ module Solargraph
       api_map
     end
 
+    # Create an ApiMap with a workspace in the specified directory and cache
+    # any missing gems.
+    #
+    #
+    # @todo IO::NULL is incorrectly inferred to be a String.
+    # @sg-ignore
+    #
+    # @param directory [String]
+    # @param out [IO] The output stream for messages
+    # @return [ApiMap]
+    def self.load_with_cache directory, out = IO::NULL
+      api_map = load(directory)
+      return api_map if api_map.uncached_gemspecs.empty?
+
+      api_map.uncached_gemspecs.each do |gemspec|
+        out.puts "Caching gem #{gemspec.name} #{gemspec.version}"
+        pins = GemPins.build(gemspec)
+        Solargraph::Cache.save('gems', "#{gemspec.name}-#{gemspec.version}.ser", pins)
+      end
+      load(directory)
+    end
+
     # @return [Array<Solargraph::Pin::Base>]
     def pins
       store.pins
     end
 
-    def rebindable_method_names
-      @rebindable_method_names ||= begin
-        # result = yard_map.rebindable_method_names
-        result = ['instance_eval', 'instance_exec', 'class_eval', 'class_exec', 'module_eval', 'module_exec', 'define_method'].to_set
-        source_maps.each do |map|
-          result.merge map.rebindable_method_names
-        end
-        result
-      end
-    end
-
     # An array of pins based on Ruby keywords (`if`, `end`, etc.).
     #
     # @return [Enumerable<Solargraph::Pin::Keyword>]
@@ -199,22 +235,62 @@ module Solargraph
       result
     end
 
-    # Get a fully qualified namespace name. This method will start the search
-    # in the specified context until it finds a match for the name.
+    # @param namespace [String]
+    # @param context [String]
+    # @return [Array<Pin::Namespace>]
+    def get_namespace_pins namespace, context
+      store.fqns_pins(qualify(namespace, context))
+    end
+
+    # Determine fully qualified tag for a given tag used inside the
+    # definition of another tag ("context"). This method will start
+    # the search in the specified context until it finds a match for
+    # the tag.
     #
-    # @param namespace [String, nil] The namespace to match
-    # @param context [String] The context to search
-    # @return [String, nil]
-    def qualify namespace, context = ''
-      return namespace if ['self', nil].include?(namespace)
-      cached = cache.get_qualified_namespace(namespace, context)
+    # Does not recurse into qualifying the type parameters, but
+    # returns any which were passed in unchanged.
+    #
+    # @param tag [String, nil] The namespace to
+    #   match, complete with generic parameters set to appropriate
+    #   values if available
+    # @param context_tag [String] The fully qualified context in which
+    #   the tag was referenced; start from here to resolve the name.
+    #   Should not be prefixed with '::'.
+    # @return [String, nil] fully qualified tag
+    def qualify tag, context_tag = ''
+      return tag if ['self', nil].include?(tag)
+
+      context_type = ComplexType.parse(context_tag).force_rooted
+      return unless context_type
+
+      type = ComplexType.try_parse(tag)
+      return unless type
+
+      fqns = qualify_namespace(type.rooted_namespace, context_type.namespace)
+      return unless fqns
+
+      fqns + type.substring
+    end
+
+    # Determine fully qualified namespace for a given namespace used
+    # inside the definition of another tag ("context"). This method
+    # will start the search in the specified context until it finds a
+    # match for the namespace.
+    #
+    # @param namespace [String, nil] The namespace to
+    #   match
+    # @param context_namespace [String] The context namespace in which the
+    #   tag was referenced; start from here to resolve the name
+    # @return [String, nil] fully qualified namespace
+    def qualify_namespace(namespace, context_namespace = '')
+      cached = cache.get_qualified_namespace(namespace, context_namespace)
       return cached.clone unless cached.nil?
       result = if namespace.start_with?('::')
                  inner_qualify(namespace[2..-1], '', Set.new)
                else
-                 inner_qualify(namespace, context, Set.new)
+                 inner_qualify(namespace, context_namespace, Set.new)
                end
-      cache.set_qualified_namespace(namespace, context, result)
+      cache.set_qualified_namespace(namespace, context_namespace, result)
       result
     end
 
@@ -240,50 +316,82 @@ module Solargraph
     # Get an array of class variable pins for a namespace.
     #
     # @param namespace [String] A fully qualified namespace
-    # @return [Array<Solargraph::Pin::ClassVariable>]
+    # @return [Enumerable<Solargraph::Pin::ClassVariable>]
     def get_class_variable_pins(namespace)
       prefer_non_nil_variables(store.get_class_variables(namespace))
     end
 
-    # @return [Array<Solargraph::Pin::Base>]
+    # @return [Enumerable<Solargraph::Pin::Base>]
     def get_symbols
       store.get_symbols
     end
 
-    # @return [Array<Solargraph::Pin::GlobalVariable>]
+    # @return [Enumerable<Solargraph::Pin::GlobalVariable>]
     def get_global_variable_pins
       store.pins_by_class(Pin::GlobalVariable)
     end
 
+    # @return [Enumerable<Solargraph::Pin::Block>]
+    def get_block_pins
+      store.pins_by_class(Pin::Block)
+    end
+
     # Get an array of methods available in a particular context.
     #
-    # @param fqns [String] The fully qualified namespace to search for methods
+    # @param rooted_tag [String] The fully qualified namespace to search for methods
     # @param scope [Symbol] :class or :instance
     # @param visibility [Array<Symbol>] :public, :protected, and/or :private
     # @param deep [Boolean] True to include superclasses, mixins, etc.
     # @return [Array<Solargraph::Pin::Method>]
-    def get_methods fqns, scope: :instance, visibility: [:public], deep: true
-      cached = cache.get_methods(fqns, scope, visibility, deep)
+    def get_methods rooted_tag, scope: :instance, visibility: [:public], deep: true
+      rooted_type = ComplexType.try_parse(rooted_tag)
+      fqns = rooted_type.namespace
+      namespace_pin = store.get_path_pins(fqns).select { |p| p.is_a?(Pin::Namespace) }.first
+      cached = cache.get_methods(rooted_tag, scope, visibility, deep)
       return cached.clone unless cached.nil?
       result = []
       skip = Set.new
-      if fqns == ''
+      if rooted_tag == ''
         # @todo Implement domains
         implicit.domains.each do |domain|
           type = ComplexType.try_parse(domain)
           next if type.undefined?
           result.concat inner_get_methods(type.name, type.scope, visibility, deep, skip)
         end
-        result.concat inner_get_methods(fqns, :class, visibility, deep, skip)
-        result.concat inner_get_methods(fqns, :instance, visibility, deep, skip)
+        result.concat inner_get_methods(rooted_tag, :class, visibility, deep, skip)
+        result.concat inner_get_methods(rooted_tag, :instance, visibility, deep, skip)
         result.concat inner_get_methods('Kernel', :instance, visibility, deep, skip)
       else
-        result.concat inner_get_methods(fqns, scope, visibility, deep, skip)
+        result.concat inner_get_methods(rooted_tag, scope, visibility, deep, skip)
+        unless %w[Class Class<Class>].include?(rooted_tag)
+          result.map! do |pin|
+            next pin unless pin.path == 'Class#new'
+            init_pin = get_method_stack(rooted_tag, 'initialize').first
+            next pin unless init_pin
+
+            type = ComplexType.try_parse(ComplexType.try_parse(rooted_tag).namespace)
+            Pin::Method.new(
+              name: 'new',
+              scope: :class,
+              location: init_pin.location,
+              parameters: init_pin.parameters,
+              signatures: init_pin.signatures.map { |sig| sig.proxy(type) },
+              return_type: type,
+              comments: init_pin.comments,
+              closure: init_pin.closure
+            # @todo Hack to force TypeChecker#internal_or_core?
+            ).tap { |pin| pin.source = :rbs }
+          end
+        end
         result.concat inner_get_methods('Kernel', :instance, [:public], deep, skip) if visibility.include?(:private)
+        result.concat inner_get_methods('Module', scope, visibility, deep, skip) if scope == :module
       end
-      resolved = resolve_method_aliases(result, visibility)
-      cache.set_methods(fqns, scope, visibility, deep, resolved)
-      resolved
+      result = resolve_method_aliases(result, visibility)
+      if namespace_pin && rooted_tag != rooted_type.name
+        result = result.map { |method_pin| method_pin.resolve_generics(namespace_pin, rooted_type) }
+      end
+      cache.set_methods(rooted_tag, scope, visibility, deep, result)
+      result
     end
 
     # Get an array of method pins for a complex type.
@@ -320,27 +428,32 @@ module Solargraph
               visibility.push :protected
               visibility.push :private if internal
             end
-            result.merge get_methods(type.namespace, scope: type.scope, visibility: visibility)
+            result.merge get_methods(type.tag, scope: type.scope, visibility: visibility)
           end
         end
       end
       result.to_a
     end
 
-    # Get a stack of method pins for a method name in a namespace. The order
-    # of the pins corresponds to the ancestry chain, with highest precedence
-    # first.
+    # Get a stack of method pins for a method name in a potentially
+    # parameterized namespace. The order of the pins corresponds to
+    # the ancestry chain, with highest precedence first.
     #
     # @example
     #   api_map.get_method_stack('Subclass', 'method_name')
     #     #=> [ <Subclass#method_name pin>, <Superclass#method_name pin> ]
     #
-    # @param fqns [String]
-    # @param name [String]
+    # @param rooted_tag [String] Parameterized namespace, fully qualified
+    # @param name [String] Method name to look up
     # @param scope [Symbol] :instance or :class
     # @return [Array<Solargraph::Pin::Method>]
-    def get_method_stack fqns, name, scope: :instance
-      get_methods(fqns, scope: scope, visibility: [:private, :protected, :public]).select { |p| p.name == name }
+    def get_method_stack rooted_tag, name, scope: :instance, visibility: [:private, :protected, :public], preserve_generics: false
+      rooted_type = ComplexType.parse(rooted_tag)
+      fqns = rooted_type.namespace
+      namespace_pin = store.get_path_pins(fqns).select { |p| p.is_a?(Pin::Namespace) }.first
+      methods = get_methods(rooted_tag, scope: scope, visibility: visibility).select { |p| p.name == name }
+      methods = erase_generics(namespace_pin, rooted_type, methods) unless preserve_generics
+      methods
     end
 
     # Get an array of all suggestions that match the specified path.
@@ -348,7 +461,7 @@ module Solargraph
     # @deprecated Use #get_path_pins instead.
     #
     # @param path [String] The path to find
-    # @return [Array<Solargraph::Pin::Base>]
+    # @return [Enumerable<Solargraph::Pin::Base>]
     def get_path_suggestions path
       return [] if path.nil?
       resolve_method_aliases store.get_path_pins(path)
@@ -357,7 +470,7 @@ module Solargraph
     # Get an array of pins that match the specified path.
     #
     # @param path [String]
-    # @return [Array<Pin::Base>]
+    # @return [Enumerable<Pin::Base>]
     def get_path_pins path
       get_path_suggestions(path)
     end
@@ -370,15 +483,9 @@ module Solargraph
     # @param query [String] The text to match
     # @return [Array<String>]
     def search query
-      rake_yard(store)
-      found = []
-      code_object_paths.each do |k|
-        if (found.empty? || (query.include?('.') || query.include?('#')) || !(k.include?('.') || k.include?('#'))) &&
-           k.downcase.include?(query.downcase)
-          found.push k
-        end
-      end
-      found
+      pins.map(&:path)
+          .compact
+          .select { |path| path.downcase.include?(query.downcase) }
     end
 
     # Get YARD documentation for the specified path.
@@ -386,13 +493,13 @@ module Solargraph
     # @example
     #   api_map.document('String#split')
     #
+    # @todo This method is likely superfluous. Calling get_path_pins directly
+    #   should be sufficient.
+    #
     # @param path [String] The path to find
-    # @return [Array<YARD::CodeObjects::Base>]
+    # @return [Enumerable<Pin::Base>]
     def document path
-      rake_yard(store)
-      docs = []
-      docs.push code_object_at(path) unless code_object_at(path).nil?
-      docs
+      get_path_pins(path)
     end
 
     # Get an array of all symbols in the workspace that match the query.
@@ -418,6 +525,7 @@ module Solargraph
     # @return [SourceMap::Clip]
     def clip cursor
       raise FileNotFoundError, "ApiMap did not catalog #{cursor.filename}" unless source_map_hash.key?(cursor.filename)
+
       SourceMap::Clip.new(self, cursor)
     end
 
@@ -469,13 +577,15 @@ module Solargraph
       false
     end
 
-    # Check if the host class includes the specified module.
+    # Check if the host class includes the specified module, ignoring
+    # type parameters used.
+    #
+    # @param host_ns [String] The class namesapce (no type parameters)
+    # @param module_ns [String] The module namespace (no type parameters)
     #
-    # @param host [String] The class
-    # @param mod [String] The module
     # @return [Boolean]
-    def type_include?(host, mod)
-      store.get_includes(host).include?(mod)
+    def type_include?(host_ns, module_ns)
+      store.get_includes(host_ns).map { |inc_tag| ComplexType.parse(inc_tag).name }.include?(module_ns)
     end
 
     private
@@ -485,14 +595,6 @@ module Solargraph
     # @return [Hash{String => SourceMap}]
     attr_reader :source_map_hash
 
-    # @param library [String]
-    # @return [RbsMap]
-    def load_rbs_map library
-      # map = RbsMap.load(library)
-      # return map if map.resolved?
-      RbsMap::StdlibMap.load(library)
-    end
-
     # @return [ApiMap::Store]
     def store
       @store ||= Store.new
@@ -501,15 +603,20 @@ module Solargraph
     # @return [Solargraph::ApiMap::Cache]
     attr_reader :cache
 
-    # @param fqns [String] A fully qualified namespace
+    # @param rooted_tag [String] A fully qualified namespace, with
+    #   generic parameter values if applicable
     # @param scope [Symbol] :class or :instance
     # @param visibility [Array<Symbol>] :public, :protected, and/or :private
     # @param deep [Boolean]
     # @param skip [Set<String>]
     # @param no_core [Boolean] Skip core classes if true
     # @return [Array<Pin::Base>]
-    def inner_get_methods fqns, scope, visibility, deep, skip, no_core = false
-      return [] if no_core && fqns =~ /^(Object|BasicObject|Class|Module|Kernel)$/
+    def inner_get_methods rooted_tag, scope, visibility, deep, skip, no_core = false
+      rooted_type = ComplexType.parse(rooted_tag).force_rooted
+      fqns = rooted_type.namespace
+      fqns_generic_params = rooted_type.all_params
+      namespace_pin = store.get_path_pins(fqns).select { |p| p.is_a?(Pin::Namespace) }.first
+      return [] if no_core && fqns =~ /^(Object|BasicObject|Class|Module)$/
       reqstr = "#{fqns}|#{scope}|#{visibility.sort}|#{deep}"
       return [] if skip.include?(reqstr)
       skip.add reqstr
@@ -520,12 +627,25 @@ module Solargraph
           result.concat inner_get_methods(fqim, scope, visibility, deep, skip, true) unless fqim.nil?
         end
       end
-      result.concat store.get_methods(fqns, scope: scope, visibility: visibility).sort{ |a, b| a.name <=> b.name }
+      # Store#get_methods doesn't know about full tags, just
+      # namespaces; resolving the generics in the method pins is this
+      # class' responsibility
+      methods = store.get_methods(fqns, scope: scope, visibility: visibility).sort{ |a, b| a.name <=> b.name }
+      result.concat methods
       if deep
         if scope == :instance
-          store.get_includes(fqns).reverse.each do |im|
-            fqim = qualify(im, fqns)
-            result.concat inner_get_methods(fqim, scope, visibility, deep, skip, true) unless fqim.nil?
+          store.get_includes(fqns).reverse.each do |include_tag|
+            rooted_include_tag = qualify(include_tag, rooted_tag)
+            # Ensure the types returned by the included methods are
+            # relative to the generics passed to the include.  e.g.,
+            # Foo<String> might include Enumerable<String>
+            #
+            # @todo perform the same translation in the other areas
+            #  here after adding a spec and handling things correctly
+            #  in ApiMap::Store and RbsMap::Conversions
+            resolved_include_type = ComplexType.parse(rooted_include_tag).force_rooted.resolve_generics(namespace_pin, rooted_type)
+            methods = inner_get_methods(resolved_include_type.tag, scope, visibility, deep, skip, true)
+            result.concat methods
           end
           fqsc = qualify_superclass(fqns)
           unless fqsc.nil?
@@ -584,11 +704,13 @@ module Solargraph
 
     # @param namespace [String]
     # @param context [String]
-    # @return [String]
+    # @return [String, nil]
     def qualify_lower namespace, context
       qualify namespace, context.split('::')[0..-2].join('::')
     end
 
+    # @param fqsub [String]
+    # @return [String, nil]
     def qualify_superclass fqsub
       sup = store.get_superclass(fqsub)
       return nil if sup.nil?
@@ -598,11 +720,12 @@ module Solargraph
       qualify(sup, parts.join('::'))
     end
 
-    # @param name [String]
-    # @param root [String]
-    # @param skip [Set<String>]
-    # @return [String, nil]
+    # @param name [String] Namespace to fully qualify
+    # @param root [String] The context to search
+    # @param skip [Set<String>] Contexts already searched
+    # @return [String, nil] Fully qualified ("rooted") namespace
     def inner_qualify name, root, skip
+      return name if name == ComplexType::GENERIC_TAG_NAME
       return nil if name.nil?
       return nil if skip.include?(root)
       skip.add root
@@ -652,8 +775,8 @@ module Solargraph
 
     # Sort an array of pins to put nil or undefined variables last.
     #
-    # @param pins [Array<Solargraph::Pin::Base>]
-    # @return [Array<Solargraph::Pin::Base>]
+    # @param pins [Enumerable<Solargraph::Pin::Base>]
+    # @return [Enumerable<Solargraph::Pin::Base>]
     def prefer_non_nil_variables pins
       result = []
       nil_pins = []
@@ -667,38 +790,74 @@ module Solargraph
       result + nil_pins
     end
 
-    # @param pins [Array<Pin::Base>]
-    # @param visibility [Array<Symbol>]
+    # @param pins [Enumerable<Pin::Base>]
+    # @param visibility [Enumerable<Symbol>]
     # @return [Array<Pin::Base>]
     def resolve_method_aliases pins, visibility = [:public, :private, :protected]
-      result = []
-      pins.each do |pin|
+      pins.map do |pin|
         resolved = resolve_method_alias(pin)
-        next if resolved.respond_to?(:visibility) && !visibility.include?(resolved.visibility)
-        result.push resolved
-      end
-      result
+        next pin if resolved.respond_to?(:visibility) && !visibility.include?(resolved.visibility)
+        resolved
+      end.compact
     end
 
     # @param pin [Pin::MethodAlias, Pin::Base]
     # @return [Pin::Method]
     def resolve_method_alias pin
-      return pin if !pin.is_a?(Pin::MethodAlias) || @method_alias_stack.include?(pin.path)
+      return pin unless pin.is_a?(Pin::MethodAlias)
+      return nil if @method_alias_stack.include?(pin.path)
       @method_alias_stack.push pin.path
-      origin = get_method_stack(pin.full_context.namespace, pin.original, scope: pin.scope).first
+      origin = get_method_stack(pin.full_context.tag, pin.original, scope: pin.scope).first
       @method_alias_stack.pop
-      return pin if origin.nil?
+      return nil if origin.nil?
       args = {
         location: pin.location,
         closure: pin.closure,
         name: pin.name,
         comments: origin.comments,
         scope: origin.scope,
+#        context: pin.context,
         visibility: origin.visibility,
         signatures: origin.signatures,
-        attribute: origin.attribute?
+        attribute: origin.attribute?,
+        generics: origin.generics,
+        return_type: origin.return_type,
       }
       Pin::Method.new **args
     end
+
+    include Logging
+
+    private
+
+    # @param namespace_pin [Pin::Namespace]
+    # @param rooted_type [ComplexType]
+    # @param pins [Enumerable<Pin::Base>]
+    # @return [Array<Pin::Base>]
+    def erase_generics(namespace_pin, rooted_type, pins)
+      return pins unless should_erase_generics_when_done?(namespace_pin, rooted_type)
+
+      logger.debug("Erasing generics on namespace_pin=#{namespace_pin} / rooted_type=#{rooted_type}")
+      pins.map do |method_pin|
+        method_pin.erase_generics(namespace_pin.generics)
+      end
+    end
+
+    # @param namespace_pin [Pin::Namespace]
+    # @param rooted_type [ComplexType]
+    def should_erase_generics_when_done?(namespace_pin, rooted_type)
+      has_generics?(namespace_pin) && !can_resolve_generics?(namespace_pin, rooted_type)
+    end
+
+    # @param namespace_pin [Pin::Namespace]
+    def has_generics?(namespace_pin)
+      namespace_pin && !namespace_pin.generics.empty?
+    end
+
+    # @param namespace_pin [Pin::Namespace]
+    # @param rooted_type [ComplexType]
+    def can_resolve_generics?(namespace_pin, rooted_type)
+      has_generics?(namespace_pin) && !rooted_type.all_params.empty?
+    end
   end
 end

data/lib/solargraph/bench.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
 
 module Solargraph
   # A container of source maps and workspace data to be cataloged in an ApiMap.
@@ -21,7 +20,9 @@ module Solargraph
     def initialize source_maps: [], workspace: Workspace.new, external_requires: []
       @source_maps = source_maps.to_set
       @workspace = workspace
-      @external_requires = external_requires.to_set
+      @external_requires = external_requires.reject { |path| workspace.would_require?(path) }
+                                            .compact
+                                            .to_set
     end
   end
 end