ruby-lsp 0.18.3 → 0.19.1

data/lib/ruby_lsp/listeners/semantic_highlighting.rb

@@ -27,7 +27,7 @@ module RubyLsp
       def initialize(dispatcher, response_builder)
         @response_builder = response_builder
         @special_methods = T.let(nil, T.nilable(T::Array[String]))
-        @current_scope = T.let(ParameterScope.new, ParameterScope)
+        @current_scope = T.let(Scope.new, Scope)
         @inside_regex_capture = T.let(false, T::Boolean)
         @inside_implicit_node = T.let(false, T::Boolean)
 
@@ -102,7 +102,7 @@ module RubyLsp
 
       sig { params(node: Prism::DefNode).void }
       def on_def_node_enter(node)
-        @current_scope = ParameterScope.new(@current_scope)
+        @current_scope = Scope.new(@current_scope)
       end
 
       sig { params(node: Prism::DefNode).void }
@@ -112,7 +112,7 @@ module RubyLsp
 
       sig { params(node: Prism::BlockNode).void }
       def on_block_node_enter(node)
-        @current_scope = ParameterScope.new(@current_scope)
+        @current_scope = Scope.new(@current_scope)
       end
 
       sig { params(node: Prism::BlockNode).void }
@@ -128,39 +128,39 @@ module RubyLsp
       sig { params(node: Prism::BlockParameterNode).void }
       def on_block_parameter_node_enter(node)
         name = node.name
-        @current_scope << name.to_sym if name
+        @current_scope.add(name.to_sym, :parameter) if name
       end
 
       sig { params(node: Prism::RequiredKeywordParameterNode).void }
       def on_required_keyword_parameter_node_enter(node)
-        @current_scope << node.name
+        @current_scope.add(node.name, :parameter)
       end
 
       sig { params(node: Prism::OptionalKeywordParameterNode).void }
       def on_optional_keyword_parameter_node_enter(node)
-        @current_scope << node.name
+        @current_scope.add(node.name, :parameter)
       end
 
       sig { params(node: Prism::KeywordRestParameterNode).void }
       def on_keyword_rest_parameter_node_enter(node)
         name = node.name
-        @current_scope << name.to_sym if name
+        @current_scope.add(name.to_sym, :parameter) if name
       end
 
       sig { params(node: Prism::OptionalParameterNode).void }
       def on_optional_parameter_node_enter(node)
-        @current_scope << node.name
+        @current_scope.add(node.name, :parameter)
       end
 
       sig { params(node: Prism::RequiredParameterNode).void }
       def on_required_parameter_node_enter(node)
-        @current_scope << node.name
+        @current_scope.add(node.name, :parameter)
       end
 
       sig { params(node: Prism::RestParameterNode).void }
       def on_rest_parameter_node_enter(node)
         name = node.name
-        @current_scope << name.to_sym if name
+        @current_scope.add(name.to_sym, :parameter) if name
       end
 
       sig { params(node: Prism::SelfNode).void }
@@ -170,8 +170,8 @@ module RubyLsp
 
       sig { params(node: Prism::LocalVariableWriteNode).void }
       def on_local_variable_write_node_enter(node)
-        type = @current_scope.type_for(node.name)
-        @response_builder.add_token(node.name_loc, type) if type == :parameter
+        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 }
@@ -184,25 +184,26 @@ module RubyLsp
           return
         end
 
-        @response_builder.add_token(node.location, @current_scope.type_for(node.name))
+        local = @current_scope.lookup(node.name)
+        @response_builder.add_token(node.location, local&.type || :variable)
       end
 
       sig { params(node: Prism::LocalVariableAndWriteNode).void }
       def on_local_variable_and_write_node_enter(node)
-        type = @current_scope.type_for(node.name)
-        @response_builder.add_token(node.name_loc, type) if type == :parameter
+        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 }
       def on_local_variable_operator_write_node_enter(node)
-        type = @current_scope.type_for(node.name)
-        @response_builder.add_token(node.name_loc, type) if type == :parameter
+        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 }
       def on_local_variable_or_write_node_enter(node)
-        type = @current_scope.type_for(node.name)
-        @response_builder.add_token(node.name_loc, type) if type == :parameter
+        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 }
@@ -213,7 +214,8 @@ module RubyLsp
         # prevent pushing local variable target tokens. See https://github.com/ruby/prism/issues/1912
         return if @inside_regex_capture
 
-        @response_builder.add_token(node.location, @current_scope.type_for(node.name))
+        local = @current_scope.lookup(node.name)
+        @response_builder.add_token(node.location, local&.type || :variable)
       end
 
       sig { params(node: Prism::ClassNode).void }
