ruby-lsp 0.17.3 → 0.17.5

data/lib/ruby_lsp/erb_document.rb

@@ -0,0 +1,125 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  class ERBDocument < Document
+    extend T::Sig
+
+    sig { override.returns(Prism::ParseResult) }
+    def parse
+      return @parse_result unless @needs_parsing
+
+      @needs_parsing = false
+      scanner = ERBScanner.new(@source)
+      scanner.scan
+      @parse_result = Prism.parse(scanner.ruby)
+    end
+
+    sig { override.returns(T::Boolean) }
+    def syntax_error?
+      @parse_result.failure?
+    end
+
+    sig { override.returns(LanguageId) }
+    def language_id
+      LanguageId::ERB
+    end
+
+    class ERBScanner
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :ruby, :html
+
+      sig { params(source: String).void }
+      def initialize(source)
+        @source = source
+        @html = T.let(+"", String)
+        @ruby = T.let(+"", String)
+        @current_pos = T.let(0, Integer)
+        @inside_ruby = T.let(false, T::Boolean)
+      end
+
+      sig { void }
+      def scan
+        while @current_pos < @source.length
+          scan_char
+          @current_pos += 1
+        end
+      end
+
+      private
+
+      sig { void }
+      def scan_char
+        char = @source[@current_pos]
+
+        case char
+        when "<"
+          if next_char == "%"
+            @inside_ruby = true
+            @current_pos += 1
+            push_char("  ")
+
+            if next_char == "=" && @source[@current_pos + 2] == "="
+              @current_pos += 2
+              push_char("  ")
+            elsif next_char == "=" || next_char == "-"
+              @current_pos += 1
+              push_char(" ")
+            end
+          else
+            push_char(T.must(char))
+          end
+        when "-"
+          if @inside_ruby && next_char == "%" &&
+              @source[@current_pos + 2] == ">"
+            @current_pos += 2
+            push_char("   ")
+            @inside_ruby = false
+          else
+            push_char(T.must(char))
+          end
+        when "%"
+          if @inside_ruby && next_char == ">"
+            @inside_ruby = false
+            @current_pos += 1
+            push_char("  ")
+          else
+            push_char(T.must(char))
+          end
+        when "\r"
+          @ruby << char
+          @html << char
+
+          if next_char == "\n"
+            @ruby << next_char
+            @html << next_char
+            @current_pos += 1
+          end
+        when "\n"
+          @ruby << char
+          @html << char
+        else
+          push_char(T.must(char))
+        end
+      end
+
+      sig { params(char: String).void }
+      def push_char(char)
+        if @inside_ruby
+          @ruby << char
+          @html << " " * char.length
+        else
+          @ruby << " " * char.length
+          @html << char
+        end
+      end
+
+      sig { returns(String) }
+      def next_char
+        @source[@current_pos + 1] || ""
+      end
+    end
+  end
+end

data/lib/ruby_lsp/global_state.rb

@@ -12,7 +12,7 @@ module RubyLsp
     attr_accessor :formatter
 
     sig { returns(T::Boolean) }
-    attr_reader :typechecker
+    attr_reader :has_type_checker
 
     sig { returns(RubyIndexer::Index) }
     attr_reader :index
@@ -21,7 +21,10 @@ module RubyLsp
     attr_reader :encoding
 
     sig { returns(T::Boolean) }
-    attr_reader :supports_watching_files
+    attr_reader :supports_watching_files, :experimental_features
+
+    sig { returns(TypeInferrer) }
+    attr_reader :type_inferrer
 
     sig { void }
     def initialize
@@ -31,10 +34,12 @@ module RubyLsp
       @formatter = T.let("auto", String)
       @linters = T.let([], T::Array[String])
       @test_library = T.let("minitest", String)
-      @typechecker = T.let(true, T::Boolean)
+      @has_type_checker = T.let(true, T::Boolean)
       @index = T.let(RubyIndexer::Index.new, RubyIndexer::Index)
+      @type_inferrer = T.let(TypeInferrer.new(@index), TypeInferrer)
       @supported_formatters = T.let({}, T::Hash[String, Requests::Support::Formatter])
       @supports_watching_files = T.let(false, T::Boolean)
+      @experimental_features = T.let(false, T::Boolean)
     end
 
     sig { params(identifier: String, instance: Requests::Support::Formatter).void }
