solargraph 0.59.0.dev.1 → 0.59.0

data/lib/solargraph/shell.rb

@@ -16,7 +16,7 @@ module Solargraph
 
     map %w[--version -v] => :version
 
-    desc "--version, -v", "Print the version"
+    desc '--version, -v', 'Print the version'
     # @return [void]
     def version
       puts Solargraph::VERSION
@@ -31,15 +31,15 @@ module Solargraph
       port = options[:port]
       port = available_port if port.zero?
       Backport.run do
-        Signal.trap("INT") do
+        Signal.trap('INT') do
           Backport.stop
         end
-        Signal.trap("TERM") do
+        Signal.trap('TERM') do
           Backport.stop
         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
-        STDERR.puts "Solargraph is listening PORT=#{port} PID=#{Process.pid}"
+        $stderr.puts "Solargraph is listening PORT=#{port} PID=#{Process.pid}"
       end
     end
 
@@ -48,15 +48,15 @@ module Solargraph
     def stdio
       require 'backport'
       Backport.run do
-        Signal.trap("INT") do
+        Signal.trap('INT') do
           Backport.stop
         end
-        Signal.trap("TERM") do
+        Signal.trap('TERM') do
           Backport.stop
         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
-        STDERR.puts "Solargraph is listening on stdio PID=#{Process.pid}"
+        $stderr.puts "Solargraph is listening on stdio PID=#{Process.pid}"
       end
     end
 
@@ -64,11 +64,11 @@ module Solargraph
     option :extensions, type: :boolean, aliases: :e, desc: 'Add installed extensions', default: true
     # @param directory [String]
     # @return [void]
-    def config(directory = '.')
+    def config directory = '.'
       matches = []
       if options[:extensions]
         Gem::Specification.each do |g|
-          if g.name.match(/^solargraph\-[A-Za-z0-9_\-]*?\-ext/)
+          if g.name.match(/^solargraph-[A-Za-z0-9_-]*?-ext/)
             require g.name
             matches.push g.name
           end
@@ -84,7 +84,7 @@ module Solargraph
       File.open(File.join(directory, '.solargraph.yml'), 'w') do |file|
         file.puts conf.to_yaml
       end
-      STDOUT.puts "Configuration file initialized."
+      $stdout.puts 'Configuration file initialized.'
     end
 
     desc 'clear', 'Delete all cached documentation'
@@ -93,7 +93,7 @@ module Solargraph
     )
     # @return [void]
     def clear
-      puts "Deleting all cached documentation (gems, core and stdlib)"
+      puts 'Deleting all cached documentation (gems, core and stdlib)'
       Solargraph::PinCache.clear
     end
     map 'clear-cache' => :clear
@@ -105,11 +105,25 @@ 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"
+    desc 'uncache GEM [...GEM]', 'Delete specific cached gem documentation'
     long_desc %(
       Specify one or more gem names to clear. 'core' or 'stdlib' may
       also be specified to clear cached system 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
-        $stderr.puts("Caching these gems: #{names}")
+        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"
@@ -195,7 +217,7 @@ module Solargraph
           # @sg-ignore Need to add nil check here
           warn e.backtrace.join("\n")
         end
-        $stderr.puts "Documentation cached for #{names.count} gems."
+        warn "Documentation cached for #{names.count} gems."
       end
     end
 
@@ -212,7 +234,7 @@ module Solargraph
 
       Type checking levels are normal, typed, strict, and strong.
     )
-    option :level, type: :string, aliases: [:mode, :m, :l], desc: 'Type checking level', default: 'normal'
+    option :level, type: :string, aliases: %i[mode m l], desc: 'Type checking level', default: 'normal'
     option :directory, type: :string, aliases: :d, desc: 'The workspace directory', default: '.'
     # @return [void]
     def typecheck *files
@@ -231,21 +253,28 @@ module Solargraph
         files.map! { |file| File.realpath(file) }
       end
       filecount = 0