@@ -311,7 +313,8 @@ module RubyLsp
           capture_name_offset = T.must(content.index("(?<#{name}>")) + 3
           local_var_loc = loc.copy(start_offset: loc.start_offset + capture_name_offset, length: name.length)
 
-          @response_builder.add_token(local_var_loc, @current_scope.type_for(name))
+          local = @current_scope.lookup(name)
+          @response_builder.add_token(local_var_loc, local&.type || :variable)
         end
       end
     end

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -23,10 +23,11 @@ module RubyLsp
         end
       end
 
-      sig { params(document: RubyDocument, code_action: T::Hash[Symbol, T.untyped]).void }
-      def initialize(document, code_action)
+      sig { params(document: RubyDocument, global_state: GlobalState, code_action: T::Hash[Symbol, T.untyped]).void }
+      def initialize(document, global_state, code_action)
         super()
         @document = document
+        @global_state = global_state
         @code_action = code_action
       end
 
@@ -191,7 +192,12 @@ 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 = RubyDocument.locate(@document.parse_result.value, start_index, node_types: [Prism::DefNode])
+        node_context = RubyDocument.locate(
+          @document.parse_result.value,
+          start_index,
+          node_types: [Prism::DefNode],
+          encoding: @global_state.encoding,
+        )
         closest_node = node_context.node
         return Error::InvalidTargetRange unless closest_node
 

data/lib/ruby_lsp/requests/completion.rb

@@ -57,6 +57,7 @@ module RubyLsp
             Prism::InstanceVariableTargetNode,
             Prism::InstanceVariableWriteNode,
           ],
+          encoding: global_state.encoding,
         )
         @response_builder = T.let(
           ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem].new,

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -40,6 +40,8 @@ module RubyLsp
         # For example, forgetting to return the `insertText` included in the original item will make the editor use the
         # `label` for the text edit instead
         label = @item[:label].dup
+        return keyword_resolve(@item) if @item.dig(:data, :keyword)
+
         entries = @index[label] || []
 
         owner_name = @item.dig(:data, :owner_name)
@@ -72,6 +74,33 @@ module RubyLsp
 
         @item
       end
