ruby-lsp 0.22.1 → 0.23.10

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

@@ -16,8 +16,8 @@ module RubyIndexer
     sig { returns(String) }
     attr_reader :name
 
-    sig { returns(String) }
-    attr_reader :file_path
+    sig { returns(URI::Generic) }
+    attr_reader :uri
 
     sig { returns(RubyIndexer::Location) }
     attr_reader :location
@@ -30,14 +30,14 @@ module RubyIndexer
     sig do
       params(
         name: String,
-        file_path: String,
+        uri: URI::Generic,
         location: Location,
         comments: T.nilable(String),
       ).void
     end
-    def initialize(name, file_path, location, comments)
+    def initialize(name, uri, location, comments)
       @name = name
-      @file_path = file_path
+      @uri = uri
       @comments = comments
       @visibility = T.let(Visibility::PUBLIC, Visibility)
       @location = location
@@ -60,14 +60,24 @@ module RubyIndexer
 
     sig { returns(String) }
     def file_name
-      File.basename(@file_path)
+      if @uri.scheme == "untitled"
+        T.must(@uri.opaque)
+      else
+        File.basename(T.must(file_path))
+      end
+    end
+
+    sig { returns(T.nilable(String)) }
+    def file_path
+      @uri.full_path
     end
 
     sig { returns(String) }
     def comments
       @comments ||= begin
         # Parse only the comments based on the file path, which is much faster than parsing the entire file
-        parsed_comments = Prism.parse_file_comments(@file_path)
+        path = file_path
+        parsed_comments = path ? Prism.parse_file_comments(path) : []
 
         # Group comments based on whether they belong to a single block of comments
         grouped = parsed_comments.slice_when do |left, right|
@@ -137,18 +147,18 @@ module RubyIndexer
       sig do
         params(
           nesting: T::Array[String],
-          file_path: String,
+          uri: URI::Generic,
           location: Location,
           name_location: Location,
           comments: T.nilable(String),
         ).void
       end
-      def initialize(nesting, file_path, location, name_location, comments)
+      def initialize(nesting, uri, location, name_location, comments)
         @name = T.let(nesting.join("::"), String)
         # The original nesting where this namespace was discovered
         @nesting = nesting
 
-        super(@name, file_path, location, comments)
+        super(@name, uri, location, comments)
 
         @name_location = name_location
       end
@@ -186,15 +196,15 @@ module RubyIndexer
       sig do
         params(
           nesting: T::Array[String],
-          file_path: String,
+          uri: URI::Generic,
           location: Location,
           name_location:  Location,
           comments: T.nilable(String),
           parent_class: T.nilable(String),
         ).void
       end
-      def initialize(nesting, file_path, location, name_location, comments, parent_class) # rubocop:disable Metrics/ParameterLists
-        super(nesting, file_path, location, name_location, comments)
+      def initialize(nesting, uri, location, name_location, comments, parent_class) # rubocop:disable Metrics/ParameterLists
+        super(nesting, uri, location, name_location, comments)
         @parent_class = parent_class
       end
 
@@ -332,15 +342,15 @@ module RubyIndexer
       sig do
         params(
           name: String,
-          file_path: String,
+          uri: URI::Generic,
           location: Location,
           comments: T.nilable(String),
           visibility: Visibility,
           owner: T.nilable(Entry::Namespace),
         ).void
       end
-      def initialize(name, file_path, location, comments, visibility, owner) # rubocop:disable Metrics/ParameterLists
-        super(name, file_path, location, comments)
+      def initialize(name, uri, location, comments, visibility, owner) # rubocop:disable Metrics/ParameterLists
+        super(name, uri, location, comments)
         @visibility = visibility
         @owner = owner
       end
@@ -399,7 +409,7 @@ module RubyIndexer
       sig do
         params(
           name: String,
-          file_path: String,
+          uri: URI::Generic,
           location: Location,
           name_location: Location,
           comments: T.nilable(String),
@@ -408,8 +418,8 @@ module RubyIndexer
           owner: T.nilable(Entry::Namespace),
         ).void
       end
-      def initialize(name, file_path, location, name_location, comments, signatures, visibility, owner) # rubocop:disable Metrics/ParameterLists
-        super(name, file_path, location, comments, visibility, owner)
+      def initialize(name, uri, location, name_location, comments, signatures, visibility, owner) # rubocop:disable Metrics/ParameterLists
+        super(name, uri, location, comments, visibility, owner)
         @signatures = signatures
         @name_location = name_location
       end
@@ -439,13 +449,13 @@ module RubyIndexer
           target: String,
           nesting: T::Array[String],
           name: String,
-          file_path: String,
+          uri: URI::Generic,
           location: Location,
           comments: T.nilable(String),
         ).void
       end
-      def initialize(target, nesting, name, file_path, location, comments) # rubocop:disable Metrics/ParameterLists
-        super(name, file_path, location, comments)
+      def initialize(target, nesting, name, uri, location, comments) # rubocop:disable Metrics/ParameterLists
+        super(name, uri, location, comments)
 
         @target = target
         @nesting = nesting
