ruby-lsp 0.23.11 → 0.26.1

data/lib/ruby_lsp/document.rb

@@ -2,80 +2,69 @@
 # frozen_string_literal: true
 
 module RubyLsp
+  # @abstract
+  #: [ParseResultType]
   class Document
-    class LanguageId < T::Enum
-      enums do
-        Ruby = new("ruby")
-        ERB = new("erb")
-        RBS = new("rbs")
-      end
-    end
-
-    extend T::Sig
-    extend T::Helpers
-    extend T::Generic
-
-    class LocationNotFoundError < StandardError; end
-    ParseResultType = type_member
+    class InvalidLocationError < StandardError; end
 
     # This maximum number of characters for providing expensive features, like semantic highlighting and diagnostics.
     # This is the same number used by the TypeScript extension in VS Code
     MAXIMUM_CHARACTERS_FOR_EXPENSIVE_FEATURES = 100_000
-    EMPTY_CACHE = T.let(Object.new.freeze, Object)
+    EMPTY_CACHE = Object.new.freeze #: Object
 
-    abstract!
-
-    sig { returns(ParseResultType) }
+    #: ParseResultType
     attr_reader :parse_result
 
-    sig { returns(String) }
+    #: String
     attr_reader :source
 
-    sig { returns(Integer) }
+    #: Integer
     attr_reader :version
 
-    sig { returns(URI::Generic) }
+    #: URI::Generic
     attr_reader :uri
 
-    sig { returns(Encoding) }
+    #: Encoding
     attr_reader :encoding
 
-    sig { returns(T.nilable(Edit)) }
+    #: Edit?
     attr_reader :last_edit
 
-    sig { returns(T.any(Interface::SemanticTokens, Object)) }
+    #: (Interface::SemanticTokens | Object)
     attr_accessor :semantic_tokens
 
-    sig { params(source: String, version: Integer, uri: URI::Generic, global_state: GlobalState).void }
+    #: (source: String, version: Integer, uri: URI::Generic, global_state: GlobalState) -> void
     def initialize(source:, version:, uri:, global_state:)
       @source = source
       @version = version
       @global_state = global_state
-      @cache = T.let(Hash.new(EMPTY_CACHE), T::Hash[String, T.untyped])
-      @semantic_tokens = T.let(EMPTY_CACHE, T.any(Interface::SemanticTokens, Object))
-      @encoding = T.let(global_state.encoding, Encoding)
-      @uri = T.let(uri, URI::Generic)
-      @needs_parsing = T.let(true, T::Boolean)
-      @parse_result = T.let(T.unsafe(nil), ParseResultType)
-      @last_edit = T.let(nil, T.nilable(Edit))
+      @cache = Hash.new(EMPTY_CACHE) #: Hash[String, untyped]
+      @semantic_tokens = EMPTY_CACHE #: (Interface::SemanticTokens | Object)
+      @encoding = global_state.encoding #: Encoding
+      @uri = uri #: URI::Generic
+      @needs_parsing = true #: bool
+      @last_edit = nil #: Edit?
+
+      # Workaround to be able to type parse_result properly. It is immediately set when invoking parse!
+      @parse_result = ( # rubocop:disable Style/RedundantParentheses
+        nil #: as untyped
+      ) #: ParseResultType
+
       parse!
     end
 
-    sig { params(other: Document[T.untyped]).returns(T::Boolean) }
+    #: (Document[untyped] other) -> bool
     def ==(other)
       self.class == other.class && uri == other.uri && @source == other.source
     end
 
-    sig { abstract.returns(LanguageId) }
-    def language_id; end
-
-    sig do
-      type_parameters(:T)
-        .params(
-          request_name: String,
-          block: T.proc.params(document: Document[ParseResultType]).returns(T.type_parameter(:T)),
-        ).returns(T.type_parameter(:T))
+    # @abstract
+    #: -> Symbol
+    def language_id
+      raise AbstractMethodInvokedError
     end
