示例 - MatrixCode

Bug 修复预计用时：5分钟

修复 TypeScript 类型错误

用户遇到了一个棘手的 TypeScript 类型错误，Agent 分析代码并找出根本原因。

👤 用户

这个函数报错了：

interface User {
  id: number;
  name: string;
  email?: string;
}

function processUsers(users: User[]): string[] {
  return users.map(user => user.email.toUpperCase());
  // ❌ Error: Object is possibly 'undefined'.
}

🤖 Agent

问题是 email 字段是可选的（email?: string），可能为 undefined。需要过滤掉没有 email 的用户。

✏️ edit user.ts:5

过滤掉 undefined 并确保类型安全：

function processUsers(users: User[]): string[] {
  return users
    .filter((user): user is User & { email: string } => 
      user.email !== undefined
    )
    .map(user => user.email.toUpperCase());
}

✅ 修复完成。使用了类型守卫（Type Guard）确保类型安全。

💡 要点

Agent 理解 TypeScript 类型系统
使用类型守卫解决可选字段问题
提供类型安全的解决方案

代码重构预计用时：8分钟

重构异步代码为模块化结构

将一个庞大的函数拆分成多个独立模块，提升代码可维护性。

👤 用户

这个函数太长了，帮我重构：

async function handleRequest(req: Request): Promise {
  // 验证请求头
  const auth = req.headers.get('authorization');
  if (!auth || !auth.startsWith('Bearer ')) {
    return new Response('Unauthorized', { status: 401 });
  }
  const token = auth.substring(7);
  
  // 验证 token
  let payload;
  try {
    payload = await verifyToken(token);
  } catch (e) {
    return new Response('Invalid token', { status: 403 });
  }
  
  // 解析请求体
  let body;
  try {
    body = await req.json();
  } catch (e) {
    return new Response('Invalid JSON', { status: 400 });
  }
  
  // 验证数据
  if (!body.name || !body.email) {
    return new Response('Missing fields', { status: 400 });
  }
  
  // 处理业务逻辑
  const user = await createUser(body);
  
  // 返回响应
  return new Response(JSON.stringify(user), {
    status: 201,
    headers: { 'Content-Type': 'application/json' }
  });
}

🤖 Agent

我来分析代码并拆分成独立模块：

🔍 code_search

搜索相关函数定义...

✏️ write auth.ts

// 认证相关工具函数
export interface AuthPayload {
  userId: string;
  role: string;
}

export async function extractToken(
  req: Request
): Promise {
  const auth = req.headers.get('authorization');
  if (!auth || !auth.startsWith('Bearer ')) {
    return null;
  }
  return auth.substring(7);
}

export async function authenticate(
  req: Request
): Promise {
  const token = await extractToken(req);
  if (!token) return null;
  
  try {
    return await verifyToken(token);
  } catch {
    return null;
  }
}

✏️ write validation.ts

// 数据验证工具
export interface UserData {
  name: string;
  email: string;
}

export async function parseBody<T>(
  req: Request
): Promise<T | null> {
  try {
    return await req.json();
  } catch {
    return null;
  }
}

export function validateUserData(
  data: unknown
): data is UserData {
  return (
    typeof data === 'object' &&
    data !== null &&
    'name' in data &&
    'email' in data &&
    typeof data.name === 'string' &&
    typeof data.email === 'string'
  );
}

✏️ edit handler.ts:1

import { authenticate } from './auth';
import { parseBody, validateUserData } from './validation';

async function handleRequest(req: Request): Promise<Response> {
  // 认证
  const payload = await authenticate(req);
  if (!payload) {
    return new Response('Unauthorized', { status: 401 });
  }
  
  // 解析请求体
  const body = await parseBody<unknown>(req);
  if (!body) {
    return new Response('Invalid JSON', { status: 400 });
  }
  
  // 验证数据
  if (!validateUserData(body)) {
    return new Response('Missing fields', { status: 400 });
  }
  
  // 处理业务逻辑
  const user = await createUser(body);
  
  return new Response(JSON.stringify(user), {
    status: 201,
    headers: { 'Content-Type': 'application/json' }
  });
}

✅ 重构完成。已拆分成 3 个模块：

auth.ts - 认证相关逻辑
validation.ts - 数据验证工具
handler.ts - 主处理函数（简化后）

💡 要点

先分析代码结构再重构
拆分成职责单一的模块
提供类型安全的接口
保持原有功能不变

