ruby-lsp 0.11.1 → 0.12.0

data/lib/ruby_indexer/test/constant_test.rb

@@ -14,8 +14,8 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("FOO", Index::Entry::Constant, "/fake/path/foo.rb:0-0:0-7")
-      assert_entry("Bar::FOO", Index::Entry::Constant, "/fake/path/foo.rb:3-2:3-9")
+      assert_entry("FOO", Entry::Constant, "/fake/path/foo.rb:0-0:0-7")
+      assert_entry("Bar::FOO", Entry::Constant, "/fake/path/foo.rb:3-2:3-9")
     end
 
     def test_constant_or_writes
@@ -27,8 +27,8 @@ module RubyIndexer
         end
       RUBY
 
-      assert_entry("FOO", Index::Entry::Constant, "/fake/path/foo.rb:0-0:0-9")
-      assert_entry("Bar::FOO", Index::Entry::Constant, "/fake/path/foo.rb:3-2:3-11")
+      assert_entry("FOO", Entry::Constant, "/fake/path/foo.rb:0-0:0-9")
+      assert_entry("Bar::FOO", Entry::Constant, "/fake/path/foo.rb:3-2:3-11")
     end
 
     def test_constant_path_writes
@@ -45,10 +45,10 @@ module RubyIndexer
         A::BAZ = 1
       RUBY
 
-      assert_entry("A::FOO", Index::Entry::Constant, "/fake/path/foo.rb:1-2:1-9")
-      assert_entry("BAR", Index::Entry::Constant, "/fake/path/foo.rb:2-2:2-11")
-      assert_entry("A::B::FOO", Index::Entry::Constant, "/fake/path/foo.rb:5-4:5-11")
-      assert_entry("A::BAZ", Index::Entry::Constant, "/fake/path/foo.rb:9-0:9-10")
+      assert_entry("A::FOO", Entry::Constant, "/fake/path/foo.rb:1-2:1-9")
+      assert_entry("BAR", Entry::Constant, "/fake/path/foo.rb:2-2:2-11")
+      assert_entry("A::B::FOO", Entry::Constant, "/fake/path/foo.rb:5-4:5-11")
+      assert_entry("A::BAZ", Entry::Constant, "/fake/path/foo.rb:9-0:9-10")
     end
 
     def test_constant_path_or_writes
@@ -61,9 +61,9 @@ module RubyIndexer
         A::BAZ ||= 1
       RUBY
 
-      assert_entry("A::FOO", Index::Entry::Constant, "/fake/path/foo.rb:1-2:1-11")
-      assert_entry("BAR", Index::Entry::Constant, "/fake/path/foo.rb:2-2:2-13")
-      assert_entry("A::BAZ", Index::Entry::Constant, "/fake/path/foo.rb:5-0:5-12")
+      assert_entry("A::FOO", Entry::Constant, "/fake/path/foo.rb:1-2:1-11")
+      assert_entry("BAR", Entry::Constant, "/fake/path/foo.rb:2-2:2-13")
+      assert_entry("A::BAZ", Entry::Constant, "/fake/path/foo.rb:5-0:5-12")
     end
 
     def test_comments_for_constants
@@ -102,7 +102,7 @@ module RubyIndexer
         self.class::FOO = 1
       RUBY
 
-      assert_no_entry
+      assert_no_entries
     end
 
     def test_private_constant_indexing
@@ -197,12 +197,12 @@ module RubyIndexer
       RUBY
 
       unresolve_entry = @index["A::FIRST"].first
-      assert_instance_of(Index::Entry::UnresolvedAlias, unresolve_entry)
+      assert_instance_of(Entry::UnresolvedAlias, unresolve_entry)
       assert_equal(["A"], unresolve_entry.nesting)
       assert_equal("B::C", unresolve_entry.target)
 
       resolved_entry = @index.resolve("A::FIRST", []).first
-      assert_instance_of(Index::Entry::Alias, resolved_entry)
+      assert_instance_of(Entry::Alias, resolved_entry)
       assert_equal("A::B::C", resolved_entry.target)
     end
 
@@ -223,25 +223,25 @@ module RubyIndexer
       RUBY
 
       unresolve_entry = @index["A::ALIAS"].first
-      assert_instance_of(Index::Entry::UnresolvedAlias, unresolve_entry)
+      assert_instance_of(Entry::UnresolvedAlias, unresolve_entry)
       assert_equal(["A"], unresolve_entry.nesting)
       assert_equal("B", unresolve_entry.target)
 
       resolved_entry = @index.resolve("ALIAS", ["A"]).first