+
+    #: [T] (String request_name) { (Document[ParseResultType] document) -> T } -> T
     def cache_fetch(request_name, &block)
       cached = @cache[request_name]
       return cached if cached != EMPTY_CACHE
@@ -85,17 +74,22 @@ module RubyLsp
       result
     end
 
-    sig { type_parameters(:T).params(request_name: String, value: T.type_parameter(:T)).returns(T.type_parameter(:T)) }
+    #: [T] (String request_name, T value) -> T
     def cache_set(request_name, value)
       @cache[request_name] = value
     end
 
-    sig { params(request_name: String).returns(T.untyped) }
+    #: (String request_name) -> untyped
     def cache_get(request_name)
       @cache[request_name]
     end
 
-    sig { params(edits: T::Array[T::Hash[Symbol, T.untyped]], version: Integer).void }
+    #: (String request_name) -> void
+    def clear_cache(request_name)
+      @cache[request_name] = EMPTY_CACHE
+    end
+
+    #: (Array[Hash[Symbol, untyped]] edits, version: Integer) -> void
     def push_edits(edits, version:)
       edits.each do |edit|
         range = edit[:range]
@@ -126,49 +120,51 @@ module RubyLsp
     end
 
     # Returns `true` if the document was parsed and `false` if nothing needed parsing
-    sig { abstract.returns(T::Boolean) }
-    def parse!; end
+    # @abstract
+    #: -> bool
+    def parse!
+      raise AbstractMethodInvokedError
+    end
 
-    sig { abstract.returns(T::Boolean) }
-    def syntax_error?; end
+    # @abstract
+    #: -> bool
+    def syntax_error?
+      raise AbstractMethodInvokedError
+    end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def past_expensive_limit?
       @source.length > MAXIMUM_CHARACTERS_FOR_EXPENSIVE_FEATURES
     end
 
-    sig do
-      params(
-        start_pos: T::Hash[Symbol, T.untyped],
-        end_pos: T.nilable(T::Hash[Symbol, T.untyped]),
-      ).returns([Integer, T.nilable(Integer)])
-    end
+    #: (Hash[Symbol, untyped] start_pos, ?Hash[Symbol, untyped]? end_pos) -> [Integer, Integer?]
     def find_index_by_position(start_pos, end_pos = nil)
-      @global_state.synchronize do
-        scanner = create_scanner
-        start_index = scanner.find_char_position(start_pos)
-        end_index = scanner.find_char_position(end_pos) if end_pos
-        [start_index, end_index]
-      end
+      scanner = create_scanner
+      start_index = scanner.find_char_position(start_pos)
+      end_index = scanner.find_char_position(end_pos) if end_pos
+      [start_index, end_index]
     end
 
     private
 
-    sig { returns(Scanner) }
+    #: -> Scanner
     def create_scanner
-      Scanner.new(@source, @encoding)
+      case @encoding
+      when Encoding::UTF_8
+        Utf8Scanner.new(@source)
+      when Encoding::UTF_16LE
+        Utf16Scanner.new(@source)
+      else
+        Utf32Scanner.new(@source)
+      end
     end
 
+    # @abstract
     class Edit
-      extend T::Sig
-      extend T::Helpers
-
-      abstract!
-
-      sig { returns(T::Hash[Symbol, T.untyped]) }
+      #: Hash[Symbol, untyped]
       attr_reader :range
 
-      sig { params(range: T::Hash[Symbol, T.untyped]).void }
+      #: (Hash[Symbol, untyped] range) -> void
       def initialize(range)
         @range = range
       end
@@ -178,33 +174,114 @@ module RubyLsp
     class Replace < Edit; end
     class Delete < Edit; end
 
+    # Parent class for all position scanners. Scanners are used to translate a position given by the editor into a
+    # string index that we can use to find the right place in the document source. The logic for finding the correct
+    # index depends on the encoding negotiated with the editor, so we have different subclasses for each encoding.
+    # See https://microsoft.github.io/language-server-protocol/specification/#positionEncodingKind for more information
+    # @abstract
     class Scanner
