ruby-lsp 0.23.11 → 0.26.1

data/lib/ruby_lsp/response_builders/response_builder.rb

@@ -3,14 +3,13 @@
 
 module RubyLsp
   module ResponseBuilders
+    # @abstract
     class ResponseBuilder
-      extend T::Sig
-      extend T::Generic
-
-      abstract!
-
-      sig { abstract.returns(T.anything) }
-      def response; end
+      # @abstract
+      #: -> top
+      def response
+        raise AbstractMethodInvokedError
+      end
     end
   end
 end

data/lib/ruby_lsp/response_builders/semantic_highlighting.rb

@@ -3,71 +3,57 @@
 
 module RubyLsp
   module ResponseBuilders
+    #: [ResponseType = Interface::SemanticTokens]
     class SemanticHighlighting < ResponseBuilder
       class UndefinedTokenType < StandardError; end
 
-      extend T::Sig
-
-      TOKEN_TYPES = T.let(
-        {
-          namespace: 0,
-          type: 1,
-          class: 2,
-          enum: 3,
-          interface: 4,
-          struct: 5,
-          typeParameter: 6,
-          parameter: 7,
-          variable: 8,
-          property: 9,
-          enumMember: 10,
-          event: 11,
-          function: 12,
-          method: 13,
-          macro: 14,
-          keyword: 15,
-          modifier: 16,
-          comment: 17,
-          string: 18,
-          number: 19,
-          regexp: 20,
-          operator: 21,
-          decorator: 22,
-        }.freeze,
-        T::Hash[Symbol, Integer],
-      )
-
-      TOKEN_MODIFIERS = T.let(
-        {
-          declaration: 0,
-          definition: 1,
-          readonly: 2,
-          static: 3,
-          deprecated: 4,
-          abstract: 5,
-          async: 6,
-          modification: 7,
-          documentation: 8,
-          default_library: 9,
-        }.freeze,
-        T::Hash[Symbol, Integer],
-      )
-
-      ResponseType = type_member { { fixed: Interface::SemanticTokens } }
-
-      sig do
-        params(code_units_cache: T.any(
-          T.proc.params(arg0: Integer).returns(Integer),
-          Prism::CodeUnitsCache,
-        )).void
-      end
+      TOKEN_TYPES = {
+        namespace: 0,
+        type: 1,
+        class: 2,
+        enum: 3,
+        interface: 4,
+        struct: 5,
+        typeParameter: 6,
+        parameter: 7,
+        variable: 8,
+        property: 9,
+        enumMember: 10,
+        event: 11,
+        function: 12,
+        method: 13,
+        macro: 14,
+        keyword: 15,
+        modifier: 16,
+        comment: 17,
+        string: 18,
+        number: 19,
+        regexp: 20,
+        operator: 21,
+        decorator: 22,
+      }.freeze #: Hash[Symbol, Integer]
+
+      TOKEN_MODIFIERS = {
+        declaration: 0,
+        definition: 1,
+        readonly: 2,
+        static: 3,
+        deprecated: 4,
+        abstract: 5,
+        async: 6,
+        modification: 7,
+        documentation: 8,
+        default_library: 9,
+      }.freeze #: Hash[Symbol, Integer]
+
+      #: ((^(Integer arg0) -> Integer | Prism::CodeUnitsCache) code_units_cache) -> void
       def initialize(code_units_cache)
         super()
         @code_units_cache = code_units_cache
-        @stack = T.let([], T::Array[SemanticToken])
+        @stack = [] #: Array[SemanticToken]
       end
 
-      sig { params(location: Prism::Location, type: Symbol, modifiers: T::Array[Symbol]).void }
+      #: (Prism::Location location, Symbol type, ?Array[Symbol] modifiers) -> void
       def add_token(location, type, modifiers = [])
         end_code_unit = location.cached_end_code_units_offset(@code_units_cache)
         length = end_code_unit - location.cached_start_code_units_offset(@code_units_cache)
@@ -77,13 +63,13 @@ module RubyLsp
             start_line: location.start_line,
             start_code_unit_column: location.cached_start_code_units_column(@code_units_cache),
             length: length,
-            type: T.must(TOKEN_TYPES[type]),
+            type: TOKEN_TYPES[type], #: as !nil
             modifier: modifiers_indices,
           ),
         )
       end
 
