solargraph 0.59.0.dev.1 → 0.59.0.dev.2

data/CHANGELOG.md

@@ -1,5 +1,11 @@
+## 0.58.2 - January 19, 2026
+- Avoid rbs pollution (#1146)
+- Fix 'solargraph pin --references ClassName' private method call (#1150)
+- Improve memory efficiency of Position class (#1054)
+- Raise InvalidOffsetError for offsets > text (#1155)
+
 ## 0.58.1 - January 2, 2026
--  Normalize line endings to LF (#1142)
+- Normalize line endings to LF (#1142)
 
 ## 0.58.0 - January 1, 2026
 - Faster constant resolution (#1083)

data/Gemfile

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 gemspec name: 'solargraph'
 
 # Local gemfile for development tools, etc.
-local_gemfile = File.expand_path(".Gemfile", __dir__)
+local_gemfile = File.expand_path('.Gemfile', __dir__)
 instance_eval File.read local_gemfile if File.exist? local_gemfile

data/Rakefile

@@ -1,42 +1,44 @@
+# frozen_string_literal: true
+
 require 'rake'
 require 'bundler/gem_tasks'
 require 'fileutils'
 require 'open3'
 
-desc "Open a Pry session preloaded with this library"
+desc 'Open a Pry session preloaded with this library'
 task :console do
-  sh "pry -I lib -r solargraph.rb"
+  sh 'pry -I lib -r solargraph.rb'
 end
 
-desc "Run the type checker"
+desc 'Run the type checker'
 task typecheck: [:typecheck_strong]
 
-desc "Run the type checker at typed level - return code issues provable without annotations being correct"
+desc 'Run the type checker at typed level - return code issues provable without annotations being correct'
 task :typecheck_typed do
-  sh "SOLARGRAPH_ASSERTS=on bundle exec solargraph typecheck --level typed"
+  sh 'SOLARGRAPH_ASSERTS=on bundle exec solargraph typecheck --level typed'
 end
 
-desc "Run the type checker at strict level - report issues using type annotations"
+desc 'Run the type checker at strict level - report issues using type annotations'
 task :typecheck_strict do
-  sh "SOLARGRAPH_ASSERTS=on bundle exec solargraph typecheck --level strict"
+  sh 'SOLARGRAPH_ASSERTS=on bundle exec solargraph typecheck --level strict'
 end
 
-desc "Run the type checker at strong level - enforce that type annotations exist"
+desc 'Run the type checker at strong level - enforce that type annotations exist'
 task :typecheck_strong do
-  sh "SOLARGRAPH_ASSERTS=on bundle exec solargraph typecheck --level strong"
+  sh 'SOLARGRAPH_ASSERTS=on bundle exec solargraph typecheck --level strong'
 end
 
-desc "Run the type checker at alpha level - run high-false-alarm checks"
+desc 'Run the type checker at alpha level - run high-false-alarm checks'
 task :typecheck_alpha do
-  sh "SOLARGRAPH_ASSERTS=on bundle exec solargraph typecheck --level alpha"
+  sh 'SOLARGRAPH_ASSERTS=on bundle exec solargraph typecheck --level alpha'
 end
 
-desc "Run RSpec tests, starting with the ones that failed last time"
+desc 'Run RSpec tests, starting with the ones that failed last time'
 task spec: %i[spec_failed undercover_no_fail full_spec] do
   undercover
 end
 
-desc "Run all RSpec tests"
+desc 'Run all RSpec tests'
 task :full_spec do
   warn 'starting spec'
   sh 'TEST_COVERAGE_COMMAND_NAME=full-new bundle exec rspec' #  --profile'
@@ -66,17 +68,17 @@ rescue StandardError => e
   # @sg-ignore Need to add nil check here
   warn "Backtrace:\n#{e.backtrace.join("\n")}"
   warn "output: #{output}"
-  puts "Flushing"
+  puts 'Flushing'
   $stdout.flush
   raise
 end
 
-desc "Check PR coverage"
+desc 'Check PR coverage'
 task :undercover do
-  raise "Undercover failed" unless undercover.success?
+  raise 'Undercover failed' unless undercover.success?
 end
 
-desc "Branch-focused fast-feedback quality/spec/coverage checks"
+desc 'Branch-focused fast-feedback quality/spec/coverage checks'
 task test: %i[overcommit spec typecheck] do
   # do these in order
   Rake::Task['typecheck_strict'].invoke
@@ -84,18 +86,18 @@ task test: %i[overcommit spec typecheck] do
   Rake::Task['typecheck_alpha'].invoke
 end
 
-desc "Re-run failed specs.  Add --fail-fast in your .rspec-local file if desired."
+desc 'Re-run failed specs.  Add --fail-fast in your .rspec-local file if desired.'
 task :spec_failed do
   # allow user to check out any persistent failures while looking for
   # more in the whole test suite
   sh 'TEST_COVERAGE_COMMAND_NAME=next-failure bundle exec rspec --only-failures || true'
 end
 
-desc "Run undercover and show output without failing the task if it fails"
+desc 'Run undercover and show output without failing the task if it fails'
 task :undercover_no_fail do
   undercover
 rescue StandardError
-  puts "Undercover failed, but continuing with other tasks."
+  puts 'Undercover failed, but continuing with other tasks.'
 end
 
 # @return [void]
@@ -104,7 +106,7 @@ def simplecov_collate
   require 'simplecov-lcov'
   require 'undercover/simplecov_formatter'
 
-  SimpleCov.collate(Dir["coverage/{next-failure,full,ad-hoc}/.resultset.json"]) do
+  SimpleCov.collate(Dir['coverage/{next-failure,full,ad-hoc}/.resultset.json']) do
     cname = 'combined'
     command_name cname
     new_dir = File.join('coverage', cname)
@@ -119,7 +121,7 @@ def simplecov_collate
              ])
     SimpleCov::Formatter::LcovFormatter.config.report_with_single_file = true
   end
-  puts "Simplecov collated results into coverage/combined/.resultset.json"
+  puts 'Simplecov collated results into coverage/combined/.resultset.json'
 rescue StandardError => e
   puts "Simplecov collate failed: #{e.message}"
 ensure
@@ -131,7 +133,7 @@ task :simplecov_collate do
   simplecov_collate
 end
 
-desc "Show quality checks on this development branch so far, including any staged files"
+desc 'Show quality checks on this development branch so far, including any staged files'
 task :overcommit do
   # OVERCOMMIT_DEBUG=1 will show more detail
   sh 'SOLARGRAPH_ASSERTS=on bundle exec overcommit --run --diff origin/master'

data/bin/solargraph

@@ -1,7 +1,8 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 # turn off warning diagnostics from Ruby
-$VERBOSE=nil
+$VERBOSE = nil
 
 require 'solargraph'
 

data/lib/solargraph/api_map/index.rb

@@ -118,15 +118,15 @@ module Solargraph
         # @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
@@ -157,20 +157,14 @@ module Solargraph
           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
+            new_pin = (path_pin_hash[pin.path.sub('#initialize', '.new')].first if pin.path.end_with?('#initialize'))
             (ovr.tags.map(&:tag_name) + ovr.delete).uniq.each do |tag|
               # @sg-ignore Wrong argument type for
               #   YARD::Docstring#delete_tags: name expected String,
               #   received String, Symbol - delete_tags is ok with a
               #   _ToS, but we should fix anyway
               pin.docstring.delete_tags tag
-              # @sg-ignore Wrong argument type for
-              #   YARD::Docstring#delete_tags: name expected String,
-              #   received String, Symbol - delete_tags is ok with a
-              #   _ToS, but we should fix anyway
-              new_pin.docstring.delete_tags tag if new_pin
+              new_pin&.docstring&.delete_tags tag
             end
             ovr.tags.each do |tag|
               pin.docstring.add_tag(tag)

data/lib/solargraph/api_map/source_to_yard.rb

@@ -3,7 +3,6 @@
 module Solargraph
   class ApiMap
     module SourceToYard
-
       # Get the YARD CodeObject at the specified path.
       #
       # @sg-ignore Declared return type generic<T>, nil does not match
@@ -15,7 +14,7 @@ module Solargraph
       # @return [generic<T>, nil]
       def code_object_at path, klass = YARD::CodeObjects::Base
         obj = code_object_map[path]
-        obj if obj&.is_a?(klass)
+        obj if obj.is_a?(klass)
       end
 
       # @return [Array<String>]
@@ -36,20 +35,20 @@ module Solargraph
           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|
+            code_object_map[pin.path] ||= YARD::CodeObjects::ClassObject.new(root_code_object, pin.path) do |obj|
               # @sg-ignore flow sensitive typing needs to handle attrs
               next if pin.location.nil? || pin.location.filename.nil?
               # @sg-ignore flow sensitive typing needs to handle attrs
               obj.add_file(pin.location.filename, pin.location.range.start.line, !pin.comments.empty?)
-            }
+            end
           else
             # @param obj [YARD::CodeObjects::RootObject]
-            code_object_map[pin.path] ||= YARD::CodeObjects::ModuleObject.new(root_code_object, pin.path) { |obj|
+            code_object_map[pin.path] ||= YARD::CodeObjects::ModuleObject.new(root_code_object, pin.path) do |obj|
               # @sg-ignore flow sensitive typing needs to handle attrs
               next if pin.location.nil? || pin.location.filename.nil?
               # @sg-ignore flow sensitive typing needs to handle attrs
               obj.add_file(pin.location.filename, pin.location.range.start.line, !pin.comments.empty?)
-            }
+            end
           end
           code_object_map[pin.path].docstring = pin.docstring
           store.get_includes(pin.path).each do |ref|
@@ -75,12 +74,14 @@ module Solargraph
 
           # @sg-ignore Need to add nil check here
           # @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|
+          code_object_map[pin.path] ||= YARD::CodeObjects::MethodObject.new(
+            code_object_at(pin.namespace, YARD::CodeObjects::NamespaceObject), pin.name, pin.scope
+          ) do |obj|
             # @sg-ignore flow sensitive typing needs to handle attrs
             next if pin.location.nil? || pin.location.filename.nil?
             # @sg-ignore flow sensitive typing needs to handle attrs
             obj.add_file pin.location.filename, pin.location.range.start.line
-          }
+          end
           method_object = code_object_at(pin.path, YARD::CodeObjects::MethodObject)
           # @sg-ignore Need to add nil check here
           method_object.docstring = pin.docstring

data/lib/solargraph/api_map/store.rb

@@ -32,16 +32,16 @@ module Solargraph
 
         # @todo Fix this map
         @fqns_pins_map = nil
-        return catalog(pinsets) if changed == 0
+        return catalog(pinsets) if changed.zero?
 
         # @sg-ignore Need to add nil check here
         pinsets[changed..].each_with_index do |pins, idx|
           @pinsets[changed + idx] = pins
           @indexes[changed + idx] = if pins.empty?
-            @indexes[changed + idx - 1]
-          else
-            @indexes[changed + idx - 1].merge(pins)
-          end
+                                      @indexes[changed + idx - 1]
+                                    else
+                                      @indexes[changed + idx - 1].merge(pins)
+                                    end
         end
         constants.clear
         cached_qualify_superclass.clear
@@ -60,10 +60,10 @@ module Solargraph
       # @param visibility [Array<Symbol>]
       # @return [Enumerable<Solargraph::Pin::Namespace, Solargraph::Pin::Constant>]
       def get_constants fqns, visibility = [:public]
-        namespace_children(fqns).select { |pin|
+        namespace_children(fqns).select do |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
       end
 
       # @param fqns [String]
@@ -77,8 +77,10 @@ module Solargraph
         GemPins.combine_method_pins_by_path(all_pins)
       end
 
-      BOOLEAN_SUPERCLASS_PIN = Pin::Reference::Superclass.new(name: 'Boolean', closure: Pin::ROOT_PIN, source: :solargraph)
-      OBJECT_SUPERCLASS_PIN = Pin::Reference::Superclass.new(name: 'Object', closure: Pin::ROOT_PIN, source: :solargraph)
+      BOOLEAN_SUPERCLASS_PIN = Pin::Reference::Superclass.new(name: 'Boolean', closure: Pin::ROOT_PIN,
+                                                              source: :solargraph)
+      OBJECT_SUPERCLASS_PIN = Pin::Reference::Superclass.new(name: 'Object', closure: Pin::ROOT_PIN,
+                                                             source: :solargraph)
 
       # @param fqns [String, nil]
       # @return [Pin::Reference::Superclass, nil]
@@ -129,17 +131,17 @@ module Solargraph
       # @param fqns [String, nil]
       # @param scope [Symbol] :class or :instance
       # @return [Enumerable<Solargraph::Pin::Base>]
-      def get_instance_variables(fqns, scope = :instance)
-        all_instance_variables.select { |pin|
+      def get_instance_variables fqns, scope = :instance
+        all_instance_variables.select do |pin|
           pin.binder.namespace == fqns && pin.binder.scope == scope
-        }
+        end
       end
 
       # @param fqns [String]
       #
       # @return [Enumerable<Solargraph::Pin::ClassVariable>]
-      def get_class_variables(fqns)
-        namespace_children(fqns).select { |pin| pin.is_a?(Pin::ClassVariable)}
+      def get_class_variables fqns
+        namespace_children(fqns).select { |pin| pin.is_a?(Pin::ClassVariable) }
       end
 
       # @return [Enumerable<Solargraph::Pin::Base>]
@@ -149,7 +151,7 @@ module Solargraph
 
       # @param fqns [String]
       # @return [Boolean]
-      def namespace_exists?(fqns)
+      def namespace_exists? fqns
         fqns_pins(fqns).any?
       end
 
@@ -165,7 +167,7 @@ module Solargraph
 
       # @param fqns [String]
       # @return [Array<String>]
-      def domains(fqns)
+      def domains fqns
         result = []
         fqns_pins(fqns).each do |nspin|
           result.concat nspin.domains
@@ -178,7 +180,7 @@ module Solargraph
         @named_macros ||= begin
           result = {}
           pins.each do |pin|
-            pin.macros.select{|m| m.tag.tag_name == 'macro' && !m.tag.text.empty? }.each do |macro|
+            pin.macros.select { |m| m.tag.tag_name == 'macro' && !m.tag.text.empty? }.each do |macro|
               next if macro.tag.name.nil? || macro.tag.name.empty?
               result[macro.tag.name] = macro
             end
@@ -217,7 +219,7 @@ module Solargraph
       # Get all ancestors (superclasses, includes, prepends, extends) for a namespace
       # @param fqns [String] The fully qualified namespace
       # @return [Array<String>] Array of ancestor namespaces including the original
-      def get_ancestors(fqns)
+      def get_ancestors fqns
         return [] if fqns.nil? || fqns.empty?
 
         ancestors = [fqns]
@@ -260,7 +262,7 @@ module Solargraph
       # @param fqns [String]
       #
       # @return [Array<Solargraph::Pin::Reference>]
-      def get_ancestor_references(fqns)
+      def get_ancestor_references fqns
         (get_prepends(fqns) + get_includes(fqns) + [get_superclass(fqns)]).compact
       end
 
@@ -350,7 +352,7 @@ module Solargraph
 
       # @param fqns [String]
       # @return [Pin::Reference::Superclass, nil]
-      def try_special_superclasses(fqns)
+      def try_special_superclasses fqns
         return OBJECT_SUPERCLASS_PIN if fqns == 'Boolean'
         return OBJECT_SUPERCLASS_PIN if !%w[BasicObject Object].include?(fqns) && namespace_exists?(fqns)
 

data/lib/solargraph/api_map.rb

@@ -51,15 +51,15 @@ module Solargraph
     #
 
     # @param other [Object]
-    def eql?(other)
+    def eql? other
       self.class == other.class &&
         # @sg-ignore flow sensitive typing needs to handle self.class == other.class
         equality_fields == other.equality_fields
     end
 
     # @param other [Object]
-    def ==(other)
-      self.eql?(other)
+    def == other
+      eql?(other)
     end
 
     # @return [Integer]
@@ -127,13 +127,6 @@ module Solargraph
       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, conventions_environ, @doc_map, @unresolved_requires, @missing_docs, @loose_unions]
-    end
-
     # @return [DocMap]
     def doc_map
       @doc_map ||= DocMap.new([], Workspace.new('.'))
@@ -212,7 +205,7 @@ module Solargraph
     # @param rebuild [Boolean]
     # @param out [StringIO, IO, nil]
     # @return [void]
-    def cache_gem(gemspec, rebuild: false, out: nil)
+    def cache_gem gemspec, rebuild: false, out: nil
       doc_map.cache(gemspec, rebuild: rebuild, out: out)
     end
 
@@ -317,19 +310,19 @@ module Solargraph
     #
     # @param pin [Pin::Reference]
     # @return [String, nil]
-    def dereference(pin)
+    def dereference pin
       store.constants.dereference(pin)
     end
 
     # @param fqns [String]
     # @return [Array<Pin::Reference::Extend>]
-    def get_extends(fqns)
+    def get_extends fqns
       store.get_extends(fqns)
     end
 
     # @param fqns [String]
     # @return [Array<Pin::Reference::Include>]
-    def get_includes(fqns)
+    def get_includes fqns
       store.get_includes(fqns)
     end
 
@@ -341,7 +334,7 @@ module Solargraph
     # @return [Array<Solargraph::Pin::InstanceVariable>]
     def get_instance_variable_pins namespace, scope = :instance
       result = []
-      used = [namespace]
+      [namespace]
       result.concat store.get_instance_variables(namespace, scope)
       sc_fqns = namespace
       while (sc = store.get_superclass(sc_fqns))
@@ -364,12 +357,12 @@ module Solargraph
     # @param location [Location]
     #
     # @return [Pin::BaseVariable, nil]
-    def var_at_location(candidates, name, closure, location)
-      with_correct_name = candidates.select { |pin| pin.name == name}
+    def var_at_location candidates, name, closure, location
+      with_correct_name = candidates.select { |pin| pin.name == name }
       vars_at_location = with_correct_name.reject do |pin|
         # visible_at? excludes the starting position, but we want to
         # include it for this purpose
-        (!pin.visible_at?(closure, location) && !pin.starts_at?(location))
+        !pin.visible_at?(closure, location) && !pin.starts_at?(location)
       end
 
       vars_at_location.inject(&:combine_with)
@@ -446,7 +439,7 @@ module Solargraph
               comments: init_pin.comments,
               closure: init_pin.closure,
               source: init_pin.source,
-              type_location: init_pin.type_location,
+              type_location: init_pin.type_location
             )
             new_pin.parameters = init_pin.parameters.map do |init_param|
               param = init_param.clone
@@ -505,7 +498,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], source: :api_map)
+          result.add Pin::DuckMethod.new(name: type.to_s[1..], source: :api_map)
           result.merge get_methods('Object')
         else
           unless type.nil? || type.name == 'void'