-      extend T::Sig
-
-      LINE_BREAK = T.let(0x0A, Integer)
+      LINE_BREAK = 0x0A #: Integer
       # After character 0xFFFF, UTF-16 considers characters to have length 2 and we have to account for that
-      SURROGATE_PAIR_START = T.let(0xFFFF, Integer)
-
-      sig { params(source: String, encoding: Encoding).void }
-      def initialize(source, encoding)
-        @current_line = T.let(0, Integer)
-        @pos = T.let(0, Integer)
-        @source = T.let(source.codepoints, T::Array[Integer])
-        @encoding = encoding
+      SURROGATE_PAIR_START = 0xFFFF #: Integer
+
+      #: -> void
+      def initialize
+        @current_line = 0 #: Integer
+        @pos = 0 #: Integer
+      end
+
+      # Finds the character index inside the source string for a given line and column. This method always returns the
+      # character index regardless of whether we are searching positions based on bytes, code units, or codepoints.
+      # @abstract
+      #: (Hash[Symbol, untyped] position) -> Integer
+      def find_char_position(position)
+        raise AbstractMethodInvokedError
+      end
+    end
+
+    # For the UTF-8 encoding, positions correspond to bytes
+    class Utf8Scanner < Scanner
+      #: (String source) -> void
+      def initialize(source)
+        super()
+        @bytes = source.bytes #: Array[Integer]
+        @character_length = 0 #: Integer
+      end
+
+      # @override
+      #: (Hash[Symbol, untyped] position) -> Integer
+      def find_char_position(position)
+        # Each group of bytes is a character. We advance based on the number of bytes to count how many full characters
+        # we have in the requested offset
+        until @current_line == position[:line]
+          byte = @bytes[@pos] #: Integer?
+          raise InvalidLocationError unless byte
+
+          until LINE_BREAK == byte
+            @pos += character_byte_length(byte)
+            @character_length += 1
+            byte = @bytes[@pos]
+            raise InvalidLocationError unless byte
+          end
+
+          @pos += 1
+          @character_length += 1
+          @current_line += 1
+        end
+
+        # @character_length has the number of characters until the beginning of the line. We don't accumulate on it for
+        # the character part because locating the same position twice must return the same value
+        line_byte_offset = 0
+        line_characters = 0
+
+        while line_byte_offset < position[:character]
+          byte = @bytes[@pos + line_byte_offset] #: Integer?
+          raise InvalidLocationError unless byte
+
+          line_byte_offset += character_byte_length(byte)
+          line_characters += 1
+        end
+
+        @character_length + line_characters
+      end
+
+      private
+
+      #: (Integer) -> Integer
+      def character_byte_length(byte)
+        if byte < 0x80 # 1-byte character
+          1
+        elsif byte < 0xE0 # 2-byte character
+          2
+        elsif byte < 0xF0 # 3-byte character
+          3
+        else # 4-byte character
+          4
+        end
+      end
+    end
+
+    # For the UTF-16 encoding, positions correspond to UTF-16 code units, which count characters beyond the surrogate
+    # pair as length 2
+    class Utf16Scanner < Scanner
+      #: (String) -> void
+      def initialize(source)
+        super()
+        @codepoints = source.codepoints #: Array[Integer]
       end
 
-      # Finds the character index inside the source string for a given line and column
-      sig { params(position: T::Hash[Symbol, T.untyped]).returns(Integer) }
+      # @override
+      #: (Hash[Symbol, untyped] position) -> Integer
       def find_char_position(position)
         # Find the character index for the beginning of the requested line
         until @current_line == position[:line]
-          until LINE_BREAK == @source[@pos]
-            @pos += 1
+          codepoint = @codepoints[@pos] #: Integer?
+          raise InvalidLocationError unless codepoint
 
-            if @pos >= @source.length
-              # Pack the code points back into the original string to provide context in the error message
-              raise LocationNotFoundError, "Requested position: #{position}\nSource:\n\n#{@source.pack("U*")}"
-            end
+          until LINE_BREAK == @codepoints[@pos]
+            @pos += 1
+            codepoint = @codepoints[@pos] #: Integer?
+            raise InvalidLocationError unless codepoint
           end
 
           @pos += 1
