ruby-lsp 0.22.1 → 0.23.0

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

@@ -29,13 +29,14 @@ module RubyIndexer
 
       # Holds references to where entries where discovered so that we can easily delete them
       # {
-      #  "/my/project/foo.rb" => [#<Entry::Class>, #<Entry::Class>],
-      #  "/my/project/bar.rb" => [#<Entry::Class>],
+      #  "file:///my/project/foo.rb" => [#<Entry::Class>, #<Entry::Class>],
+      #  "file:///my/project/bar.rb" => [#<Entry::Class>],
+      #  "untitled:Untitled-1" => [#<Entry::Class>],
       # }
-      @files_to_entries = T.let({}, T::Hash[String, T::Array[Entry]])
+      @uris_to_entries = T.let({}, T::Hash[String, T::Array[Entry]])
 
       # Holds all require paths for every indexed item so that we can provide autocomplete for requires
-      @require_paths_tree = T.let(PrefixTree[IndexablePath].new, PrefixTree[IndexablePath])
+      @require_paths_tree = T.let(PrefixTree[URI::Generic].new, PrefixTree[URI::Generic])
 
       # Holds the linearized ancestors list for every namespace
       @ancestors = T.let({}, T::Hash[String, T::Array[String]])
@@ -55,11 +56,12 @@ module RubyIndexer
       (@included_hooks[module_name] ||= []) << hook
     end
 
-    sig { params(indexable: IndexablePath).void }
-    def delete(indexable)
+    sig { params(uri: URI::Generic).void }
+    def delete(uri)
+      key = uri.to_s
       # For each constant discovered in `path`, delete the associated entry from the index. If there are no entries
       # left, delete the constant from the index.
-      @files_to_entries[indexable.full_path]&.each do |entry|
+      @uris_to_entries[key]&.each do |entry|
         name = entry.name
         entries = @entries[name]
         next unless entries
@@ -77,9 +79,9 @@ module RubyIndexer
         end
       end
 
-      @files_to_entries.delete(indexable.full_path)
+      @uris_to_entries.delete(key)
 
-      require_path = indexable.require_path
+      require_path = uri.require_path
       @require_paths_tree.delete(require_path) if require_path
     end
 
@@ -88,7 +90,7 @@ module RubyIndexer
       name = entry.name
 
       (@entries[name] ||= []) << entry
-      (@files_to_entries[entry.file_path] ||= []) << entry
+      (@uris_to_entries[entry.uri.to_s] ||= []) << entry
       @entries_tree.insert(name, T.must(@entries[name])) unless skip_prefix_tree
     end
 
@@ -97,7 +99,7 @@ module RubyIndexer
       @entries[fully_qualified_name.delete_prefix("::")]
     end
 
-    sig { params(query: String).returns(T::Array[IndexablePath]) }
+    sig { params(query: String).returns(T::Array[URI::Generic]) }
     def search_require_paths(query)
       @require_paths_tree.search(query)
     end
@@ -342,16 +344,16 @@ module RubyIndexer
       nil
     end
 
-    # Index all files for the given indexable paths, which defaults to what is configured. A block can be used to track
-    # and control indexing progress. That block is invoked with the current progress percentage and should return `true`
-    # to continue indexing or `false` to stop indexing.
+    # Index all files for the given URIs, which defaults to what is configured. A block can be used to track and control
+    # indexing progress. That block is invoked with the current progress percentage and should return `true` to continue
+    # indexing or `false` to stop indexing.
     sig do
       params(
-        indexable_paths: T::Array[IndexablePath],
+        uris: T::Array[URI::Generic],
         block: T.nilable(T.proc.params(progress: Integer).returns(T::Boolean)),
       ).void
     end
-    def index_all(indexable_paths: @configuration.indexables, &block)
+    def index_all(uris: @configuration.indexable_uris, &block)
       # When troubleshooting an indexing issue, e.g. through irb, it's not obvious that `index_all` will augment the
       # existing index values, meaning it may contain 'stale' entries. This check ensures that the user is aware of this
       # behavior and can take appropriate action.
@@ -363,54 +365,48 @@ module RubyIndexer
 
       RBSIndexer.new(self).index_ruby_core
       # Calculate how many paths are worth 1% of progress
-      progress_step = (indexable_paths.length / 100.0).ceil
+      progress_step = (uris.length / 100.0).ceil
 
