ruby-lsp 0.10.1 → 0.11.1

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -28,10 +28,10 @@ module RubyLsp
         @uri = T.let(document.uri, URI::Generic)
       end
 
-      sig { override.returns(T.nilable(T.all(T::Array[Support::RuboCopDiagnostic], Object))) }
+      sig { override.returns(T.nilable(T.all(T::Array[Interface::Diagnostic], Object))) }
       def run
         # Running RuboCop is slow, so to avoid excessive runs we only do so if the file is syntactically valid
-        return if @document.syntax_error?
+        return syntax_error_diagnostics if @document.syntax_error?
 
         return unless defined?(Support::RuboCopDiagnosticsRunner)
 
@@ -39,7 +39,30 @@ module RubyLsp
         path = @uri.to_standardized_path
         return unless path.nil? || path.start_with?(T.must(WORKSPACE_URI.to_standardized_path))
 
-        Support::RuboCopDiagnosticsRunner.instance.run(@uri, @document)
+        Support::RuboCopDiagnosticsRunner.instance.run(@uri, @document).map!(&:to_lsp_diagnostic)
+      end
+
+      private
+
+      sig { returns(T.nilable(T::Array[Interface::Diagnostic])) }
+      def syntax_error_diagnostics
+        @document.parse_result.errors.map do |error|
+          Interface::Diagnostic.new(
+            range: Interface::Range.new(
+              start: Interface::Position.new(
+                line: error.location.start_line - 1,
+                character: error.location.start_column,
+              ),
+              end: Interface::Position.new(
+                line: error.location.end_line - 1,
+                character: error.location.end_column,
+              ),
+            ),
+            message: error.message,
+            severity: Constant::DiagnosticSeverity::ERROR,
+            source: "YARP",
+          )
+        end
       end
     end
   end

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -32,8 +32,8 @@ module RubyLsp
 
       sig do
         params(
-          target: T.nilable(SyntaxTree::Node),
-          parent: T.nilable(SyntaxTree::Node),
+          target: T.nilable(YARP::Node),
+          parent: T.nilable(YARP::Node),
           emitter: EventEmitter,
           message_queue: Thread::Queue,
         ).void
@@ -47,11 +47,21 @@ module RubyLsp
 
         highlight_target =
           case target
-          when *DIRECT_HIGHLIGHTS
+          when YARP::GlobalVariableReadNode, YARP::GlobalVariableAndWriteNode, YARP::GlobalVariableOperatorWriteNode,
+            YARP::GlobalVariableOrWriteNode, YARP::GlobalVariableTargetNode, YARP::GlobalVariableWriteNode,
+            YARP::InstanceVariableAndWriteNode, YARP::InstanceVariableOperatorWriteNode,
+            YARP::InstanceVariableOrWriteNode, YARP::InstanceVariableReadNode, YARP::InstanceVariableTargetNode,
+            YARP::InstanceVariableWriteNode, YARP::ConstantAndWriteNode, YARP::ConstantOperatorWriteNode,
+            YARP::ConstantOrWriteNode, YARP::ConstantPathAndWriteNode, YARP::ConstantPathNode,
+            YARP::ConstantPathOperatorWriteNode, YARP::ConstantPathOrWriteNode, YARP::ConstantPathTargetNode,
+            YARP::ConstantPathWriteNode, YARP::ConstantReadNode, YARP::ConstantTargetNode, YARP::ConstantWriteNode,
+            YARP::ClassVariableAndWriteNode, YARP::ClassVariableOperatorWriteNode, YARP::ClassVariableOrWriteNode,
+            YARP::ClassVariableReadNode, YARP::ClassVariableTargetNode, YARP::ClassVariableWriteNode,
+            YARP::LocalVariableAndWriteNode, YARP::LocalVariableOperatorWriteNode, YARP::LocalVariableOrWriteNode,
+            YARP::LocalVariableReadNode, YARP::LocalVariableTargetNode, YARP::LocalVariableWriteNode, YARP::CallNode,
+            YARP::BlockParameterNode, YARP::KeywordParameterNode, YARP::KeywordRestParameterNode,
+            YARP::OptionalParameterNode, YARP::RequiredParameterNode, YARP::RestParameterNode
             Support::HighlightTarget.new(target)
