ruby-lsp 0.18.3 → 0.19.0

data/lib/ruby_lsp/internal.rb

@@ -26,7 +26,8 @@ require "ruby_lsp/base_server"
 require "ruby_indexer/ruby_indexer"
 require "core_ext/uri"
 require "ruby_lsp/utils"
-require "ruby_lsp/parameter_scope"
+require "ruby_lsp/static_docs"
+require "ruby_lsp/scope"
 require "ruby_lsp/global_state"
 require "ruby_lsp/server"
 require "ruby_lsp/type_inferrer"
@@ -80,3 +81,4 @@ require "ruby_lsp/requests/show_syntax_tree"
 require "ruby_lsp/requests/signature_help"
 require "ruby_lsp/requests/type_hierarchy_supertypes"
 require "ruby_lsp/requests/workspace_symbol"
+require "ruby_lsp/requests/rename"

data/lib/ruby_lsp/listeners/completion.rb

@@ -438,7 +438,7 @@ module RubyLsp
             text_edit: Interface::TextEdit.new(range: range, new_text: keyword),
             kind: Constant::CompletionItemKind::KEYWORD,
             data: {
-              skip_resolve: true,
+              keyword: true,
             },
           )
         end

data/lib/ruby_lsp/listeners/hover.rb

@@ -21,8 +21,10 @@ module RubyLsp
           Prism::InstanceVariableWriteNode,
           Prism::SymbolNode,
           Prism::StringNode,
+          Prism::InterpolatedStringNode,
           Prism::SuperNode,
           Prism::ForwardingSuperNode,
+          Prism::YieldNode,
         ],
         T::Array[T.class_of(Prism::Node)],
       )
@@ -68,9 +70,22 @@ module RubyLsp
           :on_instance_variable_target_node_enter,
           :on_super_node_enter,
           :on_forwarding_super_node_enter,
+          :on_string_node_enter,
+          :on_interpolated_string_node_enter,
+          :on_yield_node_enter,
         )
       end
 
+      sig { params(node: Prism::StringNode).void }
+      def on_string_node_enter(node)
+        generate_heredoc_hover(node)
+      end
+
+      sig { params(node: Prism::InterpolatedStringNode).void }
+      def on_interpolated_string_node_enter(node)
+        generate_heredoc_hover(node)
+      end
+
       sig { params(node: Prism::ConstantReadNode).void }
       def on_constant_read_node_enter(node)
         return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
@@ -153,8 +168,50 @@ module RubyLsp
         handle_super_node_hover
       end
 
+      sig { params(node: Prism::YieldNode).void }
+      def on_yield_node_enter(node)
+        handle_keyword_documentation(node.keyword)
+      end
+
       private
 