-      indexable_paths.each_with_index do |path, index|
+      uris.each_with_index do |uri, index|
         if block && index % progress_step == 0
           progress = (index / progress_step) + 1
           break unless block.call(progress)
         end
 
-        index_single(path, collect_comments: false)
+        index_file(uri, collect_comments: false)
       end
     end
 
-    sig { params(indexable_path: IndexablePath, source: T.nilable(String), collect_comments: T::Boolean).void }
-    def index_single(indexable_path, source = nil, collect_comments: true)
-      content = source || File.read(indexable_path.full_path)
+    sig { params(uri: URI::Generic, source: String, collect_comments: T::Boolean).void }
+    def index_single(uri, source, collect_comments: true)
       dispatcher = Prism::Dispatcher.new
 
-      result = Prism.parse(content)
-      listener = DeclarationListener.new(
-        self,
-        dispatcher,
-        result,
-        indexable_path.full_path,
-        collect_comments: collect_comments,
-      )
+      result = Prism.parse(source)
+      listener = DeclarationListener.new(self, dispatcher, result, uri, collect_comments: collect_comments)
       dispatcher.dispatch(result.value)
 
-      indexing_errors = listener.indexing_errors.uniq
-
-      require_path = indexable_path.require_path
-      @require_paths_tree.insert(require_path, indexable_path) if require_path
+      require_path = uri.require_path
+      @require_paths_tree.insert(require_path, uri) if require_path
 
-      if indexing_errors.any?
-        indexing_errors.each do |error|
-          $stderr.puts error
-        end
-      end
-    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
+      indexing_errors = listener.indexing_errors.uniq
+      indexing_errors.each { |error| $stderr.puts(error) } if indexing_errors.any?
     rescue SystemStackError => e
       if e.backtrace&.first&.include?("prism")
-        $stderr.puts "Prism error indexing #{indexable_path.full_path}: #{e.message}"
+        $stderr.puts "Prism error indexing #{uri}: #{e.message}"
       else
         raise
       end
     end
 