-      assert_instance_of(Index::Entry::Alias, resolved_entry)
+      assert_instance_of(Entry::Alias, resolved_entry)
       assert_equal("A::B", resolved_entry.target)
 
       resolved_entry = @index.resolve("ALIAS::C", ["A"]).first
-      assert_instance_of(Index::Entry::Module, resolved_entry)
+      assert_instance_of(Entry::Module, resolved_entry)
       assert_equal("A::B::C", resolved_entry.name)
 
       unresolve_entry = @index["Other::ONE_MORE"].first
-      assert_instance_of(Index::Entry::UnresolvedAlias, unresolve_entry)
+      assert_instance_of(Entry::UnresolvedAlias, unresolve_entry)
       assert_equal(["Other"], unresolve_entry.nesting)
       assert_equal("A::ALIAS", unresolve_entry.target)
 
       resolved_entry = @index.resolve("Other::ONE_MORE::C", []).first
-      assert_instance_of(Index::Entry::Module, resolved_entry)
+      assert_instance_of(Entry::Module, resolved_entry)
     end
 
     def test_indexing_same_line_constant_aliases
@@ -256,55 +256,136 @@ module RubyIndexer
 
       # B and C
       unresolve_entry = @index["A::B"].first
-      assert_instance_of(Index::Entry::UnresolvedAlias, unresolve_entry)
+      assert_instance_of(Entry::UnresolvedAlias, unresolve_entry)
       assert_equal(["A"], unresolve_entry.nesting)
       assert_equal("C", unresolve_entry.target)
 
       resolved_entry = @index.resolve("A::B", []).first
-      assert_instance_of(Index::Entry::Alias, resolved_entry)
+      assert_instance_of(Entry::Alias, resolved_entry)
       assert_equal("A::C", resolved_entry.target)
 
       constant = @index["A::C"].first
-      assert_instance_of(Index::Entry::Constant, constant)
+      assert_instance_of(Entry::Constant, constant)
 
       # D and E
       unresolve_entry = @index["A::D"].first
-      assert_instance_of(Index::Entry::UnresolvedAlias, unresolve_entry)
+      assert_instance_of(Entry::UnresolvedAlias, unresolve_entry)
       assert_equal(["A"], unresolve_entry.nesting)
       assert_equal("E", unresolve_entry.target)
 
       resolved_entry = @index.resolve("A::D", []).first
-      assert_instance_of(Index::Entry::Alias, resolved_entry)
+      assert_instance_of(Entry::Alias, resolved_entry)
       assert_equal("A::E", resolved_entry.target)
 
       # F and G::H
       unresolve_entry = @index["A::F"].first
-      assert_instance_of(Index::Entry::UnresolvedAlias, unresolve_entry)
+      assert_instance_of(Entry::UnresolvedAlias, unresolve_entry)
       assert_equal(["A"], unresolve_entry.nesting)
       assert_equal("G::H", unresolve_entry.target)
 
       resolved_entry = @index.resolve("A::F", []).first
-      assert_instance_of(Index::Entry::Alias, resolved_entry)
+      assert_instance_of(Entry::Alias, resolved_entry)
       assert_equal("A::G::H", resolved_entry.target)
 
       # I::J, K::L and M
       unresolve_entry = @index["A::I::J"].first
-      assert_instance_of(Index::Entry::UnresolvedAlias, unresolve_entry)
+      assert_instance_of(Entry::UnresolvedAlias, unresolve_entry)
       assert_equal(["A"], unresolve_entry.nesting)
       assert_equal("K::L", unresolve_entry.target)
 
       resolved_entry = @index.resolve("A::I::J", []).first
-      assert_instance_of(Index::Entry::Alias, resolved_entry)
+      assert_instance_of(Entry::Alias, resolved_entry)
       assert_equal("A::K::L", resolved_entry.target)
 
       # When we are resolving A::I::J, we invoke `resolve("K::L", ["A"])`, which recursively resolves A::K::L too.
       # Therefore, both A::I::J and A::K::L point to A::M by the end of the previous resolve invocation
       resolved_entry = @index["A::K::L"].first
-      assert_instance_of(Index::Entry::Alias, resolved_entry)
+      assert_instance_of(Entry::Alias, resolved_entry)
       assert_equal("A::M", resolved_entry.target)
 
       constant = @index["A::M"].first