@@ -536,7 +529,8 @@ module Solargraph
     # @param preserve_generics [Boolean] True to preserve any
     #   unresolved generic parameters, false to erase them
     # @return [Array<Solargraph::Pin::Method>]
-    def get_method_stack rooted_tag, name, scope: :instance, visibility: [:private, :protected, :public], preserve_generics: false
+    def get_method_stack rooted_tag, name, scope: :instance, visibility: %i[private protected public],
+                         preserve_generics: false
       rooted_type = ComplexType.parse(rooted_tag)
       fqns = rooted_type.namespace
       namespace_pin = store.get_path_pins(fqns).first
@@ -661,7 +655,7 @@ module Solargraph
     # @param sup [String] The superclass
     # @param sub [String] The subclass
     # @return [Boolean]
-    def super_and_sub?(sup, sub)
+    def super_and_sub? sup, sub
       sup = ComplexType.try_parse(sup)
       sub = ComplexType.try_parse(sub)
       # @todo If two literals are different values of the same type, it would
@@ -693,14 +687,14 @@ module Solargraph
     # @param module_ns [String] The module namespace (no type parameters)
     #
     # @return [Boolean]
-    def type_include?(host_ns, module_ns)
+    def type_include? host_ns, module_ns
       store.get_includes(host_ns).map { |inc_tag| inc_tag.type.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]