-      sig { params(location: Prism::Location).returns(T::Boolean) }
+      #: (Prism::Location location) -> bool
       def last_token_matches?(location)
         token = @stack.last
         return false unless token
@@ -92,43 +78,34 @@ module RubyLsp
           token.start_code_unit_column == location.cached_start_code_units_column(@code_units_cache)
       end
 
-      sig { returns(T.nilable(SemanticToken)) }
+      #: -> SemanticToken?
       def last
         @stack.last
       end
 
-      sig { override.returns(T::Array[SemanticToken]) }
+      # @override
+      #: -> Array[SemanticToken]
       def response
         @stack
       end
 
       class SemanticToken
-        extend T::Sig
-
-        sig { returns(Integer) }
+        #: Integer
         attr_reader :start_line
 
-        sig { returns(Integer) }
+        #: Integer
         attr_reader :start_code_unit_column
 
-        sig { returns(Integer) }
+        #: Integer
         attr_reader :length
 
-        sig { returns(Integer) }
+        #: Integer
         attr_reader :type
 
-        sig { returns(T::Array[Integer]) }
+        #: Array[Integer]
         attr_reader :modifier
 
-        sig do
-          params(
-            start_line: Integer,
-            start_code_unit_column: Integer,
-            length: Integer,
-            type: Integer,
-            modifier: T::Array[Integer],
-          ).void
-        end
+        #: (start_line: Integer, start_code_unit_column: Integer, length: Integer, type: Integer, modifier: Array[Integer]) -> void
         def initialize(start_line:, start_code_unit_column:, length:, type:, modifier:)
           @start_line = start_line
           @start_code_unit_column = start_code_unit_column
@@ -137,7 +114,7 @@ module RubyLsp
           @modifier = modifier
         end
 
-        sig { params(type_symbol: Symbol).void }
+        #: (Symbol type_symbol) -> void
         def replace_type(type_symbol)
           type_int = TOKEN_TYPES[type_symbol]
           raise UndefinedTokenType, "Undefined token type: #{type_symbol}" unless type_int
@@ -145,7 +122,7 @@ module RubyLsp
           @type = type_int
         end
 
-        sig { params(modifier_symbols: T::Array[Symbol]).void }
+        #: (Array[Symbol] modifier_symbols) -> void
         def replace_modifier(modifier_symbols)
           @modifier = modifier_symbols.filter_map do |modifier_symbol|
             modifier_index = TOKEN_MODIFIERS[modifier_symbol]
@@ -157,19 +134,13 @@ module RubyLsp
       end
 
       class SemanticTokenEncoder
-        extend T::Sig
-
-        sig { void }
+        #: -> void
         def initialize
-          @current_row = T.let(0, Integer)
-          @current_column = T.let(0, Integer)
+          @current_row = 0 #: Integer
+          @current_column = 0 #: Integer
         end
 
-        sig do
-          params(
-            tokens: T::Array[SemanticToken],
-          ).returns(T::Array[Integer])
-        end
+        #: (Array[SemanticToken] tokens) -> Array[Integer]
         def encode(tokens)
           sorted_tokens = tokens.sort_by.with_index do |token, index|
             # Enumerable#sort_by is not deterministic when the compared values are equal.
@@ -194,7 +165,7 @@ module RubyLsp
 
         # For more information on how each number is calculated, read:
         # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_semanticTokens
-        sig { params(token: SemanticToken).returns(T::Array[Integer]) }
+        #: (SemanticToken token) -> Array[Integer]
         def compute_delta(token)
           row = token.start_line - 1
           column = token.start_code_unit_column
@@ -216,7 +187,7 @@ module RubyLsp
         # For example, [:default_library] will be encoded as
         # 0b1000000000, as :default_library is the 10th bit according
         # to the token modifiers index map.
-        sig { params(modifiers: T::Array[Integer]).returns(Integer) }
+        #: (Array[Integer] modifiers) -> Integer
         def encode_modifiers(modifiers)
           modifiers.inject(0) do |encoded_modifiers, modifier|
             encoded_modifiers | (1 << modifier)

data/lib/ruby_lsp/response_builders/signature_help.rb

@@ -3,23 +3,21 @@
 
 module RubyLsp
   module ResponseBuilders
