Debug 方式概览

[lencx]

lencx/rust-fe - GitHub 仓库（内含代码）。如果文章对您有所帮助，欢迎分享或 Star 此项目，您的支持是我创作的最大动力，感恩！

示例代码：examples/debug

工欲善其事，必先利其器。在正式开发项目，我想先简单介绍一下 Rust 常用的 debug 手段，欢迎补充。

Rust Playground

Rust Playground 是 Rust 编译器的在线网页版，用于试验该语言。提供了 crates.io 下载量最高的前 100 个 crate（一个不起眼的小知识，它的前端界面使用 React 构建）。

Rust 源代码在变成机器语言之前，会经过一系列的中间表示 (IR: intermediate representation) 来完成编译。查看这些中间表示，也可以帮助我们更好的理解源代码。一般需要经过以下三级 HIR、MIR 和 LLVM（简单来说就是变得越来越看不懂了）：

源代码 -> HIR (高级 IR) -> MIR (中级 IR) -> LLVM (低级 IR) -> 机器语言

名词解释

• AST - 直接使用源代码非常不方便且容易出错。因此，Rust 编译器在做任何其他事情之前，都需要将原始源代码 (raw source code) 转换为抽象语法树 (AST)，主要包括词法分析 (lexing)、解析 (parsing)、宏扩展 (macro expansion)、名称解析 (name resolution)、条件编译 (conditional compilation)、特征门检查 (feature-gate checking) 和抽象语法树的验 (validation of the AST)。这些任务之间并没有明确的执行顺序。
• HIR - High-Level Intermediate Representation 是大多数 rustc 中使用的主要 IR。它是在解析、宏扩展和名称解析之后生成的抽象语法树 (AST) 的编译器友好表示。 HIR 的许多部分都非常类似于普通 Rust 的语法，除了 Rust 中的一些表达式已被“解构 (desugaring)”（例如：for 循环将转换为了 loop，因此在 HIR 中不会出现 for）。 这使 HIR 比普通 AST 更易于分析。
• THIR - Typed High-Level Intermediate Representation 以前称为 HAIR，是 rustc 使用的另一个 IR，在类型检查后生成。它（截至 2022 年 4 月）只用于 MIR 的构建和穷举性检查。还有一个在 THIR 上运行的实验性的不安全检查器，作为当前 MIR 不安全检查器的替代，可以通过向 rustc 传递 -Z thir-unsafeck 标志来代替 MIR 不安全检查器。
• MIR (Mid-level IR) - Mid-level Intermediate Representation 是由 HIR 构建的。MIR 是在 RFC 1211 中引入的。它是 Rust 的一种根本性的简化形式，用于某些流程敏感的安全检查——尤其是借用检查器! 同时也用于优化和代码生成。如果你想了解 MIR 的高层次介绍，以及它所依赖的一些编译器概念（如控制流图和解构），你可能会喜欢 rust-lang 博客中介绍 MIR 的文章。

插件

cargo 插件

cargo-expand 是对 cargo 命令的扩展，可以打印出宏扩展的结果和应用于当前 crate 的 #[derive] 扩展，执行以下命令安装：

$ cargo install cargo-expand

编辑 src/main.rs:

#[derive(Debug)]
struct S;

fn main() {
    println!("{:?}", S);
}

执行 cargo expand 命令:

$ cargo expand
    Checking debug v0.1.0 (/Users/lencx/rust-fe/examples/print)
    Finished dev [unoptimized + debuginfo] target(s) in 0.66s

#![feature(prelude_import)]
#[prelude_import]
use std::prelude::rust_2021::*;
#[macro_use]
extern crate std;
struct S;
#[automatically_derived]
impl ::core::fmt::Debug for S {
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "S")
    }
}
fn main() {
    {
        ::std::io::_print(
            ::core::fmt::Arguments::new_v1(
                &["", "\n"],
                &[::core::fmt::ArgumentV1::new_debug(&S)],
            ),
        );
    };
}

VS Code 插件

LLDB 的主要调试重点是 C++ 和 Rust 语言，为此 CodeLLDB 包括用于向量、字符串、映射和其他标准库类型的内置可视化工具。这里就不做过多解释，需要使用的朋友可以查看文档，了解更多。

终端调试

在源码内使用 print! 或 dbg! 会将调试信息输出在终端。

print

rust print 由 std::fmt 中定义的一系列宏处理，其中包含：

