solargraph 0.59.0.dev.2 → 0.59.0

data/lib/solargraph/rbs_map/conversions.rb

@@ -37,11 +37,6 @@ module Solargraph
 
       private
 
-      # @return [Hash{String => RBS::AST::Declarations::TypeAlias}]
-      def type_aliases
-        @type_aliases ||= {}
-      end
-
       # @param loader [RBS::EnvironmentLoader]
       #
       # @return [void]
@@ -81,8 +76,13 @@ module Solargraph
                                      # @sg-ignore flow sensitive typing should support case/when
                                      "Ignoring closure #{closure.inspect} on alias type name #{decl.name}")
           end
-          # @sg-ignore flow sensitive typing should support case/when
-          type_aliases[decl.name.to_s] = decl
+          pins.push(
+            # @sg-ignore Wrong argument type for Solargraph::Pin::Reference::TypeAlias.new: return_type expected Solargraph::ComplexType, received Solargraph::ComplexType::UniqueType, Solargraph::ComplexType
+            Solargraph::Pin::Reference::TypeAlias.new(
+              # @sg-ignore Unresolved calls to name, type, type_location; return_type type mismatch
+              name: ComplexType.try_parse(decl.name.to_s).to_s, return_type: other_type_to_type(decl.type).force_rooted, closure: closure, source: :rbs, type_location: location_decl_to_pin_location(decl.location)
+            )
+          )
         when RBS::AST::Declarations::Module
           # @sg-ignore flow sensitive typing should support case/when
           unless closure.name == '' || decl.name.absolute?
@@ -474,6 +474,8 @@ module Solargraph
       # @param scope [Symbol] :instance or :class
       # @param name [String] The name of the method
       # @return [Symbol]
+      # @sg-ignore Declared return type ::Symbol does not match inferred type
+      #   ::Symbol, :public, :private, nil for Solargraph::RbsMap::Conversions#calculate_method_visibility
       def calculate_method_visibility decl, context, closure, scope, name
         override_key = [closure.path, scope, name]
         visibility = VISIBILITY_OVERRIDE[override_key]
@@ -552,6 +554,8 @@ module Solargraph
       def method_def_to_sigs decl, pin
         # @param overload [RBS::AST::Members::MethodDefinition::Overload]
         decl.overloads.map do |overload|
+          # @sg-ignore Wrong argument type for Solargraph::RbsMap::Conversions#location_decl_to_pin_location:
+          #   location expected RBS::Location, nil, received RBS::Location<:type, :type_params>, RBS::AST::Members::Attribute::loc, nil
           type_location = location_decl_to_pin_location(overload.method_type.location)
           generics = type_parameter_names(overload.method_type)
           signature_parameters, signature_return_type = parts_of_function(overload.method_type, pin)
@@ -598,7 +602,7 @@ module Solargraph
         parameters = []
         arg_num = -1
         type.type.required_positionals.each do |param|
-          # @sg-ignore RBS generic type understanding issue
+          # @sg-ignore Unresolved call to name
           name = param.name ? param.name.to_s : "arg_#{arg_num += 1}"
           parameters.push Solargraph::Pin::Parameter.new(decl: :arg, name: name, closure: pin,
                                                          # @sg-ignore RBS generic type understanding issue
@@ -606,7 +610,7 @@ module Solargraph
                                                          source: :rbs, type_location: type_location)
         end
         type.type.optional_positionals.each do |param|
-          # @sg-ignore RBS generic type understanding issue
+          # @sg-ignore Unresolved call to name
           name = param.name ? param.name.to_s : "arg_#{arg_num += 1}"
           parameters.push Solargraph::Pin::Parameter.new(decl: :optarg, name: name, closure: pin,
                                                          # @sg-ignore RBS generic type understanding issue
@@ -626,13 +630,13 @@ module Solargraph
                                                          return_type: rest_positional_type)
         end
         type.type.trailing_positionals.each do |param|
-          # @sg-ignore RBS generic type understanding issue
+          # @sg-ignore Unresolved call to name
           name = param.name ? param.name.to_s : "arg_#{arg_num += 1}"
           parameters.push Solargraph::Pin::Parameter.new(decl: :arg, name: name, closure: pin, source: :rbs,
                                                          type_location: type_location)
         end
         type.type.required_keywords.each do |orig, param|
