solargraph 0.55.3 → 0.55.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b92431804c7f970e2e2584375047eedef4155a24ac07e37dd0cfd5b9f3a4b562
-  data.tar.gz: e60ed915ee5ff35d91e66d0d15287d8a58f7c295080041d601c833092767bde9
+  metadata.gz: 9e015963ad868b3671d88892483ec3c06a3e7c96757f2013ba56c514af35eb0e
+  data.tar.gz: 22a6383d6f179ec708a930fbf8cb81bea8cbbee694de559f43208c859240a0cd
 SHA512:
-  metadata.gz: e4d6a6fd86d4942dac41fbfe67d7860ed1bdc9534414c26adae8bba3b6cf2a402691a0de5adaf89fcf49fbb8d11fba81230d683ec4b7aed01c5b0a73671dd3fa
-  data.tar.gz: 1b12d4bfbdb9bcca0e87585fc985252ec6d343929b16f9317f12223f8e6d2d413ebb6a9674911eb09189c817703c35fbe5acb3c364666cb1f05dadd188279940
+  metadata.gz: cd7b151efc8a584829cdc5c4424c81dd3703dd22f8287c8edfcfc32d65b8409e8be9d8354ed5369c6fa0955cc1ccd534014f6782aa71ca7b0a89c5df8a0d9b06
+  data.tar.gz: 818390cee111c7948e40904e1eb48dd407dd8f15045a29b96881e6bb520022438d9fca6a7ec678dbc6d793f74b3bcdaf17d4b152e86bb5b1f563f1703423a7ed

data/.github/workflows/plugins.yml

@@ -34,6 +34,8 @@ jobs:
         bundle exec solargraph config
         yq -yi '.plugins += ["solargraph-rails"]' .solargraph.yml
         yq -yi '.plugins += ["solargraph-rspec"]' .solargraph.yml
+    - name: Install gem types
+      run: bundle exec rbs collection install
     - name: Ensure typechecking still works
       run: bundle exec solargraph typecheck --level typed
     - name: Ensure specs still run

data/.github/workflows/typecheck.yml

@@ -30,5 +30,7 @@ jobs:
         bundler-cache: false
     - name: Install gems
       run: bundle install
+    - name: Install gem types
+      run: bundle exec rbs collection install
     - name: Typecheck self
-      run: bundle exec solargraph typecheck --level typed
+      run: SOLARGRAPH_ASSERTS=on bundle exec solargraph typecheck --level typed

data/.gitignore

@@ -1,3 +1,5 @@
+/.gem_rbs_collection
+/rbs_collection.lock.yaml
 /Gemfile.lock
 .Gemfile
 .idea

data/CHANGELOG.md

