Go关键字数量≠语法关键词数！区分keyword / reserved identifier / predeclared identifier的致命差异

第一章：Go关键字数量≠语法关键词数！区分keyword / reserved identifier / predeclared identifier的致命差异

Go语言中常被误传“有25个关键字”，但这仅指keyword（语法保留字）——它们在词法分析阶段被硬编码识别，不可用作标识符。而实际影响命名自由的远不止这25个，还需严格区分三类关键概念：

keyword（语法关键字）

仅25个，用于定义语言结构，如 func, if, struct。若尝试将其用作变量名，编译器直接报错：

func main() {
    // 编译错误：cannot use 'func' as value
    func := "hello" // ❌ syntax error: unexpected func, expecting name
}

reserved identifier（保留标识符）

Go规范明确列出的37个标识符（如 init, main, nil, true, false），虽非keyword，但禁止用户定义同名包级标识符。它们在特定上下文中具有隐式语义（如 init 函数自动执行），若强行覆盖将导致链接失败或未定义行为。

predeclared identifier（预声明标识符）

包括类型（int, string, error）、内置函数（len, cap, make, panic）和常量（iota, nil）。它们属于全局作用域，可被遮蔽（shadowed），但会引发逻辑风险：

func example() {
    len := 42          // ✅ 语法合法（局部遮蔽）
    fmt.Println(len)   // 输出 42，而非字符串长度
    s := "hello"
    fmt.Println(len(s)) // ❌ 编译错误：len is not a function (已遮蔽)
}

类型	数量	是否可声明为变量	是否可遮蔽	典型示例
keyword	25	❌ 绝对禁止	—	`for`, `range`, `type`
reserved identifier	37	❌ 包级禁止（局部允许）	⚠️ 局部允许但危险	`init`, `main`, `nil`
predeclared identifier	~50+	✅ 允许（但不推荐）	✅ 允许	`len`, `int`, `error`

混淆这三者，轻则导致编译失败，重则引发运行时逻辑错误（如遮蔽 error 后无法返回标准错误类型）。检查当前Go版本的完整列表，请执行：

go tool compile -h 2>&1 | grep -A 10 "keywords"
# 或查阅官方文档：https://go.dev/ref/spec#Keywords_and_operators

第二章：Go语言中的keyword——编译器强制保留的语法基石

2.1 关键字定义与词法分析阶段的硬性约束（理论）+ 用go tool compile -x验证关键字触发的语法错误（实践）

Go 的词法分析器在扫描源码时，严格依据 Go Language Specification §2.1 中定义的 25 个保留关键字（如 func、return、range）进行标识符分类。任何将关键字用作变量名、字段名或包名的行为，均在词法分析（scanner.go）阶段直接拒绝，不进入后续解析。

验证：用 `go tool compile -x` 捕获早期错误

$ echo 'package main; func main() { var range int }' > bad.go
$ go tool compile -x bad.go
# command-line-arguments
<autogenerated>:1: syntax error: unexpected range, expecting semicolon or newline or }

该输出表明：range 在词法扫描阶段即被识别为保留字，var range int 被拒绝为非法标识符——编译器甚至未生成 AST。

关键约束清单

关键字区分大小写（If 合法，if 非法）
不允许作为字段名（type T { func int } → 错误）
无法通过 unsafe 或反射绕过词法检查

阶段	是否可恢复	错误类型
词法分析	❌ 否	`syntax error`
语法分析	❌ 否	`expected ...`
类型检查	✅ 是	`invalid operation`

graph TD
    A[源码字符流] --> B[Scanner：关键字匹配]
    B -->|匹配成功| C[Token: keyword]
    B -->|匹配失败| D[Token: identifier]
    C --> E[词法错误：禁止重定义]
    D --> F[进入Parser]

2.2 51个关键字的完整清单与历史演进对比（理论）+ 编写lexer测试用例动态提取Go 1.22所有keyword（实践）

Go 1.22 正式引入 else if 语法糖支持（非新增关键字），但关键字总量仍为 51个 —— 自 Go 1.0 起未增删，仅语义扩展（如 any 从别名转为 interface{} 的内置别名，非关键字）。

关键字稳定性与演进锚点

Go 1 兼容承诺锁定关键字集
fallthrough、goto 等长期存在但使用受限
comparable（Go 1.18）是约束类型，不是关键字 —— 常被误列

