solargraph 0.56.2 → 0.57.0

data/.yardopts

@@ -1,2 +1,3 @@
 lib/**/*.rb
 --plugin yard-solargraph
+--plugin activesupport-concern

data/CHANGELOG.md

@@ -1,3 +1,45 @@
+## 0.57.0 - September 16, 2025
+- Support ActiveSupport::Concern pattern for class methods (#948)
+- More CI checks (#996)
+- Linting / type annotation fixes (#999)
+- Avoid overlapping chdir calls in multiple threads (#1007)
+- Fix kwarg generation in ApiMap::SourceToYard (#1003)
+- Enable Steep typechecking of Solargraph code (#1004)
+- Fix convention requires (#1008)
+- Plugin Util: Add Combination Priority (#1010)
+- [regression] Fix crash while typechecking files with Struct use (#1031)
+- Remove yard reference from gemfile (#1033)
+- Allow newer RBS gem versions, exclude incompatible ones (#995)
+- Look for external requires before cataloging bench (#1021)
+- Remove Library#folding_ranges (#904)
+- Complain in strong type-checking if an @sg-ignore line is not needed (#1011)
+- Document a log level env variable (#894)
+- Fix hole in type checking evaluation (#1009)
+- Improve typechecking error message (#1014)
+- Internal strict type-checking fixes (#1013)
+- Reproduce and fix a ||= (or-asgn) evaluation issue (#1017)
+- Define closure for Pin::Symbol, for completeness (#1027)
+- Fix 'all!' config to reporters (#1018)
+- Fix DocMap.all_rbs_collection_gems_in_memory return type (#1037)
+- Fix RuboCop linting errors in regular expressions (#1038)
+- Resolve class aliases via Constant pins (#1029)
+- Speed-up LSP completion response times (#1035)
+- Revert "Resolve class aliases via Constant pins (#1029)" (#1041)
+- Avoid stack errors when resolving method aliases (#1040)
+- [regression] Refine order of object convention method pins (#1036)
+- Fix crash while generating activesupport pins (#1043)
+- Type annotation improvements (#1016)
+- Resolve class aliases via Constant pins (#1048)
+- Understand "Parser::AST::Node < AST::Node" in RBS (#1060)
+- Factor out require_paths logic to its own class (#1062)
+- Fix type errors found in strong typechecking (#1045)
+- Run plugin specs separately for perf insights (#1046)
+- Run specs from solargraph-rails configured against current code in CI (#892)
+- Fix Convention/Plugin pins not being updated on file change (#1028)
+- Fix solargraph-rails check (#1073)
+- Flow sensitive typing handles x.is_a? without an argument (#1070)
+- Refactor reference pin handling (#1058)
+
 ## 0.56.2 - July 29, 2025
 - Add support for Ruby Data.define (#970)
 - Ensure that pin locations are always populated (#965)

data/README.md

@@ -53,7 +53,7 @@ Solargraph's behavior can be controlled via optional [configuration](https://sol
 
 ### Plugins
 
-Solargraph supports [plugins](https://solargraph.org/guides/plugins) that implements their own Solargraph features, such as diagnostics reporters and conventions to provide LSP features and type-checking, e.g. for frameworks which use metaprogramming and/or DSLs.
+Solargraph supports [plugins](https://solargraph.org/guides/plugins) that implement their own Solargraph features, such as diagnostics reporters and conventions to provide LSP features and type-checking, e.g. for frameworks which use metaprogramming and/or DSLs.
 
 For better Rails support, please consider using [solargraph-rails](https://github.com/iftheshoefritz/solargraph-rails/)
 
@@ -65,7 +65,7 @@ The RSpec framework is supported via [solargraph-rspec](https://github.com/lekem
 
 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.
+If your project automatically requires bundled gem with the `Bundler.require` statement, 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
@@ -81,7 +81,7 @@ Once installed, you can also insert your own local overrides and definitions in
 
 ### 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.
+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.  In strong mode it will ask you to clarify your intentions by adding annotations for better validation.
 
 ### The Documentation Cache
 
@@ -101,7 +101,7 @@ Run `bundle install` and optionally use `bundle exec solargraph gems` to generat
 
 In order to make sure you're using the correct dependencies, you can start the language server with Bundler. In VS Code, there's a `solargraph.useBundler` option. Other clients will vary, but the command you probably want to run is `bundle exec solargraph socket` or `bundle exec solargraph stdio`.
 
-### Rubocop Version
+### RuboCop Version
 
 If you have multiple versions of [`rubocop`](https://rubygems.org/gems/rubocop) installed and you would like to choose a version other than the latest to use, this specific version can be configured.
 
@@ -132,6 +132,10 @@ See [https://solargraph.org/guides](https://solargraph.org/guides) for more tips
 
 ### Development
 
+To see more logging when typechecking or running specs, set the
+`SOLARGRAPH_LOG` environment variable to `debug` or `info`.  `warn` is
+the default value.
+
 Code contributions are always appreciated. Feel free to fork the repo and submit pull requests. Check for open issues that could use help. Start new issues to discuss changes that have a major impact on the code or require large time commitments.
 
 ### Sponsorship and Donation

data/Rakefile

@@ -1,12 +1,7 @@
 require 'rake'
-require 'rspec/core/rake_task'
 require 'bundler/gem_tasks'
-
-begin
-  require 'rspec/core/rake_task'
-  RSpec::Core::RakeTask.new(:spec)
-rescue LoadError
-end
+require 'fileutils'
+require 'open3'
 
 desc "Open a Pry session preloaded with this library"
 task :console do
@@ -14,12 +9,129 @@ task :console do
 end
 
 desc "Run the type checker"
-task :typecheck do
-  sh "bundle exec solargraph typecheck --level typed"
+task typecheck: [:typecheck_typed]
+
+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"
+end
+
+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"
+end
+
+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"
+end
+
+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"
+end
+
+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"
+task :full_spec do
+  warn 'starting spec'
+  sh 'TEST_COVERAGE_COMMAND_NAME=full-new bundle exec rspec' #  --profile'
+  warn 'ending spec'
+  # move coverage/full-new to coverage/full on success so that we
+  # always have the last successful run's 'coverage info
+  FileUtils.rm_rf('coverage/full')
+  FileUtils.mv('coverage/full-new', 'coverage/full')
+end
+
+# @sg-ignore #undercover return type could not be inferred
+# @return [Process::Status]
+def undercover
+  simplecov_collate
+  cmd = 'bundle exec undercover ' \
+        '--simplecov coverage/combined/coverage.json ' \
+        '--exclude-files "Rakefile,spec/*,spec/**/*,lib/solargraph/version.rb" ' \
+        '--compare origin/master'
+  output, status = Bundler.with_unbundled_env do
+    Open3.capture2e(cmd)
+  end
+  puts output
+  $stdout.flush
+  status
+rescue StandardError => e
+  warn "hit error: #{e.message}"
+  warn "Backtrace:\n#{e.backtrace.join("\n")}"
+  warn "output: #{output}"
+  puts "Flushing"
+  $stdout.flush
+  raise
+end
+
+desc "Check PR coverage"
+task :undercover do
+  raise "Undercover failed" unless undercover.success?
+end
+
+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
+  Rake::Task['typecheck_strong'].invoke
+  Rake::Task['typecheck_alpha'].invoke
+end
+
+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"
+task :undercover_no_fail do
+  undercover
+rescue StandardError
+  puts "Undercover failed, but continuing with other tasks."
+end
+
+# @return [void]
+def simplecov_collate
+  require 'simplecov'
+  require 'simplecov-lcov'
+  require 'undercover/simplecov_formatter'
+
+  SimpleCov.collate(Dir["coverage/{next-failure,full,ad-hoc}/.resultset.json"]) do
+    cname = 'combined'
+    command_name cname
+    new_dir = File.join('coverage', cname)
+    coverage_dir new_dir
+
+    formatter \
+      SimpleCov::Formatter::MultiFormatter
+        .new([
+               SimpleCov::Formatter::HTMLFormatter,
+               SimpleCov::Formatter::Undercover,
+               SimpleCov::Formatter::LcovFormatter
+             ])
+    SimpleCov::Formatter::LcovFormatter.config.report_with_single_file = true
+  end
+  puts "Simplecov collated results into coverage/combined/.resultset.json"
+rescue StandardError => e
+  puts "Simplecov collate failed: #{e.message}"
+ensure
+  $stdout.flush
+end
+
+desc 'Add incremental coverage for rapid iteration with undercover'
+task :simplecov_collate do
+  simplecov_collate
 end
 
-desc "Run all tests"
-task :test do
-  Rake::Task["typecheck"].invoke
-  Rake::Task["spec"].invoke
+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'
 end

data/lib/solargraph/api_map/cache.rb

@@ -4,9 +4,9 @@ module Solargraph
   class ApiMap
     class Cache
       def initialize
-        # @type [Hash{Array => Array<Pin::Method>}]
+        # @type [Hash{String => Array<Pin::Method>}]
         @methods = {}
-        # @type [Hash{(String, Array<String>) => Array<Pin::Base>}]
+        # @type [Hash{String, Array<String> => Array<Pin::Base>}]
         @constants = {}
         # @type [Hash{String => String}]
         @qualified_namespaces = {}
@@ -101,6 +101,7 @@ module Solargraph
 
       private
 
+      # @return [Array<Object>]
       def all_caches
         [@methods, @constants, @qualified_namespaces, @receiver_definitions, @clips]
       end

data/lib/solargraph/api_map/constants.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class ApiMap
+    # Methods for handling constants.
+    #
+    class Constants
+      # @param store [Store]
+      def initialize store
+        @store = store
+      end
+
+      # Resolve a name to a fully qualified namespace or constant.
+      #
+      # @param name [String]
+      # @param gates [Array<Array<String>, String>]
+      # @return [String, nil]
+      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)
+      end
+
+      # Get a fully qualified namespace from a reference pin.
+      #
+      # @param pin [Pin::Reference]
+      # @return [String, nil]
+      def dereference pin
+        resolve(pin.name, pin.reference_gates)
+      end
+
+      # Collect a list of all constants defined in the specified gates.
+      #
+      # @param gates [Array<Array<String>, String>]
+      # @return [Array<Pin::Base>]
+      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.
+      #
+      # Does not recurse into qualifying the type parameters, but
+      # returns any which were passed in unchanged.
+      #
+      # @param tag [String, nil] The namespace to
+      #   match, complete with generic parameters set to appropriate
+      #   values if available
+      # @param context_tag [String] The fully qualified context in which
+      #   the tag was referenced; start from here to resolve the name.
+      #   Should not be prefixed with '::'.
+      # @return [String, nil] fully qualified tag
+      def qualify tag, context_tag = ''
+        return tag if ['Boolean', 'self', nil].include?(tag)
+
+        type = ComplexType.try_parse(tag)
+        return unless type.defined?
+        return tag if type.literal?
+
+        context_type = ComplexType.try_parse(context_tag)
+        return unless context_type.defined?
+
+        fqns = qualify_namespace(type.rooted_namespace, context_type.rooted_namespace)
+        return unless fqns
+
+        fqns + type.substring
+      end
+
+      # @return [void]
+      def clear
+        [cached_collect, cached_resolve].each(&:clear)
+      end
+
+      private
+
+      # @return [Store]
+      attr_reader :store
+
+      # @param name [String]
+      # @param gates [Array<String>]
+      # @return [String, nil]
+      def resolve_and_cache name, gates
+        cached_resolve[[name, gates]] = resolve_uncached(name, gates)
+      end
+
+      # @param name [String]
+      # @param gates [Array<String>]
+      # @return [String, nil]
+      def resolve_uncached name, 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)
+      end
+
+      # @param name [String]
+      # @param gates [Array<String>]
+      # @return [String, nil]
+      def simple_resolve name, gates
+        gates.each do |gate|
+          here = "#{gate}::#{name}".sub(/^::/, '').sub(/::$/, '')
+          return here if store.namespace_exists?(here)
+        end
+        nil
+      end
+
+      # @param gates [Array<String>]
+      # @return [Array<Pin::Base>]
+      def collect_and_cache gates
+        skip = Set.new
+        cached_collect[gates] = gates.flat_map do |gate|
+          inner_get_constants(gate, %i[public private], skip)
+        end
+      end
+
+      # @return [Hash{Array(Name, Array<String>) => String, nil}]
+      def cached_resolve
+        @cached_resolve ||= {}
+      end
+
+      # @return [Hash{Array<String> => Array<Pin::Base>}]
+      def cached_collect
+        @cached_collect ||= {}
+      end
+
+      # Determine fully qualified namespace for a given namespace used
+      # inside the definition of another tag ("context"). This method
+      # will start the search in the specified context until it finds a
+      # match for the namespace.
+      #
+      # @param namespace [String, nil] The namespace to
+      #   match
+      # @param context_namespace [String] The context namespace in which the
+      #   tag was referenced; start from here to resolve the name
+      # @return [String, nil] fully qualified namespace
+      def qualify_namespace namespace, context_namespace = ''
+        if namespace.start_with?('::')
+          inner_qualify(namespace[2..], '', Set.new)
+        else
+          inner_qualify(namespace, context_namespace, Set.new)
+        end
+      end
+
+      # @param name [String] Namespace to fully qualify
+      # @param root [String] The context to search
+      # @param skip [Set<String>] Contexts already searched
+      # @return [String, nil] Fully qualified ("rooted") namespace
+      def inner_qualify name, root, skip
+        return name if name == ComplexType::GENERIC_TAG_NAME
+        return nil if name.nil?
+        return nil if skip.include?(root)
+        skip.add root
+        possibles = []
+        if name == ''
+          return '' if root == ''
+
+          inner_qualify(root, '', skip)
+        else
+          return name if root == '' && store.namespace_exists?(name)
+          roots = root.to_s.split('::')
+          while roots.length.positive?
+            fqns = "#{roots.join('::')}::#{name}"
+            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)
+              possibles.push foundinc unless foundinc.nil?
+            end
+            roots.pop
+          end
+          if possibles.empty?
+            incs = store.get_includes('')
+            incs.each do |inc|
+              foundinc = inner_qualify(name, inc.parametrized_tag.to_s, skip)
+              possibles.push foundinc unless foundinc.nil?
+            end
+          end
+          return name if store.namespace_exists?(name)
+          possibles.last
+        end
+      end
+
+      # @param fqns [String]
+      # @param visibility [Array<Symbol>]
+      # @param skip [Set<String>]
+      # @return [Array<Pin::Base>]
+      def inner_get_constants fqns, visibility, skip
+        return [] if fqns.nil? || skip.include?(fqns)
+        skip.add fqns
+        result = []
+
+        store.get_prepends(fqns).each do |pre|
+          pre_fqns = resolve(pre.name, pre.closure.gates - skip.to_a)
+          result.concat inner_get_constants(pre_fqns, [:public], skip)
+        end
+        result.concat(store.get_constants(fqns, visibility).sort { |a, b| a.name <=> b.name })
+        store.get_includes(fqns).each do |pin|
+          inc_fqns = resolve(pin.name, pin.closure.gates - skip.to_a)
+          result.concat inner_get_constants(inc_fqns, [:public], skip)
+        end
+        sc_ref = store.get_superclass(fqns)
+        if sc_ref
+          fqsc = dereference(sc_ref)
+          result.concat inner_get_constants(fqsc, [:public], skip) unless %w[Object BasicObject].include?(fqsc)
+        end
+        result
+      end
+    end
+  end
+end

data/lib/solargraph/api_map/index.rb

@@ -15,6 +15,9 @@ module Solargraph
         @pins ||= []
       end
 
+      # @return [Set<String>]
+      attr_reader :namespaces
+
       # @return [Hash{String => Array<Pin::Namespace>}]
       def namespace_hash
         @namespace_hash ||= Hash.new { |h, k| h[k] = [] }
@@ -36,30 +39,37 @@ module Solargraph
       def pins_by_class klass
         # @type [Set<Solargraph::Pin::Base>]
         s = Set.new
+        # @sg-ignore need to support destructured args in blocks
         @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>}]
+      # @return [Hash{String => Array<String>}]
       def include_references
         @include_references ||= Hash.new { |h, k| h[k] = [] }
       end
 
-      # @return [Hash{String => Array<Pin::Reference::Extend>}]
+      # @return [Hash{String => Array<Pin::Reference::Include>}]
+      def include_reference_pins
+        @include_reference_pins ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      # @return [Hash{String => Array<String>}]
       def extend_references
         @extend_references ||= Hash.new { |h, k| h[k] = [] }
       end
 
-      # @return [Hash{String => Array<Pin::Reference::Prepend>}]
+      # @return [Hash{String => Array<String>}]
       def prepend_references
         @prepend_references ||= Hash.new { |h, k| h[k] = [] }
       end
 
-      # @return [Hash{String => Array<Pin::Reference::Superclass>}]
+      # @return [Hash{String => Array<String>}]
       def superclass_references
         @superclass_references ||= Hash.new { |h, k| h[k] = [] }
       end
 
-      # @param pins [Array<Pin::Base>]
+      # @param pins [Enumerable<Pin::Base>]
+      # @return [self]
       def merge pins
         deep_clone.catalog pins
       end
@@ -69,6 +79,7 @@ module Solargraph
       attr_writer :pins, :pin_select_cache, :namespace_hash, :pin_class_hash, :path_pin_hash, :include_references,
                   :extend_references, :prepend_references, :superclass_references
 
+      # @return [self]
       def deep_clone
         Index.allocate.tap do |copy|
           copy.pin_select_cache = {}
@@ -83,8 +94,10 @@ module Solargraph
         end
       end
 
-      # @param new_pins [Array<Pin::Base>]
+      # @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
@@ -108,29 +121,10 @@ module Solargraph
       # @return [void]
       def map_references klass, hash
         pins_by_class(klass).each do |pin|
-          store_parametric_reference(hash, pin)
+          hash[pin.namespace].push 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|

data/lib/solargraph/api_map/source_to_yard.rb

@@ -45,12 +45,18 @@ module Solargraph
           code_object_map[pin.path].docstring = pin.docstring
           store.get_includes(pin.path).each do |ref|
             include_object = code_object_at(pin.path, YARD::CodeObjects::ClassObject)
-            include_object.instance_mixins.push code_object_map[ref] unless include_object.nil? or include_object.nil?
+            unless include_object.nil? || include_object.nil?
+              include_object.instance_mixins.push code_object_map[ref.parametrized_tag.to_s]
+            end
           end
           store.get_extends(pin.path).each do |ref|
             extend_object = code_object_at(pin.path, YARD::CodeObjects::ClassObject)
-            extend_object.instance_mixins.push code_object_map[ref] unless extend_object.nil? or extend_object.nil?
-            extend_object.class_mixins.push code_object_map[ref] unless extend_object.nil? or extend_object.nil?
+            next unless extend_object
+            code_object = code_object_map[ref.parametrized_tag.to_s]
+            next unless code_object
+            extend_object.class_mixins.push code_object
+            # @todo add spec showing why this next line is necessary
+            extend_object.instance_mixins.push code_object
           end
         end
         store.method_pins.each do |pin|
@@ -67,7 +73,7 @@ module Solargraph
           method_object.docstring = pin.docstring
           method_object.visibility = pin.visibility || :public
           method_object.parameters = pin.parameters.map do |p|
-            [p.name, p.asgn_code]
+            [p.full_name, p.asgn_code]
           end
         end
       end