ruby-lsp 0.23.11 → 0.23.17

data/lib/ruby_lsp/listeners/semantic_highlighting.rb

@@ -5,31 +5,22 @@ module RubyLsp
   module Listeners
     class SemanticHighlighting
       include Requests::Support::Common
-      extend T::Sig
-
-      SPECIAL_RUBY_METHODS = T.let(
-        [
-          Module.instance_methods(false),
-          Kernel.instance_methods(false),
-          Kernel.methods(false),
-          Bundler::Dsl.instance_methods(false),
-          Module.private_instance_methods(false),
-        ].flatten.map(&:to_s).freeze,
-        T::Array[String],
-      )
-
-      sig do
-        params(
-          dispatcher: Prism::Dispatcher,
-          response_builder: ResponseBuilders::SemanticHighlighting,
-        ).void
-      end
+
+      SPECIAL_RUBY_METHODS = [
+        Module.instance_methods(false),
+        Kernel.instance_methods(false),
+        Kernel.methods(false),
+        Bundler::Dsl.instance_methods(false),
+        Module.private_instance_methods(false),
+      ].flatten.map(&:to_s).freeze #: Array[String]
+
+      #: (Prism::Dispatcher dispatcher, ResponseBuilders::SemanticHighlighting response_builder) -> void
       def initialize(dispatcher, response_builder)
         @response_builder = response_builder
-        @special_methods = T.let(nil, T.nilable(T::Array[String]))
-        @current_scope = T.let(Scope.new, Scope)
-        @inside_regex_capture = T.let(false, T::Boolean)
-        @inside_implicit_node = T.let(false, T::Boolean)
+        @special_methods = nil #: Array[String]?
+        @current_scope = Scope.new #: Scope
+        @inside_regex_capture = false #: bool
+        @inside_implicit_node = false #: bool
 
         dispatcher.register(
           self,
@@ -62,7 +53,7 @@ module RubyLsp
         )
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
         return if @inside_implicit_node
 
@@ -76,16 +67,22 @@ module RubyLsp
         return if special_method?(message)
 
         if Requests::Support::Sorbet.annotation?(node)
-          @response_builder.add_token(T.must(node.message_loc), :type)
+          @response_builder.add_token(
+            node.message_loc, #: as !nil
+            :type,
+          )
         elsif !node.receiver && !node.opening_loc
           # If the node has a receiver, then the syntax is not ambiguous and semantic highlighting is not necessary to
           # determine that the token is a method call. The only ambiguous case is method calls with implicit self
           # receiver and no parenthesis, which may be confused with local variables
-          @response_builder.add_token(T.must(node.message_loc), :method)
+          @response_builder.add_token(
+            node.message_loc, #: as !nil
+            :method,
+          )
         end
       end
 
-      sig { params(node: Prism::MatchWriteNode).void }
+      #: (Prism::MatchWriteNode node) -> void
       def on_match_write_node_enter(node)
         call = node.call
 
@@ -95,86 +92,86 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::MatchWriteNode).void }
+      #: (Prism::MatchWriteNode node) -> void
       def on_match_write_node_leave(node)
         @inside_regex_capture = true if node.call.message == "=~"
       end
 
-      sig { params(node: Prism::DefNode).void }
+      #: (Prism::DefNode node) -> void
       def on_def_node_enter(node)
         @current_scope = Scope.new(@current_scope)
       end
 
-      sig { params(node: Prism::DefNode).void }
+      #: (Prism::DefNode node) -> void
       def on_def_node_leave(node)
-        @current_scope = T.must(@current_scope.parent)
+        @current_scope = @current_scope.parent #: as !nil
       end
 
-      sig { params(node: Prism::BlockNode).void }
+      #: (Prism::BlockNode node) -> void
       def on_block_node_enter(node)
         @current_scope = Scope.new(@current_scope)
       end
 
-      sig { params(node: Prism::BlockNode).void }
+      #: (Prism::BlockNode node) -> void
       def on_block_node_leave(node)
-        @current_scope = T.must(@current_scope.parent)
+        @current_scope = @current_scope.parent #: as !nil
       end
 