动态提取验证（Go 1.22.3）

// lexer_test.go：利用 go/scanner 扫描标准库 token 包
func TestKeywordsCount(t *testing.T) {
    seen := make(map[string]bool)
    for _, kw := range token.Tokens { // 注意：token.Keywords 是 map[token.Token]string
        if kw.IsKeyword() { // 实际需遍历 token.KeywordMap（内部常量表）
            seen[kw.String()] = true
        }
    }
    // 输出排序后51项，断言 len(seen) == 51
}

该测试绕过硬编码，直接反射 go/token 包的 keywordMap（含 break, case, …, type, var），确保与编译器词法分析器完全一致。

版本	关键字数	变更说明
Go 1.0	25	初始集合
Go 1.9	26	新增 `fallthrough`（实为1.0已有，文档修正）
Go 1.22	51	无新增，全量继承

graph TD
A[Go 1.0: 25 keywords] --> B[Go 1.4: 27]
B --> C[Go 1.9: 28]
C --> D[Go 1.18: 31]
D --> E[Go 1.22: 51<br>（含嵌套声明关键字如<br>type alias, generic constraints）]

2.3 关键字不可重载、不可导出、不可用作标识符的底层机制（理论）+ 尝试unsafe.Pointer绕过关键字检查的失败实验（实践）

Go 编译器在词法分析（lexer）阶段即严格识别并标记所有 25 个关键字（如 func、type、range），将其归入 token.KEYWORD 类别。此后，语法分析器（parser）直接拒绝将关键字作为标识符、字段名或导出名使用——该限制发生在 AST 构建前，与类型系统、运行时、甚至 unsafe 完全无关。

为何 `unsafe.Pointer` 无法绕过？

package main

import "unsafe"

func main() {
    // ❌ 编译错误：expected '}', found 'func'
    var func = unsafe.Pointer(uintptr(0)) // 'func' 是保留字，lexer 直接报错
}

逻辑分析：func 在源码扫描阶段已被 lexer 标记为 token.FUNC，根本不会进入后续的类型检查或指针转换流程；unsafe.Pointer 仅影响内存解释，不参与词法/语法解析。

关键字约束层级对比

阶段	是否可干预	原因
词法分析（lexer）	否	硬编码关键字表，无 hook 接口
语法分析（parser）	否	token 类型已固化
类型检查	否	关键字不进入符号表

graph TD
    A[源代码] --> B[Lexer]
    B -->|输出 token.FUNC| C[Parser]
    C -->|拒绝解析为 Ident| D[编译失败]
    B -.->|unsafe.Pointer 无作用| C

2.4 interface{}与type关键字协同实现泛型前夜的语义边界（理论）+ 构建type alias冲突示例揭示keyword语义绑定深度（实践）

interface{}：最宽泛的类型契约

interface{} 是 Go 1.0 时代唯一的“泛型”载体，它不约束任何方法，仅承诺可存储任意值。其本质是运行时类型擦除的起点，而非编译期类型推导。

type alias 的语义刚性

当 type MyInt = int 与 type MyInt int 并存时，前者是别名（同一类型），后者是新类型（独立方法集）。二者在接口实现、赋值、反射中行为截然不同。

type MyIntAlias = int
type MyIntNew int

func (MyIntNew) String() string { return "new" }

var _ fmt.Stringer = MyIntNew(0) // ✅
var _ fmt.Stringer = MyIntAlias(0) // ❌ 编译失败：MyIntAlias 未实现 String()

逻辑分析：MyIntAlias 完全等价于 int，继承其全部方法集（空）；而 MyIntNew 是全新类型，需显式实现接口。这揭示 type = 与 type 关键字在语义绑定上的根本差异——前者是类型恒等式，后者是类型构造器。

特性	`type T = U`	`type T U`
方法继承	全量继承	零继承
接口实现传递性	是	否
`reflect.TypeOf`	与 U 相同	独立 Type 实例

graph TD
    A[type declaration] --> B{= or not?}
    B -->|type T = U| C[Alias: identity]
    B -->|type T U| D[NewType: distinct]
    C --> E[No method expansion]
    D --> F[Requires explicit methods]

2.5 goto与defer等控制流关键字的栈帧影响分析（理论）+ 使用pprof trace观测关键字执行引发的runtime.goroutine状态切换（实践）