新功能预计用时：15分钟

实现配置文件热重载

为现有项目添加配置文件监视和热重载功能。

👤 用户

我需要给我的 Rust 项目添加配置文件热重载功能。配置文件在 config.toml，当文件变化时自动重新加载。

🤖 Agent

让我先查看项目结构和现有配置：

📁 ls

src/
  config/
    mod.rs
    loader.rs
  main.rs
Cargo.toml
config.toml

📖 read src/config/mod.rs

pub struct Config {
    pub database_url: String,
    pub port: u16,
    pub log_level: String,
}

impl Config {
    pub fn load() -> Result<Self, Error> {
        // ... 加载逻辑
    }
}

📖 read Cargo.toml

[dependencies]
toml = "0.8"
serde = { version = "1.0", features = ["derive"] }
notify = "6.0"  # 需要添加

现在我来实现热重载功能：

✏️ write src/config/hot_reload.rs

use notify::{Event, RecommendedWatcher, RecursiveMode, Watcher};
use std::path::Path;
use std::sync::mpsc::{channel, Receiver};
use std::time::Duration;

pub struct ConfigWatcher {
    watcher: RecommendedWatcher,
    receiver: Receiver<Result<Event, notify::Error>>,
}

impl ConfigWatcher {
    pub fn new<P: AsRef<Path>>(path: P) -> Result<Self, notify::Error> {
        let (tx, rx) = channel();
        
        let mut watcher = RecommendedWatcher::new(
            move |res| {
                let _ = tx.send(res);
            },
            notify::Config::default()
                .with_poll_interval(Duration::from_secs(1))
        )?;
        
        watcher.watch(path.as_ref(), RecursiveMode::NonRecursive)?;
        
        Ok(Self {
            watcher,
            receiver: rx,
        })
    }
    
    /// 等待配置文件变化
    pub fn wait_for_change(&self) -> bool {
        match self.receiver.recv() {
            Ok(Ok(event)) => {
                // 检查是否是修改事件
                event.kind.is_modify()
            }
            _ => false,
        }
    }
}

impl Config {
    /// 热重载配置
    pub fn hot_reload<P: AsRef<Path>>(
        path: P,
        mut on_reload: impl FnMut(&Config) + Send + 'static,
    ) -> Result<ConfigWatcher, Error> {
        let path = path.as_ref().to_path_buf();
        
        let watcher = ConfigWatcher::new(&path)?;
        let path_clone = path.clone();
        
        std::thread::spawn(move || {
            let watcher = ConfigWatcher::new(&path_clone).unwrap();
            loop {
                if watcher.wait_for_change() {
                    match Config::load_from(&path_clone) {
                        Ok(config) => on_reload(&config),
                        Err(e) => eprintln!("Failed to reload config: {}", e),
                    }
                }
            }
        });
        
        Ok(watcher)
    }
}

✏️ edit src/config/mod.rs:1

mod hot_reload;
mod loader;

pub use hot_reload::ConfigWatcher;
pub use loader::Config;

// ... 其他代码

✏️ edit src/main.rs:1

use config::Config;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 加载初始配置
    let config = Config::load()?;
    
    // 启动热重载
    Config::hot_reload("config.toml", |new_config| {
        println!("Config reloaded: {:?}", new_config);
        // 更新应用状态...
    })?;
    
    // 运行应用...
    Ok(())
}

✅ 热重载功能已实现。使用方法：

// 1. 添加依赖到 Cargo.toml
notify = "6.0"

// 2. 在 main.rs 中启动监视
Config::hot_reload("config.toml", |config| {
    // 配置更新回调
});

// 3. 修改 config.toml 会自动触发重新加载

💡 要点

先分析现有代码结构
添加必要的依赖
创建独立的热重载模块
提供清晰的集成方式
包含错误处理

调试分析预计用时：10分钟

调试并发死锁问题

分析并修复一个复杂的并发死锁问题。

👤 用户

我的程序偶尔会卡住，可能是死锁。帮我分析：

use std::sync::{Arc, Mutex};
use std::thread;

struct Bank {
    accounts: Vec<Mutex<u64>>,
}

impl Bank {
    fn transfer(&self, from: usize, to: usize, amount: u64) {
        let from_acc = self.accounts[from].lock().unwrap();
        let to_acc = self.accounts[to].lock().unwrap();
        
        if *from_acc >= amount {
            *from_acc -= amount;
            *to_acc += amount;
        }
    }
}