-          when SyntaxTree::Ident
-            relevant_node = parent.is_a?(SyntaxTree::Params) ? target : parent
-            Support::HighlightTarget.new(relevant_node)
           end
 
         @target = T.let(highlight_target, T.nilable(Support::HighlightTarget))
@@ -59,7 +69,7 @@ module RubyLsp
         emitter.register(self, :on_node) if @target
       end
 
-      sig { params(node: T.nilable(SyntaxTree::Node)).void }
+      sig { params(node: T.nilable(YARP::Node)).void }
       def on_node(node)
         return if node.nil?
 
@@ -69,20 +79,9 @@ module RubyLsp
 
       private
 
-      DIRECT_HIGHLIGHTS = T.let(
-        [
-          SyntaxTree::GVar,
-          SyntaxTree::IVar,
-          SyntaxTree::Const,
-          SyntaxTree::CVar,
-          SyntaxTree::VarField,
-        ],
-        T::Array[T.class_of(SyntaxTree::Node)],
-      )
-
       sig { params(match: Support::HighlightTarget::HighlightMatch).void }
       def add_highlight(match)
-        range = range_from_syntax_tree_node(match.node)
+        range = range_from_location(match.location)
         @_response << Interface::DocumentHighlight.new(range: range, kind: match.type)
       end
     end

data/lib/ruby_lsp/requests/document_link.rb

@@ -75,8 +75,15 @@ module RubyLsp
       sig { override.returns(ResponseType) }
       attr_reader :_response
 
-      sig { params(uri: URI::Generic, emitter: EventEmitter, message_queue: Thread::Queue).void }
-      def initialize(uri, emitter, message_queue)
+      sig do
+        params(
+          uri: URI::Generic,
+          comments: T::Array[YARP::Comment],
+          emitter: EventEmitter,
+          message_queue: Thread::Queue,
+        ).void
+      end
+      def initialize(uri, comments, emitter, message_queue)
         super(emitter, message_queue)
 
         # Match the version based on the version in the RBI file name. Notice that the `@` symbol is sanitized to `%40`
@@ -85,13 +92,49 @@ module RubyLsp
         version_match = path ? /(?<=%40)[\d.]+(?=\.rbi$)/.match(path) : nil
         @gem_version = T.let(version_match && version_match[0], T.nilable(String))
         @_response = T.let([], T::Array[Interface::DocumentLink])
+        @lines_to_comments = T.let(
+          comments.to_h do |comment|
+            [comment.location.end_line, comment]
+          end,
+          T::Hash[Integer, YARP::Comment],
+        )
 
-        emitter.register(self, :on_comment)
+        emitter.register(self, :on_def, :on_class, :on_module, :on_constant_write, :on_constant_path_write)
       end
 