栈帧生命周期差异

goto 不改变调用栈深度，仅跳转指令指针；defer 在函数返回前压入延迟队列，其闭包捕获变量会延长栈帧存活期；panic/recover 触发栈展开（stack unwinding），逐层调用 deferred 函数。

运行时状态切换可观测性

使用 go tool pprof -http=:8080 trace.out 可捕获 goroutine 状态跃迁：running → runnable → waiting → running。关键路径中 runtime.deferproc 和 runtime.gopark 调用即对应 defer 注册与 goroutine 阻塞。

func example() {
    defer fmt.Println("deferred") // deferproc 调用，栈帧标记为“待展开”
    go func() {                   // 新 goroutine 启动，触发 gopark/goready
        time.Sleep(time.Millisecond)
    }()
}

此处 defer 注册不立即执行，但绑定当前栈帧地址；go 语句触发 newproc → gogo，导致调度器插入新 G 到 P 的 runqueue，pprof trace 中可见 GoCreate 事件及后续 GoStart。

关键字	栈帧修改	状态切换触发点	是否跨 goroutine
goto	否	无	否
defer	是（延迟释放）	deferreturn	否
go	否（新栈）	newproc → gopark	是

graph TD
    A[main goroutine] -->|defer注册| B[deferproc]
    A -->|go启动| C[newproc]
    C --> D[gopark on chan send]
    B --> E[deferreturn at function exit]

第三章：reserved identifier——被语言规范锁定但未启用的“休眠关键字”

3.1 reserved identifier的官方定义与ISO/IEC标准兼容性渊源（理论）+ 检查$GOROOT/src/cmd/compile/internal/syntax/tokens.go中reserved列表（实践）

Go语言中，reserved identifier由ISO/IEC 9899:2018 §6.4.1及Go语言规范共同约束：不得用作标识符，且编译器必须拒绝其作为变量、函数名等使用。

标准演进脉络

C99/C11保留字集为Go提供语义锚点（如break, case）
Go在保持向后兼容前提下，扩展了go, defer, chan等并发原语

tokens.go中的保留字验证

// $GOROOT/src/cmd/compile/internal/syntax/tokens.go（节选）
var reserved = [...]string{
    "break", "case", "chan", "const", "continue",
    "default", "defer", "else", "fallthrough", "for",
    "func", "go", "goto", "if", "import", "interface",
    "map", "package", "range", "return", "select",
    "struct", "switch", "type", "var",
}

该数组被token.Lookup()调用，用于词法分析阶段快速O(1)哈希匹配；长度25固定，对应Go 1.22全部关键字，不包含nil或true（它们是预声明标识符，非reserved）。

关键差异对照表

类型	示例	语义层级	是否可重定义
reserved identifier	`func`, `chan`	语法核心	❌ 编译器硬编码拒绝
predeclared identifier	`nil`, `len`	运行时上下文	❌ 但可通过作用域遮蔽（不推荐）

graph TD
    A[词法扫描] --> B{是否在reserved数组中？}
    B -->|是| C[标记token.KEYWORD]
    B -->|否| D[尝试识别identifier]
    C --> E[语法树生成阶段强制校验]

3.2 break/continue等已启用关键字与true/false等reserved identifier的token分类差异（理论）+ 修改go/parser源码注入reserved token触发panic的调试实操（实践）

Go 的词法分析器将 break、continue 等视为 keyword（token.BREAK, token.CONTINUE），而 true、false、nil 属于 predeclared identifier，在 go/token 中被归类为 token.IDENT，但其字面值受语法层硬性约束。

Token 类型	示例	token.Kind 值	是否参与 AST 构建校验
关键字（keyword）	`for`, `if`	`token.FOR`, `token.IF`	是（直接驱动语法分支）
预声明标识符（reserved identifier）	`true`, `false`	`token.IDENT`（非 keyword）	否（仅语义检查阶段拦截）

源码注入实操：强制触发 panic

// 修改 $GOROOT/src/go/scanner/scanner.go 中 scanKeyword 函数（约 line 710）
// 在 switch 前插入：
if s.ch == 't' && s.peek() == 'r' && s.peek2() == 'u' && s.peek3() == 'e' {
    s.next() // consume 't'
    s.next() // 'r'
    s.next() // 'u'
    s.next() // 'e'
    panic("injected reserved token: true")
}

