solargraph 0.54.4 → 0.57.0

data/.yardopts

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

data/CHANGELOG.md

@@ -1,3 +1,107 @@
+## 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)
+- Improve struct support (#992)
+- Include Rakefile, Gemfile, and gemspec files in config by default (#984)
+- Use Open3 to cache gemspecs (#1000)
+- Eager load node processors (#1002)
+
+## 0.56.1 - July 13, 2025
+- Library avoids blocking on pending yardoc caches (#990)
+- DocMap checks for default Gemfile (#989)
+- [Bug fix] Fixed an error in rbs/fills/tuple.rbs (#993)
+
+## 0.56.0 - July 1, 2025
+-  [regression] Gem caching perf and logging fixes #983
+
+## 0.55.5 - July 1, 2025
+- Flatten results of DocMap external bundle query (#981)
+- [breaking] Reimplement global conventions (#877)
+- GemPins pin merging improvements (#946)
+- Support class-scoped aliases and attributes from RBS (#952)
+- Restructure ComplexType specs towards YARD doc compliance (#969)
+- Use Prism (#974)
+- Document pages (#977)
+- Enable disabled-but-working specs (#978)
+- Map RBS 'untyped' type (RBS::Types::Bases::Any) to 'undefined' (#979)
+- Re-enable support for .gem_rbs_collection directories (#942)
+- [breaking] Comply with YARD documentation on Hash tag format (#968)
+- Ignore directory paths in Workspace#would_require? (#988)
+
+## 0.55.4 - June 27, 2025
+-  Flatten results of DocMap external bundle query (#981)
+
+## 0.55.3 - June 25, 2025
+-  Nil guards in flow-sensitive typing (patch release) (#980)
+
+## 0.55.2 - June 21, 2025
+- Require external bundle (#972)
+
+## 0.55.1 - June 8, 2025
+- Fix inline Struct definition (#962)
+- Ensure DocMap requires bundler when loading gemspecs (#963)
+- DelegatedMethod improvements (#953)
+
+## 0.55.0 - June 3, 2025
+- Flow-sensitive typing - automatically downcast from is_a? calls (#856)
+- Tuple enabler: infer literal types and use them for signature selection (#836)
+- Signature selection improvements (#907)
+- Add support for Ruby Structs (#939)
+- [regression] Fix interface change breaking solargraph-rails (#940)
+- [regression] Add back bundler/require support for solargraph-rails (#941)
+- Add specs for initialize capabilities (#955)
+- Create MethodAlias pins from YARD (#945)
+- MessageWorker prioritizes synchronization (#956)
+- initialize/new method pin cleanups (#949)
+- Clip rebinds blocks when cursor is not part of receiver (#958)
+
+## 0.54.5 - May 17, 2025
+- Repair unknown encoding errors (#936, #935)
+- Index arbitrary pinsets (#937)
+- Separate YARD cache from doc map cache (#938)
+
 ## 0.54.4 - May 14, 2025
 - Delete files from Library hash (#932)
 - Clip#define returns variable pins (#934, #933)

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