-      assert_instance_of(Index::Entry::Constant, constant)
+      assert_instance_of(Entry::Constant, constant)
+    end
+
+    def test_indexing_or_and_operator_nodes
+      index(<<~RUBY)
+        A ||= 1
+        B &&= 2
+        C &= 3
+        D::E ||= 4
+        F::G &&= 5
+        H::I &= 6
+      RUBY
+
+      assert_entry("A", Entry::Constant, "/fake/path/foo.rb:0-0:0-7")
+      assert_entry("B", Entry::Constant, "/fake/path/foo.rb:1-0:1-7")
+      assert_entry("C", Entry::Constant, "/fake/path/foo.rb:2-0:2-6")
+      assert_entry("D::E", Entry::Constant, "/fake/path/foo.rb:3-0:3-10")
+      assert_entry("F::G", Entry::Constant, "/fake/path/foo.rb:4-0:4-10")
+      assert_entry("H::I", Entry::Constant, "/fake/path/foo.rb:5-0:5-9")
+    end
+
+    def test_indexing_constant_targets
+      index(<<~RUBY)
+        module A
+          B, C = [1, Y]
+          D::E, F::G = [Z, 4]
+          H, I::J = [5, B]
+          K, L = C
+        end
+
+        module Real
+          Z = 1
+          Y = 2
+        end
+      RUBY
+
+      assert_entry("A::B", Entry::Constant, "/fake/path/foo.rb:1-2:1-3")
+      assert_entry("A::C", Entry::UnresolvedAlias, "/fake/path/foo.rb:1-5:1-6")
+      assert_entry("A::D::E", Entry::UnresolvedAlias, "/fake/path/foo.rb:2-2:2-6")
+      assert_entry("A::F::G", Entry::Constant, "/fake/path/foo.rb:2-8:2-12")
+      assert_entry("A::H", Entry::Constant, "/fake/path/foo.rb:3-2:3-3")
+      assert_entry("A::I::J", Entry::UnresolvedAlias, "/fake/path/foo.rb:3-5:3-9")
+      assert_entry("A::K", Entry::Constant, "/fake/path/foo.rb:4-2:4-3")
+      assert_entry("A::L", Entry::Constant, "/fake/path/foo.rb:4-5:4-6")
+    end
+
+    def test_indexing_constant_targets_with_splats
+      index(<<~RUBY)
+        A, *, B = baz
+        C, = bar
+        (D, E) = baz
+        F, G = *baz, qux
+        H, I = [baz, *qux]
+        J, L = [*something, String]
+        M = [String]
+      RUBY
+
+      assert_entry("A", Entry::Constant, "/fake/path/foo.rb:0-0:0-1")
+      assert_entry("B", Entry::Constant, "/fake/path/foo.rb:0-6:0-7")
+      assert_entry("D", Entry::Constant, "/fake/path/foo.rb:2-1:2-2")
+      assert_entry("E", Entry::Constant, "/fake/path/foo.rb:2-4:2-5")
+      assert_entry("F", Entry::Constant, "/fake/path/foo.rb:3-0:3-1")
+      assert_entry("G", Entry::Constant, "/fake/path/foo.rb:3-3:3-4")
+      assert_entry("H", Entry::Constant, "/fake/path/foo.rb:4-0:4-1")
+      assert_entry("I", Entry::Constant, "/fake/path/foo.rb:4-3:4-4")
+      assert_entry("J", Entry::Constant, "/fake/path/foo.rb:5-0:5-1")
+      assert_entry("L", Entry::Constant, "/fake/path/foo.rb:5-3:5-4")
+      assert_entry("M", Entry::Constant, "/fake/path/foo.rb:6-0:6-12")
+    end
+
+    def test_indexing_destructuring_an_array
+      index(<<~RUBY)
+        Baz = [1, 2]
+        Foo, Bar = Baz
+        This, That = foo, bar
+      RUBY
+
+      assert_entry("Baz", Entry::Constant, "/fake/path/foo.rb:0-0:0-12")
+      assert_entry("Foo", Entry::Constant, "/fake/path/foo.rb:1-0:1-3")
+      assert_entry("Bar", Entry::Constant, "/fake/path/foo.rb:1-5:1-8")
+      assert_entry("This", Entry::Constant, "/fake/path/foo.rb:2-0:2-4")
+      assert_entry("That", Entry::Constant, "/fake/path/foo.rb:2-6:2-10")
     end
   end
 end