@@ -463,7 +473,7 @@ module RubyIndexer
       def initialize(target, unresolved_alias)
         super(
           unresolved_alias.name,
-          unresolved_alias.file_path,
+          unresolved_alias.uri,
           unresolved_alias.location,
           unresolved_alias.comments,
         )
@@ -476,6 +486,26 @@ module RubyIndexer
     # Represents a global variable e.g.: $DEBUG
     class GlobalVariable < Entry; end
 
+    # Represents a class variable e.g.: @@a = 1
+    class ClassVariable < Entry
+      sig { returns(T.nilable(Entry::Namespace)) }
+      attr_reader :owner
+
+      sig do
+        params(
+          name: String,
+          uri: URI::Generic,
+          location: Location,
+          comments: T.nilable(String),
+          owner: T.nilable(Entry::Namespace),
+        ).void
+      end
+      def initialize(name, uri, location, comments, owner)
+        super(name, uri, location, comments)
+        @owner = owner
+      end
+    end
+
     # Represents an instance variable e.g.: @a = 1
     class InstanceVariable < Entry
       sig { returns(T.nilable(Entry::Namespace)) }
@@ -484,14 +514,14 @@ module RubyIndexer
       sig do
         params(
           name: String,
-          file_path: String,
+          uri: URI::Generic,
           location: Location,
           comments: T.nilable(String),
           owner: T.nilable(Entry::Namespace),
         ).void
       end
-      def initialize(name, file_path, location, comments, owner)
-        super(name, file_path, location, comments)
+      def initialize(name, uri, location, comments, owner)
+        super(name, uri, location, comments)
         @owner = owner
       end
     end
@@ -513,13 +543,13 @@ module RubyIndexer
           new_name: String,
           old_name: String,
           owner: T.nilable(Entry::Namespace),
-          file_path: String,
+          uri: URI::Generic,
           location: Location,
           comments: T.nilable(String),
         ).void
       end
-      def initialize(new_name, old_name, owner, file_path, location, comments) # rubocop:disable Metrics/ParameterLists
-        super(new_name, file_path, location, comments)
+      def initialize(new_name, old_name, owner, uri, location, comments) # rubocop:disable Metrics/ParameterLists
+        super(new_name, uri, location, comments)
 
         @new_name = new_name
         @old_name = old_name
@@ -547,7 +577,7 @@ module RubyIndexer
 
         super(
           unresolved_alias.new_name,
-          unresolved_alias.file_path,
+          unresolved_alias.uri,
           unresolved_alias.location,
           full_comments,
         )

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

@@ -15,6 +15,45 @@ module RubyIndexer
     sig { returns(Configuration) }
     attr_reader :configuration
 
+    class << self
+      extend T::Sig
+
+      # Returns the real nesting of a constant name taking into account top level
+      # references that may be included anywhere in the name or nesting where that
+      # constant was found
+      sig { params(stack: T::Array[String], name: String).returns(T::Array[String]) }
+      def actual_nesting(stack, name)
+        nesting = stack + [name]
+        corrected_nesting = []
+
+        nesting.reverse_each do |name|
+          corrected_nesting.prepend(name.delete_prefix("::"))
+
+          break if name.start_with?("::")
+        end
+
+        corrected_nesting
+      end
+
+      # Returns the unresolved name for a constant reference including all parts of a constant path, or `nil` if the
+      # constant contains dynamic or incomplete parts
+      sig do
+        params(
+          node: T.any(
+            Prism::ConstantPathNode,
+            Prism::ConstantReadNode,
+            Prism::ConstantPathTargetNode,
+          ),
+        ).returns(T.nilable(String))
+      end
+      def constant_name(node)
+        node.full_name
+      rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError,
+             Prism::ConstantPathNode::MissingNodesInConstantPathError
+        nil
+      end
+    end
+
     sig { void }
     def initialize
       # Holds all entries in the index using the following format:
@@ -29,13 +68,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]])
@@ -47,6 +87,8 @@ module RubyIndexer
       )
 
       @configuration = T.let(RubyIndexer::Configuration.new, Configuration)
+
+      @initial_indexing_completed = T.let(false, T::Boolean)
     end
 
     # Register an included `hook` that will be executed when `module_name` is included into any namespace
@@ -55,11 +97,12 @@ module RubyIndexer
       (@included_hooks[module_name] ||= []) << hook
     end
 
-    sig { params(indexable: IndexablePath).void }
-    def delete(indexable)
+    sig { params(uri: URI::Generic, skip_require_paths_tree: T::Boolean).void }
+    def delete(uri, skip_require_paths_tree: false)
+      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 +120,10 @@ module RubyIndexer
         end
       end
 
-      @files_to_entries.delete(indexable.full_path)
+      @uris_to_entries.delete(key)
+      return if skip_require_paths_tree
 
-      require_path = indexable.require_path
+      require_path = uri.require_path
       @require_paths_tree.delete(require_path) if require_path
     end
 