• format! - 将格式化文本写入字符串 (String)
• print! - 格式与 format!一样，但文本打印到控制台 (io::stdout)
• println! - 格式与 print!一样，但新增了一个换行符（新起一行）
• eprint! - 格式与 print!一样，但文本打印到标准错误 (io::stderr)
• eprintln! - 格式与 eprint!一样，但新增了一个换行符（新起一行）

// `derive` 属性自动创建实现
// 需要使用 `fmt::Debug` 使这个 `struct` 可打印
#[derive(Debug)]
#[allow(dead_code)] // 消除代码未被使用的警告信息
struct User {
    name: String,
    age: i32,
    email: Option<String>, // 可选参数，如果没有则为 None
}

fn main() {
    println!("\n*********** 无参数 ***********\n");
    // output: Hello, world!
    println!("Hello, world!");

    println!("\n*********** 多个参数 ***********\n");
    // output: hello rust
    println!("{} {}", "hello", "rust");

    println!("\n*********** 参数重排序 ***********\n");
    // 使用参数索引重新组合排序，支持键值对
    // ⚠️ 注意：属性参数位置必须在索引参数之后，否则会报错：positional arguments cannot follow named arguments
    // output: "lencx": 1 2 rust 3
    println!("{name:?}: {0:?} {1:?} {lang} {2:?} ",
        1, // 1:?
        2, // 2:?
        3, // 3:?
        lang="rust", // lang - 字符串格式输出，不带双引号
        name="lencx", // name:? - 字符串格式输出，带双引号
    );

    println!("\n*********** Struct ***********\n");
    // output: User { name: "lencx", age: 18, email: None }
    let user = User { name: "lencx".into(), age: 18, email: None };
    println!("{:?}", user);

    println!("\n----- Struct 格式美化 -----\n");
    // output:
    // User {
    //  name: "lencx",
    //  age: 18,
    //  email: None,
    // }
    println!("{:#?}", user);

    println!("\n*********** 进制转换 ***********\n");
    println!("进制 10:               {}",   69420); // 69420
    println!("进制 2 (binary):       {:b}", 69420); // 10000111100101100
    println!("进制 8 (octal):        {:o}", 69420); // 207454
    println!("进制 16 (hexadecimal): {:x}", 69420); // 10f2c
    println!("进制 16 (hexadecimal): {:X}", 69420); // 10F2C

    println!("\n*********** 补齐 ***********\n");
    println!("\n----- 补空字符串 -----\n");
    // 右对齐：字符左边补充 15 个空字符
    // output: "          hello"
    println!("{0:>15}", "hello");
    // 右对齐：字符左边补充 10 个空字符
    // output: "Name:     lencx"
    println!("Name:{name:>10}", name="lencx");

    println!("\n----- 数字补零 -----\n");
    // 用额外的零填充在数字后面
    println!("{number:0<5}", number=1); // 10000
    // 用额外的零填充在数字前面
    println!("{number:0>5}", number=1); // 00001
    // width: 通过附加“$”在格式说明符中使用命名参数，需要在数字前补零的个数
    println!("{number:0>width$}", number=5, width=10); // 0000000005

    println!("\n----- 周围变量捕获参数 -----\n");
    // 对于 Rust 1.58 及更高版本，您可以直接从周围变量中捕获参数，a 和 b 为变量
    let a: f64 = 1.0;
    let b: usize = 5;
    println!("{a:0>b$}"); // 补零：00001
    println!("{a:>b$}");  // 补空: "    1"
}

dbg!

rust dbg! 是一个非常有用的调试宏，与 print 不同的是：它会输出文件名，当前代码行号，变量名称以及变量的值。

// `derive` 属性自动创建实现
// 需要使用 `fmt::Debug` 使这个 `struct` 可打印
#[derive(Debug)]
#[allow(dead_code)] // 消除代码未被使用的警告信息
struct User {
    name: String,
    age: i32,
    email: Option<String>, // 可选参数，如果没有则为 None
}

fn main() {
    // [src/main.rs:18] user = User {
    //     name: "lencx",
    //     age: 18,
    //     email: None,
    // }
    let user = User { name: "lencx".into(), age: 18, email: None };
    dbg!(user);

    // [src/main.rs:23] "a" = "a"
    // [src/main.rs:23] "b" = "b"
    // [src/main.rs:23] 1 = 1
    dbg!("a", "b", 1);
}