solargraph 0.56.2 → 0.58.0

data/.yardopts

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

data/CHANGELOG.md

@@ -1,3 +1,72 @@
+## 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)
+- 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_strong]
+
+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/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/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,279 @@
+# 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.
+      #
+      # `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?
+        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.
+      #
+      # @param pin [Pin::Reference]
+      # @return [String, nil]
+      def dereference pin
+        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<Solargraph::Pin::Namespace, Solargraph::Pin::Constant>]
+      def collect(*gates)
+        flat = gates.flatten
+        cached_collect[flat] || collect_and_cache(flat)
+      end
+
+      # 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.
+      #
+      # @param tag [String, nil] The type to match
+      # @param gates [Array<String>]
+      # @return [String, nil] fully qualified tag
+      def qualify tag, *gates
+        type = ComplexType.try_parse(tag)
+        qualify_type(type, *gates)&.tag
+      end
+
+      # @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'
+
+        gates.push '' unless gates.include?('')
+        fqns = resolve(type.rooted_namespace, *gates)
+        return unless fqns
+        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]
+      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]] = :in_process
+        cached_resolve[[name, gates]] = resolve_uncached(name, gates)
+      end
+
+      # @param name [String]
+      # @param gates [Array<String>]
+      # @return [String, nil]
+      def resolve_uncached name, gates
+        resolved = nil
+        base = gates
+        parts = name.split('::')
+        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, 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
+      end
+
+      # @param gates [Array<String>]
+      # @return [Array<Solargraph::Pin::Namespace, Solargraph::Pin::Constant>]
+      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(String, Array<String>) => String, :in_process, nil}]
+      def cached_resolve
+        @cached_resolve ||= {}
+      end
+
+      # @return [Hash{Array<String> => Array<Solargraph::Pin::Namespace, Solargraph::Pin::Constant>}]
+      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.type.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.type.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<Solargraph::Pin::Namespace, Solargraph::Pin::Constant>]
+      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