以下是关于ast-grep-lsp工具的完整介绍和示例：

安装方法：

使用Cargo命令安装：

cargo add ast-grep-lsp

或者在Cargo.toml中添加依赖：

ast-grep-lsp = "0.39.2"

主要功能特点：

基于抽象语法树(AST)的精确代码搜索
支持语言服务器协议(LSP)，可与各种代码编辑器集成
强大的模式匹配和代码重构能力
支持自定义搜索规则和代码转换规则

完整示例Demo：

基础LSP服务设置示例：

use ast_grep_lsp::{LanguageServer, Config};
use tower_lsp::{LspService, Server};
use std::io::{stdin, stdout};

#[tokio::main]
async fn main() {
    // 1. 创建语言服务配置
    let config = Config {
        // 启用AST模式匹配功能
        enable_ast_pattern: true,
        // 可以在此添加其他配置项
    };

    // 2. 创建LSP服务实例
    let (service, socket) = LspService::new(|client| {
        LanguageServer::new(client, config)
    });

    // 3. 启动LSP服务器
    Server::new(stdin(), stdout(), socket).serve(service).await;
}

AST模式搜索示例：

// 定义要搜索的AST模式 - 查找所有println!宏调用
let pattern = r#"
    macro_invocation! {
        macro = identifier: {
            name = "println"
        }
    }
"#;

// 使用ast-grep-lsp搜索匹配的代码
let matches = language_server.find_matches(pattern).await?;

// 打印搜索结果
for m in matches {
    println!("在位置 {:?} 发现println!宏调用", m.location);
}

代码重构示例：

// 定义代码重写规则 - 将println!替换为log::info!
let rewrite_rule = r#"
    rule:
      pattern: println!($args)  // 匹配模式
      replace: log::info!($args)  // 替换内容
"#;

// 应用代码重写规则
language_server.apply_rewrite(rewrite_rule).await?;

技术规格：

许可证：MIT
当前版本：0.39.2
开发者：Herrington Darkholme

这个工具特别适合需要批量分析和修改Rust代码库的场景，通过AST级别的模式匹配可以确保重构的准确性和安全性。

sinazl 1楼

Rust语法分析与代码搜索工具ast-grep-lsp的使用

工具介绍

ast-grep-lsp 是一个基于 LSP (Language Server Protocol) 协议的 Rust 代码分析工具，它允许开发者通过 AST (抽象语法树) 模式匹配来进行代码搜索和重构。这个工具特别适合在大型 Rust 代码库中进行精确的代码查找和自动化重构。

主要特性

支持 LSP 协议，可与主流编辑器/IDE集成
基于 AST 的模式匹配，比正则表达式更精确
支持代码重构和自动转换
专门为 Rust 语言优化

安装方法

cargo install ast-grep-lsp

或者从 GitHub 直接安装最新版本：

cargo install --git https://github.com/ast-grep/ast-grep-lsp

基本使用方法

1. 启动 LSP 服务器

在项目目录下运行：

ast-grep-lsp

2. 配置编辑器

VS Code 配置

安装 ast-grep-lsp 后
在 VS Code 设置中添加：

{
  "lsp.client": {
    "ast-grep-lsp": {
      "command": ["ast-grep-lsp"],
      "enabled": true,
      "languages": ["rust"]
    }
  }
}

3. 基本搜索示例

查找所有 `unwrap()` 调用

sg -p 'unwrap()' src/

查找所有 `println!` 宏调用

sg -p 'println!($_)' src/

4. 模式匹配与重构

将 `unwrap()` 替换为 `expect()`

sg -p 'unwrap()' --rewrite 'expect("TODO: add error message")' src/

将 `if let Some(x) = y` 转换为 `match` 表达式

sg -p 'if let Some($x) = $y { $body }' \
   --rewrite 'match $y { Some($x) => $body, None => todo!() }' \
   src/

高级用法

1. 使用规则文件

创建 sgconfig.yml 文件定义复杂规则：

id: replace-unwrap
message: Replace unwrap with expect
language: Rust
rule:
  pattern: unwrap()
fix: expect("TODO: add error message")

然后运行：

sg --config sgconfig.yml src/

2. 组合多个模式

id: redundant-clone
message: Remove redundant clone call
language: Rust
rule:
  pattern: $x.clone()
  inside:
    pattern: $x.clone().$m()
fix: $x.$m()

3. 与编辑器集成使用

安装 LSP 客户端后，可以在编辑器中：

使用 “Find References” 查找符号引用
使用 “Rename Symbol” 重命名符号
使用代码操作快速应用重构

实际应用示例

示例1：查找所有未处理的错误

sg -p '$x.unwrap()' src/

示例2：将 `Box::new(Type)` 转换为 `Box::<Type>::new`

sg -p 'Box::new($t)' --rewrite 'Box::<$t>::new()' src/

示例3：查找所有实现特定 trait 的结构体

id: find-trait-impl
message: Find all implementations of MyTrait
language: Rust
rule:
  pattern: impl MyTrait for $T

完整示例demo

下面是一个使用ast-grep-lsp进行代码重构的完整示例：

首先创建一个简单的Rust项目：

// src/main.rs
fn main() {
    let result: Result<i32, &str> = Ok(42);
    let value = result.unwrap();  // 需要重构的代码
    
    let maybe_value: Option<i32> = Some(10);
    if let Some(x) = maybe_value {
        println!("Value is {}", x);
    }
    
    let boxed = Box::new(5);  // 需要重构的代码
}

创建sgconfig.yml规则文件：

# 替换unwrap为expect
id: replace-unwrap
message: Replace unwrap with expect
language: Rust
rule:
  pattern: unwrap()
fix: expect("TODO: add error message")

# 转换Box::new为Box::<Type>::new
id: convert-box-new
message: Convert Box::new to Box::<Type>::new
language: Rust
rule:
  pattern: Box::new($t)
fix: Box::<$t>::new()

运行重构命令：

sg --config sgconfig.yml src/

重构后的代码将变为：

// src/main.rs
fn main() {
    let result: Result<i32, &str> = Ok(42);
    let value = result.expect("TODO: add error message");  // 重构后的代码
    
    let maybe_value: Option<i32> = Some(10);
    if let Some(x) = maybe_value {
        println!("Value is {}", x);
    }
    
    let boxed = Box::<i32>::new(5);  // 重构后的代码
}

注意事项

模式匹配是语法级别的，不是文本级别的
复杂的模式可能需要多次尝试才能正确匹配
重构前建议先预览更改
对于大型项目，首次分析可能需要较长时间

ast-grep-lsp 是 Rust 开发者工具箱中一个强大的补充，特别适合进行大规模的代码分析和自动化重构任务。

Rust语法分析与代码搜索工具ast-grep-lsp的使用，支持LSP协议的AST模式匹配与重构