@@ -66,7 +71,7 @@ module RubyLsp
       specified_linters = options.dig(:initializationOptions, :linters)
       @linters = specified_linters || detect_linters(direct_dependencies)
       @test_library = detect_test_library(direct_dependencies)
-      @typechecker = detect_typechecker(direct_dependencies)
+      @has_type_checker = detect_typechecker(direct_dependencies)
 
       encodings = options.dig(:capabilities, :general, :positionEncodings)
       @encoding = if !encodings || encodings.empty?
@@ -83,6 +88,8 @@ module RubyLsp
       if file_watching_caps&.dig(:dynamicRegistration) && file_watching_caps&.dig(:relativePatternSupport)
         @supports_watching_files = true
       end
+
+      @experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled) || false
     end
 
     sig { returns(String) }

data/lib/ruby_lsp/internal.rb

@@ -15,6 +15,7 @@ Bundler.ui.level = :silent
 require "uri"
 require "cgi"
 require "set"
+require "strscan"
 require "prism"
 require "prism/visitor"
 require "language_server-protocol"
@@ -28,11 +29,13 @@ require "ruby_lsp/utils"
 require "ruby_lsp/parameter_scope"
 require "ruby_lsp/global_state"
 require "ruby_lsp/server"
+require "ruby_lsp/type_inferrer"
 require "ruby_lsp/requests"
 require "ruby_lsp/response_builders"
 require "ruby_lsp/node_context"
 require "ruby_lsp/document"
 require "ruby_lsp/ruby_document"
+require "ruby_lsp/erb_document"
 require "ruby_lsp/store"
 require "ruby_lsp/addon"
 require "ruby_lsp/requests/support/rubocop_runner"

data/lib/ruby_lsp/listeners/completion.rb

@@ -15,15 +15,26 @@ module RubyLsp
           typechecker_enabled: T::Boolean,
           dispatcher: Prism::Dispatcher,
           uri: URI::Generic,
+          trigger_character: T.nilable(String),
         ).void
       end
-      def initialize(response_builder, global_state, node_context, typechecker_enabled, dispatcher, uri) # rubocop:disable Metrics/ParameterLists
+      def initialize( # rubocop:disable Metrics/ParameterLists
+        response_builder,
+        global_state,
+        node_context,
+        typechecker_enabled,
+        dispatcher,
+        uri,
+        trigger_character
+      )
         @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)
         @node_context = node_context
         @typechecker_enabled = typechecker_enabled
         @uri = uri
+        @trigger_character = trigger_character
 
         dispatcher.register(
           self,
@@ -42,7 +53,7 @@ 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.typechecker
+        return if @global_state.has_type_checker
 
         name = constant_name(node)
         return if name.nil?
@@ -63,7 +74,7 @@ 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.typechecker
+        return if @global_state.has_type_checker
 
         name = constant_name(node)
         return if name.nil?
@@ -107,7 +118,7 @@ module RubyLsp
         when "require_relative"
           complete_require_relative(node)
         else
-          complete_self_receiver_method(node, name) if !@typechecker_enabled && self_receiver?(node)
+          complete_methods(node, name) unless @typechecker_enabled
         end
       end
 
@@ -158,7 +169,7 @@ module RubyLsp
           name.delete_suffix("::")
         else
           *namespace, incomplete_name = name.split("::")
-          T.must(namespace).join("::")
+          namespace.join("::")
         end
 
         nesting = @node_context.nesting
@@ -192,11 +203,19 @@ module RubyLsp
 
       sig { params(name: String, location: Prism::Location).void }
       def handle_instance_variable_completion(name, location)
-        @index.instance_variable_completion_candidates(name, @node_context.fully_qualified_name).each do |entry|
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        @index.instance_variable_completion_candidates(name, type).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,
@@ -257,40 +276,50 @@ module RubyLsp
       end
 
       sig { params(node: Prism::CallNode, name: String).void }
-      def complete_self_receiver_method(node, name)
-        receiver_entries = @index[@node_context.fully_qualified_name]
-        return unless receiver_entries
+      def complete_methods(node, name)
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
 
-        receiver = T.must(receiver_entries.first)
+        # When the trigger character is a dot, Prism matches the name of the call node to whatever is next in the source
+        # code, leading to us searching for the wrong name. What we want to do instead is show every available method
+        # when dot is pressed
+        method_name = @trigger_character == "." ? nil : name
 
-        @index.method_completion_candidates(name, receiver.name).each do |entry|
-          @response_builder << build_method_completion(T.cast(entry, RubyIndexer::Entry::Member), node)
+        range = if method_name
+          range_from_location(T.must(node.message_loc))
+        else
+          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
-      end
 
-      sig do
-        params(
-          entry: RubyIndexer::Entry::Member,
-          node: Prism::CallNode,
-        ).returns(Interface::CompletionItem)
-      end
-      def build_method_completion(entry, node)
-        name = entry.name
+        return unless range
 
-        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.parameters.map(&:decorated_name).join(", ")})",
+        @index.method_completion_candidates(method_name, type).each do |entry|
+          entry_name = entry.name
+
+          label_details = Interface::CompletionItemLabelDetails.new(
             description: entry.file_name,
-          ),
-          documentation: Interface::MarkupContent.new(
-            kind: "markdown",
-            value: markdown_from_index_entries(name, entry),
-          ),
-        )
+            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,
+            },
+          )
+        end
+      rescue RubyIndexer::Index::NonExistingNamespaceError
+        # We have not indexed this namespace, so we can't provide any completions
       end
 
       sig { params(label: String, node: Prism::StringNode).returns(Interface::CompletionItem) }
