solargraph 0.54.1 → 0.54.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6619265fc1ba2cab9154e70c5f4a6626999b685d58e26a805ec606d6804f17b
-  data.tar.gz: cfac32a13734ba9b392d27fcb8da7c76b180f0bf64189d17698b2246ce6e3773
+  metadata.gz: bfa5a38942b03bbc954c62e283a07144fd169467e82d29aedd549e0a122ad73e
+  data.tar.gz: 9076b8982f53dffe42861873eab5f8fe654c4a2503af67c2fba1880625dee5e6
 SHA512:
-  metadata.gz: 8d1d40bf5d19b37f6a2ee8cce73e36027140ae402d27326c15e39a961217153e8b269722503ca0a8a3b592bee50cb6227fffcd812f62a1ec8a1bf94219270eea
-  data.tar.gz: 627df7fb0bd23b641f0b1a40434a6384def8f32bf318b4f92d243266ee0c3145059adc29ea487dcdc30c914045e5737bca92bff6bd67fd06527f97c2e4690fb8
+  metadata.gz: 66cad45bdab9c446a1bb25e29beabae7b6371f36270d23a36a48dd7c5b0347fb3239862b67bc30c4510b82d93ef97dee9656e3f80e242b1c281d17f86da782b6
+  data.tar.gz: b34f32af68d295b41ac2ec48d7ec9defb832933c4825b2666791b51bd9050e11d06036b52d6200f4f2897f197aecdb2123d6a5c4256f6c87502b08d8eeda7f5c

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+## 0.54.3 - May 13, 2025
+- Improve inspect()/desc()/to_s() methods for better debugging output (#913)
+- Fix generic resolution in Hash types (#906)
+- Stop parsing RBS type parameter constraints as the type name (#918)
+- Fix pin inference stack (#922)
+- Refactor pin equality for performance (#925)
+- Improve ApiMap catalog speed by preserving static pin indexes (#930)
+- Update jaro_winkler dependency (#931)
+
+## 0.54.2 - April 28, 2025
+- Resolve generics correctly on mixin inclusion (#898)
+- Pick correct String#split overload (#905)
+- Fix type sent into YARD method (#912)
+- Early CancelRequest handling (#914)
+- Destructure partial yield types (#915)
+- Dependency versions (#916)
+
 ## 0.54.1 - April 26, 2025
 - Retire more RubyVM-specific code (#797)
 - Add additional docs for key classes, modules and methods (#802)

data/lib/solargraph/api_map/cache.rb

@@ -8,7 +8,7 @@ module Solargraph
         @methods = {}
         # @type [Hash{(String, Array<String>) => Array<Pin::Base>}]
         @constants = {}
-        # @type [Hash{(String, String) => String}]
+        # @type [Hash{String => String}]
         @qualified_namespaces = {}
         # @type [Hash{String => Pin::Method}]
         @receiver_definitions = {}
@@ -16,6 +16,15 @@ module Solargraph
         @clips = {}
       end
 
+      def to_s
+        self.class.to_s
+      end
+
+      # avoid enormous dump
+      def inspect
+        to_s
+      end
+
       # @param fqns [String]
       # @param scope [Symbol]
       # @param visibility [Array<Symbol>]

data/lib/solargraph/api_map/index.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class ApiMap
+    class Index
+      # @param pins [Array<Pin::Base>]
+      def initialize pins
+        catalog pins
+      end
+
+      # @return [Array<Pin::Base>]
+      def pins
+        @pins ||= []
+      end
+
+      # @return [Hash{String => Array<Pin::Namespace>}]
+      def namespace_hash
+        @namespace_hash ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      # @return [Hash{String => Array<Pin::Base>}]
+      def pin_class_hash
+        @pin_class_hash ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      # @return [Hash{String => Array<Pin::Base>}]
+      def path_pin_hash
+        @path_pin_hash ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      # @generic T
+      # @param klass [Class<generic<T>>]
+      # @return [Set<generic<T>>]
+      def pins_by_class klass
+        # @type [Set<Solargraph::Pin::Base>]
+        s = Set.new
+        @pin_select_cache[klass] ||= pin_class_hash.each_with_object(s) { |(key, o), n| n.merge(o) if key <= klass }
+      end
+
+      # @return [Hash{String => Array<Pin::Reference::Include>}]
+      def include_references
+        @include_references ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      # @return [Hash{String => Array<Pin::Reference::Extend>}]
+      def extend_references
+        @extend_references ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      # @return [Hash{String => Array<Pin::Reference::Prepend>}]
+      def prepend_references
+        @prepend_references ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      # @return [Hash{String => Array<Pin::Reference::Superclass>}]
+      def superclass_references
+        @superclass_references ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      # @param pins [Array<Pin::Base>]
+      def merge pins
+        deep_clone.catalog pins
+      end
+
+      protected
+
+      attr_writer :pins, :pin_select_cache, :namespace_hash, :pin_class_hash, :path_pin_hash, :include_references,
+                  :extend_references, :prepend_references, :superclass_references
+
+      def deep_clone
+        Index.allocate.tap do |copy|
+          copy.pin_select_cache = {}
+          copy.pins = pins.clone
+          %i[
+            namespace_hash pin_class_hash path_pin_hash include_references extend_references prepend_references
+            superclass_references
+          ].each do |sym|
+            copy.send("#{sym}=", send(sym).clone)
+            copy.send(sym)&.transform_values!(&:clone)
+          end
+        end
+      end
+
+      # @param new_pins [Array<Pin::Base>]
+      def catalog new_pins
+        @pin_select_cache = {}
+        pins.concat new_pins
+        set = new_pins.to_set
+        set.classify(&:class)
+           .map { |k, v| pin_class_hash[k].concat v.to_a }
+        set.classify(&:namespace)
+           .map { |k, v| namespace_hash[k].concat v.to_a }
+        set.classify(&:path)
+           .map { |k, v| path_pin_hash[k].concat v.to_a }
+        @namespaces = path_pin_hash.keys.compact.to_set
+        map_references Pin::Reference::Include, include_references
+        map_references Pin::Reference::Prepend, prepend_references
+        map_references Pin::Reference::Extend, extend_references
+        map_references Pin::Reference::Superclass, superclass_references
+        map_overrides
+        self
+      end
+
+      # @param klass [Class<Pin::Reference>]
+      # @param hash [Hash{String => Array<Pin::Reference>}]
+      # @return [void]
+      def map_references klass, hash
+        pins_by_class(klass).each do |pin|
+          store_parametric_reference(hash, pin)
+        end
+      end
+
+      # Add references to a map
+      #
+      # @param hash [Hash{String => Array<Pin::Reference>}]
+      # @param reference_pin [Pin::Reference]
+      #
+      # @return [void]
+      def store_parametric_reference(hash, reference_pin)
+        referenced_ns = reference_pin.name
+        referenced_tag_params = reference_pin.generic_values
+        referenced_tag = referenced_ns +
+                         if referenced_tag_params && referenced_tag_params.length > 0
+                           "<" + referenced_tag_params.join(', ') + ">"
+                         else
+                           ''
+                         end
+        referencing_ns = reference_pin.namespace
+        hash[referencing_ns].push referenced_tag
+      end
+
+      # @return [void]
+      def map_overrides
+        pins_by_class(Pin::Reference::Override).each do |ovr|
+          pin = path_pin_hash[ovr.name].first
+          next if pin.nil?
+          new_pin = if pin.path.end_with?('#initialize')
+            path_pin_hash[pin.path.sub(/#initialize/, '.new')].first
+          end
+          (ovr.tags.map(&:tag_name) + ovr.delete).uniq.each do |tag|
+            pin.docstring.delete_tags tag
+            new_pin.docstring.delete_tags tag if new_pin
+          end
+          ovr.tags.each do |tag|
+            pin.docstring.add_tag(tag)
+            redefine_return_type pin, tag
+            if new_pin
+              new_pin.docstring.add_tag(tag)
+              redefine_return_type new_pin, tag
+            end
+          end
+        end
+      end
+
+      # @param pin [Pin::Method]
+      # @param tag [YARD::Tags::Tag]
+      # @return [void]
+      def redefine_return_type pin, tag
+        return unless pin && tag.tag_name == 'return'
+        pin.instance_variable_set(:@return_type, ComplexType.try_parse(tag.type))
+        pin.signatures.each do |sig|
+          sig.instance_variable_set(:@return_type, ComplexType.try_parse(tag.type))
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/api_map/store.rb

@@ -7,13 +7,40 @@ module Solargraph
     # core.
     #
     class Store
+      # @param static [Enumerable<Pin::Base>]
+      # @param dynamic [Enumerable<Pin::Base>]
+      def initialize static = [], dynamic = []
+        @static_index = Index.new(static)
+        @dynamic = dynamic
+        @index = @static_index.merge(dynamic)
+      end
+
       # @return [Array<Solargraph::Pin::Base>]
-      attr_reader :pins
+      def pins
+        index.pins
+      end
 
-      # @param pins [Enumerable<Solargraph::Pin::Base>]
-      def initialize pins = []
-        @pins = pins
-        index
+      # @param static [Enumerable<Pin::Base>]
+      # @param dynamic [Enumerable<Pin::Base>]
+      def update! static = [], dynamic = []
+        # @todo Fix this map
+        @fqns_pins_map = nil
+        if @static_index.pins == static
+          return self if @dynamic == dynamic
+        else
+          @static_index = Index.new(static)
+        end
+        @dynamic = dynamic
+        @index = @static_index.merge(dynamic)
+        self
+      end
+
+      def to_s
+        self.class.to_s
+      end
+
+      def inspect
+        to_s
       end
 
       # @param fqns [String]
@@ -66,11 +93,7 @@ module Solargraph
       # @param path [String]
       # @return [Array<Solargraph::Pin::Base>]
       def get_path_pins path
-        path_pin_hash[path] || []
-      end
-
-      def cacheable_pins
-        @cacheable_pins ||= pins_by_class(Pin::Namespace) + pins_by_class(Pin::Constant) + pins_by_class(Pin::Method) + pins_by_class(Pin::Reference)
+        index.path_pin_hash[path]
       end
 
       # @param fqns [String]
@@ -101,10 +124,10 @@ module Solargraph
 
       # @return [Set<String>]
       def namespaces
-        @namespaces ||= Set.new
+        index.namespaces
       end
 
-      # @return [Enumerable<Solargraph::Pin::Base>]
+      # @return [Enumerable<Solargraph::Pin::Namespace>]
       def namespace_pins
         pins_by_class(Solargraph::Pin::Namespace)
       end
@@ -143,18 +166,11 @@ module Solargraph
         pins_by_class(Pin::Block)
       end
 
-      def inspect
-        # Avoid insane dumps in specs
-        to_s
-      end
-
       # @generic T
-      # @param klass [Class<T>]
-      # @return [Set<T>]
+      # @param klass [Class<generic<T>>]
+      # @return [Set<generic<T>>]
       def pins_by_class klass
-        # @type [Set<Solargraph::Pin::Base>]
-        s = Set.new
-        @pin_select_cache[klass] ||= @pin_class_hash.each_with_object(s) { |(key, o), n| n.merge(o) if key <= klass }
+        index.pins_by_class klass
       end
 
       # @param fqns [String]
@@ -174,6 +190,8 @@ module Solargraph
 
       private
 
+      attr_reader :index
+
       # @return [Hash{::Array(String, String) => ::Array<Pin::Namespace>}]
       def fqns_pins_map
         @fqns_pins_map ||= Hash.new do |h, (base, name)|
@@ -184,129 +202,39 @@ module Solargraph
 
       # @return [Enumerable<Solargraph::Pin::Symbol>]
       def symbols
-        pins_by_class(Pin::Symbol)
+        index.pins_by_class(Pin::Symbol)
       end
 
       # @return [Hash{String => Array<String>}]
       def superclass_references
-        @superclass_references ||= {}
+        index.superclass_references
       end
 
       # @return [Hash{String => Array<String>}]
       def include_references
-        @include_references ||= {}
+        index.include_references
       end
 
       # @return [Hash{String => Array<String>}]
       def prepend_references
-        @prepend_references ||= {}
+        index.prepend_references
       end
 
       # @return [Hash{String => Array<String>}]
       def extend_references
-        @extend_references ||= {}
+        index.extend_references
       end
 
       # @param name [String]
       # @return [Enumerable<Solargraph::Pin::Base>]
       def namespace_children name
-        namespace_map[name] || []
-      end
-
-      # @return [Hash{String => Enumerable<Pin::Base>}
-      def namespace_map
-        @namespace_map ||= {}
+        return [] unless index.namespace_hash.key?(name)
+        index.namespace_hash[name]
       end
 
       # @return [Enumerable<Pin::InstanceVariable>]
       def all_instance_variables
-        pins_by_class(Pin::InstanceVariable)
-      end
-
-      # @return [Hash{String => Array<Pin::Base>}]
-      def path_pin_hash
-        @path_pin_hash ||= {}
-      end
-
-      # Add references to a map
-      #
-      # @param h [Hash{String => Pin:Base}]
-      # @param reference_pin [Pin::Reference]
-      #
-      # @return [void]
-      def store_parametric_reference(h, reference_pin)
-        referenced_ns = reference_pin.name
-        referenced_tag_params = reference_pin.generic_values
-        referenced_tag = referenced_ns +
-                         if referenced_tag_params && referenced_tag_params.length > 0
-                           "<" + referenced_tag_params.join(', ') + ">"
-                         else
-                           ''
-                         end
-        referencing_ns = reference_pin.namespace
-        h[referencing_ns] ||= []
-        h[referencing_ns].push referenced_tag
-      end
-
-      # @return [void]
-      def index
-        set = pins.to_set
-        @pin_class_hash = set.classify(&:class).transform_values(&:to_a)
-        # @type [Hash{Class => ::Array<Solargraph::Pin::Base>}]
-        @pin_select_cache = {}
-        @namespace_map = set.classify(&:namespace)
-        @path_pin_hash = set.classify(&:path)
-        @namespaces = @path_pin_hash.keys.compact.to_set
-        pins_by_class(Pin::Reference::Include).each do |pin|
-          store_parametric_reference(include_references, pin)
-        end
-        # @todo move the rest of these reference pins over to use
-        #   generic types, adding rbs_map/conversions.rb code to
-        #   populate type parameters and adding related specs ensuring
-        #   the generics get resolved, along with any api_map.rb
-        #   changes needed in
-        pins_by_class(Pin::Reference::Prepend).each do |pin|
-          prepend_references[pin.namespace] ||= []
-          prepend_references[pin.namespace].push pin.name
-        end
-        pins_by_class(Pin::Reference::Extend).each do |pin|
-          extend_references[pin.namespace] ||= []
-          extend_references[pin.namespace].push pin.name
-        end
-        pins_by_class(Pin::Reference::Superclass).each do |pin|
-          superclass_references[pin.namespace] ||= []
-          superclass_references[pin.namespace].push pin.name
-        end
-        pins_by_class(Pin::Reference::Override).each do |ovr|
-          pin = get_path_pins(ovr.name).first
-          next if pin.nil?
-          new_pin = if pin.path.end_with?('#initialize')
-            get_path_pins(pin.path.sub(/#initialize/, '.new')).first
-          end
-          (ovr.tags.map(&:tag_name) + ovr.delete).uniq.each do |tag|
-            pin.docstring.delete_tags tag.to_sym
-            new_pin.docstring.delete_tags tag.to_sym if new_pin
-          end
-          ovr.tags.each do |tag|
-            pin.docstring.add_tag(tag)
-            redefine_return_type pin, tag
-            if new_pin
-              new_pin.docstring.add_tag(tag)
-              redefine_return_type new_pin, tag
-            end
-          end
-        end
-      end
-
-      # @param pin [Pin::Base]
-      # @param tag [String]
-      # @return [void]
-      def redefine_return_type pin, tag
-        return unless pin && tag.tag_name == 'return'
-        pin.instance_variable_set(:@return_type, ComplexType.try_parse(tag.type))
-        pin.signatures.each do |sig|
-          sig.instance_variable_set(:@return_type, ComplexType.try_parse(tag.type))
-        end
+        index.pins_by_class(Pin::InstanceVariable)
       end
     end
   end

data/lib/solargraph/api_map.rb

@@ -12,6 +12,7 @@ module Solargraph
     autoload :Cache,          'solargraph/api_map/cache'
     autoload :SourceToYard,   'solargraph/api_map/source_to_yard'
     autoload :Store,          'solargraph/api_map/store'
+    autoload :Index,          'solargraph/api_map/index'
 
     # @return [Array<String>]
     attr_reader :unresolved_requires
@@ -48,6 +49,15 @@ module Solargraph
       equality_fields.hash
     end
 
+    def to_s
+      self.class.to_s
+    end
+
+    # avoid enormous dump
+    def inspect
+      to_s
+    end
+
     # @param pins [Array<Pin::Base>]
     # @return [self]
     def index pins
@@ -56,7 +66,7 @@ module Solargraph
       @source_map_hash = {}
       implicit.clear
       cache.clear
-      @store = Store.new(@@core_map.pins + pins)
+      store.update! @@core_map.pins, pins
       self
     end
 
@@ -77,6 +87,7 @@ module Solargraph
     def catalog bench
       old_api_hash = @source_map_hash&.values&.map(&:api_hash)
       need_to_uncache = (old_api_hash != bench.source_maps.map(&:api_hash))
+      # @todo Work around #to_h problem in current Ruby head (3.5)
       @source_map_hash = bench.source_maps.map { |s| [s.filename, s] }.to_h
       pins = bench.source_maps.flat_map(&:pins).flatten
       implicit.clear
@@ -89,13 +100,16 @@ module Solargraph
         @unresolved_requires = unresolved_requires
         need_to_uncache = true
       end
-      @store = Store.new(@@core_map.pins + @doc_map.pins + implicit.pins + pins)
+      store.update! @@core_map.pins + @doc_map.pins, implicit.pins + pins
       @cache.clear if need_to_uncache
 
       @missing_docs = [] # @todo Implement missing docs
       self
     end
 
+    # @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
@@ -183,7 +197,7 @@ module Solargraph
 
     # @return [Array<Solargraph::Pin::Base>]
     def pins
-      store.pins
+      store.pins.clone.freeze
     end
 
     # An array of pins based on Ruby keywords (`if`, `end`, etc.).
@@ -341,8 +355,12 @@ module Solargraph
     # @param deep [Boolean] True to include superclasses, mixins, etc.
     # @return [Array<Solargraph::Pin::Method>]
     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?
+      # @type [Array<Solargraph::Pin::Method>]
       result = []
       skip = Set.new
       if rooted_tag == ''
@@ -380,9 +398,12 @@ module Solargraph
         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(rooted_tag, 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.
@@ -438,8 +459,13 @@ module Solargraph
     # @param name [String] Method name to look up
     # @param scope [Symbol] :instance or :class
     # @return [Array<Solargraph::Pin::Method>]
-    def get_method_stack rooted_tag, name, scope: :instance
-      get_methods(rooted_tag, 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.
@@ -601,6 +627,7 @@ module Solargraph
       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)
@@ -615,15 +642,7 @@ module Solargraph
       # Store#get_methods doesn't know about full tags, just
       # namespaces; resolving the generics in the method pins is this
       # class' responsibility
-      raw_methods = store.get_methods(fqns, scope: scope, visibility: visibility).sort{ |a, b| a.name <=> b.name }
-      namespace_pin = store.get_path_pins(fqns).select { |p| p.is_a?(Pin::Namespace) }.first
-      methods = if namespace_pin && rooted_tag != fqns
-                  methods = raw_methods.map do |method_pin|
-                    method_pin.resolve_generics(namespace_pin, rooted_type)
-                  end
-                else
-                  raw_methods
-                end
+      methods = store.get_methods(fqns, scope: scope, visibility: visibility).sort{ |a, b| a.name <=> b.name }
       result.concat methods
       if deep
         if scope == :instance
@@ -768,8 +787,8 @@ module Solargraph
 
     # Sort an array of pins to put nil or undefined variables last.
     #
-    # @param pins [Enumerable<Solargraph::Pin::Base>]
-    # @return [Enumerable<Solargraph::Pin::Base>]
+    # @param pins [Enumerable<Pin::BaseVariable>]
+    # @return [Enumerable<Pin::BaseVariable>]
     def prefer_non_nil_variables pins
       result = []
       nil_pins = []
@@ -809,11 +828,48 @@ module Solargraph
         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/complex_type/type_methods.rb

@@ -129,6 +129,13 @@ module Solargraph
         end.call
       end
 
+      def namespace_type
+        return ComplexType.parse('::Object') if duck_type?
+        return ComplexType.parse('::NilClass') if nil_type?
+        return subtypes.first if (name == 'Class' || name == 'Module') && !subtypes.empty?
+        self
+      end
+
       # @return [String]
       def rooted_namespace
         return namespace unless rooted? && can_root_name?(namespace)