+    def resolve_method_aliases pins, visibility = %i[public private protected]
       with_resolved_aliases = pins.map do |pin|
         next pin unless pin.is_a?(Pin::MethodAlias)
         resolved = resolve_method_alias(pin)
@@ -730,7 +724,7 @@ module Solargraph
     # @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)
+    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
@@ -786,7 +780,7 @@ module Solargraph
     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
+      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}"
@@ -797,7 +791,9 @@ module Solargraph
       # ensure we start out with any immediate methods in this
       # namespace so we roughly match the same ordering of get_methods
       # and obey the 'deep' instruction
-      direct_convention_methods, convention_methods_by_reference = environ.pins.partition { |p| p.namespace == rooted_tag }
+      direct_convention_methods, convention_methods_by_reference = environ.pins.partition do |p|
+        p.namespace == rooted_tag
+      end
       result.concat direct_convention_methods
 
       if deep && scope == :instance
@@ -809,8 +805,10 @@ module Solargraph
       # 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 }
-      logger.info { "ApiMap#inner_get_methods(rooted_tag=#{rooted_tag.inspect}, scope=#{scope.inspect}, visibility=#{visibility.inspect}, deep=#{deep.inspect}, skip=#{skip.inspect}, fqns=#{fqns}) - added from store: #{methods}" }
+      methods = store.get_methods(fqns, scope: scope, visibility: visibility).sort { |a, b| a.name <=> b.name }
+      logger.info do
+        "ApiMap#inner_get_methods(rooted_tag=#{rooted_tag.inspect}, scope=#{scope.inspect}, visibility=#{visibility.inspect}, deep=#{deep.inspect}, skip=#{skip.inspect}, fqns=#{fqns}) - added from store: #{methods}"
+      end
       result.concat methods
       if deep
         result.concat convention_methods_by_reference
