ruby-lsp 0.22.1 → 0.23.10

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/ruby_indexer/lib/ruby_indexer/reference_finder.rb

@@ -37,6 +37,19 @@ module RubyIndexer
       end
     end
 
+    class InstanceVariableTarget < Target
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      def initialize(name)
+        super()
+        @name = name
+      end
+    end
+
     class Reference
       extend T::Sig
 
@@ -62,12 +75,14 @@ module RubyIndexer
         target: Target,
         index: RubyIndexer::Index,
         dispatcher: Prism::Dispatcher,
+        uri: URI::Generic,
         include_declarations: T::Boolean,
       ).void
     end
-    def initialize(target, index, dispatcher, include_declarations: true)
+    def initialize(target, index, dispatcher, uri, include_declarations: true)
       @target = target
       @index = index
+      @uri = uri
       @include_declarations = include_declarations
       @stack = T.let([], T::Array[String])
       @references = T.let([], T::Array[Reference])
@@ -94,6 +109,12 @@ module RubyIndexer
         :on_constant_or_write_node_enter,
         :on_constant_and_write_node_enter,
         :on_constant_operator_write_node_enter,
+        :on_instance_variable_read_node_enter,
+        :on_instance_variable_write_node_enter,
+        :on_instance_variable_and_write_node_enter,
+        :on_instance_variable_operator_write_node_enter,
+        :on_instance_variable_or_write_node_enter,
+        :on_instance_variable_target_node_enter,
         :on_call_node_enter,
       )
     end
@@ -107,15 +128,7 @@ module RubyIndexer
 
     sig { params(node: Prism::ClassNode).void }
     def on_class_node_enter(node)
-      constant_path = node.constant_path
-      name = constant_path.slice
-      nesting = actual_nesting(name)
-
-      if @target.is_a?(ConstTarget) && nesting.join("::") == @target.fully_qualified_name
-        @references << Reference.new(name, constant_path.location, declaration: true)
-      end
-
-      @stack << name
+      @stack << node.constant_path.slice
     end
 
     sig { params(node: Prism::ClassNode).void }
@@ -125,15 +138,7 @@ module RubyIndexer
 
     sig { params(node: Prism::ModuleNode).void }
     def on_module_node_enter(node)
-      constant_path = node.constant_path
-      name = constant_path.slice
-      nesting = actual_nesting(name)
-
-      if @target.is_a?(ConstTarget) && nesting.join("::") == @target.fully_qualified_name
-        @references << Reference.new(name, constant_path.location, declaration: true)
-      end
-
-      @stack << name
+      @stack << node.constant_path.slice
     end
 
     sig { params(node: Prism::ModuleNode).void }
@@ -156,7 +161,7 @@ module RubyIndexer
 
     sig { params(node: Prism::ConstantPathNode).void }
     def on_constant_path_node_enter(node)
-      name = constant_name(node)
+      name = Index.constant_name(node)
       return unless name
 
       collect_constant_references(name, node.location)
@@ -164,7 +169,7 @@ module RubyIndexer
 
     sig { params(node: Prism::ConstantReadNode).void }
     def on_constant_read_node_enter(node)
-      name = constant_name(node)
+      name = Index.constant_name(node)
       return unless name
 
       collect_constant_references(name, node.location)
@@ -185,7 +190,7 @@ module RubyIndexer
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
 
-      name = constant_name(target)
+      name = Index.constant_name(target)
       return unless name
 
       collect_constant_references(name, target.location)
@@ -196,7 +201,7 @@ module RubyIndexer
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
 
-      name = constant_name(target)
+      name = Index.constant_name(target)
       return unless name
 
       collect_constant_references(name, target.location)
@@ -207,7 +212,7 @@ module RubyIndexer
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
 
-      name = constant_name(target)
+      name = Index.constant_name(target)
       return unless name
 
       collect_constant_references(name, target.location)
@@ -218,7 +223,7 @@ module RubyIndexer
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
 
-      name = constant_name(target)
+      name = Index.constant_name(target)
       return unless name
 
       collect_constant_references(name, target.location)
@@ -262,6 +267,36 @@ module RubyIndexer
       end
     end
 
