solargraph 0.57.0 → 0.58.0

data/CHANGELOG.md

@@ -1,3 +1,30 @@
+## 0.58.0 - January 1, 2026
+- Faster constant resolution (#1083)
+- [regression] Handle RBS static method aliases (#1094)
+- More type fills and shims (#1005)
+- Fix resolution in blocks in type checker (#890)
+- Annotation fixes for strong typechecking (#1057)
+- Remove dead code (#1077)
+- Fix flakey spec (#1080)
+- Fix bad sexpr generation in op_asgn (#1089)
+- Opt-in for MFA requirement (#730)
+- [regression] Fix resolution issues with namespaces from YARD  (#1097)
+- Improve a pin combination case around selfy types (#1024)
+- Rescue reference errors in hosts (#1105)
+- Relax bundler runtime dependency version constraint to support newer versions (#1125)
+- Remove stale Pathname test (#1135)
+- Enable strong type checking in CI (#928)
+- Stale sg-ignore
+- Use rbs 3.9.5 in tests (#1136)
+- Drop broken 'namespaces' method (#1065)
+- Add ActiveRecord example from RBS (#1074)
+- Keep workspace directories as absolute paths (#1076)
+- Handle bad gem_dir from gemspec object (#1079)
+- Test for absolute require paths (#1137)
+- [regression] Fix resolution of ambiguous argument types (#1098)
+- Remove sg-ignore for String#=~ (#1138)
+- Allow levels to be changed for typechecking rules in .solargraph.yml (#1126)
+
 ## 0.57.0 - September 16, 2025
 - Support ActiveSupport::Concern pattern for class methods (#948)
 - More CI checks (#996)

data/Rakefile

@@ -9,7 +9,7 @@ task :console do
 end
 
 desc "Run the type checker"
-task typecheck: [:typecheck_typed]
+task typecheck: [:typecheck_strong]
 
 desc "Run the type checker at typed level - return code issues provable without annotations being correct"
 task :typecheck_typed do

data/bin/solargraph

@@ -1,5 +1,8 @@
-#!/usr/bin/env ruby
-
-require 'solargraph'
-
-Solargraph::Shell.start(ARGV)
+#!/usr/bin/env ruby
+
+# turn off warning diagnostics from Ruby
+$VERBOSE=nil
+
+require 'solargraph'
+
+Solargraph::Shell.start(ARGV)

data/lib/solargraph/api_map/constants.rb

@@ -12,15 +12,35 @@ module Solargraph
 
       # Resolve a name to a fully qualified namespace or constant.
       #
-      # @param name [String]
-      # @param gates [Array<Array<String>, String>]
-      # @return [String, nil]
+      # `Constants#resolve` finds fully qualified (absolute)
+      # namespaces based on relative names and the open gates
+      # (namespaces) provided.  Names must be runtime-visible (erased)
+      # non-literal types, non-duck, non-signature types - e.g.,
+      # TrueClass, NilClass, Integer and Hash instead of true, nil,
+      # 96, or Hash{String => Symbol}
+      #
+      # Note: You may want to be using #qualify.  Notably, #resolve:
+      # - does not handle anything with type parameters
+      # - will not gracefully handle nil, self and Boolean
+      # - will return a constant name instead of following its assignment
+      #
+      # @param name [String] Namespace which may relative and not be rooted.
+      # @param gates [Array<Array<String>, String>] Namespaces to search while resolving the name
+      #
+      # @return [String, nil] fully qualified namespace (i.e., is
+      #   absolute, but will not start with ::)
       def resolve(name, *gates)
         return store.get_path_pins(name[2..]).first&.path if name.start_with?('::')
 
         flat = gates.flatten
         flat.push '' if flat.empty?
-        cached_resolve[[name, flat]] || resolve_and_cache(name, flat)
+        if cached_resolve.include? [name, flat]
+          cached_result = cached_resolve[[name, flat]]
+          # don't recurse
+          return nil if cached_result == :in_process
+          return cached_result
+        end
+        resolve_and_cache(name, flat)
       end
 
       # Get a fully qualified namespace from a reference pin.
@@ -28,47 +48,49 @@ module Solargraph
       # @param pin [Pin::Reference]
       # @return [String, nil]
       def dereference pin
-        resolve(pin.name, pin.reference_gates)
+        qualify_type(pin.type, *pin.reference_gates)&.tag
       end
 
       # Collect a list of all constants defined in the specified gates.
       #
       # @param gates [Array<Array<String>, String>]
-      # @return [Array<Pin::Base>]
+      # @return [Array<Solargraph::Pin::Namespace, Solargraph::Pin::Constant>]
       def collect(*gates)
         flat = gates.flatten
         cached_collect[flat] || collect_and_cache(flat)
       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.
+      # Determine a fully qualified namespace for a given tag
+      # referenced from the specified open gates. This method will
+      # search in each gate until it finds a match for the name.
       #
-      # 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 '::'.
+      # @param tag [String, nil] The type to match
+      # @param gates [Array<String>]
       # @return [String, nil] fully qualified tag
-      def qualify tag, context_tag = ''
-        return tag if ['Boolean', 'self', nil].include?(tag)
-
+      def qualify tag, *gates
         type = ComplexType.try_parse(tag)
-        return unless type.defined?
-        return tag if type.literal?
+        qualify_type(type, *gates)&.tag
+      end
 
-        context_type = ComplexType.try_parse(context_tag)
-        return unless context_type.defined?
+      # @param type [ComplexType, nil] The type to match
+      # @param gates [Array<String>]
+      #
+      # @return [ComplexType, nil] A new rooted ComplexType
+      def qualify_type type, *gates
+        return nil if type.nil?
+        return type if type.selfy? || type.literal? || type.tag == 'nil' || type.interface? ||
+                       type.tag == 'Boolean'
 
-        fqns = qualify_namespace(type.rooted_namespace, context_type.rooted_namespace)
+        gates.push '' unless gates.include?('')
+        fqns = resolve(type.rooted_namespace, *gates)
         return unless fqns
-
-        fqns + type.substring
+        pin = store.get_path_pins(fqns).first
+        if pin.is_a?(Pin::Constant)
+          const = Solargraph::Parser::NodeMethods.unpack_name(pin.assignment)
+          return unless const
+          fqns = resolve(const, *pin.gates)
+        end
+        type.recreate(new_name: fqns, make_rooted: true)
       end
 
       # @return [void]
@@ -85,6 +107,7 @@ module Solargraph
       # @param gates [Array<String>]
       # @return [String, nil]
       def resolve_and_cache name, gates
+        cached_resolve[[name, gates]] = :in_process
         cached_resolve[[name, gates]] = resolve_uncached(name, gates)
       end
 
@@ -92,28 +115,66 @@ module Solargraph
       # @param gates [Array<String>]
       # @return [String, nil]
       def resolve_uncached name, gates
+        resolved = nil
+        base = gates
         parts = name.split('::')
-        here = parts.shift
-        resolved = simple_resolve(here, gates)
-        return resolved if parts.empty? || resolved.nil?
-
-        final = "#{resolved}::#{parts.join('::')}".sub(/^::/, '')
-        final if store.namespace_exists?(final)
+        first = nil
+        parts.each.with_index do |nam, idx|
+          resolved, remainder = complex_resolve(nam, base, idx != parts.length - 1)
+          first ||= remainder
+          if resolved
+            base = [resolved]
+          else
+            return resolve(name, first) unless first.empty?
+          end
+        end
+        resolved
       end
 
+      # @todo I'm not sure of a better way to express the return value in YARD.
+      #   It's a tuple where the first element is a nullable string. Something
+      #   like `Array(String|nil, Array<String>)` would be more accurate.
+      #
       # @param name [String]
       # @param gates [Array<String>]
+      # @param internal [Boolean] True if the name is not the last in the namespace
+      # @return [Array(Object, Array<String>)]
+      def complex_resolve name, gates, internal
+        resolved = nil
+        gates.each.with_index do |gate, idx|
+          resolved = simple_resolve(name, gate, internal)
+          return [resolved, gates[(idx + 1)..]] if resolved
+          store.get_ancestor_references(gate).each do |ref|
+            return ref.name.sub(/^::/, '') if ref.name.end_with?("::#{name}") && ref.name.start_with?('::')
+
+            mixin = resolve(ref.name, ref.reference_gates)
+            next unless mixin
+
+            resolved = simple_resolve(name, mixin, internal)
+            return [resolved, gates[(idx + 1)..]] if resolved
+          end
+        end
+        [nil, []]
+      end
+
+      # @param name [String]
+      # @param gate [String]
+      # @param internal [Boolean] True if the name is not the last in the namespace
       # @return [String, nil]
-      def simple_resolve name, gates
-        gates.each do |gate|
-          here = "#{gate}::#{name}".sub(/^::/, '').sub(/::$/, '')
-          return here if store.namespace_exists?(here)
+      def simple_resolve name, gate, internal
+        here = "#{gate}::#{name}".sub(/^::/, '').sub(/::$/, '')
+        pin = store.get_path_pins(here).first
+        if pin.is_a?(Pin::Constant) && internal
+          const = Solargraph::Parser::NodeMethods.unpack_name(pin.assignment)
+          return unless const
+          resolve(const, pin.gates)
+        else
+          pin&.path
         end
-        nil
       end
 
       # @param gates [Array<String>]
-      # @return [Array<Pin::Base>]
+      # @return [Array<Solargraph::Pin::Namespace, Solargraph::Pin::Constant>]
       def collect_and_cache gates
         skip = Set.new
         cached_collect[gates] = gates.flat_map do |gate|
@@ -121,12 +182,12 @@ module Solargraph
         end
       end
 
-      # @return [Hash{Array(Name, Array<String>) => String, nil}]
+      # @return [Hash{Array(String, Array<String>) => String, :in_process, nil}]
       def cached_resolve
         @cached_resolve ||= {}
       end
 
-      # @return [Hash{Array<String> => Array<Pin::Base>}]
+      # @return [Hash{Array<String> => Array<Solargraph::Pin::Namespace, Solargraph::Pin::Constant>}]
       def cached_collect
         @cached_collect ||= {}
       end
@@ -171,7 +232,7 @@ module Solargraph
             return fqns if store.namespace_exists?(fqns)
             incs = store.get_includes(roots.join('::'))
             incs.each do |inc|
-              foundinc = inner_qualify(name, inc.parametrized_tag.to_s, skip)
+              foundinc = inner_qualify(name, inc.type.to_s, skip)
               possibles.push foundinc unless foundinc.nil?
             end
             roots.pop
@@ -179,7 +240,7 @@ module Solargraph
           if possibles.empty?
             incs = store.get_includes('')
             incs.each do |inc|
-              foundinc = inner_qualify(name, inc.parametrized_tag.to_s, skip)
+              foundinc = inner_qualify(name, inc.type.to_s, skip)
               possibles.push foundinc unless foundinc.nil?
             end
           end
@@ -191,7 +252,7 @@ module Solargraph
       # @param fqns [String]
       # @param visibility [Array<Symbol>]
       # @param skip [Set<String>]
-      # @return [Array<Pin::Base>]
+      # @return [Array<Solargraph::Pin::Namespace, Solargraph::Pin::Constant>]
       def inner_get_constants fqns, visibility, skip
         return [] if fqns.nil? || skip.include?(fqns)
         skip.add fqns

data/lib/solargraph/api_map/index.rb

@@ -15,21 +15,24 @@ module Solargraph
         @pins ||= []
       end
 
-      # @return [Set<String>]
-      attr_reader :namespaces
-
       # @return [Hash{String => Array<Pin::Namespace>}]
       def namespace_hash
+        # @param h [String]
+        # @param k [Array<Pin::Namespace>]
         @namespace_hash ||= Hash.new { |h, k| h[k] = [] }
       end
 
       # @return [Hash{String => Array<Pin::Base>}]
       def pin_class_hash
+        # @param h [String]
+        # @param k [Array<Pin::Base>]
         @pin_class_hash ||= Hash.new { |h, k| h[k] = [] }
       end
 
       # @return [Hash{String => Array<Pin::Base>}]
       def path_pin_hash
+        # @param h [String]
+        # @param k [Array<Pin::Base>]
         @path_pin_hash ||= Hash.new { |h, k| h[k] = [] }
       end
 
@@ -45,26 +48,36 @@ module Solargraph
 
       # @return [Hash{String => Array<String>}]
       def include_references
+        # @param h [String]
+        # @param k [Array<String>]
         @include_references ||= Hash.new { |h, k| h[k] = [] }
       end
 
       # @return [Hash{String => Array<Pin::Reference::Include>}]
       def include_reference_pins
+        # @param h [String]
+        # @param k [Array<Pin::Reference::Include>]
         @include_reference_pins ||= Hash.new { |h, k| h[k] = [] }
       end
 
       # @return [Hash{String => Array<String>}]
       def extend_references
+        # @param h [String]
+        # @param k [Array<String>]
         @extend_references ||= Hash.new { |h, k| h[k] = [] }
       end
 
       # @return [Hash{String => Array<String>}]
       def prepend_references
+        # @param h [String]
+        # @param k [Array<String>]
         @prepend_references ||= Hash.new { |h, k| h[k] = [] }
       end
 
       # @return [Hash{String => Array<String>}]
       def superclass_references
+        # @param h [String]
+        # @param k [Array<String>]
         @superclass_references ||= Hash.new { |h, k| h[k] = [] }
       end
 
@@ -95,18 +108,25 @@ module Solargraph
       end
 
       # @param new_pins [Enumerable<Pin::Base>]
+      #
       # @return [self]
       def catalog new_pins
         # @type [Hash{Class<generic<T>> => Set<generic<T>>}]
         @pin_select_cache = {}
         pins.concat new_pins
         set = new_pins.to_set
+        # @param k [String]
+        # @param v [Set<Pin::Base>]
         set.classify(&:class)
-           .map { |k, v| pin_class_hash[k].concat v.to_a }
+          .map { |k, v| pin_class_hash[k].concat v.to_a }
+        # @param k [String]
+        # @param v [Set<Pin::Namespace>]
         set.classify(&:namespace)
-           .map { |k, v| namespace_hash[k].concat v.to_a }
+          .map { |k, v| namespace_hash[k].concat v.to_a }
+        # @param k [String]
+        # @param v [Set<Pin::Base>]
         set.classify(&:path)
-           .map { |k, v| path_pin_hash[k].concat v.to_a }
+          .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
@@ -116,10 +136,13 @@ module Solargraph
         self
       end
 
-      # @param klass [Class<Pin::Reference>]
-      # @param hash [Hash{String => Array<Pin::Reference>}]
+      # @generic T
+      # @param klass [Class<generic<T>>]
+      # @param hash [Hash{String => generic<T>}]
+      #
       # @return [void]
       def map_references klass, hash
+        # @param pin [generic<T>]
         pins_by_class(klass).each do |pin|
           hash[pin.namespace].push pin
         end
@@ -127,6 +150,7 @@ module Solargraph
 
       # @return [void]
       def map_overrides
+        # @param ovr [Pin::Reference::Override]
         pins_by_class(Pin::Reference::Override).each do |ovr|
           logger.debug { "ApiMap::Index#map_overrides: Looking at override #{ovr} for #{ovr.name}" }
           pins = path_pin_hash[ovr.name]

data/lib/solargraph/api_map/source_to_yard.rb

@@ -32,11 +32,13 @@ module Solargraph
             next
           end
           if pin.type == :class
+            # @param obj [YARD::CodeObjects::RootObject]
             code_object_map[pin.path] ||= YARD::CodeObjects::ClassObject.new(root_code_object, pin.path) { |obj|
               next if pin.location.nil? || pin.location.filename.nil?
               obj.add_file(pin.location.filename, pin.location.range.start.line, !pin.comments.empty?)
             }
           else
+            # @param obj [YARD::CodeObjects::RootObject]
             code_object_map[pin.path] ||= YARD::CodeObjects::ModuleObject.new(root_code_object, pin.path) { |obj|
               next if pin.location.nil? || pin.location.filename.nil?
               obj.add_file(pin.location.filename, pin.location.range.start.line, !pin.comments.empty?)
@@ -46,13 +48,13 @@ module Solargraph
           store.get_includes(pin.path).each do |ref|
             include_object = code_object_at(pin.path, YARD::CodeObjects::ClassObject)
             unless include_object.nil? || include_object.nil?
-              include_object.instance_mixins.push code_object_map[ref.parametrized_tag.to_s]
+              include_object.instance_mixins.push code_object_map[ref.type.to_s]
             end
           end
           store.get_extends(pin.path).each do |ref|
             extend_object = code_object_at(pin.path, YARD::CodeObjects::ClassObject)
             next unless extend_object
-            code_object = code_object_map[ref.parametrized_tag.to_s]
+            code_object = code_object_map[ref.type.to_s]
             next unless code_object
             extend_object.class_mixins.push code_object
             # @todo add spec showing why this next line is necessary
@@ -65,6 +67,7 @@ module Solargraph
             next
           end
 
+          # @param obj [YARD::CodeObjects::RootObject]
           code_object_map[pin.path] ||= YARD::CodeObjects::MethodObject.new(code_object_at(pin.namespace, YARD::CodeObjects::NamespaceObject), pin.name, pin.scope) { |obj|
             next if pin.location.nil? || pin.location.filename.nil?
             obj.add_file pin.location.filename, pin.location.range.start.line

data/lib/solargraph/api_map/store.rb

@@ -17,7 +17,7 @@ module Solargraph
         index.pins
       end
 
-      # @param pinsets [Array<Enumerable<Pin::Base>>]
+      # @param pinsets [Array<Array<Pin::Base>>]
       #   - pinsets[0] = core Ruby pins
       #   - pinsets[1] = documentation/gem pins
       #   - pinsets[2] = convention pins
@@ -57,9 +57,10 @@ module Solargraph
 
       # @param fqns [String]
       # @param visibility [Array<Symbol>]
-      # @return [Enumerable<Solargraph::Pin::Base>]
+      # @return [Enumerable<Solargraph::Pin::Namespace, Solargraph::Pin::Constant>]
       def get_constants fqns, visibility = [:public]
         namespace_children(fqns).select { |pin|
+          # @sg-ignore flow-sensitive typing not smart enough to handle this case
           !pin.name.empty? && (pin.is_a?(Pin::Namespace) || pin.is_a?(Pin::Constant)) && visibility.include?(pin.visibility)
         }
       end
@@ -70,6 +71,7 @@ module Solargraph
       # @return [Enumerable<Solargraph::Pin::Method>]
       def get_methods fqns, scope: :instance, visibility: [:public]
         all_pins = namespace_children(fqns).select do |pin|
+          # @sg-ignore https://github.com/castwide/solargraph/pull/1114
           pin.is_a?(Pin::Method) && pin.scope == scope && visibility.include?(pin.visibility)
         end
         GemPins.combine_method_pins_by_path(all_pins)
@@ -97,7 +99,7 @@ module Solargraph
         return unless ref
         res = constants.dereference(ref)
         return unless res
-        res + type.substring
+        res
       end
 
       # @param fqns [String]
@@ -134,7 +136,8 @@ module Solargraph
       end
 
       # @param fqns [String]
-      # @return [Enumerable<Solargraph::Pin::Base>]
+      #
+      # @return [Enumerable<Solargraph::Pin::ClassVariable>]
       def get_class_variables(fqns)
         namespace_children(fqns).select { |pin| pin.is_a?(Pin::ClassVariable)}
       end
@@ -150,11 +153,6 @@ module Solargraph
         fqns_pins(fqns).any?
       end
 
-      # @return [Set<String>]
-      def namespaces
-        index.namespaces
-      end
-
       # @return [Enumerable<Solargraph::Pin::Namespace>]
       def namespace_pins
         pins_by_class(Solargraph::Pin::Namespace)
@@ -244,7 +242,8 @@ module Solargraph
           # Add includes, prepends, and extends
           [get_includes(current), get_prepends(current), get_extends(current)].each do |refs|
             next if refs.nil?
-            refs.map(&:parametrized_tag).map(&:to_s).each do |ref|
+            # @param ref [String]
+            refs.map(&:type).map(&:to_s).each do |ref|
               next if ref.nil? || ref.empty? || visited.include?(ref)
               ancestors << ref
               queue << ref
@@ -255,6 +254,13 @@ module Solargraph
         ancestors.compact.uniq
       end
 
+      # @param fqns [String]
+      #
+      # @return [Array<Solargraph::Pin::Reference>]
+      def get_ancestor_references(fqns)
+        (get_prepends(fqns) + get_includes(fqns) + [get_superclass(fqns)]).compact
+      end
+
       # @return [Constants]
       def constants
         @constants ||= Constants.new(self)
@@ -267,8 +273,9 @@ module Solargraph
         @indexes.last
       end
 
-      # @param pinsets [Array<Enumerable<Pin::Base>>]
-      # @return [Boolean]
+      # @param pinsets [Array<Array<Pin::Base>>]
+      #
+      # @return [void]
       def catalog pinsets
         @pinsets = pinsets
         # @type [Array<Index>]
@@ -287,6 +294,9 @@ module Solargraph
 
       # @return [Hash{::Array(String, String) => ::Array<Pin::Namespace>}]
       def fqns_pins_map
+        # @param h [Hash{::Array(String, String) => ::Array<Pin::Namespace>}]
+        # @param base [String]
+        # @param name [String]
         @fqns_pins_map ||= Hash.new do |h, (base, name)|
           value = namespace_children(base).select { |pin| pin.name == name && pin.is_a?(Pin::Namespace) }
           h[[base, name]] = value