ruby-lsp 0.17.12 → 0.17.14

data/lib/ruby_lsp/rbs_document.rb

@@ -0,0 +1,41 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  class RBSDocument < Document
+    extend T::Sig
+    extend T::Generic
+
+    ParseResultType = type_member { { fixed: T::Array[RBS::AST::Declarations::Base] } }
+
+    sig { params(source: String, version: Integer, uri: URI::Generic, encoding: Encoding).void }
+    def initialize(source:, version:, uri:, encoding: Encoding::UTF_8)
+      @syntax_error = T.let(false, T::Boolean)
+      super
+    end
+
+    sig { override.returns(ParseResultType) }
+    def parse
+      return @parse_result unless @needs_parsing
+
+      @needs_parsing = false
+
+      _, _, declarations = RBS::Parser.parse_signature(@source)
+      @syntax_error = false
+      @parse_result = declarations
+    rescue RBS::ParsingError
+      @syntax_error = true
+      @parse_result
+    end
+
+    sig { override.returns(T::Boolean) }
+    def syntax_error?
+      @syntax_error
+    end
+
+    sig { override.returns(LanguageId) }
+    def language_id
+      LanguageId::RBS
+    end
+  end
+end

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -38,7 +38,7 @@ module RubyLsp
         end
       end
 
-      sig { params(document: Document, code_action: T::Hash[Symbol, T.untyped]).void }
+      sig { params(document: RubyDocument, code_action: T::Hash[Symbol, T.untyped]).void }
       def initialize(document, code_action)
         super()
         @document = document
@@ -54,7 +54,7 @@ module RubyLsp
           refactor_variable
         when CodeActions::EXTRACT_TO_METHOD_TITLE
           refactor_method
-        when CodeActions::SWITCH_BLOCK_STYLE_TITLE
+        when CodeActions::TOGGLE_BLOCK_STYLE_TITLE
           switch_block_style
         else
           Error::UnknownCodeAction