+    sig { params(node: Prism::InstanceVariableReadNode).void }
+    def on_instance_variable_read_node_enter(node)
+      collect_instance_variable_references(node.name.to_s, node.location, false)
+    end
+
+    sig { params(node: Prism::InstanceVariableWriteNode).void }
+    def on_instance_variable_write_node_enter(node)
+      collect_instance_variable_references(node.name.to_s, node.name_loc, true)
+    end
+
+    sig { params(node: Prism::InstanceVariableAndWriteNode).void }
+    def on_instance_variable_and_write_node_enter(node)
+      collect_instance_variable_references(node.name.to_s, node.name_loc, true)
+    end
+
+    sig { params(node: Prism::InstanceVariableOperatorWriteNode).void }
+    def on_instance_variable_operator_write_node_enter(node)
+      collect_instance_variable_references(node.name.to_s, node.name_loc, true)
+    end
+
+    sig { params(node: Prism::InstanceVariableOrWriteNode).void }
+    def on_instance_variable_or_write_node_enter(node)
+      collect_instance_variable_references(node.name.to_s, node.name_loc, true)
+    end
+
+    sig { params(node: Prism::InstanceVariableTargetNode).void }
+    def on_instance_variable_target_node_enter(node)
+      collect_instance_variable_references(node.name.to_s, node.location, true)
+    end
+
     sig { params(node: Prism::CallNode).void }
     def on_call_node_enter(node)
       if @target.is_a?(MethodTarget) && (name = node.name.to_s) == @target.method_name
@@ -271,20 +306,6 @@ module RubyIndexer
 
     private
 
-    sig { params(name: String).returns(T::Array[String]) }
-    def actual_nesting(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
-
     sig { params(name: String, location: Prism::Location).void }
     def collect_constant_references(name, location)
       return unless @target.is_a?(ConstTarget)
@@ -292,33 +313,33 @@ module RubyIndexer
       entries = @index.resolve(name, @stack)
       return unless entries
 
-      previous_reference = @references.last
-
-      entries.each do |entry|
-        next unless entry.name == @target.fully_qualified_name
+      # Filter down to all constant declarations that match the expected name and type
+      matching_entries = entries.select do |e|
+        [
+          Entry::Namespace,
+          Entry::Constant,
+          Entry::ConstantAlias,
+          Entry::UnresolvedConstantAlias,
+        ].any? { |klass| e.is_a?(klass) } &&
+          e.name == @target.fully_qualified_name
+      end
 
-        # When processing a class/module declaration, we eagerly handle the constant reference. To avoid duplicates,
-        # when we find the constant node defining the namespace, then we have to check if it wasn't already added
-        next if previous_reference&.location == location
+      return if matching_entries.empty?
 
-        @references << Reference.new(name, location, declaration: false)
+      # If any of the matching entries have the same location as the constant and were
+      # defined in the same file, then it is that constant's declaration
+      declaration = matching_entries.any? do |e|
+        e.uri == @uri && e.name_location == location
       end
+
+      @references << Reference.new(name, location, declaration: declaration)
     end
 
-    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
+    sig { params(name: String, location: Prism::Location, declaration: T::Boolean).void }
+    def collect_instance_variable_references(name, location, declaration)
+      return unless @target.is_a?(InstanceVariableTarget) && name == @target.name
+
+      @references << Reference.new(name, location, declaration: declaration)
     end
   end
 end

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/lib/ruby_indexer/visibility_scope.rb

@@ -0,0 +1,36 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyIndexer
+  # Represents the visibility scope in a Ruby namespace. This keeps track of whether methods are in a public, private or
+  # protected section, and whether they are module functions.
+  class VisibilityScope
+    extend T::Sig
+
+    class << self
+      extend T::Sig
+
+      sig { returns(T.attached_class) }
+      def module_function_scope
+        new(module_func: true, visibility: Entry::Visibility::PRIVATE)
+      end
+
+      sig { returns(T.attached_class) }
+      def public_scope
+        new
+      end
+    end
+
+    sig { returns(Entry::Visibility) }
+    attr_reader :visibility
+
+    sig { returns(T::Boolean) }
+    attr_reader :module_func
+
+    sig { params(visibility: Entry::Visibility, module_func: T::Boolean).void }
+    def initialize(visibility: Entry::Visibility::PUBLIC, module_func: false)
+      @visibility = visibility
+      @module_func = module_func
+    end
+  end
+end

data/lib/ruby_indexer/ruby_indexer.rb

@@ -4,7 +4,8 @@
 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/visibility_scope"
 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
@@ -642,5 +647,24 @@ module RubyIndexer
       entry = @index["Foo"].first
       assert_empty(entry.comments)
     end
+
+    def test_singleton_inside_compact_namespace
+      index(<<~RUBY)
+        module Foo::Bar
+          class << self
+            def baz; end
+          end
+        end
+      RUBY
+
+      # Verify we didn't index the incorrect name
+      assert_nil(@index["Foo::Bar::<Class:Foo::Bar>"])
+
+      # Verify we indexed the correct name
+      assert_entry("Foo::Bar::<Class:Bar>", Entry::SingletonClass, "/fake/path/foo.rb:1-2:3-5")
+
+      method = @index["baz"]&.first
+      assert_equal("Foo::Bar::<Class:Bar>", method.owner.name)
+    end
   end
 end