-      sig { params(node: Prism::BlockLocalVariableNode).void }
+      #: (Prism::BlockLocalVariableNode node) -> void
       def on_block_local_variable_node_enter(node)
         @response_builder.add_token(node.location, :variable)
       end
 
-      sig { params(node: Prism::BlockParameterNode).void }
+      #: (Prism::BlockParameterNode node) -> void
       def on_block_parameter_node_enter(node)
         name = node.name
         @current_scope.add(name.to_sym, :parameter) if name
       end
 
-      sig { params(node: Prism::RequiredKeywordParameterNode).void }
+      #: (Prism::RequiredKeywordParameterNode node) -> void
       def on_required_keyword_parameter_node_enter(node)
         @current_scope.add(node.name, :parameter)
       end
 
-      sig { params(node: Prism::OptionalKeywordParameterNode).void }
+      #: (Prism::OptionalKeywordParameterNode node) -> void
       def on_optional_keyword_parameter_node_enter(node)
         @current_scope.add(node.name, :parameter)
       end
 
-      sig { params(node: Prism::KeywordRestParameterNode).void }
+      #: (Prism::KeywordRestParameterNode node) -> void
       def on_keyword_rest_parameter_node_enter(node)
         name = node.name
         @current_scope.add(name.to_sym, :parameter) if name
       end
 
-      sig { params(node: Prism::OptionalParameterNode).void }
+      #: (Prism::OptionalParameterNode node) -> void
       def on_optional_parameter_node_enter(node)
         @current_scope.add(node.name, :parameter)
       end
 
-      sig { params(node: Prism::RequiredParameterNode).void }
+      #: (Prism::RequiredParameterNode node) -> void
       def on_required_parameter_node_enter(node)
         @current_scope.add(node.name, :parameter)
       end
 
-      sig { params(node: Prism::RestParameterNode).void }
+      #: (Prism::RestParameterNode node) -> void
       def on_rest_parameter_node_enter(node)
         name = node.name
         @current_scope.add(name.to_sym, :parameter) if name
       end
 
-      sig { params(node: Prism::SelfNode).void }
+      #: (Prism::SelfNode node) -> void
       def on_self_node_enter(node)
         @response_builder.add_token(node.location, :variable, [:default_library])
       end
 
-      sig { params(node: Prism::LocalVariableWriteNode).void }
+      #: (Prism::LocalVariableWriteNode node) -> void
       def on_local_variable_write_node_enter(node)
         local = @current_scope.lookup(node.name)
         @response_builder.add_token(node.name_loc, :parameter) if local&.type == :parameter
       end
 
-      sig { params(node: Prism::LocalVariableReadNode).void }
+      #: (Prism::LocalVariableReadNode node) -> void
       def on_local_variable_read_node_enter(node)
         return if @inside_implicit_node
 
@@ -188,25 +185,25 @@ module RubyLsp
         @response_builder.add_token(node.location, local&.type || :variable)
       end
 
-      sig { params(node: Prism::LocalVariableAndWriteNode).void }
+      #: (Prism::LocalVariableAndWriteNode node) -> void
       def on_local_variable_and_write_node_enter(node)
         local = @current_scope.lookup(node.name)
         @response_builder.add_token(node.name_loc, :parameter) if local&.type == :parameter
       end
 
-      sig { params(node: Prism::LocalVariableOperatorWriteNode).void }
+      #: (Prism::LocalVariableOperatorWriteNode node) -> void
       def on_local_variable_operator_write_node_enter(node)
         local = @current_scope.lookup(node.name)
         @response_builder.add_token(node.name_loc, :parameter) if local&.type == :parameter
       end
 
-      sig { params(node: Prism::LocalVariableOrWriteNode).void }
+      #: (Prism::LocalVariableOrWriteNode node) -> void
       def on_local_variable_or_write_node_enter(node)
         local = @current_scope.lookup(node.name)
         @response_builder.add_token(node.name_loc, :parameter) if local&.type == :parameter
       end
 
-      sig { params(node: Prism::LocalVariableTargetNode).void }
+      #: (Prism::LocalVariableTargetNode node) -> void
       def on_local_variable_target_node_enter(node)
         # If we're inside a regex capture, Prism will add LocalVariableTarget nodes for each captured variable.
         # Unfortunately, if the regex contains a backslash, the location will be incorrect and we'll end up highlighting
