ruby-lsp 0.23.11 → 0.26.1

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,214 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Listeners
+    class SpecStyle < TestDiscovery
+      class Group
+        #: String
+        attr_reader :id
+
+        #: (String) -> void
+        def initialize(id)
+          @id = id
+        end
+      end
+
+      class ClassGroup < Group; end
+      class DescribeGroup < Group; end
+
+      #: (ResponseBuilders::TestCollection, GlobalState, Prism::Dispatcher, URI::Generic) -> void
+      def initialize(response_builder, global_state, dispatcher, uri)
+        super(response_builder, global_state, uri)
+
+        @spec_group_id_stack = [] #: Array[Group?]
+
+        register_events(
+          dispatcher,
+          :on_class_node_enter,
+          :on_call_node_enter,
+          :on_call_node_leave,
+        )
+      end
+
+      #: (Prism::ClassNode) -> void
+      def on_class_node_enter(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+        with_test_ancestor_tracking(node) do |name, ancestors|
+          @spec_group_id_stack << (ancestors.include?("Minitest::Spec") ? ClassGroup.new(name) : nil)
+        end
+      end
+
+      #: (Prism::ClassNode) -> void
+      def on_class_node_leave(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+        @spec_group_id_stack.pop
+        super
+      end
+
+      #: (Prism::ModuleNode) -> void
+      def on_module_node_enter(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+        @spec_group_id_stack << nil
+        super
+      end
+
+      #: (Prism::ModuleNode) -> void
+      def on_module_node_leave(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+        @spec_group_id_stack.pop
+        super
+      end
+
+      #: (Prism::CallNode) -> void
+      def on_call_node_enter(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+        return unless in_spec_context?
+
+        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) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+        return unless node.name == :describe && !node.receiver
+
+        current_group = @spec_group_id_stack.last
+        return unless current_group.is_a?(DescribeGroup)
+
+        description = extract_description(node)
+        return unless description && current_group.id.end_with?(description)
+
+        @spec_group_id_stack.pop
+      end
+
+      private
+
+      #: (Prism::CallNode) -> void
+      def handle_describe(node)
+        # Describes will include the nesting of all classes and all outer describes as part of its ID, unlike classes
+        # that ignore describes
+        return if node.block.nil?
+
+        description = extract_description(node)
+        return unless description
+
+        parent = latest_group
+        return unless parent
+
+        id = case parent
+        when Requests::Support::TestItem
+          "#{parent.id}::#{description}"
+        else
+          description
+        end
+
+        test_item = Requests::Support::TestItem.new(
+          id,
+          description,
+          @uri,
+          range_from_node(node),
+          framework: :minitest,
+        )
+
+        parent.add(test_item)
+        @response_builder.add_code_lens(test_item)
+        @spec_group_id_stack << DescribeGroup.new(id)
+      end
+
+      #: (Prism::CallNode) -> void
+      def handle_example(node)
+        # Minitest formats the descriptions into test method names by using the count of examples with the description
+        # We are not guaranteed to discover examples in the exact order using static analysis, so we use the line number
+        # instead. Note that anonymous examples mixed with meta-programming will not be handled correctly
+        description = extract_description(node) || "anonymous"
+        line = node.location.start_line - 1
+        parent = latest_group
+        return unless parent.is_a?(Requests::Support::TestItem)
+
+        id = "#{parent.id}##{format("test_%04d_%s", line, description)}"
+
+        test_item = Requests::Support::TestItem.new(
+          id,
+          description,
+          @uri,
+          range_from_node(node),
+          framework: :minitest,
+        )
+
+        parent.add(test_item)
+        @response_builder.add_code_lens(test_item)
+      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
+
+      #: -> (Requests::Support::TestItem | ResponseBuilders::TestCollection)?
+      def latest_group
+        # If we haven't found anything yet, then return the response builder
+        return @response_builder if @spec_group_id_stack.compact.empty?
+        # If we found something that isn't a group last, then we're inside a random module or class, but not a spec
+        # group
+        return unless @spec_group_id_stack.last
+
+        # Specs using at least one class as a group require special handling
+        closest_class_index = @spec_group_id_stack.rindex { |i| i.is_a?(ClassGroup) }
+
+        if closest_class_index
+          first_class_index = @spec_group_id_stack.index { |i| i.is_a?(ClassGroup) } #: as !nil
+          first_class = @spec_group_id_stack[first_class_index] #: as !nil
+          item = @response_builder[first_class.id] #: as !nil
+
+          # Descend into child items from the beginning all the way to the latest class group, ignoring describes
+          @spec_group_id_stack[first_class_index + 1..closest_class_index] #: as !nil
+            .each do |group|
+            next unless group.is_a?(ClassGroup)
+
+            item = item[group.id] #: as !nil
+          end
+
+          # From the class forward, we must take describes into account
+          @spec_group_id_stack[closest_class_index + 1..] #: as !nil
+            .each do |group|
+            next unless group
+
+            item = item[group.id] #: as !nil
+          end
+
+          return item
+        end
+
+        # Specs only using describes
+        first_group = @spec_group_id_stack.find { |i| i.is_a?(DescribeGroup) }
+        return unless first_group
+
+        item = @response_builder[first_group.id] #: as !nil
+
+        @spec_group_id_stack[1..] #: as !nil
+          .each do |group|
+          next unless group.is_a?(DescribeGroup)
+
+          item = item[group.id] #: as !nil
+        end
+
+        item
+      end
+
+      #: -> bool
+      def in_spec_context?
+        @nesting.empty? || @spec_group_id_stack.any? { |id| id }
+      end
+    end
+  end
+end

data/lib/ruby_lsp/listeners/test_discovery.rb

@@ -0,0 +1,92 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Listeners
+    # @abstract
+    class TestDiscovery
+      include Requests::Support::Common
+
+      DYNAMIC_REFERENCE_MARKER = "<dynamic_reference>"
+
+      #: (ResponseBuilders::TestCollection response_builder, GlobalState global_state, URI::Generic uri) -> void
+      def initialize(response_builder, global_state, uri)
+        @response_builder = response_builder
+        @uri = uri
+        @index = global_state.index #: RubyIndexer::Index
+        @visibility_stack = [:public] #: Array[Symbol]
+        @nesting = [] #: Array[String]
+      end
+
+      #: (Prism::ModuleNode node) -> void
+      def on_module_node_enter(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+        @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) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+        @visibility_stack.pop
+        @nesting.pop
+      end
+
+      #: (Prism::ClassNode node) -> void
+      def on_class_node_leave(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+        @visibility_stack.pop
+        @nesting.pop
+      end
+
+      private
+
+      #: (Prism::Dispatcher, *Symbol) -> void
+      def register_events(dispatcher, *events)
+        unique_events = events.dup.push(
+          :on_class_node_leave,
+          :on_module_node_enter,
+          :on_module_node_leave,
+        )
+
+        unique_events.uniq!
+        dispatcher.register(self, *unique_events)
+      end
+
+      #: (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 } -> 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