ruby-lsp 0.23.13 → 0.23.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e224f23084eccd6f7b441b6cf6ae2793fb9c73a0045bf36f8c1bbdf2b1f00445
-  data.tar.gz: 581749c8bd2ab362075e49940d364af6a237068e6107d340a2535043d7fdec37
+  metadata.gz: e54bcceea5e2a289c338ab213823ea63915ad96901f99c1976e6ad746c5c5402
+  data.tar.gz: 643f3843f6085d5cf7f29e1d577a94c8d994cbe932708da875e6600ca4fe4c64
 SHA512:
-  metadata.gz: a5d7cb45c56ad5e9e92cba7a0012be7a1626044da4fbc936c413b7a8e5cb3cdd4463bf56dd35ef65feed10f0de363edd04702a4496572248e6e74ea9f720a373
-  data.tar.gz: 53639a355c1641e8b11d4e756a417ea9ee96421cb5a87090ffc94cd8f905d41ca3fa5111e4171a81fa62b452c23088895deca0e7eb52fd2e8fed82e1232d2d06
+  metadata.gz: 49b288356198fbfe6d66e4c6f4765585e44e6b46c5bb81d18d5df547914c5f167b9ac781add2d725f5f9fda9e042dc585323672c60e27c034c80a46eb8f121e3
+  data.tar.gz: 95a7119a9272c5a012ea17fd90c86dc70fa6d66bf81a056ad19dd7ab891d7db9c9c596aff6342432505dd2b487212d48bbb8a28f35468268370d3856b8d1d7ee

data/VERSION

@@ -1 +1 @@
-0.23.13
+0.23.15

data/exe/ruby-lsp-launcher

@@ -11,12 +11,19 @@ install_error = nil
 reboot = false
 
 workspace_uri = ARGV.first
+raw_initialize_path = File.join(".ruby-lsp", "raw_initialize")
 
 raw_initialize = if workspace_uri && !workspace_uri.start_with?("--")
   # If there's an argument without `--`, then it's the server asking to compose the bundle and passing to this
   # executable the workspace URI. We can't require gems at this point, so we built a fake initialize request manually
   reboot = true
   "{\"params\":{\"workspaceFolders\":[{\"uri\":\"#{workspace_uri}\"}]}}"
+elsif ARGV.include?("--retry")
+  # If we're trying to re-boot automatically, we can't try to read the same initialize request again from the pipe. We
+  # need to ensure that the retry mechanism always writes the request to a file, so that we can reuse it
+  content = File.read(raw_initialize_path)
+  File.delete(raw_initialize_path)
+  content
 else
   # Read the initialize request before even starting the server. We need to do this to figure out the workspace URI.
   # Editors are not required to spawn the language server process on the same directory as the workspace URI, so we need
@@ -89,7 +96,8 @@ rescue Bundler::GemNotFound, Bundler::GitError
   # scratch
   unless install_error || ARGV.include?("--retry")
     $stderr.puts("Initial bundle compose succeeded, but Bundler.setup failed. Trying to restart from scratch...")
-    exec(Gem.ruby, File.expand_path("ruby-lsp-launcher", __dir__), *ARGV, "--retry")
+    File.write(raw_initialize_path, raw_initialize)
+    exec(Gem.ruby, __FILE__, *ARGV, "--retry")
   end
 
   $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))

data/lib/ruby_indexer/lib/ruby_indexer/configuration.rb

@@ -94,7 +94,7 @@ module RubyIndexer
       # Remove user specified patterns
       bundle_path = Bundler.settings["path"]&.gsub(/[\\]+/, "/")
       uris.reject! do |indexable|
-        path = T.must(indexable.full_path)
+        path = indexable.full_path #: as !nil
         next false if test_files_ignored_from_exclusion?(path, bundle_path)
 
         excluded_patterns.any? { |pattern| File.fnmatch?(pattern, path, flags) }

data/lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb

@@ -135,7 +135,7 @@ module RubyIndexer
         existing_entries = T.cast(@index[real_nesting.join("::")], T.nilable(T::Array[Entry::SingletonClass]))
 
         if existing_entries
-          entry = T.must(existing_entries.first)
+          entry = existing_entries.first #: as !nil
           entry.update_singleton_information(
             Location.from_prism_location(node.location, @code_units_cache),
             Location.from_prism_location(expression.location, @code_units_cache),
@@ -509,7 +509,10 @@ module RubyIndexer
         parent_class_name,
       )
 