@@ -218,7 +215,7 @@ module RubyLsp
         @response_builder.add_token(node.location, local&.type || :variable)
       end
 
-      sig { params(node: Prism::ClassNode).void }
+      #: (Prism::ClassNode node) -> void
       def on_class_node_enter(node)
         constant_path = node.constant_path
 
@@ -257,7 +254,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::ModuleNode).void }
+      #: (Prism::ModuleNode node) -> void
       def on_module_node_enter(node)
         constant_path = node.constant_path
 
@@ -278,12 +275,12 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::ImplicitNode).void }
+      #: (Prism::ImplicitNode node) -> void
       def on_implicit_node_enter(node)
         @inside_implicit_node = true
       end
 
-      sig { params(node: Prism::ImplicitNode).void }
+      #: (Prism::ImplicitNode node) -> void
       def on_implicit_node_leave(node)
         @inside_implicit_node = false
       end
@@ -292,12 +289,12 @@ module RubyLsp
 
       # Textmate provides highlighting for a subset of these special Ruby-specific methods.  We want to utilize that
       # highlighting, so we avoid making a semantic token for it.
-      sig { params(method_name: String).returns(T::Boolean) }
+      #: (String method_name) -> bool
       def special_method?(method_name)
         SPECIAL_RUBY_METHODS.include?(method_name)
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def process_regexp_locals(node)
         receiver = node.receiver
 
@@ -310,7 +307,8 @@ module RubyLsp
         # For each capture name we find in the regexp, look for a local in the current_scope
         Regexp.new(content, Regexp::FIXEDENCODING).names.each do |name|
           # The +3 is to compensate for the "(?<" part of the capture name
-          capture_name_offset = T.must(content.index("(?<#{name}>")) + 3
+          capture_name_index = content.index("(?<#{name}>") #: as !nil
+          capture_name_offset = capture_name_index + 3
           local_var_loc = loc.copy(start_offset: loc.start_offset + capture_name_offset, length: name.length)
 
           local = @current_scope.lookup(name)

data/lib/ruby_lsp/listeners/signature_help.rb

@@ -4,31 +4,22 @@
 module RubyLsp
   module Listeners
     class SignatureHelp
-      extend T::Sig
       include Requests::Support::Common
 
-      sig do
-        params(
-          response_builder: ResponseBuilders::SignatureHelp,
-          global_state: GlobalState,
-          node_context: NodeContext,
-          dispatcher: Prism::Dispatcher,
-          sorbet_level: RubyDocument::SorbetLevel,
-        ).void
-      end
+      #: (ResponseBuilders::SignatureHelp response_builder, GlobalState global_state, NodeContext node_context, Prism::Dispatcher dispatcher, SorbetLevel sorbet_level) -> void
       def initialize(response_builder, global_state, node_context, dispatcher, sorbet_level)
         @sorbet_level = sorbet_level
         @response_builder = response_builder
         @global_state = global_state
-        @index = T.let(global_state.index, RubyIndexer::Index)
-        @type_inferrer = T.let(global_state.type_inferrer, TypeInferrer)
+        @index = global_state.index #: RubyIndexer::Index
+        @type_inferrer = global_state.type_inferrer #: TypeInferrer
         @node_context = node_context
         dispatcher.register(self, :on_call_node_enter)
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
-        return if sorbet_level_true_or_higher?(@sorbet_level)
+        return if @sorbet_level.true_or_higher?
 
         message = node.message
         return unless message
@@ -67,9 +58,7 @@ module RubyLsp
 
       private
 
-      sig do
-        params(node: Prism::CallNode, signatures: T::Array[RubyIndexer::Entry::Signature]).returns([Integer, Integer])
-      end
+      #: (Prism::CallNode node, Array[RubyIndexer::Entry::Signature] signatures) -> [Integer, Integer]
       def determine_active_signature_and_parameter(node, signatures)
         arguments_node = node.arguments
         arguments = arguments_node&.arguments || []
@@ -80,7 +69,11 @@ module RubyLsp
           signature.matches?(arguments)
         end || 0
 