@@ -819,7 +817,8 @@ module Solargraph
           store.get_includes(fqns).reverse.each do |ref|
             in_tag = dereference(ref)
             # @sg-ignore Need to add nil check here
-            result.concat inner_get_methods_from_reference(in_tag, namespace_pin, rooted_type, scope, visibility, deep, skip, true)
+            result.concat inner_get_methods_from_reference(in_tag, namespace_pin, rooted_type, scope, visibility, deep,
+                                                           skip, true)
           end
           rooted_sc_tag = qualify_superclass(rooted_tag)
           unless rooted_sc_tag.nil?
@@ -827,7 +826,9 @@ module Solargraph
                                                            visibility, true, skip, no_core)
           end
         else
-          logger.info { "ApiMap#inner_get_methods(#{fqns}, #{scope}, #{visibility}, #{deep}, #{skip}) - looking for get_extends() from #{fqns}" }
+          logger.info do
+            "ApiMap#inner_get_methods(#{fqns}, #{scope}, #{visibility}, #{deep}, #{skip}) - looking for get_extends() from #{fqns}"
+          end
           store.get_extends(fqns).reverse.each do |em|
             fqem = dereference(em)
             result.concat inner_get_methods(fqem, :instance, visibility, deep, skip, true) unless fqem.nil?