-      advance_namespace_stack(T.must(nesting.last), entry)
+      advance_namespace_stack(
+        nesting.last, #: as !nil
+        entry,
+      )
     end
 
     #: { (Index index, Entry::Namespace base) -> void } -> void
@@ -927,7 +930,7 @@ module RubyIndexer
 
     #: -> VisibilityScope
     def current_visibility_scope
-      T.must(@visibility_stack.last)
+      @visibility_stack.last #: as !nil
     end
 
     #: (Prism::ParametersNode? parameters_node) -> Array[Entry::Parameter]

data/lib/ruby_indexer/lib/ruby_indexer/entry.rb

@@ -52,9 +52,11 @@ module RubyIndexer
     #: -> String
     def file_name
       if @uri.scheme == "untitled"
-        T.must(@uri.opaque)
+        @uri.opaque #: as !nil
       else
-        File.basename(T.must(file_path))
+        File.basename(
+          file_path, #: as !nil
+        )
       end
     end
 

data/lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -126,7 +126,13 @@ module RubyIndexer
 
       (@entries[name] ||= []) << entry
       (@uris_to_entries[entry.uri.to_s] ||= []) << entry
-      @entries_tree.insert(name, T.must(@entries[name])) unless skip_prefix_tree
+
+      unless skip_prefix_tree
+        @entries_tree.insert(
+          name,
+          @entries[name], #: as !nil
+        )
+      end
     end
 
     #: (String fully_qualified_name) -> Array[Entry]?
@@ -188,7 +194,8 @@ module RubyIndexer
       end
 
       results = nesting.length.downto(0).flat_map do |i|
-        prefix = T.must(nesting[0...i]).join("::")
+        prefix = nesting[0...i] #: as !nil
+          .join("::")
         namespaced_query = prefix.empty? ? query : "#{prefix}::#{query}"
         @entries_tree.search(namespaced_query)
       end
@@ -288,7 +295,8 @@ module RubyIndexer
 
       # Constants defined in enclosing scopes
       nesting.length.downto(1) do |i|
-        namespace = T.must(nesting[0...i]).join("::")
+        namespace = nesting[0...i] #: as !nil
+          .join("::")
         entries.concat(@entries_tree.search("#{namespace}::#{name}"))
       end
 
@@ -406,7 +414,8 @@ module RubyIndexer
     # Indexes a File URI by reading the contents from disk
     #: (URI::Generic uri, ?collect_comments: bool) -> void
     def index_file(uri, collect_comments: true)
-      index_single(uri, File.read(T.must(uri.full_path)), collect_comments: collect_comments)
+      path = uri.full_path #: as !nil
+      index_single(uri, File.read(path), collect_comments: collect_comments)
     rescue Errno::EISDIR, Errno::ENOENT
       # If `path` is a directory, just ignore it and continue indexing. If the file doesn't exist, then we also ignore
       # it
@@ -428,7 +437,8 @@ module RubyIndexer
       real_parts = []
 
       (parts.length - 1).downto(0) do |i|
-        current_name = T.must(parts[0..i]).join("::")
+        current_name = parts[0..i] #: as !nil
+          .join("::")
         entry = @entries[current_name]&.first
 
         case entry
@@ -445,7 +455,9 @@ module RubyIndexer
           target = resolved.target
           return follow_aliased_namespace("#{target}::#{real_parts.join("::")}", seen_names)
         else
-          real_parts.unshift(T.must(parts[i]))
+          real_parts.unshift(
+            parts[i], #: as !nil
+          )
         end
       end
 
@@ -542,11 +554,12 @@ module RubyIndexer
 
       # The original nesting where we discovered this namespace, so that we resolve the correct names of the
       # included/prepended/extended modules and parent classes
-      nesting = T.must(namespaces.first).nesting.flat_map { |n| n.split("::") }
+      nesting = namespaces.first #: as !nil
+        .nesting.flat_map { |n| n.split("::") }
 
       if nesting.any?
         singleton_levels.times do
-          nesting << "<Class:#{T.must(nesting.last)}>"
+          nesting << "<Class:#{nesting.last}>"
         end
       end
 
@@ -612,7 +625,8 @@ module RubyIndexer
         name_parts = owner_name.split("::")
 
         if name_parts.last&.start_with?("<Class:")