-        parameter_length = [T.must(signatures[active_sig_index]).parameters.length - 1, 0].max
+        parameter_length = [
+          signatures[active_sig_index] #: as !nil
+            .parameters.length - 1,
+          0,
+        ].max
         active_parameter = (arguments.length - 1).clamp(0, parameter_length)
 
         # If there are arguments, then we need to check if there's a trailing comma after the end of the last argument
@@ -93,15 +86,7 @@ module RubyLsp
         [active_sig_index, active_parameter]
       end
 
-      sig do
-        params(
-          signatures: T::Array[RubyIndexer::Entry::Signature],
-          method_name: String,
-          methods: T::Array[RubyIndexer::Entry],
-          title: String,
-          extra_links: T.nilable(String),
-        ).returns(T::Array[Interface::SignatureInformation])
-      end
+      #: (Array[RubyIndexer::Entry::Signature] signatures, String method_name, Array[RubyIndexer::Entry] methods, String title, String? extra_links) -> Array[Interface::SignatureInformation]
       def generate_signatures(signatures, method_name, methods, title, extra_links)
         signatures.map do |signature|
           Interface::SignatureInformation.new(

data/lib/ruby_lsp/listeners/spec_style.rb

@@ -0,0 +1,155 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Listeners
+    class SpecStyle < TestDiscovery
+      #: (ResponseBuilders::TestCollection, GlobalState, Prism::Dispatcher, URI::Generic) -> void
+      def initialize(response_builder, global_state, dispatcher, uri)
+        super
+
+        @describe_block_nesting = [] #: Array[String]
+        @spec_class_stack = [] #: Array[bool]
+
+        dispatcher.register(
+          self,
+          # Common handlers registered in parent class
+          :on_class_node_enter,
+          :on_call_node_enter, # e.g. `describe` or `it`
+          :on_call_node_leave,
+        )
+      end
+
+      #: (Prism::ClassNode) -> void
+      def on_class_node_enter(node)
+        with_test_ancestor_tracking(node) do |_, ancestors|
+          is_spec = ancestors.include?("Minitest::Spec")
+          @spec_class_stack.push(is_spec)
+        end
+      end
+
+      #: (Prism::ClassNode) -> void
+      def on_class_node_leave(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+        super
+
+        @spec_class_stack.pop
+      end
+
+      #: (Prism::CallNode) -> void
+      def on_call_node_enter(node)
+        case node.name
+        when :describe
+          handle_describe(node)
+        when :it, :specify
+          handle_example(node)
+        end
+      end
+
+      #: (Prism::CallNode) -> void
+      def on_call_node_leave(node)
+        return unless node.name == :describe && !node.receiver
+
+        @describe_block_nesting.pop
+      end
+
+      private
+
+      #: (Prism::CallNode) -> void
+      def handle_describe(node)
+        return if node.block.nil?
+
+        description = extract_description(node)
+        return unless description
+
+        return unless in_spec_context?
+
+        if @nesting.empty? && @describe_block_nesting.empty?
+          test_item = Requests::Support::TestItem.new(
+            description,
+            description,
+            @uri,
+            range_from_node(node),
+            framework: :minitest,
+          )
+          @response_builder.add(test_item)
+          @response_builder.add_code_lens(test_item)
+        else
+          add_to_parent_test_group(description, node)
+        end
+
+        @describe_block_nesting << description
+      end
+
+      #: (Prism::CallNode) -> void
+      def handle_example(node)
+        return unless in_spec_context?
+
+        return if @describe_block_nesting.empty? && @nesting.empty?
+
+        description = extract_description(node)
+        return unless description
+
+        add_to_parent_test_group(description, node)
+      end
+
+      #: (String, Prism::CallNode) -> void
+      def add_to_parent_test_group(description, node)
+        parent_test_group = find_parent_test_group
+        return unless parent_test_group
+
+        test_item = Requests::Support::TestItem.new(
+          description,
+          description,
+          @uri,
+          range_from_node(node),
+          framework: :minitest,
+        )
+        parent_test_group.add(test_item)
+        @response_builder.add_code_lens(test_item)
+      end
+
+      #: -> Requests::Support::TestItem?
+      def find_parent_test_group
+        root_group_name, nested_describe_groups = if @nesting.empty?
+          [@describe_block_nesting.first, @describe_block_nesting[1..]]
+        else
+          [RubyIndexer::Index.actual_nesting(@nesting, nil).join("::"), @describe_block_nesting]
+        end
+        return unless root_group_name
+
+        test_group = @response_builder[root_group_name] #: Requests::Support::TestItem?
+        return unless test_group
+
+        return test_group unless nested_describe_groups
+
+        nested_describe_groups.each do |description|
+          test_group = test_group[description]
+        end
+
+        test_group
+      end
+
+      #: (Prism::CallNode) -> String?
+      def extract_description(node)
+        first_argument = node.arguments&.arguments&.first
+        return unless first_argument
+
+        case first_argument
+        when Prism::StringNode
+          first_argument.content
+        when Prism::ConstantReadNode, Prism::ConstantPathNode
+          constant_name(first_argument)
+        else
+          first_argument.slice
+        end
+      end
+
+      #: -> bool
+      def in_spec_context?
+        return true if @nesting.empty?
+
+        @spec_class_stack.last #: as !nil
+      end
+    end
+  end
+end

data/lib/ruby_lsp/listeners/test_discovery.rb

@@ -0,0 +1,89 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Listeners
+    class TestDiscovery
+      extend T::Helpers
+      abstract!
+
+      include Requests::Support::Common
+
+      DYNAMIC_REFERENCE_MARKER = "<dynamic_reference>"
+
+      #: (ResponseBuilders::TestCollection response_builder, GlobalState global_state, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
+      def initialize(response_builder, global_state, dispatcher, uri)
+        @response_builder = response_builder
+        @uri = uri
+        @index = global_state.index #: RubyIndexer::Index
+        @visibility_stack = [:public] #: Array[Symbol]
+        @nesting = [] #: Array[String]
+
+        dispatcher.register(
+          self,
+          :on_class_node_leave,
+          :on_module_node_enter,
+          :on_module_node_leave,
+        )
+      end
+
+      #: (Prism::ModuleNode node) -> void
+      def on_module_node_enter(node)
+        @visibility_stack << :public
+
+        name = constant_name(node.constant_path)
+        name ||= name_with_dynamic_reference(node.constant_path)
+
+        @nesting << name
+      end
+
+      #: (Prism::ModuleNode node) -> void
+      def on_module_node_leave(node)
+        @visibility_stack.pop
+        @nesting.pop
+      end
+
+      #: (Prism::ClassNode node) -> void
+      def on_class_node_leave(node)
+        @visibility_stack.pop
+        @nesting.pop
+      end
+
+      private
+
+      #: (String? name) -> String
+      def calc_fully_qualified_name(name)
+        RubyIndexer::Index.actual_nesting(@nesting, name).join("::")
+      end
+
+      #: (Prism::ClassNode node, String fully_qualified_name) -> Array[String]
+      def calc_attached_ancestors(node, fully_qualified_name)
+        @index.linearized_ancestors_of(fully_qualified_name)
+      rescue RubyIndexer::Index::NonExistingNamespaceError
+        # When there are dynamic parts in the constant path, we will not have indexed the namespace. We can still
+        # provide test functionality if the class inherits directly from Test::Unit::TestCase or Minitest::Test
+        [node.superclass&.slice].compact
+      end
+
+      #: (Prism::ConstantPathNode | Prism::ConstantReadNode | Prism::ConstantPathTargetNode | Prism::CallNode | Prism::MissingNode node) -> String
+      def name_with_dynamic_reference(node)
+        slice = node.slice
+        slice.gsub(/((?<=::)|^)[a-z]\w*/, DYNAMIC_REFERENCE_MARKER)
+      end
+
+      #: (Prism::ClassNode node, ^(String name, Array[String] ancestors) -> void block) -> void
+      def with_test_ancestor_tracking(node, &block)
+        @visibility_stack << :public
+        name = constant_name(node.constant_path)
+        name ||= name_with_dynamic_reference(node.constant_path)
+
+        fully_qualified_name = calc_fully_qualified_name(name)
+        attached_ancestors = calc_attached_ancestors(node, fully_qualified_name)
+
+        block.call(fully_qualified_name, attached_ancestors)
+
+        @nesting << name
+      end
+    end
+  end
+end