@@ -863,7 +864,7 @@ module Solargraph
     def get_namespace_type fqns
       return nil if fqns.nil?
       # @type [Pin::Namespace, nil]
-      pin = store.get_path_pins(fqns).select{|p| p.is_a?(Pin::Namespace)}.first
+      pin = store.get_path_pins(fqns).select { |p| p.is_a?(Pin::Namespace) }.first
       return nil if pin.nil?
       pin.type
     end
@@ -889,7 +890,7 @@ module Solargraph
 
     # @param alias_pin [Pin::MethodAlias]
     # @return [Pin::Method, nil]
-    def resolve_method_alias(alias_pin)
+    def resolve_method_alias alias_pin
       ancestors = store.get_ancestors(alias_pin.full_context.reduce_class_type.tag)
       # @type [Pin::Method, nil]
       original = nil
@@ -920,7 +921,9 @@ module Solargraph
       end
       if original.nil?
         # :nocov:
-        Solargraph.assert_or_log(:alias_target_missing) { "Rejecting alias - target is missing while looking for #{alias_pin.full_context.tag} #{alias_pin.original} in #{alias_pin.scope} scope = #{alias_pin.inspect}" }
+        Solargraph.assert_or_log(:alias_target_missing) do
+          "Rejecting alias - target is missing while looking for #{alias_pin.full_context.tag} #{alias_pin.original} in #{alias_pin.scope} scope = #{alias_pin.inspect}"
+        end
         return nil
         # :nocov:
       end