+
+      private
+
+      sig { params(item: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+      def keyword_resolve(item)
+        keyword = item[:label]
+        content = KEYWORD_DOCS[keyword]
+
+        if content
+          doc_path = File.join(STATIC_DOCS_PATH, "#{keyword}.md")
+
+          @item[:documentation] = Interface::MarkupContent.new(
+            kind: "markdown",
+            value: <<~MARKDOWN.chomp,
+              ```ruby
+              #{keyword}
+              ```
+
+              [Read more](#{doc_path})
+
+              #{content}
+            MARKDOWN
+          )
+        end
+
+        item
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/definition.rb

@@ -57,6 +57,7 @@ module RubyLsp
             Prism::SuperNode,
             Prism::ForwardingSuperNode,
           ],
+          encoding: global_state.encoding,
         )
 
         target = node_context.node

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -28,7 +28,7 @@ module RubyLsp
         char_position = document.create_scanner.find_char_position(position)
         delegate_request_if_needed!(global_state, document, char_position)
 
-        node_context = RubyDocument.locate(document.parse_result.value, char_position)
+        node_context = RubyDocument.locate(document.parse_result.value, char_position, encoding: global_state.encoding)
 
         @response_builder = T.let(
           ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight].new,

data/lib/ruby_lsp/requests/hover.rb

@@ -41,6 +41,7 @@ module RubyLsp
           document.parse_result.value,
           char_position,
           node_types: Listeners::Hover::ALLOWED_TARGETS,
+          encoding: global_state.encoding,
         )
         target = node_context.node
         parent = node_context.parent

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -63,7 +63,7 @@ module RubyLsp
           if (comment_match = @previous_line.match(/^#(\s*)/))
             handle_comment_line(T.must(comment_match[1]))
           elsif @document.syntax_error?
-            match = /(?<=<<(-|~))(?<quote>['"`]?)(?<delimiter>\w+)\k<quote>/.match(@previous_line)
+            match = /(<<((-|~)?))(?<quote>['"`]?)(?<delimiter>\w+)\k<quote>/.match(@previous_line)
             heredoc_delimiter = match && match.named_captures["delimiter"]
 
             if heredoc_delimiter

data/lib/ruby_lsp/requests/range_formatting.rb

@@ -0,0 +1,55 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # The [range formatting](https://microsoft.github.io/language-server-protocol/specification#textDocument_rangeFormatting)
+    # is used to format a selection or to format on paste.
+    class RangeFormatting < Request
+      extend T::Sig
+
+      sig { params(global_state: GlobalState, document: RubyDocument, params: T::Hash[Symbol, T.untyped]).void }
+      def initialize(global_state, document, params)
+        super()
+        @document = document
+        @uri = T.let(document.uri, URI::Generic)
+        @params = params
+        @active_formatter = T.let(global_state.active_formatter, T.nilable(Support::Formatter))
+      end
+
+      sig { override.returns(T.nilable(T::Array[Interface::TextEdit])) }
+      def perform
+        return unless @active_formatter
+        return if @document.syntax_error?
+
+        target = @document.locate_first_within_range(@params[:range])
+        return unless target
+
+        location = target.location
+
+        formatted_text = @active_formatter.run_range_formatting(
+          @uri,
+          target.slice,
+          location.start_column / 2,
+        )
+        return unless formatted_text
+
+        [
+          Interface::TextEdit.new(
+            range: Interface::Range.new(
+              start: Interface::Position.new(
+                line: location.start_line - 1,
+                character: location.start_code_units_column(@document.encoding),
+              ),
+              end: Interface::Position.new(
+                line: location.end_line - 1,
+                character: location.end_code_units_column(@document.encoding),
+              ),
+            ),
+            new_text: formatted_text.strip,
+          ),
+        ]
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/references.rb

@@ -0,0 +1,146 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # The
+    # [references](https://microsoft.github.io/language-server-protocol/specification#textDocument_references)
+    # request finds all references for the selected symbol.
+    class References < Request
+      extend T::Sig
+      include Support::Common
+
+      sig do
+        params(
+          global_state: GlobalState,
+          store: Store,
+          document: T.any(RubyDocument, ERBDocument),
+          params: T::Hash[Symbol, T.untyped],
+        ).void
+      end
+      def initialize(global_state, store, document, params)
+        super()
+        @global_state = global_state
+        @store = store
+        @document = document
+        @params = params
+        @locations = T.let([], T::Array[Interface::Location])
+      end
+
+      sig { override.returns(T::Array[Interface::Location]) }
+      def perform
+        position = @params[:position]
+        char_position = @document.create_scanner.find_char_position(position)
+
+        node_context = RubyDocument.locate(
+          @document.parse_result.value,
+          char_position,
+          node_types: [
+            Prism::ConstantReadNode,
+            Prism::ConstantPathNode,
+            Prism::ConstantPathTargetNode,
+            Prism::CallNode,
+            Prism::DefNode,
+          ],
+          encoding: @global_state.encoding,
+        )
+        target = node_context.node
+        parent = node_context.parent
+        return @locations if !target || target.is_a?(Prism::ProgramNode)
+
+        if target.is_a?(Prism::ConstantReadNode) && parent.is_a?(Prism::ConstantPathNode)
+          target = determine_target(
+            target,
+            parent,
+            position,
+          )
+        end
+
+        target = T.cast(
+          target,
+          T.any(
+            Prism::ConstantReadNode,
+            Prism::ConstantPathNode,
+            Prism::ConstantPathTargetNode,
+            Prism::CallNode,
+            Prism::DefNode,
+          ),
+        )
+
+        reference_target = create_reference_target(target, node_context)
+        return @locations unless reference_target
+
+        Dir.glob(File.join(@global_state.workspace_path, "**/*.rb")).each do |path|
+          uri = URI::Generic.from_path(path: path)
+          # If the document is being managed by the client, then we should use whatever is present in the store instead
+          # of reading from disk
+          next if @store.key?(uri)
+
+          parse_result = Prism.parse_file(path)
+          collect_references(reference_target, parse_result, uri)
+        end
+
+        @store.each do |_uri, document|
+          collect_references(reference_target, document.parse_result, document.uri)
+        end
+
+        @locations
+      end
+
+      private
+
+      sig do
+        params(
+          target_node: T.any(
+            Prism::ConstantReadNode,
+            Prism::ConstantPathNode,
+            Prism::ConstantPathTargetNode,
+            Prism::CallNode,
+            Prism::DefNode,
+          ),
+          node_context: NodeContext,
+        ).returns(T.nilable(RubyIndexer::ReferenceFinder::Target))
+      end
+      def create_reference_target(target_node, node_context)
+        case target_node
+        when Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode
+          name = constant_name(target_node)
+          return unless name
+
+          entries = @global_state.index.resolve(name, node_context.nesting)
+          return unless entries
+
+          fully_qualified_name = T.must(entries.first).name
+          RubyIndexer::ReferenceFinder::ConstTarget.new(fully_qualified_name)
+        when Prism::CallNode, Prism::DefNode
+          RubyIndexer::ReferenceFinder::MethodTarget.new(target_node.name.to_s)
+        end
+      end
+
+      sig do
+        params(
+          target: RubyIndexer::ReferenceFinder::Target,
+          parse_result: Prism::ParseResult,
+          uri: URI::Generic,
+        ).void
+      end
+      def collect_references(target, parse_result, uri)
+        dispatcher = Prism::Dispatcher.new
+        finder = RubyIndexer::ReferenceFinder.new(
+          target,
+          @global_state.index,
+          dispatcher,
+          include_declarations: @params.dig(:context, :includeDeclaration) || true,
+        )
+        dispatcher.visit(parse_result.value)
+
+        finder.references.each do |reference|
+          @locations << Interface::Location.new(
+            uri: uri.to_s,
+            range: range_from_location(reference.location),
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/rename.rb

@@ -0,0 +1,196 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # The
+    # [rename](https://microsoft.github.io/language-server-protocol/specification#textDocument_rename)
+    # request renames all instances of a symbol in a document.
+    class Rename < Request
+      extend T::Sig
+      include Support::Common
+
+      class InvalidNameError < StandardError; end
+
+      sig do
+        params(
+          global_state: GlobalState,
+          store: Store,
+          document: T.any(RubyDocument, ERBDocument),
+          params: T::Hash[Symbol, T.untyped],
+        ).void
+      end
+      def initialize(global_state, store, document, params)
+        super()
+        @global_state = global_state
+        @store = store
+        @document = document
+        @position = T.let(params[:position], T::Hash[Symbol, Integer])
+        @new_name = T.let(params[:newName], String)
+      end
+
+      sig { override.returns(T.nilable(Interface::WorkspaceEdit)) }
+      def perform
+        char_position = @document.create_scanner.find_char_position(@position)
+
+        node_context = RubyDocument.locate(
+          @document.parse_result.value,
+          char_position,
+          node_types: [Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode],
+          encoding: @global_state.encoding,
+        )
+        target = node_context.node
+        parent = node_context.parent
+        return if !target || target.is_a?(Prism::ProgramNode)
+
+        if target.is_a?(Prism::ConstantReadNode) && parent.is_a?(Prism::ConstantPathNode)
+          target = determine_target(
+            target,
+            parent,
+            @position,
+          )
+        end
+
+        target = T.cast(
+          target,
+          T.any(Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode),
+        )
+
+        name = constant_name(target)
+        return unless name
+
+        entries = @global_state.index.resolve(name, node_context.nesting)
+        return unless entries
+
+        if (conflict_entries = @global_state.index.resolve(@new_name, node_context.nesting))
+          raise InvalidNameError, "The new name is already in use by #{T.must(conflict_entries.first).name}"
+        end
+
+        fully_qualified_name = T.must(entries.first).name
+        reference_target = RubyIndexer::ReferenceFinder::ConstTarget.new(fully_qualified_name)
+        changes = collect_text_edits(reference_target, name)
+
+        # If the client doesn't support resource operations, such as renaming files, then we can only return the basic
+        # text changes
+        unless @global_state.supported_resource_operations.include?("rename")
+          return Interface::WorkspaceEdit.new(changes: changes)
+        end
+
+        # Text edits must be applied before any resource operations, such as renaming files. Otherwise, the file is
+        # renamed and then the URI associated to the text edit no longer exists, causing it to be dropped
+        document_changes = changes.map do |uri, edits|
+          Interface::TextDocumentEdit.new(
+            text_document: Interface::VersionedTextDocumentIdentifier.new(uri: uri, version: nil),
+            edits: edits,
+          )
+        end
+
+        collect_file_renames(fully_qualified_name, document_changes)
+        Interface::WorkspaceEdit.new(document_changes: document_changes)
+      end
+
+      private
+
+      sig do
+        params(
+          fully_qualified_name: String,
+          document_changes: T::Array[T.any(Interface::RenameFile, Interface::TextDocumentEdit)],
+        ).void
+      end
+      def collect_file_renames(fully_qualified_name, document_changes)
+        # Check if the declarations of the symbol being renamed match the file name. In case they do, we automatically
+        # rename the files for the user.
+        #
+        # We also look for an associated test file and rename it too
+        short_name = T.must(fully_qualified_name.split("::").last)
+
+        T.must(@global_state.index[fully_qualified_name]).each do |entry|
+          # Do not rename files that are not part of the workspace
+          next unless entry.file_path.start_with?(@global_state.workspace_path)
+
+          case entry
+          when RubyIndexer::Entry::Class, RubyIndexer::Entry::Module, RubyIndexer::Entry::Constant,
+               RubyIndexer::Entry::ConstantAlias, RubyIndexer::Entry::UnresolvedConstantAlias
+
+            file_name = file_from_constant_name(short_name)
+
+            if "#{file_name}.rb" == entry.file_name
+              new_file_name = file_from_constant_name(T.must(@new_name.split("::").last))
+
+              old_uri = URI::Generic.from_path(path: entry.file_path).to_s
+              new_uri = URI::Generic.from_path(path: File.join(
+                File.dirname(entry.file_path),
+                "#{new_file_name}.rb",
+              )).to_s
+
+              document_changes << Interface::RenameFile.new(kind: "rename", old_uri: old_uri, new_uri: new_uri)
+            end
+          end
+        end
+      end
+
+      sig do
+        params(
+          target: RubyIndexer::ReferenceFinder::Target,
+          name: String,
+        ).returns(T::Hash[String, T::Array[Interface::TextEdit]])
+      end
+      def collect_text_edits(target, name)
+        changes = {}
+
+        Dir.glob(File.join(@global_state.workspace_path, "**/*.rb")).each do |path|
+          uri = URI::Generic.from_path(path: path)
+          # If the document is being managed by the client, then we should use whatever is present in the store instead
+          # of reading from disk
+          next if @store.key?(uri)
+
+          parse_result = Prism.parse_file(path)
+          edits = collect_changes(target, parse_result, name, uri)
+          changes[uri.to_s] = edits unless edits.empty?
+        end
+
+        @store.each do |uri, document|
+          edits = collect_changes(target, document.parse_result, name, document.uri)
+          changes[uri] = edits unless edits.empty?
+        end
+
+        changes
+      end
+
+      sig do
+        params(
+          target: RubyIndexer::ReferenceFinder::Target,
+          parse_result: Prism::ParseResult,
+          name: String,
+          uri: URI::Generic,
+        ).returns(T::Array[Interface::TextEdit])
+      end
+      def collect_changes(target, parse_result, name, uri)
+        dispatcher = Prism::Dispatcher.new
+        finder = RubyIndexer::ReferenceFinder.new(target, @global_state.index, dispatcher)
+        dispatcher.visit(parse_result.value)
+
+        finder.references.map do |reference|
+          adjust_reference_for_edit(name, reference)
+        end
+      end
+
+      sig { params(name: String, reference: RubyIndexer::ReferenceFinder::Reference).returns(Interface::TextEdit) }
+      def adjust_reference_for_edit(name, reference)
+        # The reference may include a namespace in front. We need to check if the rename new name includes namespaces
+        # and then adjust both the text and the location to produce the correct edit
+        location = reference.location
+        new_text = reference.name.sub(name, @new_name)
+
+        Interface::TextEdit.new(range: range_from_location(location), new_text: new_text)
+      end
+
+      sig { params(constant_name: String).returns(String) }
+      def file_from_constant_name(constant_name)
+        constant_name
+          .gsub(/([a-z])([A-Z])|([A-Z])([A-Z][a-z])/, '\1\3_\2\4')
+          .downcase
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/signature_help.rb

@@ -39,7 +39,12 @@ module RubyLsp
         char_position = document.create_scanner.find_char_position(position)
         delegate_request_if_needed!(global_state, document, char_position)
 
-        node_context = RubyDocument.locate(document.parse_result.value, char_position, node_types: [Prism::CallNode])
+        node_context = RubyDocument.locate(
+          document.parse_result.value,
+          char_position,
+          node_types: [Prism::CallNode],
+          encoding: global_state.encoding,
+        )
 
         target = adjust_for_nested_target(node_context.node, node_context.parent, position)
 

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

@@ -5,8 +5,8 @@ module RubyLsp
   module Requests
     module Support
       module Common
-        # WARNING: Methods in this class may be used by Ruby LSP addons such as
-        # https://github.com/Shopify/ruby-lsp-rails, or addons by created by developers outside of Shopify, so be
+        # WARNING: Methods in this class may be used by Ruby LSP add-ons such as
+        # https://github.com/Shopify/ruby-lsp-rails, or add-ons by created by developers outside of Shopify, so be
         # cautious of changing anything.
         extend T::Sig
         extend T::Helpers