data/lib/ruby_indexer/test/index_test.rb

@@ -178,5 +178,20 @@ module RubyIndexer
 
       assert_equal("Bar", entries.first.name)
     end
+
+    def test_resolving_aliases_to_non_existing_constants_with_conflicting_names
+      @index.index_single(IndexablePath.new("/fake", "/fake/path/foo.rb"), <<~RUBY)
+        module Foo
+          class Float < self
+            INFINITY = ::Float::INFINITY
+          end
+        end
+      RUBY
+
+      entry = @index.resolve("INFINITY", ["Foo", "Float"]).first
+      refute_nil(entry)
+
+      assert_instance_of(Entry::UnresolvedAlias, entry)
+    end
   end
 end

data/lib/ruby_indexer/test/method_test.rb

@@ -0,0 +1,73 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "test_case"
+
+module RubyIndexer
+  class MethodTest < TestCase
+    def test_method_with_no_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar
+          end
+        end
+      RUBY
+
+      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+    end
+
+    def test_singleton_method_using_self_receiver
+      index(<<~RUBY)
+        class Foo
+          def self.bar
+          end
+        end
+      RUBY
+
+      assert_entry("bar", Entry::SingletonMethod, "/fake/path/foo.rb:1-2:2-5")
+    end
+
+    def test_singleton_method_using_other_receiver_is_not_indexed
+      index(<<~RUBY)
+        class Foo
+          def String.bar
+          end
+        end
+      RUBY
+
+      assert_no_entry("bar")
+    end
+
+    def test_method_with_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar(a)
+          end
+        end
+      RUBY
+
+      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      entry = T.must(@index["bar"].first)
+      assert_equal(1, entry.parameters.length)
+      parameter = entry.parameters.first
+      assert_equal(:a, parameter.name)
+      assert_instance_of(Entry::RequiredParameter, parameter)
+    end
+
+    def test_method_with_destructed_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar((a, (b, )))
+          end
+        end
+      RUBY
+
+      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      entry = T.must(@index["bar"].first)
+      assert_equal(1, entry.parameters.length)
+      parameter = entry.parameters.first
+      assert_equal(:"(a, (b, ))", parameter.name)
+      assert_instance_of(Entry::RequiredParameter, parameter)
+    end
+  end
+end

data/lib/ruby_indexer/test/test_case.rb

@@ -35,8 +35,12 @@ module RubyIndexer
       assert_nil(entries, "Expected #{expected_name} to not be indexed")
     end
 
-    def assert_no_entry
+    def assert_no_entries
       assert_empty(@index.instance_variable_get(:@entries), "Expected nothing to be indexed")
     end
+
+    def assert_no_entry(entry)
+      refute(@index.instance_variable_get(:@entries).key?(entry), "Expected '#{entry}' to not be indexed")
+    end
   end
 end

data/lib/ruby_lsp/addon.rb

@@ -110,31 +110,31 @@ module RubyLsp
     sig do
       overridable.params(
         uri: URI::Generic,
-        emitter: EventEmitter,
+        dispatcher: Prism::Dispatcher,
         message_queue: Thread::Queue,
       ).returns(T.nilable(Listener[T::Array[Interface::CodeLens]]))
     end
-    def create_code_lens_listener(uri, emitter, message_queue); end
+    def create_code_lens_listener(uri, dispatcher, message_queue); end
 
     # Creates a new Hover listener. This method is invoked on every Hover request
     sig do
       overridable.params(
         nesting: T::Array[String],
         index: RubyIndexer::Index,
-        emitter: EventEmitter,
+        dispatcher: Prism::Dispatcher,
         message_queue: Thread::Queue,
       ).returns(T.nilable(Listener[T.nilable(Interface::Hover)]))
     end
-    def create_hover_listener(nesting, index, emitter, message_queue); end
+    def create_hover_listener(nesting, index, dispatcher, message_queue); end
 
     # Creates a new DocumentSymbol listener. This method is invoked on every DocumentSymbol request
     sig do
       overridable.params(
-        emitter: EventEmitter,
+        dispatcher: Prism::Dispatcher,
         message_queue: Thread::Queue,
       ).returns(T.nilable(Listener[T::Array[Interface::DocumentSymbol]]))
     end