-      sig { params(node: SyntaxTree::Comment).void }
-      def on_comment(node)
-        match = node.value.match(%r{source://.*#\d+$})
+      sig { params(node: YARP::DefNode).void }
+      def on_def(node)
+        extract_document_link(node)
+      end
+
+      sig { params(node: YARP::ClassNode).void }
+      def on_class(node)
+        extract_document_link(node)
+      end
+
+      sig { params(node: YARP::ModuleNode).void }
+      def on_module(node)
+        extract_document_link(node)
+      end
+
+      sig { params(node: YARP::ConstantWriteNode).void }
+      def on_constant_write(node)
+        extract_document_link(node)
+      end
+
+      sig { params(node: YARP::ConstantPathWriteNode).void }
+      def on_constant_path_write(node)
+        extract_document_link(node)
+      end
+
+      private
+
+      sig { params(node: YARP::Node).void }
+      def extract_document_link(node)
+        comment = @lines_to_comments[node.location.start_line - 1]
+        return unless comment
+
+        match = comment.location.slice.match(%r{source://.*#\d+$})
         return unless match
 
         uri = T.cast(URI(T.must(match[0])), URI::Source)
@@ -102,14 +145,12 @@ module RubyLsp
         return if file_path.nil?
 
         @_response << Interface::DocumentLink.new(
-          range: range_from_syntax_tree_node(node),
+          range: range_from_location(comment.location),
           target: "file://#{file_path}##{uri.line_number}",
           tooltip: "Jump to #{file_path}##{uri.line_number}",
         )
       end
 
-      private
-
       # Try to figure out the gem version for a source:// link. The order of precedence is:
       # 1. The version in the URI
       # 2. The version in the RBI file name

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -64,20 +64,21 @@ module RubyLsp
           self,
           :on_class,
           :after_class,
-          :on_command,
-          :on_const_path_field,
+          :on_call,
+          :on_constant_path_write,
+          :on_constant_write,
           :on_def,
           :after_def,
           :on_module,
           :after_module,
-          :on_top_const_field,
-          :on_var_field,
+          :on_instance_variable_write,
+          :on_class_variable_write,
         )
       end
 
-      sig { override.params(extension: RubyLsp::Extension).returns(T.nilable(Listener[ResponseType])) }
-      def initialize_external_listener(extension)
-        extension.create_document_symbol_listener(@emitter, @message_queue)
+      sig { override.params(addon: Addon).returns(T.nilable(Listener[ResponseType])) }
+      def initialize_external_listener(addon)
+        addon.create_document_symbol_listener(@emitter, @message_queue)
       end
 
       # Merges responses from other listeners
@@ -87,116 +88,122 @@ module RubyLsp
         self
       end
 
-      sig { params(node: SyntaxTree::ClassDeclaration).void }
+      sig { params(node: YARP::ClassNode).void }
       def on_class(node)
         @stack << create_document_symbol(
-          name: full_constant_name(node.constant),
+          name: node.constant_path.location.slice,
           kind: Constant::SymbolKind::CLASS,
-          range_node: node,
-          selection_range_node: node.constant,
+          range_location: node.location,
+          selection_range_location: node.constant_path.location,
         )
       end
 
-      sig { params(node: SyntaxTree::ClassDeclaration).void }
+      sig { params(node: YARP::ClassNode).void }
       def after_class(node)
         @stack.pop
       end
 
-      sig { params(node: SyntaxTree::Command).void }
-      def on_command(node)
-        return unless ATTR_ACCESSORS.include?(node.message.value)
+      sig { params(node: YARP::CallNode).void }
+      def on_call(node)
+        return unless ATTR_ACCESSORS.include?(node.name) && node.receiver.nil?
 
-        node.arguments.parts.each do |argument|
-          next unless argument.is_a?(SyntaxTree::SymbolLiteral)
+        arguments = node.arguments
+        return unless arguments
+
+        arguments.arguments.each do |argument|
+          next unless argument.is_a?(YARP::SymbolNode)
+
+          name = argument.value
+          next unless name
 
           create_document_symbol(
-            name: argument.value.value,
+            name: name,
             kind: Constant::SymbolKind::FIELD,
-            range_node: argument,
-            selection_range_node: argument.value,
+            range_location: argument.location,
+            selection_range_location: T.must(argument.value_loc),
           )
         end
       end
 
-      sig { params(node: SyntaxTree::ConstPathField).void }
-      def on_const_path_field(node)
+      sig { params(node: YARP::ConstantPathWriteNode).void }
+      def on_constant_path_write(node)
+        create_document_symbol(
+          name: node.target.location.slice,
+          kind: Constant::SymbolKind::CONSTANT,
+          range_location: node.location,
+          selection_range_location: node.target.location,
+        )
+      end
+
+      sig { params(node: YARP::ConstantWriteNode).void }
+      def on_constant_write(node)
         create_document_symbol(
-          name: node.constant.value,
+          name: node.name.to_s,
           kind: Constant::SymbolKind::CONSTANT,
-          range_node: node,
-          selection_range_node: node.constant,
+          range_location: node.location,
+          selection_range_location: node.name_loc,
+        )
+      end
+
+      sig { params(node: YARP::DefNode).void }
+      def after_def(node)
+        @stack.pop
+      end
+
+      sig { params(node: YARP::ModuleNode).void }
+      def on_module(node)
+        @stack << create_document_symbol(
+          name: node.constant_path.location.slice,
+          kind: Constant::SymbolKind::MODULE,
+          range_location: node.location,
+          selection_range_location: node.constant_path.location,
         )
       end
 
-      sig { params(node: SyntaxTree::DefNode).void }
+      sig { params(node: YARP::DefNode).void }
       def on_def(node)
-        target = node.target
+        receiver = node.receiver
 
-        if target.is_a?(SyntaxTree::VarRef) && target.value.is_a?(SyntaxTree::Kw) && target.value.value == "self"
-          name = "self.#{node.name.value}"
+        if receiver.is_a?(YARP::SelfNode)
+          name = "self.#{node.name}"
           kind = Constant::SymbolKind::METHOD
         else
-          name = node.name.value
+          name = node.name.to_s
           kind = name == "initialize" ? Constant::SymbolKind::CONSTRUCTOR : Constant::SymbolKind::METHOD
         end
 
         symbol = create_document_symbol(
           name: name,
           kind: kind,
-          range_node: node,
-          selection_range_node: node.name,
+          range_location: node.location,
+          selection_range_location: node.name_loc,
         )
 
         @stack << symbol
       end
 
-      sig { params(node: SyntaxTree::DefNode).void }
-      def after_def(node)
-        @stack.pop
-      end
-
-      sig { params(node: SyntaxTree::ModuleDeclaration).void }
-      def on_module(node)
-        @stack << create_document_symbol(
-          name: full_constant_name(node.constant),
-          kind: Constant::SymbolKind::MODULE,
-          range_node: node,
-          selection_range_node: node.constant,
-        )
-      end
-
-      sig { params(node: SyntaxTree::ModuleDeclaration).void }
+      sig { params(node: YARP::ModuleNode).void }
       def after_module(node)
         @stack.pop
       end
 
-      sig { params(node: SyntaxTree::TopConstField).void }
-      def on_top_const_field(node)
+      sig { params(node: YARP::InstanceVariableWriteNode).void }
+      def on_instance_variable_write(node)
         create_document_symbol(
-          name: node.constant.value,
-          kind: Constant::SymbolKind::CONSTANT,
-          range_node: node,
-          selection_range_node: node.constant,
+          name: node.name.to_s,
+          kind: Constant::SymbolKind::VARIABLE,
+          range_location: node.name_loc,
+          selection_range_location: node.name_loc,
         )
       end
 
-      sig { params(node: SyntaxTree::VarField).void }
-      def on_var_field(node)
-        value = node.value
-        kind = case value
-        when SyntaxTree::Const
-          Constant::SymbolKind::CONSTANT
-        when SyntaxTree::CVar, SyntaxTree::IVar
-          Constant::SymbolKind::VARIABLE
-        else
-          return
-        end
-
+      sig { params(node: YARP::ClassVariableWriteNode).void }
+      def on_class_variable_write(node)
         create_document_symbol(
-          name: value.value,
-          kind: kind,
-          range_node: node,
-          selection_range_node: value,
+          name: node.name.to_s,
+          kind: Constant::SymbolKind::VARIABLE,
+          range_location: node.name_loc,
+          selection_range_location: node.name_loc,
         )
       end
 
@@ -206,16 +213,16 @@ module RubyLsp
         params(
           name: String,
           kind: Integer,
-          range_node: SyntaxTree::Node,
-          selection_range_node: SyntaxTree::Node,
+          range_location: YARP::Location,
+          selection_range_location: YARP::Location,
         ).returns(Interface::DocumentSymbol)
       end
-      def create_document_symbol(name:, kind:, range_node:, selection_range_node:)
+      def create_document_symbol(name:, kind:, range_location:, selection_range_location:)
         symbol = Interface::DocumentSymbol.new(
           name: name,
           kind: kind,
-          range: range_from_syntax_tree_node(range_node),
-          selection_range: range_from_syntax_tree_node(selection_range_node),
+          range: range_from_location(range_location),
+          selection_range: range_from_location(selection_range_location),
           children: [],
         )