@@ -81,7 +81,7 @@ module RubyLsp
         indentation = " " * target.location.start_column unless node.opening_loc.slice == "do"
 
         Interface::CodeAction.new(
-          title: CodeActions::SWITCH_BLOCK_STYLE_TITLE,
+          title: CodeActions::TOGGLE_BLOCK_STYLE_TITLE,
           edit: Interface::WorkspaceEdit.new(
             document_changes: [
               Interface::TextDocumentEdit.new(
@@ -112,7 +112,7 @@ module RubyLsp
         extracted_source = T.must(@document.source[start_index...end_index])
 
         # Find the closest statements node, so that we place the refactor in a valid position
-        node_context = @document
+        node_context = RubyDocument
           .locate(@document.parse_result.value, start_index, node_types: [Prism::StatementsNode, Prism::BlockNode])
 
         closest_statements = node_context.node
@@ -206,28 +206,44 @@ module RubyLsp
         extracted_source = T.must(@document.source[start_index...end_index])
 
         # Find the closest method declaration node, so that we place the refactor in a valid position
-        node_context = @document.locate(@document.parse_result.value, start_index, node_types: [Prism::DefNode])
-        closest_def = T.cast(node_context.node, Prism::DefNode)
-        return Error::InvalidTargetRange if closest_def.nil?
+        node_context = RubyDocument.locate(@document.parse_result.value, start_index, node_types: [Prism::DefNode])
+        closest_node = node_context.node
+        return Error::InvalidTargetRange unless closest_node
 
-        end_keyword_loc = closest_def.end_keyword_loc
-        return Error::InvalidTargetRange if end_keyword_loc.nil?
+        target_range = if closest_node.is_a?(Prism::DefNode)
+          end_keyword_loc = closest_node.end_keyword_loc
+          return Error::InvalidTargetRange unless end_keyword_loc
 
-        end_line = end_keyword_loc.end_line - 1
-        character = end_keyword_loc.end_column
-        indentation = " " * end_keyword_loc.start_column
-        target_range = {
-          start: { line: end_line, character: character },
-          end: { line: end_line, character: character },
-        }
+          end_line = end_keyword_loc.end_line - 1
+          character = end_keyword_loc.end_column
+          indentation = " " * end_keyword_loc.start_column
 
-        new_method_source = <<~RUBY.chomp
+          new_method_source = <<~RUBY.chomp
 
 
-          #{indentation}def #{NEW_METHOD_NAME}
-          #{indentation}  #{extracted_source}
-          #{indentation}end
-        RUBY
+            #{indentation}def #{NEW_METHOD_NAME}
+            #{indentation}  #{extracted_source}
+            #{indentation}end
+          RUBY
+
+          {
+            start: { line: end_line, character: character },
+            end: { line: end_line, character: character },
+          }
+        else
+          new_method_source = <<~RUBY
+            #{indentation}def #{NEW_METHOD_NAME}
+            #{indentation}  #{extracted_source.gsub("\n", "\n  ")}
+            #{indentation}end
+
+          RUBY
+
+          line = [0, source_range.dig(:start, :line) - 1].max
+          {
+            start: { line: line, character: source_range.dig(:start, :character) },
+            end: { line: line, character: source_range.dig(:start, :character) },
+          }
+        end
 
         Interface::CodeAction.new(
           title: CodeActions::EXTRACT_TO_METHOD_TITLE,

data/lib/ruby_lsp/requests/code_actions.rb

@@ -21,7 +21,7 @@ module RubyLsp
 
       EXTRACT_TO_VARIABLE_TITLE = "Refactor: Extract Variable"
       EXTRACT_TO_METHOD_TITLE = "Refactor: Extract Method"
-      SWITCH_BLOCK_STYLE_TITLE = "Refactor: Switch block style"
+      TOGGLE_BLOCK_STYLE_TITLE = "Refactor: Toggle block style"
 
       class << self
         extend T::Sig
@@ -37,7 +37,7 @@ module RubyLsp
 
       sig do
         params(
-          document: Document,
+          document: T.any(RubyDocument, ERBDocument),
           range: T::Hash[Symbol, T.untyped],
           context: T::Hash[Symbol, T.untyped],
         ).void
@@ -71,7 +71,7 @@ module RubyLsp
             data: { range: @range, uri: @uri.to_s },
           )
           code_actions << Interface::CodeAction.new(
-            title: SWITCH_BLOCK_STYLE_TITLE,
+            title: TOGGLE_BLOCK_STYLE_TITLE,
             kind: Constant::CodeActionKind::REFACTOR_REWRITE,
             data: { range: @range, uri: @uri.to_s },
           )

data/lib/ruby_lsp/requests/completion.rb

@@ -46,10 +46,10 @@ module RubyLsp
 
       sig do
         params(
-          document: Document,
+          document: T.any(RubyDocument, ERBDocument),
           global_state: GlobalState,
           params: T::Hash[Symbol, T.untyped],
-          sorbet_level: Document::SorbetLevel,
+          sorbet_level: RubyDocument::SorbetLevel,
           dispatcher: Prism::Dispatcher,
         ).void
       end
@@ -60,7 +60,7 @@ module RubyLsp
         # Completion always receives the position immediately after the character that was just typed. Here we adjust it
         # back by 1, so that we find the right node
         char_position = document.create_scanner.find_char_position(params[:position]) - 1
-        node_context = document.locate(
+        node_context = RubyDocument.locate(
           document.parse_result.value,
           char_position,
           node_types: [

data/lib/ruby_lsp/requests/definition.rb

@@ -38,11 +38,11 @@ module RubyLsp
 
       sig do
         params(
-          document: Document,
+          document: T.any(RubyDocument, ERBDocument),
           global_state: GlobalState,
           position: T::Hash[Symbol, T.untyped],
           dispatcher: Prism::Dispatcher,
-          sorbet_level: Document::SorbetLevel,
+          sorbet_level: RubyDocument::SorbetLevel,
         ).void
       end
       def initialize(document, global_state, position, dispatcher, sorbet_level)

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -32,7 +32,7 @@ module RubyLsp
         end
       end
 
-      sig { params(global_state: GlobalState, document: Document).void }
+      sig { params(global_state: GlobalState, document: RubyDocument).void }
       def initialize(global_state, document)
         super()
         @active_linters = T.let(global_state.active_linters, T::Array[Support::Formatter])

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -29,7 +29,7 @@ module RubyLsp
 
       sig do
         params(
-          document: Document,
+          document: T.any(RubyDocument, ERBDocument),
           position: T::Hash[Symbol, T.untyped],
           dispatcher: Prism::Dispatcher,
         ).void

data/lib/ruby_lsp/requests/formatting.rb

@@ -40,7 +40,7 @@ module RubyLsp
         end
       end
 
-      sig { params(global_state: GlobalState, document: Document).void }
+      sig { params(global_state: GlobalState, document: RubyDocument).void }
       def initialize(global_state, document)
         super()
         @document = document

data/lib/ruby_lsp/requests/hover.rb

@@ -32,11 +32,11 @@ module RubyLsp
 
       sig do
         params(
-          document: Document,
+          document: T.any(RubyDocument, ERBDocument),
           global_state: GlobalState,
           position: T::Hash[Symbol, T.untyped],
           dispatcher: Prism::Dispatcher,
-          sorbet_level: Document::SorbetLevel,
+          sorbet_level: RubyDocument::SorbetLevel,
         ).void
       end
       def initialize(document, global_state, position, dispatcher, sorbet_level)

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -52,7 +52,7 @@ module RubyLsp
 
       sig do
         params(
-          document: Document,
+          document: T.any(RubyDocument, ERBDocument),
           range: T::Hash[Symbol, T.untyped],
           hints_configuration: RequestConfig,
           dispatcher: Prism::Dispatcher,

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -42,7 +42,7 @@ module RubyLsp
 
       sig do
         params(
-          document: Document,
+          document: RubyDocument,
           position: T::Hash[Symbol, T.untyped],
           trigger_character: String,
           client_name: String,

data/lib/ruby_lsp/requests/prepare_type_hierarchy.rb

@@ -35,7 +35,7 @@ module RubyLsp
 
       sig do
         params(
-          document: Document,
+          document: T.any(RubyDocument, ERBDocument),
           index: RubyIndexer::Index,
           position: T::Hash[Symbol, T.untyped],
         ).void

data/lib/ruby_lsp/requests/selection_ranges.rb

@@ -23,7 +23,8 @@ module RubyLsp
     class SelectionRanges < Request
       extend T::Sig
       include Support::Common
-      sig { params(document: Document).void }
+
+      sig { params(document: T.any(RubyDocument, ERBDocument)).void }
       def initialize(document)
         super()
         @document = document

data/lib/ruby_lsp/requests/show_syntax_tree.rb

@@ -20,7 +20,7 @@ module RubyLsp
     class ShowSyntaxTree < Request
       extend T::Sig
 
-      sig { params(document: Document, range: T.nilable(T::Hash[Symbol, T.untyped])).void }
+      sig { params(document: RubyDocument, range: T.nilable(T::Hash[Symbol, T.untyped])).void }
       def initialize(document, range)
         super()
         @document = document

data/lib/ruby_lsp/requests/signature_help.rb

@@ -41,12 +41,12 @@ module RubyLsp
 
       sig do
         params(
-          document: Document,
+          document: T.any(RubyDocument, ERBDocument),
           global_state: GlobalState,
           position: T::Hash[Symbol, T.untyped],
           context: T.nilable(T::Hash[Symbol, T.untyped]),
           dispatcher: Prism::Dispatcher,
-          sorbet_level: Document::SorbetLevel,
+          sorbet_level: RubyDocument::SorbetLevel,
         ).void
       end
       def initialize(document, global_state, position, context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists

data/lib/ruby_lsp/requests/support/common.rb

@@ -209,9 +209,9 @@ module RubyLsp
           end
         end
 
-        sig { params(sorbet_level: Document::SorbetLevel).returns(T::Boolean) }
+        sig { params(sorbet_level: RubyDocument::SorbetLevel).returns(T::Boolean) }
         def sorbet_level_true_or_higher?(sorbet_level)
-          sorbet_level == Document::SorbetLevel::True || sorbet_level == Document::SorbetLevel::Strict
+          sorbet_level == RubyDocument::SorbetLevel::True || sorbet_level == RubyDocument::SorbetLevel::Strict
         end
       end
     end

data/lib/ruby_lsp/requests/support/formatter.rb

@@ -10,13 +10,13 @@ module RubyLsp
 
         interface!
 
-        sig { abstract.params(uri: URI::Generic, document: Document).returns(T.nilable(String)) }
+        sig { abstract.params(uri: URI::Generic, document: RubyDocument).returns(T.nilable(String)) }
         def run_formatting(uri, document); end
 
         sig do
           abstract.params(
             uri: URI::Generic,
-            document: Document,
+            document: RubyDocument,
           ).returns(T.nilable(T::Array[Interface::Diagnostic]))
         end
         def run_diagnostic(uri, document); end

data/lib/ruby_lsp/requests/support/rubocop_diagnostic.rb

@@ -31,7 +31,7 @@ module RubyLsp
 
         # TODO: avoid passing document once we have alternative ways to get at
         # encoding and file source
-        sig { params(document: Document, offense: RuboCop::Cop::Offense, uri: URI::Generic).void }
+        sig { params(document: RubyDocument, offense: RuboCop::Cop::Offense, uri: URI::Generic).void }
         def initialize(document, offense, uri)
           @document = document
           @offense = offense

data/lib/ruby_lsp/requests/support/rubocop_formatter.rb

@@ -17,7 +17,7 @@ module RubyLsp
           @format_runner = T.let(RuboCopRunner.new("-a"), RuboCopRunner)
         end
 
-        sig { override.params(uri: URI::Generic, document: Document).returns(T.nilable(String)) }
+        sig { override.params(uri: URI::Generic, document: RubyDocument).returns(T.nilable(String)) }
         def run_formatting(uri, document)
           filename = T.must(uri.to_standardized_path || uri.opaque)
 
@@ -29,7 +29,7 @@ module RubyLsp
         sig do
           override.params(
             uri: URI::Generic,
-            document: Document,
+            document: RubyDocument,
           ).returns(T.nilable(T::Array[Interface::Diagnostic]))
         end
         def run_diagnostic(uri, document)

data/lib/ruby_lsp/requests/support/syntax_tree_formatter.rb

@@ -29,7 +29,7 @@ module RubyLsp
             )
         end
 
-        sig { override.params(uri: URI::Generic, document: Document).returns(T.nilable(String)) }
+        sig { override.params(uri: URI::Generic, document: RubyDocument).returns(T.nilable(String)) }
         def run_formatting(uri, document)
           path = uri.to_standardized_path
           return if path && @options.ignore_files.any? { |pattern| File.fnmatch?("*/#{pattern}", path) }
@@ -40,7 +40,7 @@ module RubyLsp
         sig do
           override.params(
             uri: URI::Generic,
-            document: Document,
+            document: RubyDocument,
           ).returns(T.nilable(T::Array[Interface::Diagnostic]))
         end
         def run_diagnostic(uri, document)

data/lib/ruby_lsp/ruby_document.rb

@@ -3,7 +3,125 @@
 
 module RubyLsp
   class RubyDocument < Document
-    sig { override.returns(Prism::ParseResult) }
+    extend T::Sig
+    extend T::Generic
+
+    ParseResultType = type_member { { fixed: Prism::ParseResult } }
+
+    class SorbetLevel < T::Enum
+      enums do
+        None = new("none")
+        Ignore = new("ignore")
+        False = new("false")
+        True = new("true")
+        Strict = new("strict")
+      end
+    end
+
+    class << self
+      extend T::Sig
+
+      sig do
+        params(
+          node: Prism::Node,
+          char_position: Integer,
+          node_types: T::Array[T.class_of(Prism::Node)],
+        ).returns(NodeContext)
+      end
+      def locate(node, char_position, node_types: [])
+        queue = T.let(node.child_nodes.compact, T::Array[T.nilable(Prism::Node)])
+        closest = node
+        parent = T.let(nil, T.nilable(Prism::Node))
+        nesting_nodes = T.let(
+          [],
+          T::Array[T.any(
+            Prism::ClassNode,
+            Prism::ModuleNode,
+            Prism::SingletonClassNode,
+            Prism::DefNode,
+            Prism::BlockNode,
+            Prism::LambdaNode,
+            Prism::ProgramNode,
+          )],
+        )
+
+        nesting_nodes << node if node.is_a?(Prism::ProgramNode)
+        call_node = T.let(nil, T.nilable(Prism::CallNode))
+
+        until queue.empty?
+          candidate = queue.shift
+
+          # Skip nil child nodes
+          next if candidate.nil?
+
+          # 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
+          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_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_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_nodes.last
+          nesting_nodes.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
+          case candidate
+          when Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode, Prism::DefNode, Prism::BlockNode,
+            Prism::LambdaNode
+            nesting_nodes << candidate
+          end
+
+          if candidate.is_a?(Prism::CallNode)
+            arg_loc = candidate.arguments&.location
+            blk_loc = candidate.block&.location
+            if (arg_loc && (arg_loc.start_offset...arg_loc.end_offset).cover?(char_position)) ||
+                (blk_loc && (blk_loc.start_offset...blk_loc.end_offset).cover?(char_position))
+              call_node = candidate
+            end
+          end
+
+          # If there are node types to filter by, and the current node is not one of those types, then skip it
+          next if node_types.any? && node_types.none? { |type| candidate.class == type }
+
+          # 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_offset - loc.start_offset <= closest_loc.end_offset - closest_loc.start_offset
+            parent = closest
+            closest = candidate
+          end
+        end
+
+        # When targeting the constant part of a class/module definition, we do not want the nesting to be duplicated.
+        # That is, when targeting Bar in the following example:
+        #
+        # ```ruby
+        #   class Foo::Bar; end
+        # ```
+        # The correct target is `Foo::Bar` with an empty nesting. `Foo::Bar` should not appear in the nesting stack,
+        # even though the class/module node does indeed enclose the target, because it would lead to incorrect behavior
+        if closest.is_a?(Prism::ConstantReadNode) || closest.is_a?(Prism::ConstantPathNode)
+          last_level = nesting_nodes.last
+
+          if (last_level.is_a?(Prism::ModuleNode) || last_level.is_a?(Prism::ClassNode)) &&
+              last_level.constant_path == closest
+            nesting_nodes.pop
+          end
+        end
+
+        NodeContext.new(closest, parent, nesting_nodes, call_node)
+      end
+    end
+
+    sig { override.returns(ParseResultType) }
     def parse
       return @parse_result unless @needs_parsing
 
@@ -20,5 +138,69 @@ module RubyLsp
     def language_id
       LanguageId::Ruby
     end
+
+    sig { returns(SorbetLevel) }
+    def sorbet_level
+      sigil = parse_result.magic_comments.find do |comment|
+        comment.key == "typed"
+      end&.value
+
+      case sigil
+      when "ignore"
+        SorbetLevel::Ignore
+      when "false"
+        SorbetLevel::False
+      when "true"
+        SorbetLevel::True
+      when "strict", "strong"
+        SorbetLevel::Strict
+      else
+        SorbetLevel::None
+      end
+    end
+
+    sig do
+      params(
+        range: T::Hash[Symbol, T.untyped],
+        node_types: T::Array[T.class_of(Prism::Node)],
+      ).returns(T.nilable(Prism::Node))
+    end
+    def locate_first_within_range(range, node_types: [])
+      scanner = create_scanner
+      start_position = scanner.find_char_position(range[:start])
+      end_position = scanner.find_char_position(range[:end])
+      desired_range = (start_position...end_position)
+      queue = T.let(@parse_result.value.child_nodes.compact, T::Array[T.nilable(Prism::Node)])
+
+      until queue.empty?
+        candidate = queue.shift
+
+        # Skip nil child nodes
+        next if candidate.nil?
+
+        # 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
+        T.unsafe(queue).unshift(*candidate.child_nodes)
+
+        # Skip if the current node doesn't cover the desired position
+        loc = candidate.location
+
+        if desired_range.cover?(loc.start_offset...loc.end_offset) &&
+            (node_types.empty? || node_types.any? { |type| candidate.class == type })
+          return candidate
+        end
+      end
+    end
+
+    sig do
+      params(
+        position: T::Hash[Symbol, T.untyped],
+        node_types: T::Array[T.class_of(Prism::Node)],
+      ).returns(NodeContext)
+    end
+    def locate_node(position, node_types: [])
+      RubyDocument.locate(@parse_result.value, create_scanner.find_char_position(position), node_types: node_types)
+    end
   end
 end