-          # @sg-ignore RBS generic type understanding issue
+          # @sg-ignore Unresolved call to to_s
           name = orig ? orig.to_s : "arg_#{arg_num += 1}"
           parameters.push Solargraph::Pin::Parameter.new(decl: :kwarg, name: name, closure: pin,
                                                          # @sg-ignore RBS generic type understanding issue
@@ -640,7 +644,7 @@ module Solargraph
                                                          source: :rbs, type_location: type_location)
         end
         type.type.optional_keywords.each do |orig, param|
-          # @sg-ignore RBS generic type understanding issue
+          # @sg-ignore Unresolved call to to_s
           name = orig ? orig.to_s : "arg_#{arg_num += 1}"
           parameters.push Solargraph::Pin::Parameter.new(decl: :kwoptarg, name: name, closure: pin,
                                                          # @sg-ignore RBS generic type understanding issue
@@ -840,11 +844,7 @@ module Solargraph
       # @param type [RBS::MethodType, RBS::Types::Block]
       # @return [ComplexType, ComplexType::UniqueType]
       def method_type_to_type type
-        if type_aliases.key?(type.type.return_type.to_s)
-          other_type_to_type(type_aliases[type.type.return_type.to_s].type)
-        else
-          other_type_to_type type.type.return_type
-        end
+        other_type_to_type type.type.return_type
       end
 
       # @param type [RBS::Types::Bases::Base,Object] RBS type object.
@@ -932,7 +932,7 @@ module Solargraph
       # @param namespace [Pin::Namespace, nil]
       # @return [void]
       def add_mixins decl, namespace
-        # @param mixin [RBS::AST::Members::Include, RBS::AST::Members::Members::Extend, RBS::AST::Members::Members::Prepend]
+        # @param mixin [RBS::AST::Members::Include, RBS::AST::Members::Extend, RBS::AST::Members::Prepend]
         decl.each_mixin do |mixin|
           # @todo are we handling prepend correctly?
           klass = mixin.is_a?(RBS::AST::Members::Include) ? Pin::Reference::Include : Pin::Reference::Extend

data/lib/solargraph/rbs_map.rb

@@ -74,7 +74,7 @@ module Solargraph
         # @type gem_config [nil, Hash{String => Hash{String => String}}]
         gem_config = nil
         if rbs_collection_config_path
-          # @sg-ignore flow sensitive typing needs to handle attrs
+          # @sg-ignore rbs_collection_config_path is not nil here
           lockfile_path = RBS::Collection::Config.to_lockfile_path(Pathname.new(rbs_collection_config_path))
           if lockfile_path.exist?
             collection_config = RBS::Collection::Config.from_path lockfile_path
@@ -95,8 +95,7 @@ module Solargraph
           when 'stdlib'
             CACHE_KEY_STDLIB
           else
-            # @sg-ignore Need to add nil check here
-            Digest::SHA1.hexdigest(data)
+            Digest::SHA1.hexdigest(data || '')
           end
         end
       end

data/lib/solargraph/shell.rb

@@ -39,7 +39,7 @@ module Solargraph
         end
         # @sg-ignore Wrong argument type for Backport.prepare_tcp_server: adapter expected Backport::Adapter, received Module<Solargraph::LanguageServer::Transport::Adapter>
         Backport.prepare_tcp_server host: options[:host], port: port, adapter: Solargraph::LanguageServer::Transport::Adapter
-        warn "Solargraph is listening PORT=#{port} PID=#{Process.pid}"
+        $stderr.puts "Solargraph is listening PORT=#{port} PID=#{Process.pid}"
       end
     end
 
@@ -56,7 +56,7 @@ module Solargraph
         end
         # @sg-ignore Wrong argument type for Backport.prepare_stdio_server: adapter expected Backport::Adapter, received Module<Solargraph::LanguageServer::Transport::Adapter>
         Backport.prepare_stdio_server adapter: Solargraph::LanguageServer::Transport::Adapter
-        warn "Solargraph is listening on stdio PID=#{Process.pid}"
+        $stderr.puts "Solargraph is listening on stdio PID=#{Process.pid}"
       end
     end
 
@@ -105,8 +105,22 @@ module Solargraph
     # @param gem [String]
     # @param version [String, nil]
     def cache gem, version = nil
-      gems(gem + (version ? "=#{version}" : ''))
-      # '
+      gemspec = Gem::Specification.find_by_name(gem, version)
+
+      if options[:rebuild] || !PinCache.has_yard?(gemspec)
+        pins = GemPins.build_yard_pins(['yard-activesupport-concern'], gemspec)
+        PinCache.serialize_yard_gem(gemspec, pins)
+      end
+
+      workspace = Solargraph::Workspace.new(Dir.pwd)
+      rbs_map = RbsMap.from_gemspec(gemspec, workspace.rbs_collection_path, workspace.rbs_collection_config_path)
+      if options[:rebuild] || !PinCache.has_rbs_collection?(gemspec, rbs_map.cache_key)
+        # cache pins even if result is zero, so we don't retry building pins
+        pins = rbs_map.pins || []
+        PinCache.serialize_rbs_collection_gem(gemspec, rbs_map.cache_key, pins)
+      end
+    rescue Gem::MissingSpecError
+      warn "Gem '#{gem}' not found"
     end
 
     desc 'uncache GEM [...GEM]', 'Delete specific cached gem documentation'
@@ -119,24 +133,19 @@ module Solargraph
     # @return [void]
     def uncache *gems
       raise ArgumentError, 'No gems specified.' if gems.empty?
-      workspace = Solargraph::Workspace.new(Dir.pwd)
-
       gems.each do |gem|
         if gem == 'core'
-          PinCache.uncache_core(out: $stdout)
+          PinCache.uncache_core
           next
         end
 
         if gem == 'stdlib'
-          PinCache.uncache_stdlib(out: $stdout)
+          PinCache.uncache_stdlib
           next
         end
 
-        spec = workspace.find_gem(gem)
-        raise Thor::InvocationError, "Gem '#{gem}' not found" if spec.nil?
-
-        # @sg-ignore flow sensitive typing needs to handle 'raise if'
-        workspace.uncache_gem(spec, out: $stdout)
+        spec = Gem::Specification.find_by_name(gem)
+        PinCache.uncache_gem(spec, out: $stdout)
       end
     end
 
@@ -172,11 +181,13 @@ module Solargraph
       workspace = Solargraph::Workspace.new('.')
 
       if names.empty?
-        workspace.cache_all_for_workspace!($stdout, rebuild: options[:rebuild])
+        Gem::Specification.to_a.each { |spec| do_cache spec, rebuild: options[:rebuild] }
+        $stderr.puts "Documentation cached for all #{Gem::Specification.count} gems."
       else
         warn("Caching these gems: #{names}")
         names.each do |name|
           if name == 'core'
+            # @sg-ignore cache_core and core? are dynamically defined
             PinCache.cache_core(out: $stdout) if !PinCache.core? || options[:rebuild]
             next
           end
@@ -185,7 +196,18 @@ module Solargraph
           if gemspec.nil?
             warn "Gem '#{name}' not found"
           else
-            workspace.cache_gem(gemspec, rebuild: options[:rebuild], out: $stdout)
+            if options[:rebuild] || !PinCache.has_yard?(gemspec)
+              pins = GemPins.build_yard_pins(['yard-activesupport-concern'], gemspec)
+              PinCache.serialize_yard_gem(gemspec, pins)
+            end
+
+            workspace = Solargraph::Workspace.new(Dir.pwd)
+            rbs_map = RbsMap.from_gemspec(gemspec, workspace.rbs_collection_path, workspace.rbs_collection_config_path)
+            if options[:rebuild] || !PinCache.has_rbs_collection?(gemspec, rbs_map.cache_key)
+              # cache pins even if result is zero, so we don't retry building pins
+              pins = rbs_map.pins || []
+              PinCache.serialize_rbs_collection_gem(gemspec, rbs_map.cache_key, pins)
+            end
           end
         rescue Gem::MissingSpecError
           warn "Gem '#{name}' not found"
@@ -364,6 +386,110 @@ module Solargraph
       end
     end
 
+    desc 'profile [FILE]', 'Profile go-to-definition performance using vernier'
+    option :directory, type: :string, aliases: :d, desc: 'The workspace directory', default: '.'
+    option :output_dir, type: :string, aliases: :o, desc: 'The output directory for profiles', default: './tmp/profiles'
+    option :line, type: :numeric, aliases: :l, desc: 'Line number (0-based)', default: 4
+    option :column, type: :numeric, aliases: :c, desc: 'Column number', default: 10
+    option :memory, type: :boolean, aliases: :m, desc: 'Include memory usage counter', default: true
+    # @param file [String, nil]
+    # @return [void]
+    def profile file = nil
+      begin
+        require 'vernier'
+      rescue LoadError
+        $stderr.puts 'vernier gem not found. Please install this dependency:'
+        $stderr.puts
+        $stderr.puts "  gem 'vernier', '>1.0', '<2'"
+
+        return
+      end
+
+      hooks = []
+      hooks << :memory_usage if options[:memory]
+
+      directory = File.realpath(options[:directory])
+      FileUtils.mkdir_p(options[:output_dir])
+
+      host = Solargraph::LanguageServer::Host.new
+      host.client_capabilities.merge!({ 'window' => { 'workDoneProgress' => true } })
+      # @param method [String] The message method
+      # @param params [Hash] The method parameters
+      # @return [void]
+      def host.send_notification method, params
+        puts "Notification: #{method} - #{params}"
+      end
+
+      puts 'Parsing and mapping source files...'
+      prepare_start = Time.now
+      Vernier.profile(out: "#{options[:output_dir]}/parse_benchmark.json.gz", hooks: hooks) do
+        puts 'Mapping libraries'
+        host.prepare(directory)
+        sleep 0.2 until host.libraries.all?(&:mapped?)
+      end
+      prepare_time = Time.now - prepare_start
+
+      puts 'Building the catalog...'
+      catalog_start = Time.now
+      Vernier.profile(out: "#{options[:output_dir]}/catalog_benchmark.json.gz", hooks: hooks) do
+        host.catalog
+      end
+      catalog_time = Time.now - catalog_start
+
+      # Determine test file
+      if file
+        test_file = File.join(directory, file)
+      else
+        test_file = File.join(directory, 'lib', 'other.rb')
+        unless File.exist?(test_file)
+          # Fallback to any Ruby file in the workspace
+          workspace = Solargraph::Workspace.new(directory)
+          test_file = workspace.filenames.find { |f| f.end_with?('.rb') }
+          unless test_file
+            warn 'No Ruby files found in workspace'
+            return
+          end
+        end
+      end
+
+      file_uri = Solargraph::LanguageServer::UriHelpers.file_to_uri(File.absolute_path(test_file))
+
+      puts "Profiling go-to-definition for #{test_file}"
+      puts "Position: line #{options[:line]}, column #{options[:column]}"
+
+      definition_start = Time.now
+      Vernier.profile(out: "#{options[:output_dir]}/definition_benchmark.json.gz", hooks: hooks) do
+        message = Solargraph::LanguageServer::Message::TextDocument::Definition.new(
+          host, {
+            'params' => {
+              'textDocument' => { 'uri' => file_uri },
+              'position' => { 'line' => options[:line], 'character' => options[:column] }
+            }
+          }
+        )
+        puts 'Processing go-to-definition request...'
+        result = message.process
+
+        puts "Result: #{result.inspect}"
+      end
+      definition_time = Time.now - definition_start
+
+      puts "\n=== Timing Results ==="
+      puts "Parsing & mapping: #{(prepare_time * 1000).round(2)}ms"
+      puts "Catalog building: #{(catalog_time * 1000).round(2)}ms"
+      puts "Go-to-definition: #{(definition_time * 1000).round(2)}ms"
+      total_time = prepare_time + catalog_time + definition_time
+      puts "Total time: #{(total_time * 1000).round(2)}ms"
+
+      puts "\nProfiles saved to:"
+      puts "  - #{File.expand_path('parse_benchmark.json.gz', options[:output_dir])}"
+      puts "  - #{File.expand_path('catalog_benchmark.json.gz', options[:output_dir])}"
+      puts "  - #{File.expand_path('definition_benchmark.json.gz', options[:output_dir])}"
+
+      puts "\nUpload the JSON files to https://vernier.prof/ to view the profiles."
+      puts 'Or use https://rubygems.org/gems/profile-viewer to view them locally.'
+    end
+
     private
 
     # @param pin [Solargraph::Pin::Base]
@@ -403,5 +529,27 @@ module Solargraph
         puts pin.inspect
       end
     end
+
+    # @param gemspec [Gem::Specification, nil]
+    # @param rebuild [Boolean]
+    # @return [void]
+    def do_cache gemspec, rebuild: false
+      if gemspec.nil?
+        warn "Gem '#{gemspec&.name}' not found"
+      else
+        if rebuild || !PinCache.has_yard?(gemspec)
+          pins = GemPins.build_yard_pins(['yard-activesupport-concern'], gemspec)
+          PinCache.serialize_yard_gem(gemspec, pins)
+        end
+
+        workspace = Solargraph::Workspace.new(Dir.pwd)
+        rbs_map = RbsMap.from_gemspec(gemspec, workspace.rbs_collection_path, workspace.rbs_collection_config_path)
+        if rebuild || !PinCache.has_rbs_collection?(gemspec, rbs_map.cache_key)
+          # cache pins even if result is zero, so we don't retry building pins
+          pins = rbs_map.pins || []
+          PinCache.serialize_rbs_collection_gem(gemspec, rbs_map.cache_key, pins)
+        end
+      end
+    end
   end
 end

data/lib/solargraph/source/chain.rb

@@ -170,7 +170,9 @@ module Solargraph
         type = infer_from_definitions(pins, links.last.last_context, api_map, locals)
         out = maybe_nil(type)
         logger.debug do
-          "Chain#infer_uncached(links=#{links.map(&:desc)}, locals=#{locals.map(&:desc)}, name_pin=#{name_pin}, name_pin.closure=#{name_pin.closure.inspect}, name_pin.binder=#{name_pin.binder}) => #{out.rooted_tags.inspect}"
+          "Chain#infer_uncached(links=#{links.map(&:desc)}, locals=#{locals.map(&:desc)}, " \
+            "name_pin=#{name_pin}, name_pin.closure=#{name_pin&.closure&.inspect}, " \
+            "name_pin.binder=#{name_pin&.binder}) => #{out.rooted_tags.inspect}"
         end
         out
       end

data/lib/solargraph/source_map/mapper.rb

@@ -174,7 +174,6 @@ module Solargraph
         when 'visibility'
 
           kind = directive.tag.text&.to_sym
-          # @sg-ignore Need to look at Tuple#include? handling
           return unless %i[private protected public].include?(kind)
 
           name = directive.tag.name
@@ -225,7 +224,6 @@ module Solargraph
           # @sg-ignore flow sensitive typing should be able to handle redefinition
           namespace.domains.concat directive.tag.types unless directive.tag.types.nil?
         when 'override'
-          # @sg-ignore Need to add nil check here
           pins.push Pin::Reference::Override.new(location, directive.tag.name, docstring.tags,
                                                  source: :source_map)
         when 'macro'

data/lib/solargraph/type_checker.rb

@@ -351,7 +351,6 @@ module Solargraph
           all_closest = all_found.map { |pin| pin.typify(api_map) }
           closest = ComplexType.new(all_closest.flat_map(&:items).uniq)
           # @todo remove the internal_or_core? check at a higher-than-strict level
-          # @sg-ignore Need to add nil check here
           if (!found || found.is_a?(Pin::BaseVariable) || (closest.defined? && internal_or_core?(found))) && !(closest.generic? || ignored_pins.include?(found))
             if closest.defined?
               result.push Problem.new(location, "Unresolved call to #{missing.links.last.word} on #{closest}")
@@ -479,7 +478,7 @@ module Solargraph
             ptype = params.key?(par.name) ? params[par.name][:qualified] : ComplexType::UNDEFINED
             ptype = ptype.self_to_type(par.context)
             if ptype.nil?
-            # @todo Some level (strong, I guess) should require the param here
+              # @todo Some level (strong, I guess) should require the param here
             else
               argtype = argchain.infer(api_map, closure_pin, locals)
               argtype = argtype.self_to_type(closure_pin.context)

data/lib/solargraph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Solargraph
-  VERSION = ENV.fetch('SOLARGRAPH_FORCE_VERSION', '0.59.0.dev.2')
+  VERSION = ENV.fetch('SOLARGRAPH_FORCE_VERSION', '0.59.0')
 end

data/lib/solargraph/workspace/config.rb

@@ -168,7 +168,7 @@ module Solargraph
       # @return [Hash{String => Array, Hash, Integer}]
       def default_config
         {
-          'include' => ['Rakefile', 'Gemfile', '*.gemspec', '**/*.rb'],
+          'include' => ['Rakefile', 'Gemfile', '*.gemspec', './**/*.rb'],
           'exclude' => ['spec/**/*', 'test/**/*', 'vendor/**/*', '.bundle/**/*'],
           'require' => [],
           'domains' => [],

data/lib/solargraph/workspace/gemspecs.rb

@@ -190,7 +190,7 @@ module Solargraph
                                                           end
                                                         # @sg-ignore Unresolved constant Gem::StubSpecification
                                                         when Gem::StubSpecification
-                                                          # @sg-ignore flow sensitive typing ought to be able to handle 'when ClassName'
+                                                          # @sg-ignore Unresolved call to to_spec on Gem::Specification, Bundler::LazySpecification, Bundler::StubSpecification
                                                           specish.to_spec
                                                         else
                                                           raise "Unexpected type while resolving gem: #{specish.class}"
@@ -313,7 +313,7 @@ module Solargraph
         end
       end
 
-      # @sg-ignore flow sensitive typing needs better handling of ||= on lvars
+      # @sg-ignore return type could not be inferred
       # @return [Array<Gem::Specification>]
       def all_gemspecs_from_external_bundle
         @all_gemspecs_from_external_bundle ||=