1
// 源码
2
fn greet(name: &str) -> String {
3
    format!("Hello, {}!", name)
4
}
5

6
// HIR 概念结构（简化）
7
// FnDef {
8
//     name: "greet",
9
//     inputs: [Ref(Str, Shared)],
10
//     output: String,
11
//     body: Call(format!, ["Hello, {}!", name])
12
// }

1
// MIR 概念结构（简化）
2
// BasicBlock 0:
3
//   _1 = &_2                    // 借用
4
//   _3 = move _1                // 移动
5
//   switch _3 -> [true: bb1, false: bb2]
6
//
7
// BasicBlock 1:
8
//   _4 = (*_3).field            // 解引用
9
//   drop _3                     // 析构
10
//   return
11
//
12
// BasicBlock 2:
13
//   drop _1                     // 析构
14
//   return

1
// MIR
2
// _1 = _2 + _3
3

4
// LLVM IR
5
// %1 = add i64 %2, %3

1
// 规则 1：每个值有唯一的所有者
2
let s1 = String::from("hello");
3
let s2 = s1;  // 所有权从 s1 移动到 s2
4
// println!("{}", s1);  // 编译错误：s1 的值已被移动
5

6
// 规则 2：多个不可变借用 或 一个可变借用
7
let mut data = vec![1, 2, 3];
8
let r1 = &data;      // 不可变借用
9
let r2 = &data;      // 多个不可变借用
10
// let r3 = &mut data; // 不可变借用存在时不能可变借用
11

12
// 规则 3：借用不能超过所有者的生命周期
13
fn dangling() -> &String {
14
    let s = String::from("hello");
15
    &s  // s 在函数结束时析构，返回悬垂引用
16
}

1
借用检查器的工作流程：
2
1. 为每个局部变量计算生命周期区域
3
2. 在每个程序点检查借用是否活跃
4
3. 检查是否存在冲突借用（可变+不可变同时活跃）
5
4. 检查借用是否超过所有者的生命周期
6
5. 报告错误或通过

1
// 借用检查器会拒绝的代码
2
fn bad_borrow() {
3
    let mut x = 1;
4
    let r = &x;       // 不可变借用开始
5
    x = 2;            // 可变借用冲突
6
    println!("{}", r); // 不可变借用在此使用
7
}
8

9
// 借用检查器会接受的代码（NLL）
10
fn good_borrow() {
11
    let mut x = 1;
12
    let r = &x;       // 不可变借用开始
13
    println!("{}", r); // 不可变借用在此结束
14
    x = 2;            // 不可变借用已结束，可以可变
15
}

1
// 显式生命周期标注
2
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
3
    if x.len() > y.len() { x } else { y }
4
}
5

6
// 生命周期省略规则（编译器自动推导）
7
fn first_word(s: &str) -> &str {
8
    // 等价于：fn first_word<'a>(s: &'a str) -> &'a str
9
    let bytes = s.as_bytes();
10
    for (i, &item) in bytes.iter().enumerate() {
11
        if item == b' ' { return &s[0..i]; }
12
    }
13
    &s[..]
14
}
15

16
// 结构体中的生命周期
17
struct Parser<'a> {
18
    input: &'a str,
19
    pos: usize,
20
}
21

22
impl<'a> Parser<'a> {
23
    fn new(input: &'a str) -> Self {
24
        Parser { input, pos: 0 }
25
    }
26

27
    fn peek(&self) -> Option<char> {
28
        self.input.chars().nth(self.pos)
29
    }
30
}

1
生命周期推导步骤：
2
1. 为每个引用参数和返回值分配生命周期变量
3
2. 根据函数体中的约束生成方程
4
3. 求解方程，确定每个生命周期的范围
5
4. 检查返回值的生命周期 ≤ 某个输入的生命周期
6

7
约束类型：
8
- 子类型约束：'a: 'b（'a 活至少和 'b 一样长）
9
- 引用约束：&'a T 中的 'a 必须 ≥ T 内所有引用的生命周期
10
- 返回约束：返回值的生命周期必须 ≤ 某个输入的生命周期

