ruby-lsp 0.23.11 → 0.23.17

data/lib/ruby_lsp/erb_document.rb

@@ -3,35 +3,28 @@
 
 module RubyLsp
   class ERBDocument < Document
-    extend T::Sig
     extend T::Generic
 
     ParseResultType = type_member { { fixed: Prism::ParseResult } }
 
-    sig { returns(String) }
+    #: String
     attr_reader :host_language_source
 
-    sig do
-      returns(T.any(
-        T.proc.params(arg0: Integer).returns(Integer),
-        Prism::CodeUnitsCache,
-      ))
-    end
+    #: (^(Integer arg0) -> Integer | Prism::CodeUnitsCache)
     attr_reader :code_units_cache
 
-    sig { params(source: String, version: Integer, uri: URI::Generic, global_state: GlobalState).void }
+    #: (source: String, version: Integer, uri: URI::Generic, global_state: GlobalState) -> void
     def initialize(source:, version:, uri:, global_state:)
       # This has to be initialized before calling super because we call `parse` in the parent constructor, which
       # overrides this with the proper virtual host language source
-      @host_language_source = T.let("", String)
+      @host_language_source = "" #: String
       super
-      @code_units_cache = T.let(@parse_result.code_units_cache(@encoding), T.any(
-        T.proc.params(arg0: Integer).returns(Integer),
-        Prism::CodeUnitsCache,
-      ))
+      @code_units_cache =
+        @parse_result.code_units_cache(@encoding) #: (^(Integer arg0) -> Integer | Prism::CodeUnitsCache)
     end
 
-    sig { override.returns(T::Boolean) }
+    # @override
+    #: -> bool
     def parse!
       return false unless @needs_parsing
 
@@ -46,22 +39,19 @@ module RubyLsp
       true
     end
 
-    sig { override.returns(T::Boolean) }
+    # @override
+    #: -> bool
     def syntax_error?
       @parse_result.failure?
     end
 
-    sig { override.returns(LanguageId) }
+    # @override
+    #: -> Symbol
     def language_id
-      LanguageId::ERB
+      :erb
     end
 
-    sig do
-      params(
-        position: T::Hash[Symbol, T.untyped],
-        node_types: T::Array[T.class_of(Prism::Node)],
-      ).returns(NodeContext)
-    end
+    #: (Hash[Symbol, untyped] position, ?node_types: Array[singleton(Prism::Node)]) -> NodeContext
     def locate_node(position, node_types: [])
       char_position, _ = find_index_by_position(position)
 
@@ -73,28 +63,26 @@ module RubyLsp
       )
     end
 
-    sig { params(char_position: Integer).returns(T.nilable(T::Boolean)) }
+    #: (Integer char_position) -> bool?
     def inside_host_language?(char_position)
       char = @host_language_source[char_position]
       char && char != " "
     end
 
     class ERBScanner
-      extend T::Sig
-
-      sig { returns(String) }
+      #: String
       attr_reader :ruby, :host_language
 
-      sig { params(source: String).void }
+      #: (String source) -> void
       def initialize(source)
         @source = source
-        @host_language = T.let(+"", String)
-        @ruby = T.let(+"", String)
-        @current_pos = T.let(0, Integer)
-        @inside_ruby = T.let(false, T::Boolean)
+        @host_language = +"" #: String
+        @ruby = +"" #: String
+        @current_pos = 0 #: Integer
+        @inside_ruby = false #: bool
       end
 
-      sig { void }
+      #: -> void
       def scan
         while @current_pos < @source.length
           scan_char
@@ -104,7 +92,7 @@ module RubyLsp
 
       private
 
-      sig { void }
+      #: -> void
       def scan_char
         char = @source[@current_pos]
 
@@ -123,7 +111,9 @@ module RubyLsp
               push_char(" ")
             end
           else
-            push_char(T.must(char))
+            push_char(
+              char, #: as !nil
+            )
           end
         when "-"
           if @inside_ruby && next_char == "%" &&
@@ -132,7 +122,9 @@ module RubyLsp
             push_char("   ")
             @inside_ruby = false
           else
-            push_char(T.must(char))
+            push_char(
+              char, #: as !nil
+            )
           end
         when "%"
           if @inside_ruby && next_char == ">"
@@ -140,7 +132,9 @@ module RubyLsp
             @current_pos += 1
             push_char("  ")
           else
-            push_char(T.must(char))
+            push_char(
+              char, #: as !nil
+            )
           end
         when "\r"
           @ruby << char
@@ -155,11 +149,13 @@ module RubyLsp
           @ruby << char
           @host_language << char
         else
-          push_char(T.must(char))
+          push_char(
+            char, #: as !nil
+          )
         end
       end
 