该修改绕过正常 token.IDENT 分配流程，在扫描阶段直接中断；s.peekN() 系列方法读取后续字节而不推进位置指针，确保匹配原子性。panic 发生在 scanner.Scan() 返回前，验证了词法层对保留字的早期识别边界。

graph TD
    A[scanKeyword] --> B{ch == 't'?}
    B -->|Yes| C[peek next 3 chars]
    C -->|“true”| D[panic]
    C -->|No| E[fallthrough to default case]

3.3 未来版本扩展预留机制对vendor兼容性的隐性风险（理论）+ 构建跨版本go.mod依赖图识别reserved identifier潜在冲突点（实践）

预留标识符的语义漂移陷阱

Go 工具链在 go.mod 中隐式保留如 v0.0.0-00010101000000-000000000000 这类伪版本号用于内部解析，但 vendor 目录若缓存含该格式的旧模块（如 github.com/example/lib v0.0.0-20220101000000-abcdef123456），新 Go 版本可能因语义变更拒绝加载——非错误即静默降级。

跨版本依赖图构建脚本

# 递归提取所有 go.mod 的 module + require 行，标准化版本字段
find ./vendor -name "go.mod" -exec awk '/^module|^require/ {print $2, $3}' {} \; | \
  sort -u | sed 's/"/ /g' | awk '{print $1,$2}' > deps.tsv

逻辑分析：awk '/^module|^require/' 精准捕获声明行；sed 's/"/ /g' 清除引号干扰；$1,$2 提取模块路径与版本，为后续图谱构建提供结构化输入。参数 $2 是模块名，$3 是版本（含伪版本），二者共同构成唯一依赖边。

风险识别矩阵

模块路径	版本类型	是否含 reserved 格式	Go 1.20+ 兼容性
`golang.org/x/net`	pseudo	✅ `v0.0.0-2023...`	⚠️ 部分解析失败
`github.com/gorilla/mux`	semver	❌ `v1.8.0`	✅ 完全兼容

依赖图谱验证流程

graph TD
    A[扫描 vendor/go.mod] --> B[提取 module & require]
    B --> C[标准化版本字符串]
    C --> D{是否匹配 ^v0\.0\.0-[0-9]{8}[0-9]{6}-[0-9a-f]{12}$}
    D -->|是| E[标记为 reserved-risk 边]
    D -->|否| F[标记为 stable 边]

第四章：predeclared identifier——运行时内建的“伪关键字”家族

4.1 predeclared identifier的三大类别：类型、常量、函数（理论）+ 反汇编main函数观察len/cap/nil在runtime·gcstack中的调用链（实践）

Go语言中预声明标识符（predeclared identifier）不依赖任何导入包即可使用，分为三类：

类型：int, string, bool, error, any, comparable
常量：true, false, iota, nil
函数：len, cap, make, new, append, copy, panic, recover, print, println

// go tool compile -S main.go 中截取 runtime·gcstack 调用片段（简化）
TEXT runtime·gcstack(SB) /usr/local/go/src/runtime/stack.go
    CALL runtime·growslice(SB)     // cap() 触发切片扩容时隐式介入
    CALL runtime·slicecopy(SB)      // copy() 与 len() 协同校验源/目标长度

len/cap 是编译器内建（compiler intrinsic），不生成真实函数调用；但当其结果参与逃逸分析或栈增长决策时，会出现在 runtime·gcstack 的调用上下文中。nil 则作为零值标记，在 SSA 构建阶段直接转为 const 0。

标识符	是否可寻址	运行时是否具象为函数？	编译阶段处理时机
`len`	否	否（内联展开）	SSA 构建期
`nil`	否	否（字面量）	类型检查后
`make`	否	是（`runtime.makeslice`等）	代码生成期

func main() {
    s := make([]int, 3)
    _ = len(s) // 此处 len 不产生 call 指令，但影响 stack growth 决策
}

该语句在 SSA 中被优化为立即数 3，但若 s 在后续被传递至可能触发栈复制的函数，则 len(s) 的值将参与 runtime·gcstack 的帧大小计算路径。

4.2 error/string等预声明类型与interface{}的底层类型系统映射关系（理论）+ 使用go/types API解析predeclared identifier的TypeObject结构体（实践）