1
// 简单的声明宏
2
macro_rules! vec_create {
3
    ($($x:expr),*) => {
4
        {
5
            let mut v = Vec::new();
6
            $(v.push($x);)*
7
            v
8
        }
9
    };
10
}
11

12
let v = vec_create!(1, 2, 3);
13
// 展开为：
14
// {
15
//     let mut v = Vec::new();
16
//     v.push(1);
17
//     v.push(2);
18
//     v.push(3);
19
//     v
20
// }

1
// 派生宏（proc-macro-derive）
2
use proc_macro::TokenStream;
3

4
#[proc_macro_derive(Debug)]
5
pub fn derive_debug(input: TokenStream) -> TokenStream {
6
    // 解析输入 TokenStream
7
    // 生成 Debug impl 的 TokenStream
8
    // 返回生成的代码
9
}
10

11
// 属性宏（proc-macro-attribute）
12
#[proc_macro_attribute]
13
pub fn inline_test(attr: TokenStream, item: TokenStream) -> TokenStream {
14
    // 将函数转换为测试用例
15
}
16

17
// 函数式宏（proc-macro）
18
#[proc_macro]
19
pub fn sql(input: TokenStream) -> TokenStream {
20
    // 编译时 SQL 解析和验证
21
}

1
// Rust 使用 Hindley-Milner 变体进行类型推导
2
let x = 42;          // 推导为 i32
3
let y = 3.14;        // 推导为 f64
4
let z = vec![];      // 需要类型注解或上下文
5
let z: Vec<i32> = vec![];  // 显式类型
6

7
// 闭包类型推导
8
let add = |x, y| x + y;  // 推导为 i32 -> i32 -> i32

1
// Trait 约束求解
2
fn print<T: std::fmt::Display>(value: T) {
3
    println!("{}", value);
4
}
5

6
// 编译器需要证明：T 实现了 Display
7
// 求解过程：
8
// 1. 检查本地 impl
9
// 2. 检查 trait 约束传递
10
// 3. 检查孤儿规则（不能为外部类型实现外部 trait）

1
// 源码
2
fn max(a: i32, b: i32) -> i32 {
3
    if a > b { a } else { b }
4
}

1
// HIR（高级 IR）- 保留高级语法结构
2
// FnDef {
3
//     name: "max",
4
//     inputs: [i32, i32],
5
//     output: i32,
6
//     body: If {
7
//         cond: BinOp(Gt, a, b),
8
//         then: a,
9
//         else: b
10
//     }
11
// }

1
// MIR（中级 IR）- 基本块 + SSA 风格
2
fn max(i32, i32) -> i32 {
3
    let _0: i32;                    // 返回值
4
    let _1: i32;                    // 参数 a
5
    let _2: i32;                    // 参数 b
6

7
    bb0: {
8
        _3 = Gt(_1, _2);           // a > b
9
        switchInt(_3) -> [0: bb2, otherwise: bb1]
10
    }
11

12
    bb1: {
13
        _0 = _1;                   // return a
14
        return
15
    }
16

17
    bb2: {
18
        _0 = _2;                   // return b
19
        return
20
    }
21
}

1
; LLVM IR - 最终输出
2
define i32 @max(i32 %a, i32 %b) unnamed_addr {
3
start:
4
  %0 = icmp sgt i32 %a, %b
5
  br i1 %0, label %then, label %else
6

7
then:
8
  ret i32 %a
9

10
else:
11
  ret i32 %b
12
}

1
规则 1：每个引用参数获得一个独立的生命周期
2
  fn first_word(s: &str) -> &str
3
  → fn first_word<'a>(s: &'a str) -> &str
4

5
规则 2：如果只有一个输入生命周期，它赋给所有输出
6
  fn first_word<'a>(s: &'a str) -> &'a str  // 自动应用
7

8
规则 3：如果有多个输入生命周期但包含 &self/&mut self，
9
        self 的生命周期赋给所有输出
10
  fn get(&self, key: &str) -> &Value
11
  → fn get<'a, 'b>(&'a self, key: &'b str) -> &'a Value