fn main() {
    let bank = Arc::new(Bank {
        accounts: vec![
            Mutex::new(1000),
            Mutex::new(1000),
        ],
    });
    
    let bank1 = bank.clone();
    let h1 = thread::spawn(move || {
        for _ in 0..100 {
            bank1.transfer(0, 1, 10);
        }
    });
    
    let bank2 = bank.clone();
    let h2 = thread::spawn(move || {
        for _ in 0..100 {
            bank2.transfer(1, 0, 10);  // ❌ 死锁风险
        }
    });
    
    h1.join().unwrap();
    h2.join().unwrap();
}

🤖 Agent

找到问题了！这是典型的锁顺序死锁。

🔴 问题分析

当两个线程同时执行：

线程 1: transfer(0, 1) → 先锁账户0，再锁账户1
线程 2: transfer(1, 0) → 先锁账户1，再锁账户0

如果时机巧合：

线程 1 锁住账户 0
线程 2 锁住账户 1
线程 1 等待账户 1（被线程 2 持有）
线程 2 等待账户 0（被线程 1 持有）
💀 死锁！

✏️ edit bank.rs:10

impl Bank {
    fn transfer(&self, from: usize, to: usize, amount: u64) {
        // ✅ 解决方案：按固定顺序获取锁
        // 使用账户索引排序，总是先锁小的
        let (first, second) = if from < to {
            (&self.accounts[from], &self.accounts[to])
        } else {
            (&self.accounts[to], &self.accounts[from])
        };
        
        let first_acc = first.lock().unwrap();
        let second_acc = second.lock().unwrap();
        
        let (from_acc, to_acc) = if from < to {
            (&first_acc, &second_acc)
        } else {
            (&second_acc, &first_acc)
        };
        
        if **from_acc >= amount {
            **from_acc -= amount;
            **to_acc += amount;
        }
    }
}

✅ 修复完成。现在所有转账都会按相同顺序获取锁，避免循环等待。

其他解决方案

// 方案 2：使用 RwLock（读多写少场景）
use std::sync::RwLock;
let accounts: Vec> = ...;

// 方案 3：使用单一大锁保护所有账户
struct Bank {
    accounts: Mutex>,
}

// 方案 4：使用无锁数据结构
use crossbeam::atomic::AtomicCell;
let accounts: Vec> = ...;

💡 要点

Agent 识别出经典的锁顺序死锁问题
解释了死锁发生的具体过程
提供标准的解决方案（固定锁顺序）
给出多种替代方案供选择

文档生成预计用时：5分钟

生成 API 文档

为现有代码生成完整的 API 文档。

👤 用户

帮我给这个模块生成文档：

pub struct Cache<K, V> {
    inner: HashMap<K, V>,
    capacity: usize,
}

impl<K, V> Cache<K, V> 
where 
    K: Eq + Hash + Clone,
    V: Clone,
{
    pub fn new(capacity: usize) -> Self {
        Self {
            inner: HashMap::with_capacity(capacity),
            capacity,
        }
    }
    
    pub fn get(&self, key: &K) -> Option<&V> {
        self.inner.get(key)
    }
    
    pub fn insert(&mut self, key: K, value: V) -> Option<V> {
        if self.inner.len() >= self.capacity {
            self.evict();
        }
        self.inner.insert(key, value)
    }
    
    pub fn remove(&mut self, key: &K) -> Option<V> {
        self.inner.remove(key)
    }
    
    fn evict(&mut self) {
        // 移除一半的元素
        let keys: Vec<_> = self.inner.keys().take(self.capacity / 2).cloned().collect();
        for key in keys {
            self.inner.remove(&key);
        }
    }
}

🤖 Agent

✏️ multi_edit cache.rs

//! 内存缓存模块
//! 
//! 提供一个简单的固定容量内存缓存实现。
//! 
//! # 示例
//! 
//! ```
//! use cache::Cache;
//! 
//! let mut cache = Cache::new(100);
//! cache.insert("key", "value");
//! assert_eq!(cache.get(&"key"), Some(&"value"));
//! ```

use std::collections::HashMap;
use std::hash::Hash;

/// 固定容量的内存缓存
/// 
/// 当缓存达到容量上限时，会自动驱逐部分元素。
/// 
/// # 类型参数
/// 
/// - `K`: 键类型，必须实现 `Eq + Hash + Clone`
/// - `V`: 值类型，必须实现 `Clone`
/// 
/// # 示例
/// 
/// ```
/// let mut cache = Cache::new(10);
/// cache.insert("user:1", "Alice");
/// ```
pub struct Cache<K, V> {
    inner: HashMap<K, V>,
    capacity: usize,
}