Go 的预声明类型（如 string、error、bool）在编译器中由 go/types 包以 *types.Named 或 *types.Basic 形式静态注册，其 Underlying() 直接指向底层基本类型。error 是接口类型别名，实际为 *types.Interface，其方法集含 Error() string；而 interface{} 是空接口，对应 *types.Interface 且方法集为空。

预声明类型的底层分类

string, int, float64 → *types.Basic
error → *types.Named wrapping *types.Interface
interface{} → *types.Interface（无方法）

解析 predeclared identifier 示例

// 使用 go/types 获取 error 类型对象
conf := &types.Config{}
info := &types.Info{Types: make(map[ast.Expr]types.TypeAndValue)}
pkg, _ := conf.Check("", fset, []*ast.File{file}, info)
errType := pkg.Scope().Lookup("error").(*types.TypeName).Type()
fmt.Printf("error type: %s, underlying: %s\n", errType, errType.Underlying())

逻辑分析：pkg.Scope().Lookup("error") 返回预声明标识符的 *types.TypeName；.Type() 获取其类型对象；Underlying() 揭示其真实接口结构。参数 fset 为文件集，file 为含 import "errors" 的 AST 文件节点。

类型名	TypeObject 类型	Underlying() 结果
`string`	`*types.Basic`	`string`（自身）
`error`	`*types.Named`	`*types.Interface`
`interface{}`	`*types.Interface`	`<empty interface>`

graph TD
    A[predeclared identifier] --> B{TypeObject 类型}
    B --> C["string → *types.Basic"]
    B --> D["error → *types.Named"]
    B --> E["interface{} → *types.Interface"]
    D --> F["Underlying → *types.Interface"]

4.3 panic/recover的goroutine局部存储实现原理（理论）+ 通过debug.SetGCPercent干扰recover行为验证其非关键字本质（实践）

Go 的 panic/recover 并非语言级“异常处理关键字”，而是基于 goroutine 私有栈上 _panic 链表的协作式控制流机制。

数据同步机制

每个 goroutine 的 g 结构体中嵌入 _panic 指针，构成 LIFO 链表；recover 仅能捕获当前 goroutine 最近未被处理的 panic，且仅在 defer 函数中有效。

非关键字本质验证

import "runtime/debug"

func main() {
    debug.SetGCPercent(-1) // 禁用 GC，延长 _panic 结构体生命周期
    defer func() {
        if r := recover(); r != nil {
            println("recovered:", r)
        }
    }()
    panic("test")
}

逻辑分析：debug.SetGCPercent(-1) 阻止 GC 回收 _panic 对象，但 recover 仍只匹配当前 goroutine 的 panic 链——证明其行为由运行时状态机驱动，而非语法关键字硬编码。

特性	panic/recover	Java try/catch
作用域	goroutine 局部	线程局部
触发时机	显式调用 + defer 执行期	JVM 字节码异常表匹配

graph TD
    A[panic\\(“msg”\\)] --> B[g.panic = &p]
    B --> C[执行defer链]
    C --> D{recover\\(\\)调用？}
    D -->|是| E[pop g.panic, 返回值]
    D -->|否| F[unwind stack, os exit]

4.4 nil作为zero value占位符的内存布局特性（理论）+ unsafe.Sizeof(nil)与unsafe.Sizeof((*int)(nil))的对比实验（实践）

nil 在 Go 中并非统一实体，而是类型依赖的零值占位符：它不占用存储空间，但语义依附于具体类型（如 *int、[]string、map[string]int）。

`nil` 的内存本质

nil 本身无类型，不能直接取大小；
(*int)(nil) 是类型化空指针，底层为 0x0 地址，但 unsafe.Sizeof 只计算其头部尺寸（即指针宽度）；
nil（未类型化）无法通过 unsafe.Sizeof 编译，必须显式类型转换。

实验验证

package main
import (
    "fmt"
    "unsafe"
)
func main() {
    var p *int
    fmt.Println(unsafe.Sizeof(p))           // 输出: 8 (64位系统)
    fmt.Println(unsafe.Sizeof((*int)(nil))) // 输出: 8 —— 同上，因是 *int 类型
    // fmt.Println(unsafe.Sizeof(nil))      // ❌ 编译错误：cannot use nil as type
}

逻辑分析：unsafe.Sizeof 接收类型确定的值。(*int)(nil) 被视为 *int 类型的零值，其大小恒等于指针宽度（uintptr 大小），与是否指向有效内存无关。而裸 nil 无类型信息，编译器拒绝求值。