@@ -1,5 +1,11 @@
+## 0.55.5 - July 1, 2025
+- Ignore directory paths in Workspace#would_require? (#988)
+
+## 0.55.4 - June 27, 2025
+-  Flatten results of DocMap external bundle query (#981)
+
 ## 0.55.3 - June 25, 2025
--  Nil guards in flow-sensitive typing (patch release) #980 
+-  Nil guards in flow-sensitive typing (patch release) (#980)
 
 ## 0.55.2 - June 21, 2025
 - Require external bundle (#972)

data/README.md

@@ -63,12 +63,22 @@ The RSpec framework is supported via [solargraph-rspec](https://github.com/lekem
 
 **Note: Before version 0.53.0, it was recommended to run `yard gems` periodically or automate it with `yard config` to ensure that Solargraph had access to gem documentation. These steps are no longer necessary. Solargraph maintains its own gem documentation cache independent of the yardocs in your gem installations.**
 
-Solargraph automatically generates code maps from installed gems. You can also manage your cached gem documentation with the `solargraph gems` command.
-
-When editing code, a `require` call that references a gem will pull the documentation into the code maps and include the gem's API in code completion and intellisense.
+When editing code, a `require` call that references a gem will pull the documentation into the code maps and include the gem's API in code completion and intellisense.  Solargraph automatically generates code maps from installed gems, based on the YARD or RBS type information inside the gem.  You can also eagerly cache gem documentation with the `solargraph gems` command.
 
 If your project automatically requires bundled gems (e.g., `require 'bundler/require'`), Solargraph will add all of the Gemfile's default dependencies to the map.
 
+To ensure you have types for gems which contain neither RBS nor YARD
+information, use
+[gem\_rbs\_collection](https://github.com/ruby/gem_rbs_collection) to
+install a community-supported set of RBS types for various gems:
+
+```sh
+bundle exec rbs collection init
+bundle exec rbs collection install
+```
+
+Once installed, you can also insert your own local overrides and definitions in RBS in a directory configured in the `rbs_collection.yaml` that the above commands create.
+
 ### Type Checking
 
 As of version 0.33.0, Solargraph includes a [type checker](https://github.com/castwide/solargraph/issues/192) that uses a combination of YARD tags and code analysis to report missing type definitions. In strict mode, it performs type inference to determine whether the tags match the types it detects from code.

data/lib/solargraph/api_map/index.rb

@@ -3,6 +3,8 @@
 module Solargraph
   class ApiMap
     class Index
+      include Logging
+
       # @param pins [Array<Pin::Base>]
       def initialize pins = []
         catalog pins
@@ -132,21 +134,24 @@ module Solargraph
       # @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
+          logger.debug { "ApiMap::Index#map_overrides: Looking at override #{ovr} for #{ovr.name}" }
+          pins = path_pin_hash[ovr.name]
+          logger.debug { "ApiMap::Index#map_overrides: pins for path=#{ovr.name}: #{pins}" }
+          pins.each do |pin|
+            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
@@ -156,11 +161,14 @@ module Solargraph
       # @param tag [YARD::Tags::Tag]
       # @return [void]
       def redefine_return_type pin, tag
+        # @todo can this be made to not mutate existing pins and use
+        #   proxy() / proxy_with_signatures() instead?
         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
+        pin.reset_generated!
       end
     end
   end

data/lib/solargraph/api_map/store.rb

@@ -61,15 +61,19 @@ module Solargraph
       # @param visibility [Array<Symbol>]
       # @return [Enumerable<Solargraph::Pin::Method>]
       def get_methods fqns, scope: :instance, visibility: [:public]
-        namespace_children(fqns).select do |pin|
+        all_pins = namespace_children(fqns).select do |pin|
           pin.is_a?(Pin::Method) && pin.scope == scope && visibility.include?(pin.visibility)
         end
+        GemPins.combine_method_pins_by_path(all_pins)
       end
 
-      # @param fqns [String]
+      # @param fq_tag [String]
       # @return [String, nil]
-      def get_superclass fqns
-        raise "Do not prefix fully qualified namespaces with '::' - #{fqns.inspect}" if fqns.start_with?('::')
+      def get_superclass fq_tag
+        raise "Do not prefix fully qualified tags with '::' - #{fq_tag.inspect}" if fq_tag.start_with?('::')
+        sub = ComplexType.parse(fq_tag)
+        fqns = sub.namespace
+        return superclass_references[fq_tag].first if superclass_references.key?(fq_tag)
         return superclass_references[fqns].first if superclass_references.key?(fqns)
         return 'Object' if fqns != 'BasicObject' && namespace_exists?(fqns)
         return 'Object' if fqns == 'Boolean'

data/lib/solargraph/api_map.rb

@@ -93,9 +93,13 @@ module Solargraph
         implicit.merge map.environ
       end
       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?
+      recreate_docmap = @unresolved_requires != unresolved_requires ||
+                     @doc_map&.uncached_yard_gemspecs&.any? ||
+                     @doc_map&.uncached_rbs_collection_gemspecs&.any? ||
+                     @doc_map&.rbs_collection_path != bench.workspace.rbs_collection_path
+      if recreate_docmap
         @doc_map = DocMap.new(unresolved_requires, [], bench.workspace) # @todo Implement gem preferences
-        @unresolved_requires = unresolved_requires
+        @unresolved_requires = @doc_map.unresolved_requires
       end
       @cache.clear if store.update(@@core_map.pins, @doc_map.pins, implicit.pins, iced_pins, live_pins)
       @missing_docs = [] # @todo Implement missing docs
@@ -109,11 +113,25 @@ module Solargraph
       [self.class, @source_map_hash, implicit, @doc_map, @unresolved_requires]
     end
 
+    def doc_map
+      @doc_map ||= DocMap.new([], [])
+    end
+
     # @return [::Array<Gem::Specification>]
     def uncached_gemspecs
       @doc_map&.uncached_gemspecs || []
     end
 
+    # @return [::Array<Gem::Specification>]
+    def uncached_rbs_collection_gemspecs
+      @doc_map.uncached_rbs_collection_gemspecs
+    end
+
+    # @return [::Array<Gem::Specification>]
+    def uncached_yard_gemspecs
+      @doc_map.uncached_yard_gemspecs
+    end
+
     # @return [Array<Pin::Base>]
     def core_pins
       @@core_map.pins
@@ -168,6 +186,18 @@ module Solargraph
       api_map
     end
 
+    def cache_all!(out)
+      @doc_map.cache_all!(out)
+    end
+
+    def cache_gem(gemspec, rebuild: false, out: nil)
+      @doc_map.cache(gemspec, rebuild: rebuild, out: out)
+    end
+
+    class << self
+      include Logging
+    end
+
     # Create an ApiMap with a workspace in the specified directory and cache
     # any missing gems.
     #
@@ -178,15 +208,14 @@ module Solargraph
     # @param directory [String]
     # @param out [IO] The output stream for messages
     # @return [ApiMap]
-    def self.load_with_cache directory, out = IO::NULL
+    def self.load_with_cache directory, out
       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)
+      if api_map.uncached_gemspecs.empty?
+        logger.info { "All gems cached for #{directory}" }
+        return api_map
       end
+
+      api_map.cache_all!(out)
       load(directory)
     end
 
@@ -359,6 +388,11 @@ 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
+      if rooted_tag.start_with? 'Array('
+        # Array() are really tuples - use our fill, as the RBS repo
+        # does not give us definitions for it
+        rooted_tag = "Solargraph::Fills::Tuple(#{rooted_tag[6..-2]})"
+      end
       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
@@ -386,18 +420,35 @@ module Solargraph
             next pin unless init_pin
 
             type = ComplexType::SELF
-            Pin::Method.new(
+            new_pin = 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,
               source: init_pin.source,
               type_location: init_pin.type_location,
             )
+            new_pin.parameters = init_pin.parameters.map do |init_param|
+              param = init_param.clone
+              param.closure = new_pin
+              param.reset_generated!
+              param
+            end.freeze
+            new_pin.signatures = init_pin.signatures.map do |init_sig|
+              sig = init_sig.proxy(type)
+              sig.parameters = init_sig.parameters.map do |param|
+                param = param.clone
+                param.closure = new_pin
+                param.reset_generated!
+                param
+              end.freeze
+              sig.closure = new_pin
+              sig.reset_generated!
+              sig
+            end.freeze
+            new_pin
           end
         end
         result.concat inner_get_methods('Kernel', :instance, [:public], deep, skip) if visibility.include?(:private)
@@ -436,7 +487,7 @@ module Solargraph
       result = Set.new
       complex_type.each do |type|
         if type.duck_type?
-          result.add Pin::DuckMethod.new(name: type.to_s[1..-1])
+          result.add Pin::DuckMethod.new(name: type.to_s[1..-1], source: :api_map)
           result.merge get_methods('Object')
         else
           unless type.nil? || type.name == 'void'
@@ -505,13 +556,8 @@ module Solargraph
           .select { |path| path.downcase.include?(query.downcase) }
     end
 
-    # Get YARD documentation for the specified path.
-    #
-    # @example
-    #   api_map.document('String#split')
-    #
-    # @todo This method is likely superfluous. Calling get_path_pins directly
-    #   should be sufficient.
+    # @deprecated This method is likely superfluous. Calling #get_path_pins
+    #   directly should be sufficient.
     #
     # @param path [String] The path to find
     # @return [Enumerable<Pin::Base>]
@@ -605,6 +651,19 @@ module Solargraph
       store.get_includes(host_ns).map { |inc_tag| ComplexType.parse(inc_tag).name }.include?(module_ns)
     end
 
+    # @param pins [Enumerable<Pin::Base>]
+    # @param visibility [Enumerable<Symbol>]
+    # @return [Array<Pin::Base>]
+    def resolve_method_aliases pins, visibility = [:public, :private, :protected]
+      with_resolved_aliases = pins.map do |pin|
+        resolved = resolve_method_alias(pin)
+        next nil if resolved.respond_to?(:visibility) && !visibility.include?(resolved.visibility)
+        resolved
+      end.compact
+      logger.debug { "ApiMap#resolve_method_aliases(pins=#{pins.map(&:name)}, visibility=#{visibility}) => #{with_resolved_aliases.map(&:name)}" }
+      GemPins.combine_method_pins_by_path(with_resolved_aliases)
+    end
+
     private
 
     # A hash of source maps with filename keys.
@@ -653,29 +712,20 @@ module Solargraph
         if scope == :instance
           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
+            result.concat inner_get_methods_from_reference(rooted_include_tag, namespace_pin, rooted_type, scope, visibility, deep, skip, true)
           end
-          fqsc = qualify_superclass(fqns)
-          unless fqsc.nil?
-            result.concat inner_get_methods(fqsc, scope, visibility, true, skip, no_core) unless fqsc.nil?
+          rooted_sc_tag = qualify_superclass(rooted_tag)
+          unless rooted_sc_tag.nil?
+            result.concat inner_get_methods_from_reference(rooted_sc_tag, namespace_pin, rooted_type, scope, visibility, true, skip, no_core)
           end
         else
           store.get_extends(fqns).reverse.each do |em|
             fqem = qualify(em, fqns)
             result.concat inner_get_methods(fqem, :instance, visibility, deep, skip, true) unless fqem.nil?
           end
-          fqsc = qualify_superclass(fqns)
-          unless fqsc.nil?
-            result.concat inner_get_methods(fqsc, scope, visibility, true, skip, true) unless fqsc.nil?
+          rooted_sc_tag = qualify_superclass(rooted_tag)
+          unless rooted_sc_tag.nil?
+            result.concat inner_get_methods_from_reference(rooted_sc_tag, namespace_pin, rooted_type, scope, visibility, true, skip, true)
           end
           unless no_core || fqns.empty?
             type = get_namespace_type(fqns)
@@ -691,6 +741,41 @@ module Solargraph
       result
     end
 
+    # @param fq_reference_tag [String] A fully qualified whose method should be pulled in
+    # @param namespace_pin [Pin::Base] Namespace pin for the rooted_type
+    #   parameter - used to pull generics information
+    # @param type [ComplexType] The type which is having its
+    #   methods supplemented from fq_reference_tag
+    # @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_from_reference(fq_reference_tag, namespace_pin, type, scope, visibility, deep, skip, no_core)
+      # logger.debug { "ApiMap#add_methods_from_reference(type=#{type}) starting" }
+
+      # Ensure the types returned by the methods in the referenced
+      # type are relative to the generic values passed in the
+      # reference.  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 for each
+      resolved_reference_type = ComplexType.parse(fq_reference_tag).force_rooted.resolve_generics(namespace_pin, type)
+      # @todo Can inner_get_methods be cached?  Lots of lookups of base types going on.
+      methods = inner_get_methods(resolved_reference_type.tag, scope, visibility, deep, skip, no_core)
+      if namespace_pin && !resolved_reference_type.all_params.empty?
+        reference_pin = store.get_path_pins(resolved_reference_type.name).select { |p| p.is_a?(Pin::Namespace) }.first
+        # logger.debug { "ApiMap#add_methods_from_reference(type=#{type}) - resolving generics with #{reference_pin.generics}, #{resolved_reference_type.rooted_tags}" }
+        methods = methods.map do |method_pin|
+          method_pin.resolve_generics(reference_pin, resolved_reference_type)
+        end
+      end
+      # logger.debug { "ApiMap#add_methods_from_reference(type=#{type}) - resolved_reference_type: #{resolved_reference_type} for type=#{type}: #{methods.map(&:name)}" }
+      methods
+    end
+
     # @param fqns [String]
     # @param visibility [Array<Symbol>]
     # @param skip [Set<String>]
@@ -726,15 +811,19 @@ module Solargraph
       qualify namespace, context.split('::')[0..-2].join('::')
     end
 
-    # @param fqsub [String]
+    # @param fq_tag [String]
     # @return [String, nil]
-    def qualify_superclass fqsub
-      sup = store.get_superclass(fqsub)
-      return nil if sup.nil?
-      parts = fqsub.split('::')
+    def qualify_superclass fq_sub_tag
+      fq_sub_type = ComplexType.try_parse(fq_sub_tag)
+      fq_sub_ns = fq_sub_type.name
+      sup_tag = store.get_superclass(fq_sub_tag)
+      sup_type = ComplexType.try_parse(sup_tag)
+      sup_ns = sup_type.name
+      return nil if sup_tag.nil?
+      parts = fq_sub_ns.split('::')
       last = parts.pop
-      parts.pop if last == sup
-      qualify(sup, parts.join('::'))
+      parts.pop if last == sup_ns
+      qualify(sup_tag, parts.join('::'))
     end
 
     # @param name [String] Namespace to fully qualify
@@ -807,17 +896,6 @@ module Solargraph
       result + nil_pins
     end
 
-    # @param pins [Enumerable<Pin::Base>]
-    # @param visibility [Enumerable<Symbol>]
-    # @return [Array<Pin::Base>]
-    def resolve_method_aliases pins, visibility = [:public, :private, :protected]
-      pins.map do |pin|
-        resolved = resolve_method_alias(pin)
-        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
@@ -829,18 +907,33 @@ module Solargraph
       return nil if origin.nil?
       args = {
         location: pin.location,
+        type_location: origin.type_location,
         closure: pin.closure,
         name: pin.name,
         comments: origin.comments,
         scope: origin.scope,
 #        context: pin.context,
         visibility: origin.visibility,
-        signatures: origin.signatures,
+        signatures: origin.signatures.map(&:clone).freeze,
         attribute: origin.attribute?,
-        generics: origin.generics,
+        generics: origin.generics.clone,
         return_type: origin.return_type,
+        source: :resolve_method_alias
       }
-      Pin::Method.new **args
+      out = Pin::Method.new **args
+      out.signatures.each do |sig|
+        sig.parameters = sig.parameters.map(&:clone).freeze
+        sig.source = :resolve_method_alias
+        sig.parameters.each do |param|
+          param.closure = out
+          param.source = :resolve_method_alias
+          param.reset_generated!
+        end
+        sig.closure = out
+        sig.reset_generated!
+      end
+      logger.debug { "ApiMap#resolve_method_alias(pin=#{pin}) - returning #{out} from #{origin}" }
+      out
     end
 
     include Logging

data/lib/solargraph/complex_type/type_methods.rb

@@ -88,6 +88,7 @@ module Solargraph
       # @return [Symbol, nil]
       attr_reader :parameters_type
 
+      # @type [Hash{String => Symbol}]
       PARAMETERS_TYPE_BY_STARTING_TAG = {
         '{' => :hash,
         '(' => :fixed,
@@ -171,7 +172,11 @@ module Solargraph
         elsif fixed_parameters?
           "(#{subtypes_str})"
         else
-          "<#{subtypes_str}>"
+          if name == 'Hash'
+            "<#{key_types_str}, #{subtypes_str}>"
+          else
+            "<#{key_types_str}#{subtypes_str}>"
+          end
         end
       end
 

data/lib/solargraph/complex_type/unique_type.rb

@@ -55,6 +55,13 @@ module Solargraph
             key_types.concat(subs[0].map { |u| ComplexType.new([u]) })
             # @sg-ignore
             subtypes.concat(subs[1].map { |u| ComplexType.new([u]) })
+          elsif parameters_type == :list && name == 'Hash'
+            # Treat Hash<A, B> as Hash{A => B}
+            if subs.length != 2
+              raise ComplexTypeError, "Bad hash type: name=#{name}, substring=#{substring} - must have exactly two parameters"
+            end
+            key_types.concat(subs[0].map { |u| ComplexType.new([u]) })
+            subtypes.concat(subs[1].map { |u| ComplexType.new([u]) })
           else
             subtypes.concat subs
           end
@@ -306,7 +313,8 @@ module Solargraph
 
         transform(name) do |t|
           if t.name == GENERIC_TAG_NAME
-            idx = definitions.generics.index(t.subtypes.first&.name)
+            generic_name = t.subtypes.first&.name
+            idx = definitions.generics.index(generic_name)
             next t if idx.nil?
             if context_type.parameters_type == :hash
               if idx == 0
@@ -323,7 +331,7 @@ module Solargraph
                 ComplexType::UNDEFINED
               end
             else
-              context_type.all_params[idx] || ComplexType::UNDEFINED
+              context_type.all_params[idx] || definitions.generic_defaults[generic_name] || ComplexType::UNDEFINED
             end
           else
             t

data/lib/solargraph/convention/base.rb

@@ -20,12 +20,12 @@ module Solargraph
         EMPTY_ENVIRON
       end
 
-      # The Environ for a YARD map.
+      # The Environ for a DocMap.
       # Subclasses can override this method.
       #
-      # @param yard_map [YardMap]
+      # @param doc_map [DocMap]
       # @return [Environ]
-      def global yard_map
+      def global doc_map
         EMPTY_ENVIRON
       end
     end

data/lib/solargraph/convention.rb

@@ -31,12 +31,12 @@ module Solargraph
       result
     end
 
-    # @param yard_map [YardMap]
+    # @param yard_map [DocMap]
     # @return [Environ]
-    def self.for_global(yard_map)
+    def self.for_global(doc_map)
       result = Environ.new
       @@conventions.each do |conv|
-        result.merge conv.global(yard_map)
+        result.merge conv.global(doc_map)
       end
       result
     end