@@ -213,29 +290,53 @@ module RubyLsp
 
         # The final position is the beginning of the line plus the requested column. If the encoding is UTF-16, we also
         # need to adjust for surrogate pairs
-        requested_position = @pos + position[:character]
+        line_characters = 0
+        line_code_units = 0
+
+        while line_code_units < position[:character]
+          code_point = @codepoints[@pos + line_characters]
+          raise InvalidLocationError unless code_point
+
+          line_code_units += if code_point > SURROGATE_PAIR_START
+            2 # Surrogate pair, so we skip the next code unit
+          else
+            1 # Single code unit character
+          end
 
-        if @encoding == Encoding::UTF_16LE
-          requested_position -= utf_16_character_position_correction(@pos, requested_position)
+          line_characters += 1
         end
 
-        requested_position
+        @pos + line_characters
       end
+    end
 
-      # Subtract 1 for each character after 0xFFFF in the current line from the column position, so that we hit the
-      # right character in the UTF-8 representation
-      sig { params(current_position: Integer, requested_position: Integer).returns(Integer) }
-      def utf_16_character_position_correction(current_position, requested_position)
-        utf16_unicode_correction = 0
+    # For the UTF-32 encoding, positions correspond directly to codepoints
+    class Utf32Scanner < Scanner
+      #: (String) -> void
+      def initialize(source)
+        super()
+        @codepoints = source.codepoints #: Array[Integer]
+      end
 
-        until current_position == requested_position
-          codepoint = @source[current_position]
-          utf16_unicode_correction += 1 if codepoint && codepoint > SURROGATE_PAIR_START
+      # @override
+      #: (Hash[Symbol, untyped] position) -> Integer
+      def find_char_position(position)
+        # Find the character index for the beginning of the requested line
+        until @current_line == position[:line]
+          codepoint = @codepoints[@pos] #: Integer?
+          raise InvalidLocationError unless codepoint
 
-          current_position += 1
+          until LINE_BREAK == @codepoints[@pos]
+            @pos += 1
+            codepoint = @codepoints[@pos] #: Integer?
+            raise InvalidLocationError unless codepoint
+          end
+
+          @pos += 1
+          @current_line += 1
         end
 
-        utf16_unicode_correction
+        @pos + position[:character]
       end
     end
   end

data/lib/ruby_lsp/erb_document.rb

@@ -2,36 +2,26 @@
 # frozen_string_literal: true
 
 module RubyLsp
+  #: [ParseResultType = Prism::ParseLexResult]
   class ERBDocument < Document
-    extend T::Sig
-    extend T::Generic
-
-    ParseResultType = type_member { { fixed: Prism::ParseResult } }
-
-    sig { returns(String) }
+    #: String
     attr_reader :host_language_source
 
-    sig do
-      returns(T.any(
-        T.proc.params(arg0: Integer).returns(Integer),
-        Prism::CodeUnitsCache,
-      ))
-    end
+    #: (^(Integer arg0) -> Integer | Prism::CodeUnitsCache)
     attr_reader :code_units_cache
 
-    sig { params(source: String, version: Integer, uri: URI::Generic, global_state: GlobalState).void }
+    #: (source: String, version: Integer, uri: URI::Generic, global_state: GlobalState) -> void
     def initialize(source:, version:, uri:, global_state:)
       # This has to be initialized before calling super because we call `parse` in the parent constructor, which
       # overrides this with the proper virtual host language source
-      @host_language_source = T.let("", String)
+      @host_language_source = "" #: String
       super
-      @code_units_cache = T.let(@parse_result.code_units_cache(@encoding), T.any(
-        T.proc.params(arg0: Integer).returns(Integer),
-        Prism::CodeUnitsCache,
-      ))
+      @code_units_cache =
+        @parse_result.code_units_cache(@encoding) #: (^(Integer arg0) -> Integer | Prism::CodeUnitsCache)
     end
 