表达式	是否可编译	`unsafe.Sizeof` 结果	说明
`(*int)(nil)`	✅	`8`（amd64）	类型化空指针，尺寸=指针宽
`nil`（裸）	❌	—	类型缺失，非法操作
`[]int(nil)`	✅	`24`（slice header）	slice header 固定三字段

graph TD
    A[unsafe.Sizeof] --> B{输入是否具类型？}
    B -->|否| C[编译失败]
    B -->|是| D[返回该类型底层结构大小]
    D --> E[指针→8字节<br>slice→24字节<br>chan/map→8字节<sup>*</sup>]

第五章：终极辨析：三类标识符在AST、IR、机器码层面的根本分野

什么是三类标识符：变量名、函数名与类型名的语义锚点

在真实编译流程中，int32_t count; 中的 count（变量名）、memcpy（函数名）和 int32_t（类型名）虽同属标识符，却在编译器各阶段承载截然不同的语义责任。Clang 15 的 AST dump 显示：count 被建模为 VarDecl 节点，其 getDeclContext() 指向作用域链；memcpy 对应 FunctionDecl，携带调用约定与符号可见性；而 int32_t 则被解析为 TypedefNameDecl，其 getUnderlyingType() 指向 BuiltinType。三者在 AST 层即已分化为不同 Decl 子类，不可互换。

LLVM IR 中的符号表映射差异

下表对比三类标识符在 IR 中的典型表现（以 -O0 -emit-llvm 编译 test.c 得到）：

标识符类型	IR 示例	符号属性	是否参与 SSA 命名
变量名	`%count = alloca i32, align 4`	全局/局部地址，无符号导出	否（地址值不参与 PHI）
函数名	`declare void @memcpy(ptr, ptr, i64)`	外部链接符号，带调用签名	否（函数名本身非 SSA 值）
类型名	`typedef i32 %int32_t`（实际不显式存在）	仅影响类型检查，IR 中被展开为 `i32`	不适用

注意：类型名在 IR 层彻底消失——int32_t 被前端展开为 i32，不再保留任何类型别名痕迹。

x86-64 机器码中的物理实现断层

使用 clang -S -O2 test.c -o test.s 观察汇编输出：

# 变量名 → 栈偏移或寄存器分配
movl    %eax, -4(%rbp)    # count 存于 rbp-4，无符号残留

# 函数名 → 符号引用与 PLT 跳转
call    memcpy@PLT          # 符号名保留在 .rela.dyn 中，链接时重定位

# 类型名 → 完全不可见
# int32_t 与 uint32_t 在 movl 指令中无任何区分

三阶段验证：一个真实调试案例

某嵌入式项目中，static const struct DeviceOps ops = { ... }; 编译后出现符号未定义错误。通过 llvm-objdump --syms firmware.elf 发现 ops 符号缺失，但 llvm-ir 显示 @ops = internal constant %struct.DeviceOps 存在。进一步用 clang -cc1 -ast-dump 确认 ops 为 VarDecl，且 isStaticLocal() 返回 true；最终定位到 LTO 链接阶段因 DeviceOps 类型名未被显式导出，导致跨模块类型合并失败——类型名在 IR 层消亡，却在链接期引发 ABI 不一致。

flowchart LR
    A[AST: VarDecl 'count'] -->|前端语义分析| B[IR: %count = alloca i32]
    C[AST: FunctionDecl 'memcpy'] -->|符号导出| D[IR: declare @memcpy]
    E[AST: TypedefNameDecl 'int32_t'] -->|类型展开| F[IR: i32 literal]
    B --> G[MachineInstr: movl %eax -4%rbp]
    D --> H[MachineInstr: call memcpy@PLT]
    F --> I[MachineInstr: movl immediate 42]

编译器优化对标识符生命周期的剪裁效应

在 -O2 下，局部变量 int temp = x + y; 若未取地址，Clang 直接将其提升为 SSA 值 %temp = add i32 %x, %y，原始标识符 temp 在 IR 中被完全擦除；而函数名 helper() 即使内联，其符号仍可能保留在 .debug_pubnames 中供 GDB 使用；类型名则从始至终不生成任何 debug info 条目——DWARF 中仅记录 DW_TAG_base_type 而非 DW_TAG_typedef。