impl<K, V> Cache<K, V> 
where 
    K: Eq + Hash + Clone,
    V: Clone,
{
    /// 创建一个新的缓存实例
    /// 
    /// # 参数
    /// 
    /// - `capacity`: 缓存的最大容量
    /// 
    /// # 示例
    /// 
    /// ```
    /// let cache: Cache<&str, i32> = Cache::new(100);
    /// ```
    pub fn new(capacity: usize) -> Self {
        Self {
            inner: HashMap::with_capacity(capacity),
            capacity,
        }
    }
    
    /// 获取缓存中的值
    /// 
    /// # 参数
    /// 
    /// - `key`: 要查找的键
    /// 
    /// # 返回值
    /// 
    /// 返回值的引用，如果不存在则返回 `None`
    /// 
    /// # 时间复杂度
    /// 
    /// O(1) 平均情况
    /// 
    /// # 示例
    /// 
    /// ```
    /// let mut cache = Cache::new(10);
    /// cache.insert("key", 42);
    /// assert_eq!(cache.get(&"key"), Some(&42));
    /// ```
    pub fn get(&self, key: &K) -> Option<&V> {
        self.inner.get(key)
    }
    
    /// 插入键值对到缓存
    /// 
    /// 如果缓存已满，会先驱逐部分元素。
    /// 
    /// # 参数
    /// 
    /// - `key`: 键
    /// - `value`: 值
    /// 
    /// # 返回值
    /// 
    /// 如果键已��在，返回旧值；否则返回 `None`
    /// 
    /// # 时间复杂度
    /// 
    /// - 最好情况: O(1)
    /// - 最坏情况（需驱逐）: O(n)，n 为容量的一半
    /// 
    /// # 示例
    /// 
    /// ```
    /// let mut cache = Cache::new(2);
    /// let old = cache.insert("key", 1);
    /// assert_eq!(old, None);
    /// 
    /// let old = cache.insert("key", 2);
    /// assert_eq!(old, Some(1));
    /// ```
    pub fn insert(&mut self, key: K, value: V) -> Option<V> {
        if self.inner.len() >= self.capacity {
            self.evict();
        }
        self.inner.insert(key, value)
    }
    
    /// 从缓存中移除键值对
    /// 
    /// # 参数
    /// 
    /// - `key`: 要移除的键
    /// 
    /// # 返回值
    /// 
    /// 如果键存在，返回对应的值；否则返回 `None`
    /// 
    /// # 时间复杂度
    /// 
    /// O(1) 平均情况
    /// 
    /// # 示例
    /// 
    /// ```
    /// let mut cache = Cache::new(10);
    /// cache.insert("key", 42);
    /// assert_eq!(cache.remove(&"key"), Some(42));
    /// assert_eq!(cache.get(&"key"), None);
    /// ```
    pub fn remove(&mut self, key: &K) -> Option<V> {
        self.inner.remove(key)
    }
    
    /// 驱逐部分缓存元素
    /// 
    /// 当缓存达到容量上限��调用。
    /// 移除当前容量一半的元素（FIFO 策略）。
    fn evict(&mut self) {
        let keys: Vec<_> = self.inner.keys().take(self.capacity / 2).cloned().collect();
        for key in keys {
            self.inner.remove(&key);
        }
    }
}

✅ 文档已生成。运行 cargo doc --open 查看生成的 HTML 文档。

💡 要点

添加模块级文档说明
为所有公共类型和方法添加文档注释
包含参数、返回值、时间复杂度说明
提供完整的代码示例
使用 Markdown 格式化

代码重构预计用时：20分钟

将同步代码改为异步

将一个完整的同步 HTTP 客户端改造成异步版本。

👤 用户

帮我把这个同步 HTTP 客户端改成异步：

use reqwest::blocking::Client;

pub struct ApiClient {
    client: Client,
    base_url: String,
}

impl ApiClient {
    pub fn new(base_url: &str) -> Self {
        Self {
            client: Client::new(),
            base_url: base_url.to_string(),
        }
    }
    
    pub fn get_user(&self, id: u64) -> Result {
        let url = format!("{}/users/{}", self.base_url, id);
        let resp = self.client.get(&url).send()?;
        let user = resp.json::()?;
        Ok(user)
    }
    