@@ -88,7 +132,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 +141,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
@@ -115,8 +159,16 @@ module RubyIndexer
       )]))
     end
     def first_unqualified_const(name)
+      # Look for an exact match first
       _name, entries = @entries.find do |const_name, _entries|
-        const_name.end_with?(name)
+        const_name == name || const_name.end_with?("::#{name}")
+      end
+
+      # If an exact match is not found, then try to find a constant that ends with the name
+      unless entries
+        _name, entries = @entries.find do |const_name, _entries|
+          const_name.end_with?(name)
+        end
       end
 
       T.cast(
@@ -342,75 +394,70 @@ 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.
-      # binding.break
-      if @entries.any?
+      if @initial_indexing_completed
         raise IndexNotEmptyError,
           "The index is not empty. To prevent invalid entries, `index_all` can only be called once."
       end
 
+      @initial_indexing_completed = true
+
       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,29 +635,81 @@ 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_attached_ancestors(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]) }
+    sig do
+      params(name: String, owner_name: String).returns(T::Array[T.any(Entry::InstanceVariable, Entry::ClassVariable)])
+    end
     def instance_variable_completion_candidates(name, owner_name)
-      entries = T.cast(prefix_search(name).flatten, T::Array[Entry::InstanceVariable])
+      entries = T.cast(prefix_search(name).flatten, T::Array[T.any(Entry::InstanceVariable, Entry::ClassVariable)])
+      # Avoid wasting time linearizing ancestors if we didn't find anything
+      return entries if entries.empty?
+
       ancestors = linearized_ancestors_of(owner_name)
 
-      variables = entries.select { |e| ancestors.any?(e.owner&.name) }
+      instance_variables, class_variables = entries.partition { |e| e.is_a?(Entry::InstanceVariable) }
+      variables = instance_variables.select { |e| ancestors.any?(e.owner&.name) }
+
+      # Class variables are only owned by the attached class in our representation. If the owner is in a singleton
+      # context, we have to search for ancestors of the attached class
+      if class_variables.any?
+        name_parts = owner_name.split("::")
+
+        if name_parts.last&.start_with?("<Class:")
+          attached_name = T.must(name_parts[0..-2]).join("::")
+          attached_ancestors = linearized_ancestors_of(attached_name)
+          variables.concat(class_variables.select { |e| attached_ancestors.any?(e.owner&.name) })
+        else
+          variables.concat(class_variables.select { |e| ancestors.any?(e.owner&.name) })
+        end
+      end
+
       variables.uniq!(&:name)
       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])
+      # Avoid wasting time linearizing ancestors if we didn't find anything
+      return entries if entries.empty?
 
-      delete(indexable)
-      index_single(indexable)
+      ancestors = linearized_attached_ancestors(owner_name)
+      variables = entries.select { |e| ancestors.any?(e.owner&.name) }
+      variables.uniq!(&:name)
+      variables
+    end
 
-      updated_entries = @files_to_entries[indexable.full_path]
+    # 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. If a block is passed, the
+    # consumer of this API has to handle deleting and inserting/updating entries in the index instead of passing the
+    # document's source (used to handle unsaved changes to files)
+    sig do
+      params(uri: URI::Generic, source: T.nilable(String), block: T.nilable(T.proc.params(index: Index).void)).void
+    end
+    def handle_change(uri, source = nil, &block)
+      key = uri.to_s
+      original_entries = @uris_to_entries[key]
 
+      if block
+        block.call(self)
+      else
+        delete(uri)
+        index_single(uri, T.must(source))
+      end
+
+      updated_entries = @uris_to_entries[key]
       return unless original_entries && updated_entries
 
       # A change in one ancestor may impact several different others, which could be including that ancestor through
@@ -661,7 +760,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 +774,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)
@@ -688,6 +787,20 @@ module RubyIndexer
 
     private
 
+    # Always returns the linearized ancestors for the attached class, regardless of whether `name` refers to a singleton
+    # or attached namespace
+    sig { params(name: String).returns(T::Array[String]) }
+    def linearized_attached_ancestors(name)
+      name_parts = name.split("::")
+
+      if name_parts.last&.start_with?("<Class:")
+        attached_name = T.must(name_parts[0..-2]).join("::")
+        linearized_ancestors_of(attached_name)
+      else
+        linearized_ancestors_of(name)
+      end
+    end
+
     # Runs the registered included hooks
     sig { params(fully_qualified_name: String, nesting: T::Array[String]).void }
     def run_included_hooks(fully_qualified_name, nesting)

data/lib/ruby_indexer/lib/ruby_indexer/location.rb

@@ -44,5 +44,17 @@ module RubyIndexer
       @start_column = start_column
       @end_column = end_column
     end
+
+    sig do
+      params(
+        other: T.any(Location, Prism::Location),
+      ).returns(T::Boolean)
+    end
+    def ==(other)
+      start_line == other.start_line &&
+        end_line == other.end_line &&
+        start_column == other.start_column &&
+        end_column == other.end_column
+    end
   end
 end