-      sig { params(char: String).void }
+      #: (String char) -> void
       def push_char(char)
         if @inside_ruby
           @ruby << char
@@ -170,7 +166,7 @@ module RubyLsp
         end
       end
 
-      sig { returns(String) }
+      #: -> String
       def next_char
         @source[@current_pos + 1] || ""
       end

data/lib/ruby_lsp/global_state.rb

@@ -3,93 +3,88 @@
 
 module RubyLsp
   class GlobalState
-    extend T::Sig
-
-    sig { returns(String) }
+    #: String
     attr_reader :test_library
 
-    sig { returns(String) }
+    #: String
     attr_accessor :formatter
 
-    sig { returns(T::Boolean) }
+    #: bool
     attr_reader :has_type_checker
 
-    sig { returns(RubyIndexer::Index) }
+    #: RubyIndexer::Index
     attr_reader :index
 
-    sig { returns(Encoding) }
+    #: Encoding
     attr_reader :encoding
 
-    sig { returns(T::Boolean) }
+    #: bool
     attr_reader :top_level_bundle
 
-    sig { returns(TypeInferrer) }
+    #: TypeInferrer
     attr_reader :type_inferrer
 
-    sig { returns(ClientCapabilities) }
+    #: ClientCapabilities
     attr_reader :client_capabilities
 
-    sig { returns(URI::Generic) }
+    #: URI::Generic
     attr_reader :workspace_uri
 
-    sig { returns(T.nilable(String)) }
+    #: String?
     attr_reader :telemetry_machine_id
 
-    sig { void }
+    #: -> void
     def initialize
-      @workspace_uri = T.let(URI::Generic.from_path(path: Dir.pwd), URI::Generic)
-      @encoding = T.let(Encoding::UTF_8, Encoding)
-
-      @formatter = T.let("auto", String)
-      @linters = T.let([], T::Array[String])
-      @test_library = T.let("minitest", String)
-      @has_type_checker = T.let(true, T::Boolean)
-      @index = T.let(RubyIndexer::Index.new, RubyIndexer::Index)
-      @supported_formatters = T.let({}, T::Hash[String, Requests::Support::Formatter])
-      @type_inferrer = T.let(TypeInferrer.new(@index), TypeInferrer)
-      @addon_settings = T.let({}, T::Hash[String, T.untyped])
-      @top_level_bundle = T.let(
-        begin
-          Bundler.with_original_env { Bundler.default_gemfile }
-          true
-        rescue Bundler::GemfileNotFound, Bundler::GitError
-          false
-        end,
-        T::Boolean,
-      )
-      @client_capabilities = T.let(ClientCapabilities.new, ClientCapabilities)
-      @enabled_feature_flags = T.let({}, T::Hash[Symbol, T::Boolean])
-      @mutex = T.let(Mutex.new, Mutex)
-      @telemetry_machine_id = T.let(nil, T.nilable(String))
+      @workspace_uri = URI::Generic.from_path(path: Dir.pwd) #: URI::Generic
+      @encoding = Encoding::UTF_8 #: Encoding
+
+      @formatter = "auto" #: String
+      @linters = [] #: Array[String]
+      @test_library = "minitest" #: String
+      @has_type_checker = true #: bool
+      @index = RubyIndexer::Index.new #: RubyIndexer::Index
+      @supported_formatters = {} #: Hash[String, Requests::Support::Formatter]
+      @type_inferrer = TypeInferrer.new(@index) #: TypeInferrer
+      @addon_settings = {} #: Hash[String, untyped]
+      @top_level_bundle = begin
+        Bundler.with_original_env { Bundler.default_gemfile }
+        true
+      rescue Bundler::GemfileNotFound, Bundler::GitError
+        false
+      end #: bool
+      @client_capabilities = ClientCapabilities.new #: ClientCapabilities
+      @enabled_feature_flags = {} #: Hash[Symbol, bool]
+      @mutex = Mutex.new #: Mutex
+      @telemetry_machine_id = nil #: String?
     end
 
-    sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+    #: [T] { -> T } -> T
     def synchronize(&block)
       @mutex.synchronize(&block)
     end
 
