ruby-lsp 0.17.4 → 0.17.13

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -34,14 +34,9 @@ module RubyLsp
       class << self
         extend T::Sig
 
-        sig { returns(Interface::DocumentSymbolClientCapabilities) }
+        sig { returns(Interface::DocumentSymbolOptions) }
         def provider
-          Interface::DocumentSymbolClientCapabilities.new(
-            hierarchical_document_symbol_support: true,
-            symbol_kind: {
-              value_set: (Constant::SymbolKind::FILE..Constant::SymbolKind::TYPE_PARAMETER).to_a,
-            },
-          )
+          Interface::DocumentSymbolOptions.new
         end
       end
 

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -23,9 +23,13 @@ module RubyLsp
       class << self
         extend T::Sig
 
-        sig { returns(Interface::FoldingRangeClientCapabilities) }
+        sig { returns(Interface::FoldingRangeRegistrationOptions) }
         def provider
-          Interface::FoldingRangeClientCapabilities.new(line_folding_only: true)
+          Interface::FoldingRangeRegistrationOptions.new(
+            document_selector: [
+              Interface::DocumentFilter.new(language: "ruby"),
+            ],
+          )
         end
       end
 

data/lib/ruby_lsp/requests/formatting.rb

@@ -27,6 +27,19 @@ module RubyLsp
 
       class Error < StandardError; end
 
+      class << self
+        extend T::Sig
+
+        sig { returns(Interface::DocumentFormattingRegistrationOptions) }
+        def provider
+          Interface::DocumentFormattingRegistrationOptions.new(
+            document_selector: [
+              Interface::DocumentFilter.new(language: "ruby"),
+            ],
+          )
+        end
+      end
+
       sig { params(global_state: GlobalState, document: Document).void }
       def initialize(global_state, document)
         super()
@@ -40,6 +53,8 @@ module RubyLsp
         return unless @active_formatter
         return if @document.syntax_error?
 
+        # We don't format erb documents yet
+
         formatted_text = @active_formatter.run_formatting(@uri, @document)
         return unless formatted_text
 

data/lib/ruby_lsp/requests/hover.rb

@@ -22,9 +22,9 @@ module RubyLsp
       class << self
         extend T::Sig
 
-        sig { returns(Interface::HoverClientCapabilities) }
+        sig { returns(Interface::HoverOptions) }
         def provider
-          Interface::HoverClientCapabilities.new(dynamic_registration: false)
+          Interface::HoverOptions.new
         end
       end
 
@@ -36,10 +36,10 @@ module RubyLsp
           global_state: GlobalState,
           position: T::Hash[Symbol, T.untyped],
           dispatcher: Prism::Dispatcher,
-          typechecker_enabled: T::Boolean,
+          sorbet_level: RubyDocument::SorbetLevel,
         ).void
       end
-      def initialize(document, global_state, position, dispatcher, typechecker_enabled)
+      def initialize(document, global_state, position, dispatcher, sorbet_level)
         super()
         node_context = document.locate_node(position, node_types: Listeners::Hover::ALLOWED_TARGETS)
         target = node_context.node
@@ -65,7 +65,7 @@ module RubyLsp
         @target = T.let(target, T.nilable(Prism::Node))
         uri = document.uri
         @response_builder = T.let(ResponseBuilders::Hover.new, ResponseBuilders::Hover)
-        Listeners::Hover.new(@response_builder, global_state, uri, node_context, dispatcher, typechecker_enabled)
+        Listeners::Hover.new(@response_builder, global_state, uri, node_context, dispatcher, sorbet_level)
         Addon.addons.each do |addon|
           addon.create_hover_listener(@response_builder, node_context, dispatcher)
         end

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -21,9 +21,10 @@ module RubyLsp
       class << self
         extend T::Sig
 
-        sig { returns(Interface::DocumentOnTypeFormattingOptions) }
+        sig { returns(Interface::DocumentOnTypeFormattingRegistrationOptions) }
         def provider
