feat(rename): Allow RPCs, fields, reference sites to be renamed with rpc/request/response chains (#131)

I would like the "rename" action to just work everywhere for the symbol
under the cursor. This is wired into my muscle-memory from using other
editors and I tend to do it even when it's a bit silly, like in cases
where the symbol just would never be referenced from anywhere else (such
as a service name in Protobuf). I like to just not have to think about
it.

I filed an issue before (#129) about wanting to be able to rename a
message from a referenced site. This PR includes that, but also some
other rename improvements. If you would rather want me to split it into
separate PRs, let me know.

I find the rpc/Request/Response chain rename especially useful. I
realize all protobuf users may not follow this convention, but it should
(hopefully) not get in the way for people who don't. Let me know if you
would rather like this to be configurable.

## Additions

**Service and RPC symbol rename.** `can_rename` was gated on
`message_name`/`enum_name` parents only, so invoking rename on a service
or RPC method was a silent no-op. A new `is_renameable` predicate
accepts `service_name` and `rpc_name`, and `rename_tree`'s
empty-ancestor path returns a single in-file edit (services/RPCs have no
cross-file references to propagate).

**Rename from a type-reference site.** Previously you had to navigate to
the declaration first. Now invoking rename on a `MyRequest` reference
inside `rpc DoThing(MyRequest)` — or on the inner segment of a qualified
type like `Outer.Inner` — works: the LSP resolves the partial qualified
path under the cursor to the declaration via the existing definition
machinery and runs the regular rename from there. The user's "rename the
segment under cursor" intent is honored: cursor on `Outer` renames
`Outer`, cursor on `Inner` renames `Inner`.

**Field name, oneof, and enum-value rename.** Identifiers whose parent
is `field`, `map_field`, `oneof_field`, `oneof`, or `enum_field` are now
renameable. Each is single-site — these don't appear as type references
in other `.proto` files — so the workspace pass is intentionally a no-op
for them, avoiding accidental renames if a lowercase type happens to
share a name.

**Chained `rpc`/`Request`/`Response` rename.** When an `rpc` follows the
`rpc <Name>(<Name>Request) returns (<Name>Response)` convention from the
[Google API design guide](https://google.aip.dev/) (AIPs 131–136),
renaming any one of the three triggers a chained rename of the other
two. The chain only kicks in when all of these hold:

- the matching message name follows the convention exactly (trailing
segment of its qualified text),
- the request/response is used by exactly one rpc in the workspace, and
- the user's new name preserves the convention (e.g. renaming a request,
the new name still ends with `Request`).

If any check fails, only the symbol the user invoked rename on is
renamed — the primary rename is never blocked by chain-detection
failures.

## Implementation

This implementation has been assisted by Claude Code using Opus 4.7. I
have read and generally understood the code and sign off on it as a
human being. I have previous experience with Rust, but would not
consider myself an expert. I have no previous experience with writing
LSP:s.

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Co-authored-by: Ashar <coder3101@users.noreply.github.com>
Co-authored-by: Ashar <ashar786khan@gmail.com>

Author: 3 people

README.md

@@ -32,6 +32,7 @@
   - [Configuration Sections](#configuration-sections)
     - [Basic Configuration](#basic-configuration)
     - [Path Configuration](#path-configuration)
+    - [Rename Configuration](#rename-configuration)
 - [Usage](#-usage)
   - [Code Completion](#code-completion)
   - [Diagnostics](#diagnostics)
@@ -170,6 +171,9 @@ include_paths = ["foobar", "bazbaaz"] # Include paths to look for protofiles dur
 [config.path]
 clang_format = "clang-format"
 protoc = "protoc"
+
+[config.rename]
+chain_rpc_request_response = false # Also rename <Rpc>Request/<Rpc>Response messages when renaming an rpc
 ```
 
 ### Configuration Sections
@@ -197,6 +201,16 @@ The `[config.path]` section contains path for various tools used by LSP.
 - `clang_format`: Uses clang_format from this path for formatting
 - `protoc`: Uses protoc from this path for diagnostics
 
+#### Rename Configuration
+
+The `[config.rename]` section tunes rename behaviour.
+
+- `chain_rpc_request_response` (default `false`): when enabled, renaming an `rpc`
+  also renames its convention-named `<Rpc>Request` and `<Rpc>Response` messages —
+  and renaming such a message renames the `rpc` and its sibling message. The chain
+  only fires when the names follow the [Google API design guide](https://cloud.google.com/apis/design/naming_convention#request_and_response_messages)
+  convention and the messages are used by exactly one `rpc`.
+
 ---
 
 ## 🛠 Usage
@@ -233,7 +247,9 @@ Hover over any symbol or imports to get detailed documentation and comments asso
 
 ### Rename Symbols
 
-Rename symbols like messages or enums, and Propagate the changes throughout the codebase. Currently, field renaming within symbols is not supported.
+Rename symbols like messages, enums, services and RPC methods, and propagate the changes throughout the codebase. Rename also works when invoked on a type reference (e.g. the request or response type of an `rpc`) — the LSP pivots to the declaration and applies the rename from there. Field names, oneof names, and enum values can also be renamed at their declaration site (single-site rename, since they aren't referenced as types from other `.proto` files).
+
+When an `rpc` follows the `rpc <Name>(<Name>Request) returns (<Name>Response)` convention from the [Google API design guide](https://google.aip.dev/) (AIPs 131–136), renaming any one of the three triggers a chained rename of the other two — but only when (a) the matching message name follows the convention exactly, (b) the request/response is used by exactly one rpc in the workspace, and (c) the user's new name preserves the convention. If any check fails, only the symbol the user invoked rename on is renamed.
 
 ### Find References
 

protols.toml

@@ -1,2 +1,5 @@
 [config]
 include_paths = ["src/workspace/input"]
+
+[config.rename]
+chain_rpc_request_response = true

sample/simple.proto

@@ -51,6 +51,7 @@ service BookService {
   rpc GetBooksViaAuthor(GetBookViaAuthor) returns (stream Book) {}
   rpc GetGreatestBook(stream GetBookRequest) returns (Book) {}
   rpc GetBooks(stream GetBookRequest) returns (stream Book) {}
+  rpc ReadBook(ReadBookRequest) returns (ReadBookResponse) {}
 }
 
 message BookStore {
@@ -61,6 +62,9 @@ message BookStore {
   EnumSample sample = 4;
 }
 
+message ReadBookRequest {}
+message ReadBookResponse {}
+
 // These are enum options representing some operation in the proto
 // these are meant to be ony called from one place,
 

src/config/input/protols-valid.toml

@@ -4,3 +4,6 @@ include_paths = ["foobar", "bazbaaz"]
 [config.path]
 protoc = "/usr/bin/protoc"
 clang_format = "/usr/bin/clang-format"
+
+[config.rename]
+chain_rpc_request_response = true

src/config/mod.rs

@@ -21,6 +21,7 @@ pub struct ProtolsConfig {
 pub struct Config {
     pub include_paths: Vec<String>,
     pub path: PathConfig,
+    pub rename: RenameConfig,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
@@ -38,3 +39,14 @@ impl Default for PathConfig {
         }
     }
 }
+
+#[derive(Serialize, Deserialize, Debug, Clone, Default)]
+#[serde(default)]
+pub struct RenameConfig {
+    /// When renaming an `rpc`, also rename its convention-named
+    /// `<Rpc>Request` / `<Rpc>Response` messages — and, when renaming such a
+    /// message, the `rpc` and its sibling message. Opt-in: defaults to `false`
+    /// since not every codebase follows the `<Rpc>Request`/`Response` naming
+    /// convention.
+    pub chain_rpc_request_response: bool,
+}

src/config/snapshots/protols__config__workspace__test__get_for_workspace-2.snap

@@ -7,3 +7,5 @@ config:
   path:
     clang_format: clang-format
     protoc: protoc
+  rename:
+    chain_rpc_request_response: false

src/config/snapshots/protols__config__workspace__test__get_for_workspace.snap

@@ -9,3 +9,5 @@ config:
   path:
     clang_format: /usr/bin/clang-format
     protoc: /usr/bin/protoc
+  rename:
+    chain_rpc_request_response: true

src/lsp.rs

@@ -1,5 +1,5 @@
 use std::ops::ControlFlow;
-use std::{collections::HashMap, fs::read_to_string, path::PathBuf};
+use std::{fs::read_to_string, path::PathBuf};
 use tracing::{error, info, warn};
 
 use async_lsp::lsp_types::{
@@ -20,6 +20,7 @@ use async_lsp::{Error, LanguageClient, ResponseError};
 use futures::future::BoxFuture;
 use serde_json::Value;
 
+use crate::context::jumpable::Jumpable;
 use crate::formatter::ProtoFormatter;
 use crate::server::ProtoLanguageServer;
 use crate::{docs, log};
@@ -244,7 +245,6 @@ impl ProtoLanguageServer {
     ) -> BoxFuture<'static, Result<Option<WorkspaceEdit>, ResponseError>> {
         let uri = params.text_document_position.text_document.uri;
         let pos = params.text_document_position.position;
-
         let new_name = params.new_name;
 
         let Some(tree) = self.state.get_tree(&uri) else {
@@ -253,38 +253,72 @@ impl ProtoLanguageServer {
         };
 
         let content = self.state.get_content(&uri);
-
         let current_package = tree.get_package_name(content.as_bytes()).unwrap_or(".");
+        let ipath = self.configs.get_include_paths(&uri).unwrap_or_default();
 
-        let Some((edit, otext, ntext)) = tree.rename_tree(&pos, &new_name, content.as_bytes())
-        else {
-            error!(uri=%uri, "failed to rename in a tree");
-            return Box::pin(async move { Ok(None) });
+        // If the cursor is on a type reference (inside a message_or_enum_type
+        // node), pivot to the declaration and rename from there. The workspace
+        // pass then handles all references — including the one the user is
+        // standing on.
+        let (decl_uri, decl_pos) = match tree.rename_pivot_identifier(&pos, content.as_bytes()) {
+            Some(decl_path) => {
+                let locations =
+                    self.state
+                        .definition(&ipath, current_package, Jumpable::Identifier(decl_path));
+                let Some(decl) = locations.into_iter().next() else {
+                    error!(uri=%uri, "failed to resolve declaration for reference-site rename");
+                    return Box::pin(async move { Ok(None) });
+                };
+                (decl.uri, decl.range.start)
+            }
+            None => (uri.clone(), pos),
         };
 
-        let Some(workspace) = self.configs.get_workspace_for_uri(&uri) else {
-            error!(uri=%uri, "failed to get workspace");
+        let Some(workspace) = self.configs.get_workspace_for_uri(&decl_uri) else {
+            error!(uri=%decl_uri, "failed to get workspace");
+            return Box::pin(async move { Ok(None) });
+        };
+        let Ok(workspace_path) = workspace.to_file_path() else {
+            error!(uri=%workspace, "workspace url is not a file path");
             return Box::pin(async move { Ok(None) });
         };
 
-        let work_done_token = params.work_done_progress_params.work_done_token;
-        let progress_sender = work_done_token.map(|token| self.with_report_progress(token));
-
-        let mut h = HashMap::new();
-        h.extend(self.state.rename_fields(
-            current_package,
-            &otext,
-            &ntext,
-            workspace.to_file_path().unwrap(),
-            progress_sender,
-        ));
+        let progress_sender = params
+            .work_done_progress_params
+            .work_done_token
+            .map(|token| self.with_report_progress(token));
 
-        h.entry(tree.uri).or_insert(edit.clone()).extend(edit);
+        // The rpc/request/response chain rename is opt-in via the workspace's
+        // `[config.rename]` settings; without a config it stays off.
+        let chain_rpc_request_response = self
+            .configs
+            .get_config_for_uri(&uri)
+            .map(|c| c.config.rename.chain_rpc_request_response)
+            .unwrap_or_default();
+
+        let ops = self.state.compute_rename_ops(
+            &decl_uri,
+            decl_pos,
+            &new_name,
+            &ipath,
+            chain_rpc_request_response,
+        );
+        let Some(all_edits) = self
+            .state
+            .apply_rename_ops(&ops, workspace_path, progress_sender)
+        else {
+            error!(uri=%decl_uri, "failed to apply primary rename");
+            return Box::pin(async move { Ok(None) });
+        };
 
-        let response = Some(WorkspaceEdit {
-            changes: Some(h),
-            ..Default::default()
-        });
+        let response = if all_edits.is_empty() {
+            None
+        } else {
+            Some(WorkspaceEdit {
+                changes: Some(all_edits),
+                ..Default::default()
+            })
+        };
 
         Box::pin(async move { Ok(response) })
     }

src/nodekind.rs

@@ -63,10 +63,35 @@ impl NodeKind {
         n.kind() == Self::FieldName.as_str()
     }
 
+    pub fn is_rpc_name(n: &Node) -> bool {
+        n.kind() == Self::RpcName.as_str()
+    }
+
     pub fn is_userdefined(n: &Node) -> bool {
         n.kind() == Self::EnumName.as_str() || n.kind() == Self::MessageName.as_str()
     }
 
+    pub fn is_renameable(n: &Node) -> bool {
+        Self::is_userdefined(n)
+            || n.kind() == Self::ServiceName.as_str()
+            || n.kind() == Self::RpcName.as_str()
+            || n.kind() == Self::FieldName.as_str()
+            || Self::is_field_decl_parent(n)
+    }
+
+    /// Kinds whose direct identifier child is the *name* of a field-like
+    /// declaration: regular fields, map fields, oneof fields, the oneof itself,
+    /// and enum values. For `string title = 1;`, the identifier `title` has
+    /// parent `field` — that's what we match here. The type identifier (e.g.
+    /// `Author` in `Author author = 2;`) is nested deeper under
+    /// `message_or_enum_type`, so it isn't caught by this predicate.
+    pub fn is_field_decl_parent(n: &Node) -> bool {
+        matches!(
+            n.kind(),
+            "field" | "map_field" | "oneof_field" | "oneof" | "enum_field"
+        )
+    }
+
     pub fn is_actionable(n: &Node) -> bool {
         n.kind() == Self::MessageName.as_str()
             || n.kind() == Self::EnumName.as_str()

src/parser/input/test_rename_field.proto

@@ -0,0 +1,22 @@
+syntax = "proto3";
+
+package com.parser;
+
+enum Color {
+    RED = 0;
+    GREEN = 1;
+}
+
+message Author {
+    string name = 1;
+}
+
+message Book {
+    string title = 1;
+    Author author = 2;
+    map<string, int32> counts = 3;
+    oneof body {
+        string text = 4;
+        bytes blob = 5;
+    }
+}