-    sig { params(addon_name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+    #: (String addon_name) -> Hash[Symbol, untyped]?
     def settings_for_addon(addon_name)
       @addon_settings[addon_name]
     end
 
-    sig { params(identifier: String, instance: Requests::Support::Formatter).void }
+    #: (String identifier, Requests::Support::Formatter instance) -> void
     def register_formatter(identifier, instance)
       @supported_formatters[identifier] = instance
     end
 
-    sig { returns(T.nilable(Requests::Support::Formatter)) }
+    #: -> Requests::Support::Formatter?
     def active_formatter
       @supported_formatters[@formatter]
     end
 
-    sig { returns(T::Array[Requests::Support::Formatter]) }
+    #: -> Array[Requests::Support::Formatter]
     def active_linters
       @linters.filter_map { |name| @supported_formatters[name] }
     end
 
     # Applies the options provided by the editor and returns an array of notifications to send back to the client
-    sig { params(options: T::Hash[Symbol, T.untyped]).returns(T::Array[Notification]) }
+    #: (Hash[Symbol, untyped] options) -> Array[Notification]
     def apply_options(options)
       notifications = []
       direct_dependencies = gather_direct_dependencies
@@ -183,17 +178,17 @@ module RubyLsp
       notifications
     end
 
-    sig { params(flag: Symbol).returns(T.nilable(T::Boolean)) }
+    #: (Symbol flag) -> bool?
     def enabled_feature?(flag)
       @enabled_feature_flags[:all] || @enabled_feature_flags[flag]
     end
 
-    sig { returns(String) }
+    #: -> String
     def workspace_path
-      T.must(@workspace_uri.to_standardized_path)
+      @workspace_uri.to_standardized_path #: as !nil
     end
 
-    sig { returns(String) }
+    #: -> String
     def encoding_name
       case @encoding
       when Encoding::UTF_8
@@ -205,14 +200,14 @@ module RubyLsp
       end
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def supports_watching_files
       @client_capabilities.supports_watching_files
     end
 
     private
 
-    sig { params(direct_dependencies: T::Array[String], all_dependencies: T::Array[String]).returns(String) }
+    #: (Array[String] direct_dependencies, Array[String] all_dependencies) -> String
     def detect_formatter(direct_dependencies, all_dependencies)
       # NOTE: Intentionally no $ at end, since we want to match rubocop-shopify, etc.
       return "rubocop_internal" if direct_dependencies.any?(/^rubocop/)
@@ -228,7 +223,7 @@ module RubyLsp
 
     # Try to detect if there are linters in the project's dependencies. For auto-detection, we always only consider a
     # single linter. To have multiple linters running, the user must configure them manually
-    sig { params(dependencies: T::Array[String], all_dependencies: T::Array[String]).returns(T::Array[String]) }
+    #: (Array[String] dependencies, Array[String] all_dependencies) -> Array[String]
     def detect_linters(dependencies, all_dependencies)
       linters = []
 
@@ -239,7 +234,7 @@ module RubyLsp
       linters
     end
 
-    sig { params(dependencies: T::Array[String]).returns(String) }
+    #: (Array[String] dependencies) -> String
     def detect_test_library(dependencies)
       if dependencies.any?(/^rspec/)
         "rspec"
@@ -259,7 +254,7 @@ module RubyLsp
       end
     end
 
-    sig { params(dependencies: T::Array[String]).returns(T::Boolean) }
+    #: (Array[String] dependencies) -> bool
     def detect_typechecker(dependencies)
       return false if ENV["RUBY_LSP_BYPASS_TYPECHECKER"]
 
@@ -268,17 +263,17 @@ module RubyLsp
       false
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def bin_rails_present
       File.exist?(File.join(workspace_path, "bin/rails"))
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def dot_rubocop_yml_present
       File.exist?(File.join(workspace_path, ".rubocop.yml"))
     end
 
-    sig { returns(T::Array[String]) }
+    #: -> Array[String]
     def gather_direct_dependencies
       Bundler.with_original_env { Bundler.default_gemfile }
 
@@ -288,14 +283,14 @@ module RubyLsp
       []
     end
 
-    sig { returns(T::Array[String]) }
+    #: -> Array[String]
     def gemspec_dependencies
       (Bundler.locked_gems&.sources || [])
         .grep(Bundler::Source::Gemspec)
         .flat_map { _1.gemspec&.dependencies&.map(&:name) }
     end
 
-    sig { returns(T::Array[String]) }
+    #: -> Array[String]
     def gather_direct_and_indirect_dependencies
       Bundler.with_original_env { Bundler.default_gemfile }
       Bundler.locked_gems&.specs&.map(&:name) || []

data/lib/ruby_lsp/internal.rb

@@ -25,6 +25,7 @@ require "fileutils"
 require "open3"
 require "securerandom"
 require "shellwords"
+require "set"
 
 require "ruby-lsp"
 require "ruby_lsp/base_server"
@@ -79,6 +80,7 @@ require "ruby_lsp/requests/document_link"
 require "ruby_lsp/requests/document_symbol"
 require "ruby_lsp/requests/folding_ranges"
 require "ruby_lsp/requests/formatting"
+require "ruby_lsp/requests/go_to_relevant_file"
 require "ruby_lsp/requests/hover"
 require "ruby_lsp/requests/inlay_hints"
 require "ruby_lsp/requests/on_type_formatting"