    pub fn get_users(&self) -> Result, Error> {
        let url = format!("{}/users", self.base_url);
        let resp = self.client.get(&url).send()?;
        let users = resp.json::>()?;
        Ok(users)
    }
    
    pub fn create_user(&self, user: &NewUser) -> Result {
        let url = format!("{}/users", self.base_url);
        let resp = self.client.post(&url).json(user).send()?;
        let created = resp.json::()?;
        Ok(created)
    }
}

🤖 Agent

📖 read Cargo.toml

✏️ edit Cargo.toml

[dependencies]
reqwest = { version = "0.11", features = ["json"] }
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }

✏️ write src/api_client.rs

use reqwest::Client;
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
pub struct User {
    pub id: u64,
    pub name: String,
    pub email: String,
}

#[derive(Debug, Serialize)]
pub struct NewUser {
    pub name: String,
    pub email: String,
}

#[derive(Debug, thiserror::Error)]
pub enum ApiError {
    #[error("HTTP error: {0}")]
    Http(#[from] reqwest::Error),
    
    #[error("Invalid response")]
    InvalidResponse,
}

pub struct ApiClient {
    client: Client,
    base_url: String,
}

impl ApiClient {
    /// 创建新的异步 API 客户端
    pub fn new(base_url: &str) -> Self {
        Self {
            client: Client::new(),
            base_url: base_url.to_string(),
        }
    }
    
    /// 获取单个用户
    pub async fn get_user(&self, id: u64) -> Result {
        let url = format!("{}/users/{}", self.base_url, id);
        let user = self.client
            .get(&url)
            .send()
            .await?
            .json::()
            .await?;
        Ok(user)
    }
    
    /// 获取所有用户
    pub async fn get_users(&self) -> Result, ApiError> {
        let url = format!("{}/users", self.base_url);
        let users = self.client
            .get(&url)
            .send()
            .await?
            .json::>()
            .await?;
        Ok(users)
    }
    
    /// 创建新用户
    pub async fn create_user(&self, user: &NewUser) -> Result {
        let url = format!("{}/users", self.base_url);
        let created = self.client
            .post(&url)
            .json(user)
            .send()
            .await?
            .json::()
            .await?;
        Ok(created)
    }
    
    /// 批量获取用户（并发请求）
    pub async fn get_users_batch(&self, ids: &[u64]) -> Result, ApiError> {
        let futures: Vec<_> = ids
            .iter()
            .map(|&id| self.get_user(id))
            .collect();
        
        let results = futures::future::join_all(futures).await;
        
        results.into_iter().collect()
    }
}

✏️ write src/main.rs

mod api_client;

use api_client::{ApiClient, NewUser};

#[tokio::main]
async fn main() -> Result<(), Box> {
    let client = ApiClient::new("https://api.example.com");
    
    // 获取单个用户
    let user = client.get_user(1).await?;
    println!("User: {:?}", user);
    
    // 获取所有用户
    let users = client.get_users().await?;
    println!("Users: {:?}", users);
    
    // 创建新用户
    let new_user = NewUser {
        name: "Alice".to_string(),
        email: "alice@example.com".to_string(),
    };
    let created = client.create_user(&new_user).await?;
    println!("Created: {:?}", created);
    
    // 批量获取（并发）
    let batch = client.get_users_batch(&[1, 2, 3]).await?;
    println!("Batch: {:?}", batch);
    
    Ok(())
}

✅ 异步改造完成！主要变化：

将 reqwest::blocking::Client 改为 reqwest::Client
所有方法添加 async
所有 .send() 和 .json() 调用添加 .await
添加 get_users_batch 方法展示并发能力
使用 #[tokio::main] 异步运行时

💡 要点

更新依赖项支持异步
所有 I/O 操作改为异步
展示异步并发优势
提供完整的使用示例

Bug 修复预计用时：3分钟

修复内存泄漏

发现并修复一个隐蔽的内存泄漏问题。

👤 用户

我的程序运行一段时间后内存占用持续增长，帮忙看看：

use std::collections::HashMap;

pub struct EventManager {
    handlers: HashMap<String, Vec<Box<dyn Fn(&Event)>>>,
}

impl EventManager {
    pub fn new() -> Self {
        Self {
            handlers: HashMap::new(),
        }
    }
    