+    # Indexes a File URI by reading the contents from disk
+    sig { params(uri: URI::Generic, collect_comments: T::Boolean).void }
+    def index_file(uri, collect_comments: true)
+      index_single(uri, File.read(T.must(uri.full_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
+    end
+
     # Follows aliases in a namespace. The algorithm keeps checking if the name is an alias and then recursively follows
     # it. The idea is that we test the name in parts starting from the complete name to the first namespace. For
     # `Foo::Bar::Baz`, we would test:
@@ -588,6 +584,17 @@ module RubyIndexer
       entries.select { |e| ancestors.include?(e.owner&.name) }
     end
 
+    sig { params(variable_name: String, owner_name: String).returns(T.nilable(T::Array[Entry::ClassVariable])) }
+    def resolve_class_variable(variable_name, owner_name)
+      entries = self[variable_name]&.grep(Entry::ClassVariable)
+      return unless entries&.any?
+
+      ancestors = linearized_ancestors_of(owner_name)
+      return if ancestors.empty?
+
+      entries.select { |e| ancestors.include?(e.owner&.name) }
+    end
+
     # Returns a list of possible candidates for completion of instance variables for a given owner name. The name must
     # include the `@` prefix
     sig { params(name: String, owner_name: String).returns(T::Array[Entry::InstanceVariable]) }
@@ -600,16 +607,27 @@ module RubyIndexer
       variables
     end
 
-    # Synchronizes a change made to the given indexable path. This method will ensure that new declarations are indexed,
-    # removed declarations removed and that the ancestor linearization cache is cleared if necessary
-    sig { params(indexable: IndexablePath).void }
-    def handle_change(indexable)
-      original_entries = @files_to_entries[indexable.full_path]
+    sig { params(name: String, owner_name: String).returns(T::Array[Entry::ClassVariable]) }
+    def class_variable_completion_candidates(name, owner_name)
+      entries = T.cast(prefix_search(name).flatten, T::Array[Entry::ClassVariable])
+      ancestors = linearized_ancestors_of(owner_name)
+
+      variables = entries.select { |e| ancestors.any?(e.owner&.name) }
+      variables.uniq!(&:name)
+      variables
+    end
+
+    # Synchronizes a change made to the given URI. This method will ensure that new declarations are indexed, removed
+    # declarations removed and that the ancestor linearization cache is cleared if necessary
+    sig { params(uri: URI::Generic, source: String).void }
+    def handle_change(uri, source)
+      key = uri.to_s
+      original_entries = @uris_to_entries[key]
 
-      delete(indexable)
-      index_single(indexable)
+      delete(uri)
+      index_single(uri, source)
 
-      updated_entries = @files_to_entries[indexable.full_path]
+      updated_entries = @uris_to_entries[key]
 
       return unless original_entries && updated_entries
 
@@ -661,7 +679,7 @@ module RubyIndexer
 
         singleton = Entry::SingletonClass.new(
           [full_singleton_name],
-          attached_ancestor.file_path,
+          attached_ancestor.uri,
           attached_ancestor.location,
           attached_ancestor.name_location,
           nil,
@@ -675,12 +693,12 @@ module RubyIndexer
 
     sig do
       type_parameters(:T).params(
-        path: String,
+        uri: String,
         type: T.nilable(T::Class[T.all(T.type_parameter(:T), Entry)]),
       ).returns(T.nilable(T.any(T::Array[Entry], T::Array[T.type_parameter(:T)])))
     end
-    def entries_for(path, type = nil)
-      entries = @files_to_entries[path]
+    def entries_for(uri, type = nil)
+      entries = @uris_to_entries[uri.to_s]
       return entries unless type
 
       entries&.grep(type)

data/lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb

@@ -43,7 +43,7 @@ module RubyIndexer
         handle_class_or_module_declaration(declaration, pathname)
       when RBS::AST::Declarations::Constant
         namespace_nesting = declaration.name.namespace.path.map(&:to_s)
-        handle_constant(declaration, namespace_nesting, pathname.to_s)
+        handle_constant(declaration, namespace_nesting, URI::Generic.from_path(path: pathname.to_s))
       when RBS::AST::Declarations::Global
         handle_global_variable(declaration, pathname)
       else # rubocop:disable Style/EmptyElse
@@ -56,23 +56,25 @@ module RubyIndexer
     end
     def handle_class_or_module_declaration(declaration, pathname)
       nesting = [declaration.name.name.to_s]
-      file_path = pathname.to_s
+      uri = URI::Generic.from_path(path: pathname.to_s)
       location = to_ruby_indexer_location(declaration.location)
       comments = comments_to_string(declaration)
       entry = if declaration.is_a?(RBS::AST::Declarations::Class)
         parent_class = declaration.super_class&.name&.name&.to_s
-        Entry::Class.new(nesting, file_path, location, location, comments, parent_class)
+        Entry::Class.new(nesting, uri, location, location, comments, parent_class)
       else
-        Entry::Module.new(nesting, file_path, location, location, comments)
+        Entry::Module.new(nesting, uri, location, location, comments)
       end
+
       add_declaration_mixins_to_entry(declaration, entry)
       @index.add(entry)
+
       declaration.members.each do |member|
         case member
         when RBS::AST::Members::MethodDefinition
           handle_method(member, entry)
         when RBS::AST::Declarations::Constant
-          handle_constant(member, nesting, file_path)
+          handle_constant(member, nesting, uri)
         when RBS::AST::Members::Alias
           # In RBS, an alias means that two methods have the same signature.
           # It does not mean the same thing as a Ruby alias.
@@ -115,7 +117,7 @@ module RubyIndexer
     sig { params(member: RBS::AST::Members::MethodDefinition, owner: Entry::Namespace).void }
     def handle_method(member, owner)
       name = member.name.name
-      file_path = member.location.buffer.name
+      uri = URI::Generic.from_path(path: member.location.buffer.name)
       location = to_ruby_indexer_location(member.location)
       comments = comments_to_string(member)
 
@@ -132,7 +134,7 @@ module RubyIndexer
       signatures = signatures(member)
       @index.add(Entry::Method.new(
         name,
-        file_path,
+        uri,
         location,
         location,
         comments,
@@ -260,12 +262,12 @@ module RubyIndexer
     # Complex::I = ... # Complex::I is a top-level constant
     #
     # And we need to handle their nesting differently.
-    sig { params(declaration: RBS::AST::Declarations::Constant, nesting: T::Array[String], file_path: String).void }
-    def handle_constant(declaration, nesting, file_path)
+    sig { params(declaration: RBS::AST::Declarations::Constant, nesting: T::Array[String], uri: URI::Generic).void }
+    def handle_constant(declaration, nesting, uri)
       fully_qualified_name = [*nesting, declaration.name.name.to_s].join("::")
       @index.add(Entry::Constant.new(
         fully_qualified_name,
-        file_path,
+        uri,
         to_ruby_indexer_location(declaration.location),
         comments_to_string(declaration),
       ))
@@ -274,13 +276,13 @@ module RubyIndexer
     sig { params(declaration: RBS::AST::Declarations::Global, pathname: Pathname).void }
     def handle_global_variable(declaration, pathname)
       name = declaration.name.to_s
-      file_path = pathname.to_s
+      uri = URI::Generic.from_path(path: pathname.to_s)
       location = to_ruby_indexer_location(declaration.location)
       comments = comments_to_string(declaration)
 
       @index.add(Entry::GlobalVariable.new(
         name,
-        file_path,
+        uri,
         location,
         comments,
       ))
@@ -288,14 +290,14 @@ module RubyIndexer
 
     sig { params(member: RBS::AST::Members::Alias, owner_entry: Entry::Namespace).void }
     def handle_signature_alias(member, owner_entry)
-      file_path = member.location.buffer.name
+      uri = URI::Generic.from_path(path: member.location.buffer.name)
       comments = comments_to_string(member)
 
       entry = Entry::UnresolvedMethodAlias.new(
         member.new_name.to_s,
         member.old_name.to_s,
         owner_entry,
-        file_path,
+        uri,
         to_ruby_indexer_location(member.location),
         comments,
       )

data/lib/{core_ext → ruby_indexer/lib/ruby_indexer}/uri.rb

@@ -13,8 +13,15 @@ module URI
     class << self
       extend T::Sig
 
-      sig { params(path: String, fragment: T.nilable(String), scheme: String).returns(URI::Generic) }
-      def from_path(path:, fragment: nil, scheme: "file")
+      sig do
+        params(
+          path: String,
+          fragment: T.nilable(String),
+          scheme: String,
+          load_path_entry: T.nilable(String),
+        ).returns(URI::Generic)
+      end
+      def from_path(path:, fragment: nil, scheme: "file", load_path_entry: nil)
         # 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}")
@@ -25,10 +32,27 @@ module URI
           PARSER.escape(path)
         end
 
-        build(scheme: scheme, path: escaped_path, fragment: fragment)
+        uri = build(scheme: scheme, path: escaped_path, fragment: fragment)
+
+        if load_path_entry
+          uri.require_path = path.delete_prefix("#{load_path_entry}/").delete_suffix(".rb")
+        end
+
+        uri
       end
     end
 
+    sig { returns(T.nilable(String)) }
+    attr_accessor :require_path
+
+    sig { params(load_path_entry: String).void }
+    def add_require_path_from_load_entry(load_path_entry)
+      path = to_standardized_path
+      return unless path
+
+      self.require_path = path.delete_prefix("#{load_path_entry}/").delete_suffix(".rb")
+    end
+
     sig { returns(T.nilable(String)) }
     def to_standardized_path
       parsed_path = path
@@ -44,5 +68,7 @@ module URI
         unescaped_path
       end
     end
+
+    alias_method :full_path, :to_standardized_path
   end
 end

data/lib/ruby_indexer/ruby_indexer.rb

@@ -4,7 +4,7 @@
 require "yaml"
 require "did_you_mean"
 
-require "ruby_indexer/lib/ruby_indexer/indexable_path"
+require "ruby_indexer/lib/ruby_indexer/uri"
 require "ruby_indexer/lib/ruby_indexer/declaration_listener"
 require "ruby_indexer/lib/ruby_indexer/reference_finder"
 require "ruby_indexer/lib/ruby_indexer/enhancement"

data/lib/ruby_indexer/test/class_variables_test.rb

@@ -0,0 +1,140 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "test_case"
+
+module RubyIndexer
+  class ClassVariableTest < TestCase
+    def test_class_variable_and_write
+      index(<<~RUBY)
+        class Foo
+          @@bar &&= 1
+        end
+      RUBY
+
+      assert_entry("@@bar", Entry::ClassVariable, "/fake/path/foo.rb:1-2:1-7")
+
+      entry = T.must(@index["@@bar"]&.first)
+      owner = T.must(entry.owner)
+      assert_instance_of(Entry::Class, owner)
+      assert_equal("Foo", owner.name)
+    end
+
+    def test_class_variable_operator_write
+      index(<<~RUBY)
+        class Foo
+          @@bar += 1
+        end
+      RUBY
+
+      assert_entry("@@bar", Entry::ClassVariable, "/fake/path/foo.rb:1-2:1-7")
+    end
+
+    def test_class_variable_or_write
+      index(<<~RUBY)
+        class Foo
+          @@bar ||= 1
+        end
+      RUBY
+
+      assert_entry("@@bar", Entry::ClassVariable, "/fake/path/foo.rb:1-2:1-7")
+    end
+
+    def test_class_variable_target_node
+      index(<<~RUBY)
+        class Foo
+          @@foo, @@bar = 1
+        end
+      RUBY
+
+      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)
+      assert_instance_of(Entry::Class, owner)
+      assert_equal("Foo", owner.name)
+
+      entry = T.must(@index["@@bar"]&.first)
+      owner = T.must(entry.owner)
+      assert_instance_of(Entry::Class, owner)
+      assert_equal("Foo", owner.name)
+    end
+
+    def test_class_variable_write
+      index(<<~RUBY)
+        class Foo
+          @@bar = 1
+        end
+      RUBY
+
+      assert_entry("@@bar", Entry::ClassVariable, "/fake/path/foo.rb:1-2:1-7")
+    end
+
+    def test_empty_name_class_variable
+      index(<<~RUBY)
+        module Foo
+          @@ = 1
+        end
+      RUBY
+
+      refute_entry("@@")
+    end
+
+    def test_top_level_class_variable
+      index(<<~RUBY)
+        @foo = 123
+      RUBY
+
+      entry = T.must(@index["@foo"]&.first)
+      assert_nil(entry.owner)
+    end
+
+    def test_class_variable_inside_self_method
+      index(<<~RUBY)
+        class Foo
+          def self.bar
+            @@bar = 123
+          end
+        end
+      RUBY
+
+      entry = T.must(@index["@@bar"]&.first)
+      owner = T.must(entry.owner)
+      assert_instance_of(Entry::Class, owner)
+      assert_equal("Foo", owner.name)
+    end
+
+    def test_class_variable_inside_singleton_class
+      index(<<~RUBY)
+        class Foo
+          class << self
+            @@bar = 123
+          end
+        end
+      RUBY
+
+      entry = T.must(@index["@@bar"]&.first)
+      owner = T.must(entry.owner)
+      assert_instance_of(Entry::Class, owner)
+      assert_equal("Foo", owner.name)
+    end
+
+    def test_class_variable_in_singleton_class_method
+      index(<<~RUBY)
+        class Foo
+          class << self
+            def self.bar
+              @@bar = 123
+            end
+          end
+        end
+      RUBY
+
+      entry = T.must(@index["@@bar"]&.first)
+      owner = T.must(entry.owner)
+      assert_instance_of(Entry::Class, owner)
+      assert_equal("Foo", owner.name)
+    end
+  end
+end

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -200,7 +200,7 @@ module RubyIndexer
 
       assert_entry("Foo", Entry::Class, "/fake/path/foo.rb:0-0:1-3")
 
-      @index.delete(IndexablePath.new(nil, "/fake/path/foo.rb"))
+      @index.delete(URI::Generic.from_path(path: "/fake/path/foo.rb"))
       refute_entry("Foo")
 
       assert_no_indexed_entries
@@ -618,10 +618,12 @@ module RubyIndexer
     end
 
     def test_lazy_comment_fetching_uses_correct_line_breaks_for_rendering
-      path = "lib/ruby_lsp/node_context.rb"
-      indexable = IndexablePath.new("#{Dir.pwd}/lib", path)
+      uri = URI::Generic.from_path(
+        load_path_entry: "#{Dir.pwd}/lib",
+        path: "#{Dir.pwd}/lib/ruby_lsp/node_context.rb",
+      )
 
-      @index.index_single(indexable, collect_comments: false)
+      @index.index_file(uri, collect_comments: false)
 
       entry = @index["RubyLsp::NodeContext"].first
 
@@ -632,9 +634,12 @@ module RubyIndexer
     end
 
     def test_lazy_comment_fetching_does_not_fail_if_file_gets_deleted
-      indexable = IndexablePath.new("#{Dir.pwd}/lib", "lib/ruby_lsp/does_not_exist.rb")
+      uri = URI::Generic.from_path(
+        load_path_entry: "#{Dir.pwd}/lib",
+        path: "#{Dir.pwd}/lib/ruby_lsp/does_not_exist.rb",
+      )
 
-      @index.index_single(indexable, <<~RUBY, collect_comments: false)
+      @index.index_single(uri, <<~RUBY, collect_comments: false)
         class Foo
         end
       RUBY