-      time = Benchmark.measure {
+      time = Benchmark.measure do
         files.each do |file|
-          checker = TypeChecker.new(file, api_map: api_map, rules: rules, level: options[:level].to_sym, workspace: workspace)
+          checker = TypeChecker.new(file, api_map: api_map, rules: rules, level: options[:level].to_sym,
+                                          workspace: workspace)
           problems = checker.problems
           next if problems.empty?
           problems.sort! { |a, b| a.location.range.start.line <=> b.location.range.start.line }
-          puts problems.map { |prob| "#{prob.location.filename}:#{prob.location.range.start.line + 1} - #{prob.message}" }.join("\n")
+          puts problems.map { |prob|
+            "#{prob.location.filename}:#{prob.location.range.start.line + 1} - #{prob.message}"
+          }.join("\n")
           filecount += 1
           probcount += problems.length
         end
-      }
+      end
       puts "Typecheck finished in #{time.real} seconds."
-      puts "#{probcount} problem#{probcount != 1 ? 's' : ''} found#{files.length != 1 ? " in #{filecount} of #{files.length} files" : ''}."
+      puts "#{probcount} problem#{if probcount != 1
+                                    's'
+                                  end} found#{if files.length != 1
+                                                                  " in #{filecount} of #{files.length} files"
+                                                                end}."
       # "
-      exit 1 if probcount > 0
+      exit 1 if probcount.positive?
     end
 
     desc 'scan', 'Test the workspace for problems'
@@ -262,26 +291,26 @@ module Solargraph
       directory = File.realpath(options[:directory])
       # @type [Solargraph::ApiMap, nil]
       api_map = nil
-      time = Benchmark.measure {
+      time = Benchmark.measure do
         api_map = Solargraph::ApiMap.load_with_cache(directory, $stdout)
         # @sg-ignore flow sensitive typing should be able to handle redefinition
         api_map.pins.each do |pin|
-          begin
-            puts pin_description(pin) if options[:verbose]
-            pin.typify api_map
-            pin.probe api_map
-          rescue StandardError => e
-            # @todo to add nil check here
-            # @todo should warn on nil dereference below
-            STDERR.puts "Error testing #{pin_description(pin)} #{pin.location ? "at #{pin.location.filename}:#{pin.location.range.start.line + 1}" : ''}"
-            STDERR.puts "[#{e.class}]: #{e.message}"
-            # @todo Need to add nil check here
-            # @todo flow sensitive typing should be able to handle redefinition
-            STDERR.puts e.backtrace.join("\n")
-            exit 1
-          end
+          puts pin_description(pin) if options[:verbose]
+          pin.typify api_map
+          pin.probe api_map
+        rescue StandardError => e
+          # @todo to add nil check here
+          # @todo should warn on nil dereference below
+          warn "Error testing #{pin_description(pin)} #{if pin.location
+                                                          "at #{pin.location.filename}:#{pin.location.range.start.line + 1}"
+                                                        end}"
+          warn "[#{e.class}]: #{e.message}"
+          # @todo Need to add nil check here
+          # @todo flow sensitive typing should be able to handle redefinition
+          warn e.backtrace.join("\n")
+          exit 1
         end
-      }
+      end
       # @sg-ignore Need to add nil check here
       puts "Scanned #{directory} (#{api_map.pins.length} pins) in #{time.real} seconds."
     end
@@ -296,12 +325,15 @@ module Solargraph
       puts "#{workspace.filenames.length} files total."
     end
 
-    desc 'pin [PATH]', 'Describe a pin', hide: true
+    desc 'pin [PATH]', 'Describe a pin'
     option :rbs, type: :boolean, desc: 'Output the pin as RBS', default: false
-    option :typify, type: :boolean, desc: 'Output the calculated return type of the pin from annotations', default: false
+    option :typify, type: :boolean, desc: 'Output the calculated return type of the pin from annotations',
+                    default: false
     option :references, type: :boolean, desc: 'Show references', default: false
-    option :probe, type: :boolean, desc: 'Output the calculated return type of the pin from annotations and inference', default: false
-    option :stack, type: :boolean, desc: 'Show entire stack of a method pin by including definitions in superclasses', default: false
+    option :probe, type: :boolean, desc: 'Output the calculated return type of the pin from annotations and inference',
+                   default: false
+    option :stack, type: :boolean, desc: 'Show entire stack of a method pin by including definitions in superclasses',
+                   default: false
     # @param path [String] The path to the method pin, e.g. 'Class#method' or 'Class.method'
     # @return [void]
     def pin path