@@ -374,8 +403,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,18 +11,24 @@ 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,
         ).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, typechecker_enabled) # 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
@@ -48,7 +54,15 @@ module RubyLsp
         message = node.message
         return unless message
 
-        handle_method_definition(message, self_receiver?(node))
+        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 == "Object"
+          inferrer_receiver_type = nil
+        end
+
+        handle_method_definition(message, inferrer_receiver_type)
       end
 
       sig { params(node: Prism::StringNode).void }
@@ -70,7 +84,7 @@ module RubyLsp
         value = expression.value
         return unless value
 
-        handle_method_definition(value, false)
+        handle_method_definition(value, nil)
       end
 
       sig { params(node: Prism::ConstantPathNode).void }
@@ -123,7 +137,10 @@ module RubyLsp
 
       sig { params(name: String).void }
       def handle_instance_variable_definition(name)
-        entries = @index.resolve_instance_variable(name, @node_context.fully_qualified_name)
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        entries = @index.resolve_instance_variable(name, type)
         return unless entries
 
         entries.each do |entry|
@@ -141,10 +158,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, self_receiver: T::Boolean).void }
-      def handle_method_definition(message, self_receiver)
-        methods = if self_receiver
-          @index.resolve_method(message, @node_context.fully_qualified_name)
+      sig { params(message: String, receiver_type: T.nilable(String)).void }
+      def handle_method_definition(message, receiver_type)
+        methods = if receiver_type
+          @index.resolve_method(message, receiver_type)
         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
@@ -154,16 +171,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)
 
-          @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
@@ -214,19 +228,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
           file_path = entry.file_path
           next if @typechecker_enabled && 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/hover.rb

@@ -47,6 +47,7 @@ module RubyLsp
         @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)
         @path = T.let(uri.to_standardized_path, T.nilable(String))
         @node_context = node_context
         @typechecker_enabled = typechecker_enabled
@@ -78,14 +79,14 @@ module RubyLsp
 
       sig { params(node: Prism::ConstantWriteNode).void }
       def on_constant_write_node_enter(node)
-        return if @global_state.typechecker
+        return if @global_state.has_type_checker
 
         generate_hover(node.name.to_s, node.name_loc)
       end
 
       sig { params(node: Prism::ConstantPathNode).void }
       def on_constant_path_node_enter(node)
-        return if @global_state.typechecker
+        return if @global_state.has_type_checker
 
         name = constant_name(node)
         return if name.nil?
@@ -95,8 +96,6 @@ module RubyLsp
 
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
-        return unless self_receiver?(node)
-
         if @path && File.basename(@path) == GEMFILE_NAME && node.name == :gem
           generate_gem_hover(node)
           return
@@ -107,10 +106,15 @@ module RubyLsp
         message = node.message
         return unless message
 
-        methods = @index.resolve_method(message, @node_context.fully_qualified_name)
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        methods = @index.resolve_method(message, type)
         return unless methods
 
-        categorized_markdown_from_index_entries(message, methods).each do |category, content|
+        title = "#{message}#{T.must(methods.first).decorated_parameters}"
+
+        categorized_markdown_from_index_entries(title, methods).each do |category, content|
           @response_builder.push(content, category: category)
         end
       end
