ruby-lsp 0.10.1 → 0.11.1

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