-    sig { override.returns(T::Boolean) }
+    # @override
+    #: -> bool
     def parse!
       return false unless @needs_parsing
 
@@ -41,60 +31,60 @@ module RubyLsp
       @host_language_source = scanner.host_language
       # Use partial script to avoid syntax errors in ERB files where keywords may be used without the full context in
       # which they will be evaluated
-      @parse_result = Prism.parse(scanner.ruby, partial_script: true)
+      @parse_result = Prism.parse_lex(scanner.ruby, partial_script: true)
       @code_units_cache = @parse_result.code_units_cache(@encoding)
       true
     end
 
-    sig { override.returns(T::Boolean) }
+    #: -> Prism::ProgramNode
+    def ast
+      @parse_result.value.first
+    end
+
+    # @override
+    #: -> bool
     def syntax_error?
       @parse_result.failure?
     end
 
-    sig { override.returns(LanguageId) }
+    # @override
+    #: -> Symbol
     def language_id
-      LanguageId::ERB
+      :erb
     end
 
-    sig do
-      params(
-        position: T::Hash[Symbol, T.untyped],
-        node_types: T::Array[T.class_of(Prism::Node)],
-      ).returns(NodeContext)
-    end
+    #: (Hash[Symbol, untyped] position, ?node_types: Array[singleton(Prism::Node)]) -> NodeContext
     def locate_node(position, node_types: [])
       char_position, _ = find_index_by_position(position)
 
       RubyDocument.locate(
-        @parse_result.value,
+        ast,
         char_position,
         code_units_cache: @code_units_cache,
         node_types: node_types,
       )
     end
 
-    sig { params(char_position: Integer).returns(T.nilable(T::Boolean)) }
+    #: (Integer char_position) -> bool?
     def inside_host_language?(char_position)
       char = @host_language_source[char_position]
       char && char != " "
     end
 
     class ERBScanner
-      extend T::Sig
-
-      sig { returns(String) }
+      #: String
       attr_reader :ruby, :host_language
 
-      sig { params(source: String).void }
+      #: (String source) -> void
       def initialize(source)
         @source = source
-        @host_language = T.let(+"", String)
-        @ruby = T.let(+"", String)
-        @current_pos = T.let(0, Integer)
-        @inside_ruby = T.let(false, T::Boolean)
+        @host_language = +"" #: String
+        @ruby = +"" #: String
+        @current_pos = 0 #: Integer
+        @inside_ruby = false #: bool
       end
 
-      sig { void }
+      #: -> void
       def scan
         while @current_pos < @source.length
           scan_char
@@ -104,7 +94,7 @@ module RubyLsp
 
       private
 
-      sig { void }
+      #: -> void
       def scan_char
         char = @source[@current_pos]
 
@@ -123,7 +113,9 @@ module RubyLsp
               push_char(" ")
             end
           else
-            push_char(T.must(char))
+            push_char(
+              char, #: as !nil
+            )
           end
         when "-"
           if @inside_ruby && next_char == "%" &&
@@ -132,7 +124,9 @@ module RubyLsp
             push_char("   ")
             @inside_ruby = false
           else
-            push_char(T.must(char))
+            push_char(
+              char, #: as !nil
+            )
           end
         when "%"
           if @inside_ruby && next_char == ">"
@@ -140,7 +134,9 @@ module RubyLsp
             @current_pos += 1
             push_char("  ")
           else
-            push_char(T.must(char))
+            push_char(
+              char, #: as !nil
+            )
           end
         when "\r"
           @ruby << char
@@ -155,11 +151,13 @@ module RubyLsp
           @ruby << char
           @host_language << char
         else
-          push_char(T.must(char))
+          push_char(
+            char, #: as !nil
+          )
         end
       end
 
-      sig { params(char: String).void }
+      #: (String char) -> void
       def push_char(char)
         if @inside_ruby
           @ruby << char
@@ -170,7 +168,7 @@ module RubyLsp
         end
       end
 
-      sig { returns(String) }
+      #: -> String
       def next_char
         @source[@current_pos + 1] || ""
       end