@@ -149,7 +153,10 @@ module RubyLsp
 
       sig { params(name: String).void }
       def handle_instance_variable_hover(name)
-        entries = @index.resolve_instance_variable(name, @node_context.fully_qualified_name)
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        entries = @index.resolve_instance_variable(name, type)
         return unless entries
 
         categorized_markdown_from_index_entries(name, entries).each do |category, content|

data/lib/ruby_lsp/listeners/signature_help.rb

@@ -21,6 +21,7 @@ module RubyLsp
         @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)
         @node_context = node_context
         dispatcher.register(self, :on_call_node_enter)
       end
@@ -28,12 +29,14 @@ module RubyLsp
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
         return if @typechecker_enabled
-        return unless self_receiver?(node)
 
         message = node.message
         return unless message
 
-        methods = @index.resolve_method(message, @node_context.fully_qualified_name)
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        methods = @index.resolve_method(message, type)
         return unless methods
 
         target_method = methods.first

data/lib/ruby_lsp/node_context.rb

@@ -16,19 +16,24 @@ module RubyLsp
     sig { returns(T.nilable(Prism::CallNode)) }
     attr_reader :call_node
 
+    sig { returns(T.nilable(String)) }
+    attr_reader :surrounding_method
+
     sig do
       params(
         node: T.nilable(Prism::Node),
         parent: T.nilable(Prism::Node),
         nesting: T::Array[String],
         call_node: T.nilable(Prism::CallNode),
+        surrounding_method: T.nilable(String),
       ).void
     end
-    def initialize(node, parent, nesting, call_node)
+    def initialize(node, parent, nesting, call_node, surrounding_method)
       @node = node
       @parent = parent
       @nesting = nesting
       @call_node = call_node
+      @surrounding_method = surrounding_method
     end
 
     sig { returns(String) }

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -69,7 +69,7 @@ module RubyLsp
 
         # Find the closest statements node, so that we place the refactor in a valid position
         node_context = @document
-          .locate(@document.tree, start_index, node_types: [Prism::StatementsNode, Prism::BlockNode])
+          .locate(@document.parse_result.value, start_index, node_types: [Prism::StatementsNode, Prism::BlockNode])
 
         closest_statements = node_context.node
         parent_statements = node_context.parent
@@ -164,7 +164,7 @@ module RubyLsp
         extracted_source = T.must(@document.source[start_index...end_index])
 
         # Find the closest method declaration node, so that we place the refactor in a valid position
-        node_context = @document.locate(@document.tree, start_index, node_types: [Prism::DefNode])
+        node_context = @document.locate(@document.parse_result.value, start_index, node_types: [Prism::DefNode])
         closest_def = T.cast(node_context.node, Prism::DefNode)
         return Error::InvalidTargetRange if closest_def.nil?
 

data/lib/ruby_lsp/requests/completion.rb

@@ -36,7 +36,7 @@ module RubyLsp
         def provider
           Interface::CompletionOptions.new(
             resolve_provider: true,
-            trigger_characters: ["/", "\"", "'", ":", "@"],
+            trigger_characters: ["/", "\"", "'", ":", "@", "."],
             completion_item: {
               labelDetailsSupport: true,
             },
@@ -48,20 +48,20 @@ module RubyLsp
         params(
           document: Document,
           global_state: GlobalState,
-          position: T::Hash[Symbol, T.untyped],
+          params: T::Hash[Symbol, T.untyped],
           typechecker_enabled: T::Boolean,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(document, global_state, position, typechecker_enabled, dispatcher)
+      def initialize(document, global_state, params, typechecker_enabled, dispatcher)
         super()
         @target = T.let(nil, T.nilable(Prism::Node))
         @dispatcher = dispatcher
         # Completion always receives the position immediately after the character that was just typed. Here we adjust it
         # back by 1, so that we find the right node
-        char_position = document.create_scanner.find_char_position(position) - 1
+        char_position = document.create_scanner.find_char_position(params[:position]) - 1
         node_context = document.locate(
-          document.tree,
+          document.parse_result.value,
           char_position,
           node_types: [
             Prism::CallNode,
@@ -87,6 +87,7 @@ module RubyLsp
           typechecker_enabled,
           dispatcher,
           document.uri,
+          params.dig(:context, :triggerCharacter),
         )
 
         Addon.addons.each do |addon|