@@ -326,7 +358,7 @@ module Solargraph
       pin = pins.first
       case pin
       when nil
-        $stderr.puts "Pin not found for path '#{path}'"
+        warn "Pin not found for path '#{path}'"
         exit 1
       when Pin::Namespace
         if options[:references]
@@ -354,21 +386,125 @@ 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]
     # @return [String]
     def pin_description pin
       desc = if pin.path.nil? || pin.path.empty?
-        if pin.closure
-          # @sg-ignore Need to add nil check here
-          "#{pin.closure.path} | #{pin.name}"
-        else
-          "#{pin.context.namespace} | #{pin.name}"
-        end
-      else
-        pin.path
-      end
+               if pin.closure
+                 # @sg-ignore Need to add nil check here
+                 "#{pin.closure.path} | #{pin.name}"
+               else
+                 "#{pin.context.namespace} | #{pin.name}"
+               end
+             else
+               pin.path
+             end
       # @sg-ignore Need to add nil check here
       desc += " (#{pin.location.filename} #{pin.location.range.start.line})" if pin.location
       desc
@@ -376,7 +512,7 @@ module Solargraph
 
     # @param type [ComplexType, ComplexType::UniqueType]
     # @return [void]
-    def print_type(type)
+    def print_type type
       if options[:rbs]
         puts type.to_rbs
       else
@@ -386,12 +522,34 @@ module Solargraph
 
     # @param pin [Solargraph::Pin::Base]
     # @return [void]
-    def print_pin(pin)
+    def print_pin pin
       if options[:rbs]
         puts pin.to_rbs
       else
         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/array.rb

@@ -1,37 +1,39 @@
-module Solargraph
-  class Source
-    class Chain
-      class Array < Literal
-        # @param children [::Array<Chain>]
-        # @param node [Parser::AST::Node]
-        def initialize children, node
-          super('::Array', node)
-          @children = children
-        end
-
-        def word
-          @word ||= "<#{@type}>"
-        end
-
-        # @param api_map [ApiMap]
-        # @param name_pin [Pin::Base]
-        # @param locals [::Array<Pin::Parameter, Pin::LocalVariable>]
-        def resolve api_map, name_pin, locals
-          child_types = @children.map do |child|
-            child.infer(api_map, name_pin, locals).simplify_literals
-          end
-          type = if child_types.length == 0 || child_types.any?(&:undefined?)
-                   ComplexType::UniqueType.new('Array', rooted: true)
-                 elsif child_types.uniq.length == 1 && child_types.first.defined?
-                   ComplexType::UniqueType.new('Array', [], child_types.uniq, rooted: true, parameters_type: :list)
-                 elsif child_types.length == 0
-                   ComplexType::UniqueType.new('Array', rooted: true, parameters_type: :list)
-                 else
-                   ComplexType::UniqueType.new('Array', [], child_types, rooted: true, parameters_type: :fixed)
-                 end
-          [Pin::ProxyType.anonymous(type, source: :chain)]
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class Array < Literal
+        # @param children [::Array<Chain>]
+        # @param node [Parser::AST::Node]
+        def initialize children, node
+          super('::Array', node)
+          @children = children
+        end
+
+        def word
+          @word ||= "<#{@type}>"
+        end
+
+        # @param api_map [ApiMap]
+        # @param name_pin [Pin::Base]
+        # @param locals [::Array<Pin::Parameter, Pin::LocalVariable>]
+        def resolve api_map, name_pin, locals
+          child_types = @children.map do |child|
+            child.infer(api_map, name_pin, locals).simplify_literals
+          end
+          type = if child_types.empty? || child_types.any?(&:undefined?)
+                   ComplexType::UniqueType.new('Array', rooted: true)
+                 elsif child_types.uniq.length == 1 && child_types.first.defined?
+                   ComplexType::UniqueType.new('Array', [], child_types.uniq, rooted: true, parameters_type: :list)
+                 elsif child_types.empty?
+                   ComplexType::UniqueType.new('Array', rooted: true, parameters_type: :list)
+                 else
+                   ComplexType::UniqueType.new('Array', [], child_types, rooted: true, parameters_type: :fixed)
+                 end
+          [Pin::ProxyType.anonymous(type, source: :chain)]
+        end
+      end
+    end
+  end
+end