+    #: [ResponseType = Interface::SignatureHelp?]
     class SignatureHelp < ResponseBuilder
-      extend T::Sig
-
-      ResponseType = type_member { { fixed: T.nilable(Interface::SignatureHelp) } }
-
-      sig { void }
+      #: -> void
       def initialize
         super
-        @signature_help = T.let(nil, ResponseType)
+        @signature_help = nil #: ResponseType
       end
 
-      sig { params(signature_help: ResponseType).void }
+      #: (ResponseType signature_help) -> void
       def replace(signature_help)
         @signature_help = signature_help
       end
 
-      sig { override.returns(ResponseType) }
+      # @override
+      #: -> ResponseType
       def response
         @signature_help
       end

data/lib/ruby_lsp/response_builders/test_collection.rb

@@ -3,33 +3,55 @@
 
 module RubyLsp
   module ResponseBuilders
+    #: [ResponseType = Requests::Support::TestItem]
     class TestCollection < ResponseBuilder
-      class DuplicateIdError < StandardError; end
+      #: Array[Interface::CodeLens]
+      attr_reader :code_lens
 
-      extend T::Sig
-      extend T::Generic
-
-      ResponseType = type_member { { fixed: Requests::Support::TestItem } }
-
-      sig { void }
+      #: -> void
       def initialize
         super
-        @items = T.let({}, T::Hash[String, ResponseType])
+        @items = {} #: Hash[String, ResponseType]
+        @code_lens = [] #: Array[Interface::CodeLens]
       end
 
-      sig { params(item: ResponseType).void }
+      #: (ResponseType item) -> void
       def add(item)
-        raise DuplicateIdError, "TestItem ID is already in use" if @items.key?(item.id)
-
         @items[item.id] = item
       end
 
-      sig { params(id: String).returns(T.nilable(ResponseType)) }
+      #: (ResponseType item) -> void
+      def add_code_lens(item)
+        arguments = [item.uri.to_standardized_path, item.id]
+        start = item.range.start
+        range = Interface::Range.new(
+          start: start,
+          end: Interface::Position.new(line: start.line, character: start.character + 1),
+        )
+
+        @code_lens << Interface::CodeLens.new(
+          range: range,
+          data: { arguments: arguments, kind: "run_test" },
+        )
+
+        @code_lens << Interface::CodeLens.new(
+          range: range,
+          data: { arguments: arguments, kind: "run_test_in_terminal" },
+        )
+
+        @code_lens << Interface::CodeLens.new(
+          range: range,
+          data: { arguments: arguments, kind: "debug_test" },
+        )
+      end
+
+      #: (String id) -> ResponseType?
       def [](id)
         @items[id]
       end
 
-      sig { override.returns(T::Array[ResponseType]) }
+      # @override
+      #: -> Array[ResponseType]
       def response
         @items.values
       end

data/lib/ruby_lsp/ruby_document.rb

@@ -2,12 +2,8 @@
 # frozen_string_literal: true
 
 module RubyLsp
+  #: [ParseResultType = Prism::ParseLexResult]
   class RubyDocument < Document
-    extend T::Sig
-    extend T::Generic
-
-    ParseResultType = type_member { { fixed: Prism::ParseResult } }
-
     METHODS_THAT_CHANGE_DECLARATIONS = [
       :private_constant,
       :attr_reader,
@@ -24,49 +20,16 @@ module RubyLsp
       :private_class_method,
     ].freeze
 
-    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,
-          code_units_cache: T.any(
-            T.proc.params(arg0: Integer).returns(Integer),
-            Prism::CodeUnitsCache,
-          ),
-          node_types: T::Array[T.class_of(Prism::Node)],
-        ).returns(NodeContext)
-      end
+      #: (Prism::Node node, Integer char_position, code_units_cache: (^(Integer arg0) -> Integer | Prism::CodeUnitsCache), ?node_types: Array[singleton(Prism::Node)]) -> NodeContext
       def locate(node, char_position, code_units_cache:, node_types: [])
-        queue = T.let(node.child_nodes.compact, T::Array[T.nilable(Prism::Node)])
+        queue = node.child_nodes.compact #: Array[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,
-          )],
-        )
+        parent = nil #: Prism::Node?
+        nesting_nodes = [] #: Array[(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))
+        call_node = nil #: Prism::CallNode?
 
         until queue.empty?
           candidate = queue.shift