-          attached_name = T.must(name_parts[0..-2]).join("::")
+          attached_name = name_parts[0..-2] #: as !nil
+            .join("::")
           attached_ancestors = linearized_ancestors_of(attached_name)
           variables.concat(class_variables.select { |e| attached_ancestors.any?(e.owner&.name) })
         else
@@ -649,7 +663,10 @@ module RubyIndexer
         block.call(self)
       else
         delete(uri)
-        index_single(uri, T.must(source))
+        index_single(
+          uri,
+          source, #: as !nil
+        )
       end
 
       updated_entries = @uris_to_entries[key]
@@ -699,7 +716,7 @@ module RubyIndexer
       singleton = T.cast(self[full_singleton_name]&.first, T.nilable(Entry::SingletonClass))
 
       unless singleton
-        attached_ancestor = T.must(self[name]&.first)
+        attached_ancestor = self[name]&.first #: as !nil
 
         singleton = Entry::SingletonClass.new(
           [full_singleton_name],
@@ -732,7 +749,8 @@ module RubyIndexer
       name_parts = name.split("::")
 
       if name_parts.last&.start_with?("<Class:")
-        attached_name = T.must(name_parts[0..-2]).join("::")
+        attached_name = name_parts[0..-2] #: as !nil
+          .join("::")
         linearized_ancestors_of(attached_name)
       else
         linearized_ancestors_of(name)
@@ -755,7 +773,8 @@ module RubyIndexer
           resolved_modules = resolve(operation.module_name, nesting)
           next unless resolved_modules
 
-          module_name = T.must(resolved_modules.first).name
+          module_name = resolved_modules.first #: as !nil
+            .name
 
           # Then we grab any hooks registered for that module
           hooks = @included_hooks[module_name]
@@ -778,7 +797,8 @@ module RubyIndexer
         resolved_module = resolve(operation.module_name, nesting)
         next unless resolved_module
 
-        module_fully_qualified_name = T.must(resolved_module.first).name
+        module_fully_qualified_name = resolved_module.first #: as !nil
+          .name
 
         case operation
         when Entry::Prepend
@@ -790,20 +810,20 @@ module RubyIndexer
           # When there are duplicate prepended modules, we have to insert the new prepends after the existing ones. For
           # example, if the current ancestors are `["A", "Foo"]` and we try to prepend `["A", "B"]`, then `"B"` has to
           # be inserted after `"A`
-          uniq_prepends = linearized_prepends - T.must(ancestors[0...main_namespace_index])
+          prepended_ancestors = ancestors[0...main_namespace_index] #: as !nil
+          uniq_prepends = linearized_prepends - prepended_ancestors
           insert_position = linearized_prepends.length - uniq_prepends.length
 
-          T.unsafe(ancestors).insert(
-            insert_position,
-            *(linearized_prepends - T.must(ancestors[0...main_namespace_index])),
-          )
+          ancestors #: as untyped
+            .insert(insert_position, *uniq_prepends)
 
           main_namespace_index += linearized_prepends.length
         when Entry::Include
           # When including a module, Ruby will always prevent duplicate entries in case the module has already been
           # prepended or included
           linearized_includes = linearized_ancestors_of(module_fully_qualified_name)
-          T.unsafe(ancestors).insert(main_namespace_index + 1, *(linearized_includes - ancestors))
+          ancestors #: as untyped
+            .insert(main_namespace_index + 1, *(linearized_includes - ancestors))
         end
       end
     end
@@ -833,7 +853,7 @@ module RubyIndexer
       if superclass
         # If the user makes a mistake and creates a class that inherits from itself, this method would throw a stack
         # error. We need to ensure that this isn't the case
-        parent_class = T.must(superclass.parent_class)
+        parent_class = superclass.parent_class #: as !nil
 
         resolved_parent_class = resolve(parent_class, nesting)
         parent_class_name = resolved_parent_class&.first&.name
@@ -888,11 +908,12 @@ module RubyIndexer
       target = resolve(entry.target, entry.nesting, seen_names)
       return entry unless target
 
-      target_name = T.must(target.first).name
+      target_name = target.first #: as !nil
+        .name
       resolved_alias = Entry::ConstantAlias.new(target_name, entry)
 
       # Replace the UnresolvedAlias by a resolved one so that we don't have to do this again later
-      original_entries = T.must(@entries[alias_name])
+      original_entries = @entries[alias_name] #: as !nil
       original_entries.delete(entry)
       original_entries << resolved_alias
 
@@ -904,7 +925,8 @@ module RubyIndexer
     #: (String name, Array[String] nesting, Array[String] seen_names) -> Array[(Entry::Namespace | Entry::ConstantAlias | Entry::UnresolvedConstantAlias)]?
     def lookup_enclosing_scopes(name, nesting, seen_names)
       nesting.length.downto(1) do |i|
-        namespace = T.must(nesting[0...i]).join("::")
+        namespace = nesting[0...i] #: as !nil
+          .join("::")
 
         # If we find an entry with `full_name` directly, then we can already return it, even if it contains aliases -
         # because the user might be trying to jump to the alias definition.
@@ -928,7 +950,9 @@ module RubyIndexer
       namespace_entries = resolve(nesting_parts.join("::"), [], seen_names)
       return unless namespace_entries
 
-      ancestors = nesting_parts.empty? ? [] : linearized_ancestors_of(T.must(namespace_entries.first).name)
+      namespace_name = namespace_entries.first #: as !nil
+        .name
+      ancestors = nesting_parts.empty? ? [] : linearized_ancestors_of(namespace_name)
 
       ancestors.each do |ancestor_name|
         entries = direct_or_aliased_constant("#{ancestor_name}::#{constant_name}", seen_names)
@@ -952,7 +976,9 @@ module RubyIndexer
       end
       return [] unless namespace_entries
 
-      ancestors = linearized_ancestors_of(T.must(namespace_entries.first).name)
+      namespace_name = namespace_entries.first #: as !nil
+        .name
+      ancestors = linearized_ancestors_of(namespace_name)
       candidates = ancestors.flat_map do |ancestor_name|
         @entries_tree.search("#{ancestor_name}::#{constant_name}")
       end
@@ -960,7 +986,8 @@ module RubyIndexer
       # For candidates with the same name, we must only show the first entry in the inheritance chain, since that's the
       # one the user will be referring to in completion
       completion_items = candidates.each_with_object({}) do |entries, hash|
-        *parts, short_name = T.must(entries.first).name.split("::")
+        *parts, short_name = entries.first #: as !nil
+          .name.split("::")
         namespace_name = parts.join("::")
         ancestor_index = ancestors.index(namespace_name)
         existing_entry, existing_entry_index = hash[short_name]
@@ -1027,8 +1054,11 @@ module RubyIndexer
       target_method_entries = resolve_method(entry.old_name, receiver_name, seen_names)
       return entry unless target_method_entries
 
-      resolved_alias = Entry::MethodAlias.new(T.must(target_method_entries.first), entry)
-      original_entries = T.must(@entries[new_name])
+      resolved_alias = Entry::MethodAlias.new(
+        target_method_entries.first, #: as !nil
+        entry,
+      )
+      original_entries = @entries[new_name] #: as !nil
       original_entries.delete(entry)
       original_entries << resolved_alias
       resolved_alias

data/lib/ruby_indexer/lib/ruby_indexer/prefix_tree.rb

@@ -78,7 +78,7 @@ module RubyIndexer
       return unless node
 
       # Remove the node from the tree and then go up the parents to remove any of them with empty children
-      parent = T.must(node.parent) #: Node[Value]?
+      parent = node.parent #: Node[Value]?
 
       while parent
         parent.children.delete(node.key)
@@ -138,10 +138,11 @@ module RubyIndexer
       #: -> Array[Value]
       def collect
         result = []
-        result << @value if @leaf
+        stack = [self]
 
-        @children.each_value do |node|
-          result.concat(node.collect)
+        while (node = stack.pop)
+          result << node.value if node.leaf
+          stack.concat(node.children.values)
         end
 
         result

data/lib/ruby_indexer/lib/ruby_indexer/reference_finder.rb

@@ -282,7 +282,11 @@ module RubyIndexer
     #: (Prism::CallNode node) -> void
     def on_call_node_enter(node)
       if @target.is_a?(MethodTarget) && (name = node.name.to_s) == @target.method_name
-        @references << Reference.new(name, T.must(node.message_loc), declaration: false)
+        @references << Reference.new(
+          name,
+          node.message_loc, #: as !nil
+          declaration: false,
+        )
       end
     end
 

data/lib/ruby_indexer/lib/ruby_indexer/uri.rb

@@ -15,14 +15,19 @@ module URI
     class << self
       #: (path: String, ?fragment: String?, ?scheme: String, ?load_path_entry: String?) -> URI::Generic
       def from_path(path:, fragment: nil, scheme: "file", load_path_entry: nil)
+        # This unsafe regex is the same one used in the URI::RFC2396_REGEXP class with the exception of the fact that we
+        # do not include colon as a safe character. VS Code URIs always escape colons and we need to ensure we do the
+        # same to avoid inconsistencies in our URIs, which are used to identify resources
+        unsafe_regex = %r{[^\-_.!~*'()a-zA-Z\d;/?@&=+$,\[\]]}
+
         # On Windows, if the path begins with the disk name, we need to add a leading slash to make it a valid URI
         escaped_path = if /^[A-Z]:/i.match?(path)
-          PARSER.escape("/#{path}")
+          PARSER.escape("/#{path}", unsafe_regex)
         elsif path.start_with?("//?/")
           # Some paths on Windows start with "//?/". This is a special prefix that allows for long file paths
-          PARSER.escape(path.delete_prefix("//?"))
+          PARSER.escape(path.delete_prefix("//?"), unsafe_regex)
         else
-          PARSER.escape(path)
+          PARSER.escape(path, unsafe_regex)
         end
 
         uri = build(scheme: scheme, path: escaped_path, fragment: fragment)

data/lib/ruby_indexer/test/class_variables_test.rb

@@ -14,8 +14,8 @@ module RubyIndexer
 
       assert_entry("@@bar", Entry::ClassVariable, "/fake/path/foo.rb:1-2:1-7")
 
-      entry = T.must(@index["@@bar"]&.first)
-      owner = T.must(entry.owner)
+      entry = @index["@@bar"]&.first #: as Entry::ClassVariable
+      owner = entry.owner #: as !nil
       assert_instance_of(Entry::Class, owner)
       assert_equal("Foo", owner.name)
     end
@@ -50,13 +50,13 @@ module RubyIndexer
       assert_entry("@@foo", Entry::ClassVariable, "/fake/path/foo.rb:1-2:1-7")
       assert_entry("@@bar", Entry::ClassVariable, "/fake/path/foo.rb:1-9:1-14")
 
-      entry = T.must(@index["@@foo"]&.first)
-      owner = T.must(entry.owner)
+      entry = @index["@@foo"]&.first #: as Entry::ClassVariable
+      owner = entry.owner #: as !nil
       assert_instance_of(Entry::Class, owner)
       assert_equal("Foo", owner.name)
 
-      entry = T.must(@index["@@bar"]&.first)
-      owner = T.must(entry.owner)
+      entry = @index["@@bar"]&.first #: as Entry::ClassVariable
+      owner = entry.owner #: as !nil
       assert_instance_of(Entry::Class, owner)
       assert_equal("Foo", owner.name)
     end
@@ -83,10 +83,10 @@ module RubyIndexer
 
     def test_top_level_class_variable
       index(<<~RUBY)
-        @foo = 123
+        @@foo = 123
       RUBY
 
-      entry = T.must(@index["@foo"]&.first)
+      entry = @index["@@foo"]&.first #: as Entry::ClassVariable
       assert_nil(entry.owner)
     end
 
@@ -99,8 +99,8 @@ module RubyIndexer
         end
       RUBY
 
-      entry = T.must(@index["@@bar"]&.first)
-      owner = T.must(entry.owner)
+      entry = @index["@@bar"]&.first #: as Entry::ClassVariable
+      owner = entry.owner #: as !nil
       assert_instance_of(Entry::Class, owner)
       assert_equal("Foo", owner.name)
     end
@@ -114,8 +114,8 @@ module RubyIndexer
         end
       RUBY
 
-      entry = T.must(@index["@@bar"]&.first)
-      owner = T.must(entry.owner)
+      entry = @index["@@bar"]&.first #: as Entry::ClassVariable
+      owner = entry.owner #: as !nil
       assert_instance_of(Entry::Class, owner)
       assert_equal("Foo", owner.name)
     end
@@ -131,8 +131,8 @@ module RubyIndexer
         end
       RUBY
 
-      entry = T.must(@index["@@bar"]&.first)
-      owner = T.must(entry.owner)
+      entry = @index["@@bar"]&.first #: as Entry::ClassVariable
+      owner = entry.owner #: as !nil
       assert_instance_of(Entry::Class, owner)
       assert_equal("Foo", owner.name)
     end