ruby-lsp 0.10.0 → 0.11.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-6")
-      assert_entry("Bar::FOO", Index::Entry::Constant, "/fake/path/foo.rb:3-2:3-8")
+      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")
     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-8")
-      assert_entry("Bar::FOO", Index::Entry::Constant, "/fake/path/foo.rb:3-2:3-10")
+      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")
     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-8")
-      assert_entry("BAR", Index::Entry::Constant, "/fake/path/foo.rb:2-2:2-10")
-      assert_entry("A::B::FOO", Index::Entry::Constant, "/fake/path/foo.rb:5-4:5-10")
-      assert_entry("A::BAZ", Index::Entry::Constant, "/fake/path/foo.rb:9-0:9-9")
+      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")
     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-10")
-      assert_entry("BAR", Index::Entry::Constant, "/fake/path/foo.rb:2-2:2-12")
-      assert_entry("A::BAZ", Index::Entry::Constant, "/fake/path/foo.rb:5-0:5-11")
+      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")
     end
 
     def test_comments_for_constants
@@ -104,5 +104,207 @@ module RubyIndexer
 
       assert_no_entry
     end
+
+    def test_private_constant_indexing
+      index(<<~RUBY)
+        class A
+          B = 1
+          private_constant(:B)
+
+          C = 2
+          private_constant("C")
+
+          D = 1
+        end
+      RUBY
+
+      b_const = @index["A::B"].first
+      assert_equal(:private, b_const.visibility)
+
+      c_const = @index["A::C"].first
+      assert_equal(:private, c_const.visibility)
+
+      d_const = @index["A::D"].first
+      assert_equal(:public, d_const.visibility)
+    end
+
+    def test_marking_constants_as_private_reopening_namespaces
+      index(<<~RUBY)
+        module A
+          module B
+            CONST_A = 1
+            private_constant(:CONST_A)
+
+            CONST_B = 2
+            CONST_C = 3
+          end
+
+          module B
+            private_constant(:CONST_B)
+          end
+        end
+
+        module A
+          module B
+            private_constant(:CONST_C)
+          end
+        end
+      RUBY
+
+      a_const = @index["A::B::CONST_A"].first
+      assert_equal(:private, a_const.visibility)
+
+      b_const = @index["A::B::CONST_B"].first
+      assert_equal(:private, b_const.visibility)
+
+      c_const = @index["A::B::CONST_C"].first
+      assert_equal(:private, c_const.visibility)
+    end
+
+    def test_marking_constants_as_private_with_receiver
+      index(<<~RUBY)
+        module A
+          module B
+            CONST_A = 1
+            CONST_B = 2
+          end
+
+          B.private_constant(:CONST_A)
+        end
+
+        A::B.private_constant(:CONST_B)
+      RUBY
+
+      a_const = @index["A::B::CONST_A"].first
+      assert_equal(:private, a_const.visibility)
+
+      b_const = @index["A::B::CONST_B"].first
+      assert_equal(:private, b_const.visibility)
+    end
+
+    def test_indexing_constant_aliases
+      index(<<~RUBY)
+        module A
+          module B
+            module C
+            end
+          end
+
+          FIRST = B::C
+        end
+
+        SECOND = A::FIRST
+      RUBY
+
+      unresolve_entry = @index["A::FIRST"].first
+      assert_instance_of(Index::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_equal("A::B::C", resolved_entry.target)
+    end
+
+    def test_aliasing_namespaces
+      index(<<~RUBY)
+        module A
+          module B
+            module C
+            end
+          end
+
+          ALIAS = B
+        end
+
+        module Other
+          ONE_MORE = A::ALIAS
+        end
+      RUBY
+
+      unresolve_entry = @index["A::ALIAS"].first
+      assert_instance_of(Index::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_equal("A::B", resolved_entry.target)
+
+      resolved_entry = @index.resolve("ALIAS::C", ["A"]).first
+      assert_instance_of(Index::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_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)
+    end
+
+    def test_indexing_same_line_constant_aliases
+      index(<<~RUBY)
+        module A
+          B = C = 1
+          D = E ||= 1
+          F = G::H &&= 1
+          I::J = K::L = M = 1
+        end
+      RUBY
+
+      # B and C
+      unresolve_entry = @index["A::B"].first
+      assert_instance_of(Index::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_equal("A::C", resolved_entry.target)
+
+      constant = @index["A::C"].first
+      assert_instance_of(Index::Entry::Constant, constant)
+
+      # D and E
+      unresolve_entry = @index["A::D"].first
+      assert_instance_of(Index::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_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_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_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_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_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_equal("A::M", resolved_entry.target)
+
+      constant = @index["A::M"].first
+      assert_instance_of(Index::Entry::Constant, constant)
+    end
   end
 end

data/lib/ruby_indexer/test/index_test.rb

@@ -158,5 +158,25 @@ module RubyIndexer
       results = @index.prefix_search("Ba", ["Foo"]).map { |entries| entries.map(&:name) }
       assert_equal([["Foo::Bar", "Foo::Bar"], ["Foo::Baz"]], results)
     end
+
+    def test_resolve_normalizes_top_level_names
+      @index.index_single(IndexablePath.new("/fake", "/fake/path/foo.rb"), <<~RUBY)
+        class Bar; end
+
+        module Foo
+          class Bar; end
+        end
+      RUBY
+
+      entries = @index.resolve("::Foo::Bar", [])
+      refute_nil(entries)
+
+      assert_equal("Foo::Bar", entries.first.name)
+
+      entries = @index.resolve("::Bar", ["Foo"])
+      refute_nil(entries)
+
+      assert_equal("Bar", entries.first.name)
+    end
   end
 end

data/lib/ruby_lsp/{extension.rb → addon.rb}

@@ -2,24 +2,24 @@
 # frozen_string_literal: true
 
 module RubyLsp
-  # To register an extension, inherit from this class and implement both `name` and `activate`
+  # To register an addon, inherit from this class and implement both `name` and `activate`
   #
   # # Example
   #
   # ```ruby
   # module MyGem
-  #   class MyExtension < Extension
+  #   class MyAddon < Addon
   #     def activate
   #       # Perform any relevant initialization
   #     end
   #
   #     def name
-  #       "My extension name"
+  #       "My addon name"
   #     end
   #   end
   # end
   # ```
-  class Extension
+  class Addon
     extend T::Sig
     extend T::Helpers
 
@@ -28,37 +28,37 @@ module RubyLsp
     class << self
       extend T::Sig
 
-      # Automatically track and instantiate extension classes
-      sig { params(child_class: T.class_of(Extension)).void }
+      # Automatically track and instantiate addon classes
+      sig { params(child_class: T.class_of(Addon)).void }
       def inherited(child_class)
-        extensions << child_class.new
+        addons << child_class.new
         super
       end
 
-      sig { returns(T::Array[Extension]) }
-      def extensions
-        @extensions ||= T.let([], T.nilable(T::Array[Extension]))
+      sig { returns(T::Array[Addon]) }
+      def addons
+        @addons ||= T.let([], T.nilable(T::Array[Addon]))
       end
 
-      # Discovers and loads all extensions. Returns the list of activated extensions
-      sig { returns(T::Array[Extension]) }
-      def load_extensions
-        # Require all extensions entry points, which should be placed under
-        # `some_gem/lib/ruby_lsp/your_gem_name/extension.rb`
-        Gem.find_files("ruby_lsp/**/extension.rb").each do |extension|
-          require File.expand_path(extension)
+      # Discovers and loads all addons. Returns the list of activated addons
+      sig { returns(T::Array[Addon]) }
+      def load_addons
+        # Require all addons entry points, which should be placed under
+        # `some_gem/lib/ruby_lsp/your_gem_name/addon.rb`
+        Gem.find_files("ruby_lsp/**/addon.rb").each do |addon|
+          require File.expand_path(addon)
         rescue => e
           warn(e.message)
           warn(e.backtrace.to_s) # rubocop:disable Lint/RedundantStringCoercion
         end
 
-        # Activate each one of the discovered extensions. If any problems occur in the extensions, we don't want to
+        # Activate each one of the discovered addons. If any problems occur in the addons, we don't want to
         # fail to boot the server
-        extensions.each do |extension|
-          extension.activate
+        addons.each do |addon|
+          addon.activate
           nil
         rescue => e
-          extension.add_error(e)
+          addon.add_error(e)
         end
       end
     end
@@ -92,17 +92,17 @@ module RubyLsp
       @errors.filter_map(&:backtrace).join("\n\n")
     end
 
-    # Each extension should implement `MyExtension#activate` and use to perform any sort of initialization, such as
+    # Each addon should implement `MyAddon#activate` and use to perform any sort of initialization, such as
     # reading information into memory or even spawning a separate process
     sig { abstract.void }
     def activate; end
 
-    # Each extension should implement `MyExtension#deactivate` and use to perform any clean up, like shutting down a
+    # Each addon should implement `MyAddon#deactivate` and use to perform any clean up, like shutting down a
     # child process
     sig { abstract.void }
     def deactivate; end
 
-    # Extensions should override the `name` method to return the extension name
+    # Addons should override the `name` method to return the addon name
     sig { abstract.returns(String) }
     def name; end
 
@@ -119,11 +119,13 @@ module RubyLsp
     # 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,
         message_queue: Thread::Queue,
       ).returns(T.nilable(Listener[T.nilable(Interface::Hover)]))
     end
-    def create_hover_listener(emitter, message_queue); end
+    def create_hover_listener(nesting, index, emitter, message_queue); end
 
     # Creates a new DocumentSymbol listener. This method is invoked on every DocumentSymbol request
     sig do

data/lib/ruby_lsp/check_docs.rb

@@ -5,9 +5,9 @@ require "ruby_lsp/internal"
 require "objspace"
 
 module RubyLsp
-  # This rake task checks that all requests or extensions are fully documented. Add the rake task to your Rakefile and
-  # specify the absolute path for all files that must be required in order to discover all listeners and their
-  # related GIFs
+  # This rake task checks that all requests or addons are fully documented. Add the rake task to your Rakefile and
+  # specify the absolute path for all files that must be required in order to discover all listeners and their related
+  # GIFs
   #
   #   # Rakefile
   #   request_files = FileList.new("#{__dir__}/lib/ruby_lsp/requests/*.rb") do |fl|
@@ -53,8 +53,7 @@ module RubyLsp
       # documented
       features = ObjectSpace.each_object(Class).filter_map do |k|
         klass = T.unsafe(k)
-        klass if klass < RubyLsp::Requests::BaseRequest ||
-          (klass < RubyLsp::Listener && klass != RubyLsp::ExtensibleListener)
+        klass if klass < Requests::BaseRequest || (klass < Listener && klass != ExtensibleListener)
       end
 
       missing_docs = T.let(Hash.new { |h, k| h[k] = [] }, T::Hash[String, T::Array[String]])
@@ -82,14 +81,14 @@ module RubyLsp
           T.must(missing_docs[class_name]) << "No documentation found"
         elsif !%r{\(https://microsoft.github.io/language-server-protocol/specification#.*\)}.match?(documentation)
           T.must(missing_docs[class_name]) << <<~DOCS
-            Missing specification link. Requests and extensions should include a link to the LSP specification for the
+            Missing specification link. Requests and addons should include a link to the LSP specification for the
             related feature. For example:
 
             [Inlay hint](https://microsoft.github.io/language-server-protocol/specification#textDocument_inlayHint)
           DOCS
         elsif !documentation.include?("# Example")
           T.must(missing_docs[class_name]) << <<~DOCS
-            Missing example. Requests and extensions should include a code example that explains what the feature does.
+            Missing example. Requests and addons should include a code example that explains what the feature does.
 
             # # Example
             # ```ruby
@@ -99,7 +98,7 @@ module RubyLsp
           DOCS
         elsif !/\[.* demo\]\(.*\.gif\)/.match?(documentation)
           T.must(missing_docs[class_name]) << <<~DOCS
-            Missing demonstration GIF. Each request and extension must be documented with a GIF that shows the feature
+            Missing demonstration GIF. Each request and addon must be documented with a GIF that shows the feature
             working. For example:
 
             # [Inlay hint demo](../../inlay_hint.gif)

data/lib/ruby_lsp/document.rb

@@ -9,8 +9,8 @@ module RubyLsp
     RangeShape = T.type_alias { { start: PositionShape, end: PositionShape } }
     EditShape = T.type_alias { { range: RangeShape, text: String } }
 
-    sig { returns(T.nilable(SyntaxTree::Node)) }
-    attr_reader :tree
+    sig { returns(YARP::ParseResult) }
+    attr_reader :parse_result
 
     sig { returns(String) }
     attr_reader :source
@@ -28,11 +28,18 @@ module RubyLsp
       @source = T.let(source, String)
       @version = T.let(version, Integer)
       @uri = T.let(uri, URI::Generic)
-      @unparsed_edits = T.let([], T::Array[EditShape])
-      @syntax_error = T.let(false, T::Boolean)
-      @tree = T.let(SyntaxTree.parse(@source), T.nilable(SyntaxTree::Node))
-    rescue SyntaxTree::Parser::ParseError
-      @syntax_error = true
+      @needs_parsing = T.let(false, T::Boolean)
+      @parse_result = T.let(YARP.parse(@source), YARP::ParseResult)
+    end
+
+    sig { returns(YARP::ProgramNode) }
+    def tree
+      @parse_result.value
+    end
+
+    sig { returns(T::Array[YARP::Comment]) }
+    def comments
+      @parse_result.comments
     end
 
     sig { params(other: Document).returns(T::Boolean) }
@@ -80,29 +87,21 @@ module RubyLsp
       end
 
       @version = version
-      @unparsed_edits.concat(edits)
+      @needs_parsing = true
       @cache.clear
     end
 
     sig { void }
     def parse
-      return if @unparsed_edits.empty?
+      return unless @needs_parsing
 
-      @unparsed_edits.clear
-      @tree = SyntaxTree.parse(@source)
-      @syntax_error = false
-    rescue SyntaxTree::Parser::ParseError
-      @syntax_error = true
+      @needs_parsing = false
+      @parse_result = YARP.parse(@source)
     end
 
     sig { returns(T::Boolean) }
     def syntax_error?
-      @syntax_error
-    end
-
-    sig { returns(T::Boolean) }
-    def parsed?
-      !@tree.nil?
+      @parse_result.failure?
     end
 
     sig { returns(Scanner) }
@@ -113,27 +112,25 @@ module RubyLsp
     sig do
       params(
         position: PositionShape,
-        node_types: T::Array[T.class_of(SyntaxTree::Node)],
-      ).returns([T.nilable(SyntaxTree::Node), T.nilable(SyntaxTree::Node), T::Array[String]])
+        node_types: T::Array[T.class_of(YARP::Node)],
+      ).returns([T.nilable(YARP::Node), T.nilable(YARP::Node), T::Array[String]])
     end
     def locate_node(position, node_types: [])
-      return [nil, nil, []] unless parsed?
-
-      locate(T.must(@tree), create_scanner.find_char_position(position), node_types: node_types)
+      locate(@parse_result.value, create_scanner.find_char_position(position), node_types: node_types)
     end
 
     sig do
       params(
-        node: SyntaxTree::Node,
+        node: YARP::Node,
         char_position: Integer,
-        node_types: T::Array[T.class_of(SyntaxTree::Node)],
-      ).returns([T.nilable(SyntaxTree::Node), T.nilable(SyntaxTree::Node), T::Array[String]])
+        node_types: T::Array[T.class_of(YARP::Node)],
+      ).returns([T.nilable(YARP::Node), T.nilable(YARP::Node), T::Array[String]])
     end
     def locate(node, char_position, node_types: [])
-      queue = T.let(node.child_nodes.compact, T::Array[T.nilable(SyntaxTree::Node)])
+      queue = T.let(node.child_nodes.compact, T::Array[T.nilable(YARP::Node)])
       closest = node
-      parent = T.let(nil, T.nilable(SyntaxTree::Node))
-      nesting = T.let([], T::Array[T.any(SyntaxTree::ClassDeclaration, SyntaxTree::ModuleDeclaration)])
+      parent = T.let(nil, T.nilable(YARP::Node))
+      nesting = T.let([], T::Array[T.any(YARP::ClassNode, YARP::ModuleNode)])
 
       until queue.empty?
         candidate = queue.shift
@@ -144,24 +141,24 @@ module RubyLsp
         # Add the next child_nodes to the queue to be processed. The order here is important! We want to move in the
         # same order as the visiting mechanism, which means searching the child nodes before moving on to the next
         # sibling
-        queue.unshift(*candidate.child_nodes)
+        T.unsafe(queue).unshift(*candidate.child_nodes)
 
         # Skip if the current node doesn't cover the desired position
         loc = candidate.location
-        next unless (loc.start_char...loc.end_char).cover?(char_position)
+        next unless (loc.start_offset...loc.end_offset).cover?(char_position)
 
         # If the node's start character is already past the position, then we should've found the closest node
         # already
-        break if char_position < loc.start_char
+        break if char_position < loc.start_offset
 
         # If the candidate starts after the end of the previous nesting level, then we've exited that nesting level and
         # need to pop the stack
         previous_level = nesting.last
-        nesting.pop if previous_level && candidate.start_char > previous_level.end_char
+        nesting.pop if previous_level && loc.start_offset > previous_level.location.end_offset
 
         # 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?(SyntaxTree::ClassDeclaration) || candidate.is_a?(SyntaxTree::ModuleDeclaration)
+        if candidate.is_a?(YARP::ClassNode) || candidate.is_a?(YARP::ModuleNode)
           nesting << candidate
         end
 
@@ -170,13 +167,13 @@ module RubyLsp
 
         # If the current node is narrower than or equal to the previous closest node, then it is more precise
         closest_loc = closest.location
-        if loc.end_char - loc.start_char <= closest_loc.end_char - closest_loc.start_char
+        if loc.end_offset - loc.start_offset <= closest_loc.end_offset - closest_loc.start_offset
           parent = closest
           closest = candidate
         end
       end
 
-      [closest, parent, nesting.map { |n| n.constant.constant.value }]
+      [closest, parent, nesting.map { |n| n.constant_path.location.slice }]
     end
 
     class Scanner