-          Interface::DocumentOnTypeFormattingOptions.new(
+          Interface::DocumentOnTypeFormattingRegistrationOptions.new(
+            document_selector: [Interface::DocumentFilter.new(language: "ruby")],
             first_trigger_character: "{",
             more_trigger_character: ["\n", "|", "d"],
           )
@@ -32,8 +33,9 @@ module RubyLsp
 
       END_REGEXES = T.let(
         [
-          /\b(if|unless|for|while|class|module|until|def|case)\b.*/,
-          /.*\s\bdo\b/,
+          /\b(if|unless|for|while|until)\b($|\s|\()/,
+          /\b(class|module|def|case)\b($|\s)/,
+          /.*\s\bdo\b($|\s)/,
         ],
         T::Array[Regexp],
       )

data/lib/ruby_lsp/requests/selection_ranges.rb

@@ -34,7 +34,7 @@ module RubyLsp
       sig { override.returns(T.all(T::Array[Support::SelectionRange], Object)) }
       def perform
         # [node, parent]
-        queue = [[@document.tree, nil]]
+        queue = [[@document.parse_result.value, nil]]
 
         until queue.empty?
           node, parent = queue.shift

data/lib/ruby_lsp/requests/show_syntax_tree.rb

@@ -25,6 +25,7 @@ module RubyLsp
         super()
         @document = document
         @range = range
+        @tree = T.let(document.parse_result.value, Prism::ProgramNode)
       end
 
       sig { override.returns(String) }
@@ -32,7 +33,7 @@ module RubyLsp
         return ast_for_range if @range
 
         output_string = +""
-        PP.pp(@document.tree, output_string)
+        PP.pp(@tree, output_string)
         output_string
       end
 
@@ -46,7 +47,7 @@ module RubyLsp
         start_char = scanner.find_char_position(range[:start])
         end_char = scanner.find_char_position(range[:end])
 
-        queue = @document.tree.statements.body.dup
+        queue = @tree.statements.body.dup
         found_nodes = []
 
         until queue.empty?

data/lib/ruby_lsp/requests/signature_help.rb

@@ -46,10 +46,10 @@ module RubyLsp
           position: T::Hash[Symbol, T.untyped],
           context: T.nilable(T::Hash[Symbol, T.untyped]),
           dispatcher: Prism::Dispatcher,
-          typechecker_enabled: T::Boolean,
+          sorbet_level: RubyDocument::SorbetLevel,
         ).void
       end
-      def initialize(document, global_state, position, context, dispatcher, typechecker_enabled) # rubocop:disable Metrics/ParameterLists
+      def initialize(document, global_state, position, context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
         super()
         node_context = document.locate_node(
           { line: position[:line], character: position[:character] },
@@ -61,7 +61,7 @@ module RubyLsp
         @target = T.let(target, T.nilable(Prism::Node))
         @dispatcher = dispatcher
         @response_builder = T.let(ResponseBuilders::SignatureHelp.new, ResponseBuilders::SignatureHelp)
-        Listeners::SignatureHelp.new(@response_builder, global_state, node_context, dispatcher, typechecker_enabled)
+        Listeners::SignatureHelp.new(@response_builder, global_state, node_context, dispatcher, sorbet_level)
       end
 
       sig { override.returns(T.nilable(Interface::SignatureHelp)) }

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

@@ -130,13 +130,17 @@ module RubyLsp
             title: String,
             entries: T.any(T::Array[RubyIndexer::Entry], RubyIndexer::Entry),
             max_entries: T.nilable(Integer),
+            extra_links: T.nilable(String),
           ).returns(String)
         end
-        def markdown_from_index_entries(title, entries, max_entries = nil)
+        def markdown_from_index_entries(title, entries, max_entries = nil, extra_links: nil)
           categorized_markdown = categorized_markdown_from_index_entries(title, entries, max_entries)
 
+          markdown = +(categorized_markdown[:title] || "")
+          markdown << "\n\n#{extra_links}" if extra_links
+
           <<~MARKDOWN.chomp
-            #{categorized_markdown[:title]}
+            #{markdown}
 
             #{categorized_markdown[:links]}
 
@@ -204,6 +208,11 @@ module RubyLsp
             Constant::SymbolKind::FIELD
           end
         end
+
+        sig { params(sorbet_level: RubyDocument::SorbetLevel).returns(T::Boolean) }
+        def sorbet_level_true_or_higher?(sorbet_level)
+          sorbet_level == RubyDocument::SorbetLevel::True || sorbet_level == RubyDocument::SorbetLevel::Strict
+        end
       end
     end
   end

data/lib/ruby_lsp/requests/type_hierarchy_supertypes.rb

@@ -54,8 +54,6 @@ module RubyLsp
           end
 
           entry.mixin_operations.each do |mixin_operation|
-            next if mixin_operation.is_a?(RubyIndexer::Entry::Extend)
-
             mixin_name = mixin_operation.module_name
             resolved_mixin_entries = @index.resolve(mixin_name, entry.nesting)
             next unless resolved_mixin_entries
@@ -75,14 +73,12 @@ module RubyLsp
 
       sig { params(entry: RubyIndexer::Entry).returns(Interface::TypeHierarchyItem) }
       def hierarchy_item(entry)
-        range = range_from_location(entry.location)
-
         Interface::TypeHierarchyItem.new(
           name: entry.name,
           kind: kind_for_entry(entry),
           uri: URI::Generic.from_path(path: entry.file_path).to_s,
-          range: range,
-          selection_range: range,
+          range: range_from_location(entry.location),
+          selection_range: range_from_location(entry.name_location),
           detail: entry.file_name,
         )
       end

data/lib/ruby_lsp/ruby_document.rb

@@ -3,6 +3,16 @@
 
 module RubyLsp
   class RubyDocument < Document
+    class SorbetLevel < T::Enum
+      enums do
+        None = new("none")
+        Ignore = new("ignore")
+        False = new("false")
+        True = new("true")
+        Strict = new("strict")
+      end
+    end
+
     sig { override.returns(Prism::ParseResult) }
     def parse
       return @parse_result unless @needs_parsing
@@ -10,5 +20,69 @@ module RubyLsp
       @needs_parsing = false
       @parse_result = Prism.parse(@source)
     end
+
+    sig { override.returns(T::Boolean) }
+    def syntax_error?
+      @parse_result.failure?
+    end
+
+    sig { override.returns(LanguageId) }
+    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
   end
 end