@@ -77,7 +40,7 @@ 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
-          T.unsafe(queue).unshift(*candidate.child_nodes)
+          queue.unshift(*candidate.child_nodes)
 
           # Skip if the current node doesn't cover the desired position
           loc = candidate.location
@@ -150,74 +113,50 @@ module RubyLsp
       end
     end
 
-    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:)
       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
 
       @needs_parsing = false
-      @parse_result = Prism.parse(@source)
+      @parse_result = Prism.parse_lex(@source)
       @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::Ruby
+      :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
+    #: (Hash[Symbol, untyped] range, ?node_types: Array[singleton(Prism::Node)]) -> Prism::Node?
     def locate_first_within_range(range, node_types: [])
       start_position, end_position = find_index_by_position(range[:start], range[:end])
 
       desired_range = (start_position...end_position)
-      queue = T.let(@parse_result.value.child_nodes.compact, T::Array[T.nilable(Prism::Node)])
+      queue = ast.child_nodes.compact #: Array[Prism::Node?]
 
       until queue.empty?
         candidate = queue.shift
@@ -228,7 +167,7 @@ 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
-        T.unsafe(queue).unshift(*candidate.child_nodes)
+        queue.unshift(*candidate.child_nodes)
 
         # Skip if the current node doesn't cover the desired position
         loc = candidate.location
@@ -240,24 +179,19 @@ module RubyLsp
       end
     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 { returns(T::Boolean) }
+    #: -> bool
     def should_index?
       # This method controls when we should index documents. If there's no recent edit and the document has just been
       # opened, we need to index it
@@ -268,7 +202,7 @@ module RubyLsp
 
     private
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def last_edit_may_change_declarations?
       case @last_edit
       when Delete
@@ -282,7 +216,7 @@ module RubyLsp
       end
     end
 
-    sig { params(position: T::Hash[Symbol, Integer]).returns(T::Boolean) }
+    #: (Hash[Symbol, Integer] position) -> bool
     def position_may_impact_declarations?(position)
       node_context = locate_node(position)
       node_at_edit = node_context.node

data/lib/ruby_lsp/scope.rb

@@ -3,26 +3,24 @@
 
 module RubyLsp
   class Scope
-    extend T::Sig
-
-    sig { returns(T.nilable(Scope)) }
+    #: Scope?
     attr_reader :parent
 
-    sig { params(parent: T.nilable(Scope)).void }
+    #: (?Scope? parent) -> void
     def initialize(parent = nil)
       @parent = parent
 
       # A hash of name => type
-      @locals = T.let({}, T::Hash[Symbol, Local])
+      @locals = {} #: Hash[Symbol, Local]
     end
 
     # Add a new local to this scope. The types should only be `:parameter` or `:variable`
-    sig { params(name: T.any(String, Symbol), type: Symbol).void }
+    #: ((String | Symbol) name, Symbol type) -> void
     def add(name, type)
       @locals[name.to_sym] = Local.new(type)
     end
 
-    sig { params(name: T.any(String, Symbol)).returns(T.nilable(Local)) }
+    #: ((String | Symbol) name) -> Local?
     def lookup(name)
       sym = name.to_sym
       entry = @locals[sym]
@@ -33,12 +31,10 @@ module RubyLsp
     end
 
     class Local
-      extend T::Sig
-
-      sig { returns(Symbol) }
+      #: Symbol
       attr_reader :type
 
-      sig { params(type: Symbol).void }
+      #: (Symbol type) -> void
       def initialize(type)
         @type = type
       end

data/lib/ruby_lsp/scripts/compose_bundle.rb

@@ -13,8 +13,10 @@ def compose(raw_initialize)
   workspace_path ||= Dir.pwd
 
   env = RubyLsp::SetupBundler.new(workspace_path, launcher: true).setup!
-  File.write(
-    File.join(".ruby-lsp", "bundle_env"),
-    env.map { |k, v| "#{k}=#{v}" }.join("\n"),
-  )
+
+  File.open(File.join(".ruby-lsp", "bundle_env"), "w") do |f|
+    f.flock(File::LOCK_EX)
+    f.write(env.map { |k, v| "#{k}=#{v}" }.join("\n"))
+    f.flush
+  end
 end