@@ -933,7 +936,7 @@ module Solargraph
     # @param alias_pin [Pin::MethodAlias] The alias pin to resolve
     # @param original [Pin::Method] The original method pin that was already found
     # @return [Pin::Method] The resolved method pin
-    def create_resolved_alias_pin(alias_pin, original)
+    def create_resolved_alias_pin alias_pin, original
       # Build the resolved method pin directly (same logic as resolve_method_alias but without lookup)
       args = {
         location: alias_pin.location,
@@ -949,7 +952,7 @@ module Solargraph
         return_type: original.return_type,
         source: :resolve_method_alias
       }
-      resolved_pin = Pin::Method.new **args
+      resolved_pin = Pin::Method.new(**args)
 
       # Clone signatures and parameters
       resolved_pin.signatures.each do |sig|
@@ -987,7 +990,7 @@ module Solargraph
     end
 
     # @param namespace_pin [Pin::Namespace, Pin::Constant]
-    def has_generics?(namespace_pin)
+    def has_generics? namespace_pin
       namespace_pin.is_a?(Pin::Namespace) && !namespace_pin.generics.empty?
     end
 
@@ -996,5 +999,15 @@ module Solargraph
     def can_resolve_generics? namespace_pin, rooted_type
       has_generics?(namespace_pin) && !rooted_type.all_params.empty?
     end
+
+    protected
+
+    # @todo need to model type def statement in chains as a symbol so
+    #   that this overload of 'protected' will typecheck @sg-ignore
+    # @sg-ignore
+    def equality_fields
+      [self.class, @source_map_hash, conventions_environ, @doc_map, @unresolved_requires, @missing_docs,
+       @loose_unions]
+    end
   end
 end