ruby-lsp 0.17.4 → 0.17.13

data/lib/ruby_lsp/listeners/completion.rb

@@ -7,12 +7,56 @@ module RubyLsp
       extend T::Sig
       include Requests::Support::Common
 
+      KEYWORDS = [
+        "alias",
+        "and",
+        "begin",
+        "BEGIN",
+        "break",
+        "case",
+        "class",
+        "def",
+        "defined?",
+        "do",
+        "else",
+        "elsif",
+        "end",
+        "END",
+        "ensure",
+        "false",
+        "for",
+        "if",
+        "in",
+        "module",
+        "next",
+        "nil",
+        "not",
+        "or",
+        "redo",
+        "rescue",
+        "retry",
+        "return",
+        "self",
+        "super",
+        "then",
+        "true",
+        "undef",
+        "unless",
+        "until",
+        "when",
+        "while",
+        "yield",
+        "__ENCODING__",
+        "__FILE__",
+        "__LINE__",
+      ].freeze
+
       sig do
         params(
           response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
           global_state: GlobalState,
           node_context: NodeContext,
-          typechecker_enabled: T::Boolean,
+          sorbet_level: RubyDocument::SorbetLevel,
           dispatcher: Prism::Dispatcher,
           uri: URI::Generic,
           trigger_character: T.nilable(String),
@@ -22,7 +66,7 @@ module RubyLsp
         response_builder,
         global_state,
         node_context,
-        typechecker_enabled,
+        sorbet_level,
         dispatcher,
         uri,
         trigger_character
@@ -32,7 +76,7 @@ module RubyLsp
         @index = T.let(global_state.index, RubyIndexer::Index)
         @type_inferrer = T.let(global_state.type_inferrer, TypeInferrer)
         @node_context = node_context
-        @typechecker_enabled = typechecker_enabled
+        @sorbet_level = sorbet_level
         @uri = uri
         @trigger_character = trigger_character
 
@@ -53,7 +97,9 @@ module RubyLsp
       # Handle completion on regular constant references (e.g. `Bar`)
       sig { params(node: Prism::ConstantReadNode).void }
       def on_constant_read_node_enter(node)
-        return if @global_state.has_type_checker
+        # The only scenario where Sorbet doesn't provide constant completion is on ignored files. Even if the file has
+        # no sigil, Sorbet will still provide completion for constants
+        return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
 
         name = constant_name(node)
         return if name.nil?
@@ -74,7 +120,9 @@ module RubyLsp
       # Handle completion on namespaced constant references (e.g. `Foo::Bar`)
       sig { params(node: Prism::ConstantPathNode).void }
       def on_constant_path_node_enter(node)
-        return if @global_state.has_type_checker
+        # The only scenario where Sorbet doesn't provide constant completion is on ignored files. Even if the file has
+        # no sigil, Sorbet will still provide completion for constants
+        return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
 
         name = constant_name(node)
         return if name.nil?
@@ -84,28 +132,32 @@ module RubyLsp
 
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
-        receiver = node.receiver
-
-        # When writing `Foo::`, the AST assigns a method call node (because you can use that syntax to invoke singleton
-        # methods). However, in addition to providing method completion, we also need to show possible constant
-        # completions
-        if (receiver.is_a?(Prism::ConstantReadNode) || receiver.is_a?(Prism::ConstantPathNode)) &&
-            node.call_operator == "::"
-
-          name = constant_name(receiver)
-
-          if name
-            start_loc = node.location
-            end_loc = T.must(node.call_operator_loc)
-
-            constant_path_completion(
-              "#{name}::",
-              Interface::Range.new(
-                start: Interface::Position.new(line: start_loc.start_line - 1, character: start_loc.start_column),
-                end: Interface::Position.new(line: end_loc.end_line - 1, character: end_loc.end_column),
-              ),
-            )
-            return
+        # The only scenario where Sorbet doesn't provide constant completion is on ignored files. Even if the file has
+        # no sigil, Sorbet will still provide completion for constants
+        if @sorbet_level == RubyDocument::SorbetLevel::Ignore
+          receiver = node.receiver
+
+          # When writing `Foo::`, the AST assigns a method call node (because you can use that syntax to invoke
+          # singleton methods). However, in addition to providing method completion, we also need to show possible
+          # constant completions
+          if (receiver.is_a?(Prism::ConstantReadNode) || receiver.is_a?(Prism::ConstantPathNode)) &&
+              node.call_operator == "::"
+
+            name = constant_name(receiver)
+
+            if name
+              start_loc = node.location
+              end_loc = T.must(node.call_operator_loc)
+
+              constant_path_completion(
+                "#{name}::",
+                Interface::Range.new(
+                  start: Interface::Position.new(line: start_loc.start_line - 1, character: start_loc.start_column),
+                  end: Interface::Position.new(line: end_loc.end_line - 1, character: end_loc.end_column),
+                ),
+              )
+              return
+            end
           end
         end
 
@@ -118,7 +170,7 @@ module RubyLsp
         when "require_relative"
           complete_require_relative(node)
         else
-          complete_methods(node, name) unless @typechecker_enabled
+          complete_methods(node, name)
         end
       end
 
@@ -203,14 +255,23 @@ module RubyLsp
 
       sig { params(name: String, location: Prism::Location).void }
       def handle_instance_variable_completion(name, location)
+        # Sorbet enforces that all instance variables be declared on typed strict or higher, which means it will be able
+        # to provide all features for them
+        return if @sorbet_level == RubyDocument::SorbetLevel::Strict
+
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
 
-        @index.instance_variable_completion_candidates(name, type).each do |entry|
+        @index.instance_variable_completion_candidates(name, type.name).each do |entry|
           variable_name = entry.name
 
+          label_details = Interface::CompletionItemLabelDetails.new(
+            description: entry.file_name,
+          )
+
           @response_builder << Interface::CompletionItem.new(
             label: variable_name,
+            label_details: label_details,
             text_edit: Interface::TextEdit.new(
               range: range_from_location(location),
               new_text: variable_name,
@@ -272,6 +333,16 @@ module RubyLsp
 
       sig { params(node: Prism::CallNode, name: String).void }
       def complete_methods(node, name)
+        # If the node has a receiver, then we don't need to provide local nor keyword completions. Sorbet can provide
+        # local and keyword completion for any file with a Sorbet level of true or higher
+        if !sorbet_level_true_or_higher?(@sorbet_level) && !node.receiver
+          add_local_completions(node, name)
+          add_keyword_completions(node, name)
+        end
+
+        # Sorbet can provide completion for methods invoked on self on typed true or higher files
+        return if sorbet_level_true_or_higher?(@sorbet_level) && self_receiver?(node)
+
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
 
@@ -283,23 +354,37 @@ module RubyLsp
         range = if method_name
           range_from_location(T.must(node.message_loc))
         else
-          loc = T.must(node.call_operator_loc)
-          Interface::Range.new(
-            start: Interface::Position.new(line: loc.start_line - 1, character: loc.start_column + 1),
-            end: Interface::Position.new(line: loc.start_line - 1, character: loc.start_column + 1),
-          )
+          loc = node.call_operator_loc
+
+          if loc
+            Interface::Range.new(
+              start: Interface::Position.new(line: loc.start_line - 1, character: loc.start_column + 1),
+              end: Interface::Position.new(line: loc.start_line - 1, character: loc.start_column + 1),
+            )
+          end
         end
 
-        @index.method_completion_candidates(method_name, type).each do |entry|
+        return unless range
+
+        guessed_type = type.name
+
+        @index.method_completion_candidates(method_name, type.name).each do |entry|
           entry_name = entry.name
+          owner_name = entry.owner&.name
 
+          label_details = Interface::CompletionItemLabelDetails.new(
+            description: entry.file_name,
+            detail: entry.decorated_parameters,
+          )
           @response_builder << Interface::CompletionItem.new(
             label: entry_name,
             filter_text: entry_name,
+            label_details: label_details,
             text_edit: Interface::TextEdit.new(range: range, new_text: entry_name),
             kind: Constant::CompletionItemKind::METHOD,
             data: {
-              owner_name: entry.owner&.name,
+              owner_name: owner_name,
+              guessed_type: guessed_type,
             },
           )
         end
@@ -307,29 +392,42 @@ module RubyLsp
         # We have not indexed this namespace, so we can't provide any completions
       end
 
-      sig do
-        params(
-          entry: T.any(RubyIndexer::Entry::Member, RubyIndexer::Entry::MethodAlias),
-          node: Prism::CallNode,
-        ).returns(Interface::CompletionItem)
+      sig { params(node: Prism::CallNode, name: String).void }
+      def add_local_completions(node, name)
+        range = range_from_location(T.must(node.message_loc))
+
+        @node_context.locals_for_scope.each do |local|
+          local_name = local.to_s
+          next unless local_name.start_with?(name)
+
+          @response_builder << Interface::CompletionItem.new(
+            label: local_name,
+            filter_text: local_name,
+            text_edit: Interface::TextEdit.new(range: range, new_text: local_name),
+            kind: Constant::CompletionItemKind::VARIABLE,
+            data: {
+              skip_resolve: true,
+            },
+          )
+        end
       end
-      def build_method_completion(entry, node)
-        name = entry.name
 
-        Interface::CompletionItem.new(
-          label: name,
-          filter_text: name,
-          text_edit: Interface::TextEdit.new(range: range_from_location(T.must(node.message_loc)), new_text: name),
-          kind: Constant::CompletionItemKind::METHOD,
-          label_details: Interface::CompletionItemLabelDetails.new(
-            detail: entry.decorated_parameters,
-            description: entry.file_name,
-          ),
-          documentation: Interface::MarkupContent.new(
-            kind: "markdown",
-            value: markdown_from_index_entries(name, entry),
-          ),
-        )
+      sig { params(node: Prism::CallNode, name: String).void }
+      def add_keyword_completions(node, name)
+        range = range_from_location(T.must(node.message_loc))
+
+        KEYWORDS.each do |keyword|
+          next unless keyword.start_with?(name)
+
+          @response_builder << Interface::CompletionItem.new(
+            label: keyword,
+            text_edit: Interface::TextEdit.new(range: range, new_text: keyword),
+            kind: Constant::CompletionItemKind::KEYWORD,
+            data: {
+              skip_resolve: true,
+            },
+          )
+        end
       end
 
       sig { params(label: String, node: Prism::StringNode).returns(Interface::CompletionItem) }
@@ -413,8 +511,14 @@ module RubyLsp
         # When using a top level constant reference (e.g.: `::Bar`), the editor includes the `::` as part of the filter.
         # For these top level references, we need to include the `::` as part of the filter text or else it won't match
         # the right entries in the index
+
+        label_details = Interface::CompletionItemLabelDetails.new(
+          description: entries.map(&:file_name).join(","),
+        )
+
         Interface::CompletionItem.new(
           label: real_name,
+          label_details: label_details,
           filter_text: filter_text,
           text_edit: Interface::TextEdit.new(
             range: range,

data/lib/ruby_lsp/listeners/definition.rb

@@ -11,22 +11,27 @@ module RubyLsp
 
       sig do
         params(
-          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::Location],
+          response_builder: ResponseBuilders::CollectionResponseBuilder[T.any(
+            Interface::Location,
+            Interface::LocationLink,
+          )],
           global_state: GlobalState,
+          language_id: Document::LanguageId,
           uri: URI::Generic,
           node_context: NodeContext,
           dispatcher: Prism::Dispatcher,
-          typechecker_enabled: T::Boolean,
+          sorbet_level: RubyDocument::SorbetLevel,
         ).void
       end
-      def initialize(response_builder, global_state, uri, node_context, dispatcher, typechecker_enabled) # rubocop:disable Metrics/ParameterLists
+      def initialize(response_builder, global_state, language_id, uri, node_context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
         @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)
+        @language_id = language_id
         @uri = uri
         @node_context = node_context
-        @typechecker_enabled = typechecker_enabled
+        @sorbet_level = sorbet_level
 
         dispatcher.register(
           self,
@@ -41,15 +46,29 @@ module RubyLsp
           :on_instance_variable_or_write_node_enter,
           :on_instance_variable_target_node_enter,
           :on_string_node_enter,
+          :on_symbol_node_enter,
+          :on_super_node_enter,
+          :on_forwarding_super_node_enter,
         )
       end
 
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
+        # Sorbet can handle go to definition for methods invoked on self on typed true or higher
+        return if sorbet_level_true_or_higher?(@sorbet_level) && self_receiver?(node)
+
         message = node.message
         return unless message
 
-        handle_method_definition(message, @type_inferrer.infer_receiver_type(@node_context))
+        inferrer_receiver_type = @type_inferrer.infer_receiver_type(@node_context)
+
+        # Until we can properly infer the receiver type in erb files (maybe with ruby-lsp-rails),
+        # treating method calls' type as `nil` will allow users to get some completion support first
+        if @language_id == Document::LanguageId::ERB && inferrer_receiver_type&.name == "Object"
+          inferrer_receiver_type = nil
+        end
+
+        handle_method_definition(message, inferrer_receiver_type)
       end
 
       sig { params(node: Prism::StringNode).void }
@@ -63,6 +82,17 @@ module RubyLsp
         handle_require_definition(node, name)
       end
 
+      sig { params(node: Prism::SymbolNode).void }
+      def on_symbol_node_enter(node)
+        enclosing_call = @node_context.call_node
+        return unless enclosing_call
+
+        name = enclosing_call.name
+        return unless name == :autoload
+
+        handle_autoload_definition(enclosing_call)
+      end
+
       sig { params(node: Prism::BlockArgumentNode).void }
       def on_block_argument_node_enter(node)
         expression = node.expression
@@ -120,14 +150,43 @@ module RubyLsp
         handle_instance_variable_definition(node.name.to_s)
       end
 
+      sig { params(node: Prism::SuperNode).void }
+      def on_super_node_enter(node)
+        handle_super_node_definition
+      end
+
+      sig { params(node: Prism::ForwardingSuperNode).void }
+      def on_forwarding_super_node_enter(node)
+        handle_super_node_definition
+      end
+
       private
 
+      sig { void }
+      def handle_super_node_definition
+        # Sorbet can handle super hover on typed true or higher
+        return if sorbet_level_true_or_higher?(@sorbet_level)
+
+        surrounding_method = @node_context.surrounding_method
+        return unless surrounding_method
+
+        handle_method_definition(
+          surrounding_method,
+          @type_inferrer.infer_receiver_type(@node_context),
+          inherited_only: true,
+        )
+      end
+
       sig { params(name: String).void }
       def handle_instance_variable_definition(name)
+        # Sorbet enforces that all instance variables be declared on typed strict or higher, which means it will be able
+        # to provide all features for them
+        return if @sorbet_level == RubyDocument::SorbetLevel::Strict
+
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
 
-        entries = @index.resolve_instance_variable(name, type)
+        entries = @index.resolve_instance_variable(name, type.name)
         return unless entries
 
         entries.each do |entry|
@@ -145,10 +204,10 @@ module RubyLsp
         # If by any chance we haven't indexed the owner, then there's no way to find the right declaration
       end
 
-      sig { params(message: String, receiver_type: T.nilable(String)).void }
-      def handle_method_definition(message, receiver_type)
+      sig { params(message: String, receiver_type: T.nilable(TypeInferrer::Type), inherited_only: T::Boolean).void }
+      def handle_method_definition(message, receiver_type, inherited_only: false)
         methods = if receiver_type
-          @index.resolve_method(message, receiver_type)
+          @index.resolve_method(message, receiver_type.name, inherited_only: inherited_only)
         else
           # If the method doesn't have a receiver, then we provide a few candidates to jump to
           # But we don't want to provide too many candidates, as it can be overwhelming
@@ -158,16 +217,13 @@ module RubyLsp
         return unless methods
 
         methods.each do |target_method|
-          location = target_method.location
           file_path = target_method.file_path
-          next if @typechecker_enabled && not_in_dependencies?(file_path)
+          next if sorbet_level_true_or_higher?(@sorbet_level) && not_in_dependencies?(file_path)
 
-          @response_builder << Interface::Location.new(
-            uri: URI::Generic.from_path(path: file_path).to_s,
-            range: Interface::Range.new(
-              start: Interface::Position.new(line: location.start_line - 1, character: location.start_column),
-              end: Interface::Position.new(line: location.end_line - 1, character: location.end_column),
-            ),
+          @response_builder << Interface::LocationLink.new(
+            target_uri: URI::Generic.from_path(path: file_path).to_s,
+            target_range: range_from_location(target_method.location),
+            target_selection_range: range_from_location(target_method.name_location),
           )
         end
       end
@@ -207,6 +263,17 @@ module RubyLsp
         end
       end
 
+      sig { params(node: Prism::CallNode).void }
+      def handle_autoload_definition(node)
+        argument = node.arguments&.arguments&.first
+        return unless argument.is_a?(Prism::SymbolNode)
+
+        constant_name = argument.value
+        return unless constant_name
+
+        find_in_index(constant_name)
+      end
+
       sig { params(value: String).void }
       def find_in_index(value)
         entries = @index.resolve(value, @node_context.nesting)
@@ -218,19 +285,16 @@ module RubyLsp
         return if first_entry.private? && first_entry.name != "#{@node_context.fully_qualified_name}::#{value}"
 
         entries.each do |entry|
-          location = entry.location
           # If the project has Sorbet, then we only want to handle go to definition for constants defined in gems, as an
-          # additional behavior on top of jumping to RBIs. Sorbet can already handle go to definition for all constants
-          # in the project, even if the files are typed false
+          # additional behavior on top of jumping to RBIs. The only sigil where Sorbet cannot handle constants is typed
+          # ignore
           file_path = entry.file_path
-          next if @typechecker_enabled && not_in_dependencies?(file_path)
+          next if @sorbet_level != RubyDocument::SorbetLevel::Ignore && not_in_dependencies?(file_path)
 
-          @response_builder << Interface::Location.new(
-            uri: URI::Generic.from_path(path: file_path).to_s,
-            range: Interface::Range.new(
-              start: Interface::Position.new(line: location.start_line - 1, character: location.start_column),
-              end: Interface::Position.new(line: location.end_line - 1, character: location.end_column),
-            ),
+          @response_builder << Interface::LocationLink.new(
+            target_uri: URI::Generic.from_path(path: file_path).to_s,
+            target_range: range_from_location(entry.location),
+            target_selection_range: range_from_location(entry.name_location),
           )
         end
       end

data/lib/ruby_lsp/listeners/document_highlight.rb

@@ -180,7 +180,11 @@ module RubyLsp
       def on_call_node_enter(node)
         return unless matches?(node, [Prism::CallNode, Prism::DefNode])
 
-        add_highlight(Constant::DocumentHighlightKind::READ, node.location)
+        loc = node.message_loc
+        # if we have `foo.` it's a call node but there is no message yet.
+        return unless loc
+
+        add_highlight(Constant::DocumentHighlightKind::READ, loc)
       end
 
       sig { params(node: Prism::DefNode).void }