    pub fn on<F: Fn(&Event) + 'static>(&mut self, event: &str, handler: F) {
        self.handlers
            .entry(event.to_string())
            .or_insert_with(Vec::new)
            .push(Box::new(handler));
    }
    
    pub fn emit(&self, event: &Event) {
        if let Some(handlers) = self.handlers.get(&event.name) {
            for handler in handlers {
                handler(event);
            }
        }
    }
}

// 每次请求都创建新的 handler
fn handle_request(manager: &mut EventManager) {
    manager.on("data", |e| {
        println!("Received: {:?}", e);
    });
}

🤖 Agent

找到问题了！每次调用 handle_request 都会添加新的 handler，但从不移除，导致 handlers 向量无限增长。

🔴 问题根源

on() 方法只添加不移除
每次请求都创建新的闭包
闭包会被永久保存在 HashMap 中

✏️ multi_edit event_manager.rs

use std::collections::HashMap;
use std::time::{Duration, Instant};

pub struct EventManager {
    handlers: HashMap<String, Vec<(usize, Box<dyn Fn(&Event)>)>>,
    next_id: usize,
}

impl EventManager {
    pub fn new() -> Self {
        Self {
            handlers: HashMap::new(),
            next_id: 0,
        }
    }
    
    /// 注册事件处理器，返回 handler ID 用于后续移除
    pub fn on<F: Fn(&Event) + 'static>(
        &mut self, 
        event: &str, 
        handler: F
    ) -> usize {
        let id = self.next_id;
        self.next_id += 1;
        
        self.handlers
            .entry(event.to_string())
            .or_insert_with(Vec::new)
            .push((id, Box::new(handler)));
        
        id
    }
    
    /// 移除事件处理器
    pub fn off(&mut self, event: &str, handler_id: usize) -> bool {
        if let Some(handlers) = self.handlers.get_mut(event) {
            if let Some(pos) = handlers.iter().position(|(id, _)| *id == handler_id) {
                handlers.remove(pos);
                return true;
            }
        }
        false
    }
    
    /// 触发事件
    pub fn emit(&self, event: &Event) {
        if let Some(handlers) = self.handlers.get(&event.name) {
            for (_, handler) in handlers {
                handler(event);
            }
        }
    }
    
    /// 清空所有处理器
    pub fn clear(&mut self) {
        self.handlers.clear();
    }
    
    /// 获取处理器数量（用于调试）
    pub fn handler_count(&self) -> usize {
        self.handlers.values().map(|v| v.len()).sum()
    }
}

// 正确用法
fn main() {
    let mut manager = EventManager::new();
    
    // 注册一次性处理器
    let handler_id = manager.on("data", |e| {
        println!("Received: {:?}", e);
    });
    
    // 触发事件
    manager.emit(&Event { name: "data".to_string() });
    
    // 移除处理器
    manager.off("data", handler_id);
}

✅ 修复完成。现在提供了 off() 方法来移除处理器，避免内存泄漏。

其他解决方案

// 方案 2：使用弱引用自动清理
use std::sync::{Arc, Weak};

// 方案 3：设置 TTL 自动过期
pub struct TimedHandler {
    handler: Box,
    expires_at: Instant,
}

💡 要点

识别出只增不减的数据结构
提供移除机制（handler ID）
添加清理方法
提供调试工具（handler_count）

快速命令预计用时：1分钟

快速命令参考

常用任务的快速命令示例。

📁 文件操作

查看文件结构

ls 一下项目目录

查找文件

找所有 .rs 文件

搜索代码

搜索 "TODO" 注释

🔍 代码分析

查找定��

找 parse 函数的定义

查找调用者

谁调用了 run 方法？

分析依赖

分析项目依赖关系

🛠️ 代码修改

重命名

把 old_name 改成 new_name

重构

把这个函数拆分成多个小函数

添加文档

给这个模块生成文档注释

🧪 测试与构建

运行测试

构建项目

cargo build --release

检查警告

cargo clippy

真实场景示例

修复 TypeScript 类型错误

💡 要点

重构异步代码为模块化结构

💡 要点

实现配置文件热重载

💡 要点

调试并发死锁问题

🔴 问题分析

其他解决方案

💡 要点

生成 API 文档

💡 要点

将同步代码改为异步

💡 要点

修复内存泄漏

🔴 问题根源

其他解决方案

💡 要点

快速命令参考

📁 文件操作

🔍 代码分析

🛠️ 代码修改

🧪 测试与构建

准备好开始了吗？