当前位置：首页 > news >正文

所有权与解构：一次把“拆”与“留”写进类型系统的旅程 ——从语法糖到零拷贝 AST

news 2025/10/31 8:07:03

在这里插入图片描述

0 引子：为什么解构不是“语法糖”？

在 Rust 中写下

let Point { x, y } = p;

时，我们不仅得到了两个新绑定，还重新划分了所有权：

x 与 y 的 所有权 从 p 中被移动出来；
如果 p 还有未解构的字段，它们会在同一作用域继续存活；
编译器在 MIR 层为每个字段插入精确的 drop flag，保证析构恰好一次。

因此，解构 = 所有权的编译期重新布线。
本文将：

从 语言规则 到 MIR 生成 拆解这一过程；
用 3 个递进案例 展示 “拆” 与 “留” 的零成本艺术；
用 200 行真实代码 实现一个 零拷贝 JSON 解析器，把解构写进 宏规则。

1 规则速览：解构如何与所有权交互？

解构形式	所有权语义	剩余字段状态
`let Struct { a, b } = s`	整体 move，字段 `a`、`b` 获得所有权	无剩余（`s` 失效）
`let Struct { a, .. } = s`	仅 `a` move，`..` 字段原地析构	`s` 部分失效
`let [x, y] = arr`	固定长度数组整体 move	无剩余
`let [x, rest @ ..] = slice`	`x` move，`rest` 成为新切片	原切片失效
`let (a, b) = tuple`	元组整体 move	无剩余

所有规则都在 借用检查器 内完成；剩余字段的 drop 由 字段级 drop flags 实现，LLVM 可常量折叠，零运行时开销。

2 初级：结构体字段解构

2.1 代码

#[derive(Debug)]
struct Config {db_url: String,port: u16,debug: bool,
}fn start_server(mut cfg: Config) {// 只关心 db_url，其余字段留在 cfglet Config { db_url, .. } = cfg;println!("connecting to {}", db_url);// cfg.port / cfg.debug 仍可用
}

2.2 MIR 视角

bb0:_2 = move (_1.0);   // db_urldrop(_1.1);         // portdrop(_1.2);         // debug

_1（cfg）被 部分 move；
剩余字段 立刻 drop，无额外运行时表。

3 中级：数组 & 切片解构

3.1 固定长度数组

fn parse_rgb([r, g, b]: [u8; 3]) -> u32 {((r as u32) << 16) | ((g as u32) << 8) | b as u32
}

整体 move，无剩余字段。

3.2 可变长度切片

fn parse_csv(line: &str) -> (&str, &[&str]) {let mut parts = line.split(',');let head = parts.next().unwrap();let tail = parts.collect::<Vec<_>>();(head, &tail[..])          // ❌ tail 在函数作用域外悬垂
}

修复：使用 collect 转移所有权，或 返回 Vec：

fn parse_csv(line: &str) -> (&str, Vec<&str>) {let mut parts = line.split(',');let head = parts.next().unwrap();let tail = parts.collect();(head, tail)
}

4 高级：把解构写进宏——零拷贝 JSON AST

目标：

解析 JSON → 不复制字符串
AST 节点全部用 不可变借用（&'input str）
用宏把「字段级解构」写进 DSL

4.1 数据结构

#[derive(Debug)]
enum Json<'a> {Null,Bool(bool),Num(&'a str),Str(&'a str),Arr(Vec<Json<'a>>),Obj(Vec<(&'a str, Json<'a>)>),
}

4.2 解析器骨架

struct Parser<'a> {src: &'a str,pos: usize,
}impl<'a> Parser<'a> {fn parse(&mut self) -> Json<'a> {self.skip_ws();match self.peek() {Some(b'n') => { self.consume("null"); Json::Null }Some(b't') => { self.consume("true"); Json::Bool(true) }Some(b'f') => { self.consume("false"); Json::Bool(false) }Some(b'"') => Json::Str(self.parse_str()),Some(b'[') => self.parse_arr(),Some(b'{') => self.parse_obj(),_ => Json::Num(self.parse_num()),}}fn parse_str(&mut self) -> &'a str {let start = self.pos + 1;self.bump(); // skip '"'while self.peek() != Some(b'"') { self.bump(); }let end = self.pos;self.bump(); // skip closing '"'&self.src[start..end]}fn parse_num(&mut self) -> &'a str {let start = self.pos;while self.peek().map_or(false, |c| c.is_ascii_digit()) { self.bump(); }&self.src[start..self.pos]}fn parse_arr(&mut self) -> Json<'a> {self.bump(); // '['self.skip_ws();let mut out = Vec::new();while self.peek() != Some(b']') {out.push(self.parse());self.skip_ws();if self.peek() == Some(b',') { self.bump(); self.skip_ws(); }}self.bump(); // ']'Json::Arr(out)}fn parse_obj(&mut self) -> Json<'a> {self.bump(); // '{'self.skip_ws();let mut out = Vec::new();while self.peek() != Some(b'}') {let key = self.parse_str();self.skip_ws();assert_eq!(self.bump(), Some(b':'));self.skip_ws();let val = self.parse();out.push((key, val));self.skip_ws();if self.peek() == Some(b',') { self.bump(); self.skip_ws(); }}self.bump(); // '}'Json::Obj(out)}fn peek(&self) -> Option<u8> { self.src.as_bytes().get(self.pos).copied() }fn bump(&mut self) -> Option<u8> { let c = self.peek(); self.pos += 1; c }fn skip_ws(&mut self) { while self.peek().map_or(false, u8::is_ascii_whitespace) { self.bump(); } }
}

4.3 宏：把解构写进模式

macro_rules! destructure {($struct:ident { $($field:ident),+ } = $expr:expr => $body:block) => {{let $struct { $($field),+ , .. } = $expr;$body}};
}fn demo_macro(tok: Json<'_>) {destructure!(Json::Obj { entries } = tok => {for (k, v) in entries {println!("key={}, val={:?}", k, v);}});
}

5 常见坑与编译器诊断

代码	错误	原因
`let a = s.x; use(s)`	E0382	`s` 部分 move
`let [x, y] = slice`	E0509	固定长度 vs 动态长度
`match x { Some(y) => y, _ => x }`	使用 `mem::take`

6 性能观察：drop flags 被优化为常量

#[derive(Debug)]
struct Loud(i32);
impl Drop for Loud {fn drop(&mut self) {println!("drop {}", self.0);}
}fn demo() {let s = (Loud(1), Loud(2), Loud(3));let (_, b, _) = s; // 仅 b 保留
}