-    def create_document_symbol_listener(emitter, message_queue); end
+    def create_document_symbol_listener(dispatcher, message_queue); end
 
     # Creates a new Definition listener. This method is invoked on every Definition request
     sig do
@@ -142,10 +142,10 @@ module RubyLsp
         uri: URI::Generic,
         nesting: T::Array[String],
         index: RubyIndexer::Index,
-        emitter: EventEmitter,
+        dispatcher: Prism::Dispatcher,
         message_queue: Thread::Queue,
       ).returns(T.nilable(Listener[T.nilable(T.any(T::Array[Interface::Location], Interface::Location))]))
     end
-    def create_definition_listener(uri, nesting, index, emitter, message_queue); end
+    def create_definition_listener(uri, nesting, index, dispatcher, message_queue); end
   end
 end

data/lib/ruby_lsp/document.rb

@@ -9,7 +9,7 @@ module RubyLsp
     RangeShape = T.type_alias { { start: PositionShape, end: PositionShape } }
     EditShape = T.type_alias { { range: RangeShape, text: String } }
 
-    sig { returns(YARP::ParseResult) }
+    sig { returns(Prism::ParseResult) }
     attr_reader :parse_result
 
     sig { returns(String) }
@@ -29,15 +29,15 @@ module RubyLsp
       @version = T.let(version, Integer)
       @uri = T.let(uri, URI::Generic)
       @needs_parsing = T.let(false, T::Boolean)
-      @parse_result = T.let(YARP.parse(@source), YARP::ParseResult)
+      @parse_result = T.let(Prism.parse(@source), Prism::ParseResult)
     end
 
-    sig { returns(YARP::ProgramNode) }
+    sig { returns(Prism::ProgramNode) }
     def tree
       @parse_result.value
     end
 
-    sig { returns(T::Array[YARP::Comment]) }
+    sig { returns(T::Array[Prism::Comment]) }
     def comments
       @parse_result.comments
     end
@@ -96,7 +96,7 @@ module RubyLsp
       return unless @needs_parsing
 
       @needs_parsing = false
-      @parse_result = YARP.parse(@source)
+      @parse_result = Prism.parse(@source)
     end
 
     sig { returns(T::Boolean) }
@@ -112,8 +112,8 @@ module RubyLsp
     sig do
       params(
         position: PositionShape,
-        node_types: T::Array[T.class_of(YARP::Node)],
-      ).returns([T.nilable(YARP::Node), T.nilable(YARP::Node), T::Array[String]])
+        node_types: T::Array[T.class_of(Prism::Node)],
+      ).returns([T.nilable(Prism::Node), T.nilable(Prism::Node), T::Array[String]])
     end
     def locate_node(position, node_types: [])
       locate(@parse_result.value, create_scanner.find_char_position(position), node_types: node_types)
@@ -121,16 +121,16 @@ module RubyLsp
 
     sig do
       params(
-        node: YARP::Node,
+        node: Prism::Node,
         char_position: Integer,
-        node_types: T::Array[T.class_of(YARP::Node)],
-      ).returns([T.nilable(YARP::Node), T.nilable(YARP::Node), T::Array[String]])
+        node_types: T::Array[T.class_of(Prism::Node)],
+      ).returns([T.nilable(Prism::Node), T.nilable(Prism::Node), T::Array[String]])
     end
     def locate(node, char_position, node_types: [])
-      queue = T.let(node.child_nodes.compact, T::Array[T.nilable(YARP::Node)])
+      queue = T.let(node.child_nodes.compact, T::Array[T.nilable(Prism::Node)])
       closest = node
-      parent = T.let(nil, T.nilable(YARP::Node))
-      nesting = T.let([], T::Array[T.any(YARP::ClassNode, YARP::ModuleNode)])
+      parent = T.let(nil, T.nilable(Prism::Node))
+      nesting = T.let([], T::Array[T.any(Prism::ClassNode, Prism::ModuleNode)])
 
       until queue.empty?
         candidate = queue.shift
@@ -158,7 +158,7 @@ module RubyLsp
 
         # Keep track of the nesting where we found the target. This is used to determine the fully qualified name of the
         # target when it is a constant
-        if candidate.is_a?(YARP::ClassNode) || candidate.is_a?(YARP::ModuleNode)
+        if candidate.is_a?(Prism::ClassNode) || candidate.is_a?(Prism::ModuleNode)
           nesting << candidate
         end