+      sig { params(node: T.any(Prism::InterpolatedStringNode, Prism::StringNode)).void }
+      def generate_heredoc_hover(node)
+        return unless node.heredoc?
+
+        opening_content = node.opening_loc&.slice
+        return unless opening_content
+
+        match = /(<<(?<type>(-|~)?))(?<quote>['"`]?)(?<delimiter>\w+)\k<quote>/.match(opening_content)
+        return unless match
+
+        heredoc_delimiter = match.named_captures["delimiter"]
+
+        if heredoc_delimiter
+          message = if match["type"] == "~"
+            "This is a squiggly heredoc definition using the `#{heredoc_delimiter}` delimiter. " \
+              "Indentation will be ignored in the resulting string."
+          else
+            "This is a heredoc definition using the `#{heredoc_delimiter}` delimiter. " \
+              "Indentation will be considered part of the string."
+          end
+
+          @response_builder.push(message, category: :documentation)
+        end
+      end
+
+      sig { params(keyword: String).void }
+      def handle_keyword_documentation(keyword)
+        content = KEYWORD_DOCS[keyword]
+        return unless content
+
+        doc_path = File.join(STATIC_DOCS_PATH, "#{keyword}.md")
+
+        @response_builder.push("```ruby\n#{keyword}\n```", category: :title)
+        @response_builder.push("[Read more](#{doc_path})", category: :links)
+        @response_builder.push(content, category: :documentation)
+      end
+
       sig { void }
       def handle_super_node_hover
         # Sorbet can handle super hover on typed true or higher

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/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/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/rename.rb

@@ -0,0 +1,189 @@
+# 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],
+        )
+        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
+        changes = collect_text_edits(fully_qualified_name, 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 { params(fully_qualified_name: String, name: String).returns(T::Hash[String, T::Array[Interface::TextEdit]]) }
+      def collect_text_edits(fully_qualified_name, 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(fully_qualified_name, parse_result, name, uri)
+          changes[uri.to_s] = edits unless edits.empty?
+        end
+
+        @store.each do |uri, document|
+          edits = collect_changes(fully_qualified_name, document.parse_result, name, document.uri)
+          changes[uri] = edits unless edits.empty?
+        end
+
+        changes
+      end
+
+      sig do
+        params(
+          fully_qualified_name: String,
+          parse_result: Prism::ParseResult,
+          name: String,
+          uri: URI::Generic,
+        ).returns(T::Array[Interface::TextEdit])
+      end
+      def collect_changes(fully_qualified_name, parse_result, name, uri)
+        dispatcher = Prism::Dispatcher.new
+        finder = RubyIndexer::ReferenceFinder.new(fully_qualified_name, @global_state.index, dispatcher)
+        dispatcher.visit(parse_result.value)
+
+        finder.references.uniq(&:location).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/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

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

@@ -19,6 +19,13 @@ module URI
       T::Array[Symbol],
     )
 
+    # `uri` for Ruby 3.4 switched the default parser from RFC2396 to RFC3986. The new parser emits a deprecation
+    # warning on a few methods and delegates them to RFC2396, namely `extract`/`make_regexp`/`escape`/`unescape`.
+    # On earlier versions of the uri gem, the RFC2396_PARSER constant doesn't exist, so it needs some special
+    # handling to select a parser that doesn't emit deprecations. While it was backported to Ruby 3.1, users may
+    # have the uri gem in their own bundle and thus not use a compatible version.
+    PARSER = T.let(const_defined?(:RFC2396_PARSER) ? RFC2396_PARSER : DEFAULT_PARSER, RFC2396_Parser)
+
     T.unsafe(self).alias_method(:gem_name, :host)
     T.unsafe(self).alias_method(:line_number, :fragment)
 
@@ -41,7 +48,7 @@ module URI
           {
             scheme: "source",
             host: gem_name,
-            path: DEFAULT_PARSER.escape("/#{gem_version}/#{path}"),
+            path: PARSER.escape("/#{gem_version}/#{path}"),
             fragment: line_number,
           }
         )

data/lib/ruby_lsp/scope.rb

@@ -0,0 +1,47 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  class Scope
+    extend T::Sig
+
+    sig { returns(T.nilable(Scope)) }
+    attr_reader :parent
+
+    sig { params(parent: T.nilable(Scope)).void }
+    def initialize(parent = nil)
+      @parent = parent
+
+      # A hash of name => type
+      @locals = T.let({}, T::Hash[Symbol, Local])
+    end
+
+    # Add a new local to this scope. The types should only be `:parameter` or `:variable`
+    sig { params(name: T.any(String, Symbol), type: Symbol).void }
+    def add(name, type)
+      @locals[name.to_sym] = Local.new(type)
+    end
+
+    sig { params(name: T.any(String, Symbol)).returns(T.nilable(Local)) }
+    def lookup(name)
+      sym = name.to_sym
+      entry = @locals[sym]
+      return entry if entry
+      return unless @parent
+
+      @parent.lookup(sym)
+    end
+
+    class Local
+      extend T::Sig
+
+      sig { returns(Symbol) }
+      attr_reader :type
+
+      sig { params(type: Symbol).void }
+      def initialize(type)
+        @type = type
+      end
+    end
+  end
+end