3B.5 Unit Test及AST可视化

在了解了语法树的数据结构与基本解析思路之后，就没有必要继续钻入各个代码角落去学习解析细节了。此时更好的方式是反向学习：通过 UT 来调用解析函数，查看各种代码块的解析结果。

语法分析器很容易进行单元测试，因为其本质上只需要一段代码作为输入，对运行环境没有额外的要求，因此我们不需要做太多的初始化工作。测试文件 parsertest.go 中已经包含了很多测试用例可供参考，可以直接运行。但在运行 UT 或者构建自己的 UT 之前，我们先来看一下如何更好的查看语法树的内容，毕竟其内嵌结构可能很深。

文件 dumper.go 中的函数 Fdump 可以将一个 Node 的结构 dump 出来，而包括 File 在内，所有前面介绍过得结构体都实现了 Node 接口，所以该函数是我们可视化语法树的好工具。

下面我们通过一些 UT 来进一步学习一下语法解析的功能。

在 parser_test.go 内创建如下 UT

func TestParser(t *testing.T) {
    code := `
package main

import (
"fmt"
"net/http"
)

const （a, b)                    
var names []string = make([]int, 10)

func iterate[T any](list []T, f func(T))  {
    for _, t  := range list {
        f(t)
    }
}
`

    ast, _ := Parse(NewFileBase("dump_source.go"), bytes.NewBuffer([]byte(code)), func(err error) {
        fmt.Printf("Parsing Error: %v\n", err)
    }, nil, CheckBranches|AllowGenerics) // 开启泛型支持，以便解析出类型参数

    if ast != nil {
        Fdump(os.Stdout, ast)
    }
}

执行该 UT 得到输出结果：

1  *syntax.File {
2  .  Pragma: nil
3  .  PkgName: main @ dumpsource.go:2:9
4  .  DeclList: []syntax.Decl (5 entries) {
5  .  .  0: *syntax.ImportDecl {
6  .  .  .  Group: *syntax.Group {}
7  .  .  .  Pragma: nil
8  .  .  .  LocalPkgName: nil
9  .  .  .  Path: *syntax.BasicLit {
10  .  .  .  .  Value: “\”fmt\“”
11  .  .  .  .  Kind: 4
12  .  .  .  .  Bad: false
13  .  .  .  }
14  .  .  }
15  .  .  1: *syntax.ImportDecl {
16  .  .  .  Group: *syntax.Group {}
17  .  .  .  Pragma: nil
18  .  .  .  LocalPkgName: nil
19  .  .  .  Path: *syntax.BasicLit {
20  .  .  .  .  Value: “\”net/http\“”
21  .  .  .  .  Kind: 4
22  .  .  .  .  Bad: false
23  .  .  .  }
24  .  .  }
25  .  .  2: *syntax.ConstDecl {
26  .  .  .  Group: *syntax.Group {}
27  .  .  .  Pragma: nil
28  .  .  .  NameList: []*syntax.Name (2 entries) {
29  .  .  .  .  0: a @ dumpsource.go:9:8
30  .  .  .  .  1: b @ dumpsource.go:9:11
31  .  .  .  }
32  .  .  .  Type: nil
33  .  .  .  Values: nil
34  .  .  }
35  .  .  3: *syntax.VarDecl {
36  .  .  .  Group: nil
37  .  .  .  Pragma: nil
38  .  .  .  NameList: []*syntax.Name (1 entries) {
39  .  .  .  .  0: names @ dumpsource.go:10:5
40  .  .  .  }
41  .  .  .  Type: *syntax.SliceType {
42  .  .  .  .  Elem: string @ dumpsource.go:10:13
43  .  .  .  }
44  .  .  .  Values: *syntax.CallExpr {
45  .  .  .  .  Fun: make @ dumpsource.go:10:22
46  .  .  .  .  ArgList: []syntax.Expr (2 entries) {
47  .  .  .  .  .  0: *syntax.SliceType {
48  .  .  .  .  .  .  Elem: int @ dumpsource.go:10:29
49  .  .  .  .  .  }
50  .  .  .  .  .  1: *syntax.BasicLit {
51  .  .  .  .  .  .  Value: “10”
52  .  .  .  .  .  .  Kind: 0
53  .  .  .  .  .  .  Bad: false
54  .  .  .  .  .  }
55  .  .  .  .  }
56  .  .  .  .  HasDots: false
57  .  .  .  }
58  .  .  }
59  .  .  4: *syntax.FuncDecl {
60  .  .  .  Pragma: nil
61  .  .  .  Recv: nil
62  .  .  .  Name: iterate @ dumpsource.go:12:6
63  .  .  .  TParamList: []*syntax.Field (1 entries) {
64  .  .  .  .  0: *syntax.Field {
65  .  .  .  .  .  Name: T @ dumpsource.go:12:14
66  .  .  .  .  .  Type: any @ dumpsource.go:12:16
67  .  .  .  .  }
68  .  .  .  }
69  .  .  .  Type: *syntax.FuncType {
70  .  .  .  .  ParamList: []*syntax.Field (2 entries) {
71  .  .  .  .  .  0: *syntax.Field {
72  .  .  .  .  .  .  Name: list @ dumpsource.go:12:21
73  .  .  .  .  .  .  Type: *syntax.SliceType {
74  .  .  .  .  .  .  .  Elem: T @ dumpsource.go:12:28
75  .  .  .  .  .  .  }
76  .  .  .  .  .  }
77  .  .  .  .  .  1: *syntax.Field {
78  .  .  .  .  .  .  Name: f @ dumpsource.go:12:31
79  .  .  .  .  .  .  Type: *syntax.FuncType {
80  .  .  .  .  .  .  .  ParamList: []*syntax.Field (1 entries) {
81  .  .  .  .  .  .  .  .  0: *syntax.Field {
82  .  .  .  .  .  .  .  .  .  Name: nil
83  .  .  .  .  .  .  .  .  .  Type: T @ dumpsource.go:12:38
84  .  .  .  .  .  .  .  .  }
85  .  .  .  .  .  .  .  }
86  .  .  .  .  .  .  .  ResultList: nil
87  .  .  .  .  .  .  }
88  .  .  .  .  .  }
89  .  .  .  .  }
90  .  .  .  .  ResultList: nil
91  .  .  .  }
92  .  .  .  Body: *syntax.BlockStmt {
93  .  .  .  .  List: []syntax.Stmt (2 entries) {
94  .  .  .  .  .  0: *syntax.ForStmt {
95  .  .  .  .  .  .  Init: *syntax.RangeClause {
96  .  .  .  .  .  .  .  Lhs: *syntax.ListExpr {
97  .  .  .  .  .  .  .  .  ElemList: []syntax.Expr (2 entries) {
98  .  .  .  .  .  .  .  .  .  0: _ @ dumpsource.go:13:6
99  .  .  .  .  .  .  .  .  .  1: t @ dumpsource.go:13:9
100  .  .  .  .  .  .  .  .  }
101  .  .  .  .  .  .  .  }
102  .  .  .  .  .  .  .  Def: true
103  .  .  .  .  .  .  .  X: list @ dumpsource.go:13:21
104  .  .  .  .  .  .  }
105  .  .  .  .  .  .  Cond: nil
106  .  .  .  .  .  .  Post: nil
107  .  .  .  .  .  .  Body: *syntax.BlockStmt {
108  .  .  .  .  .  .  .  List: []syntax.Stmt (1 entries) {
109  .  .  .  .  .  .  .  .  0: *syntax.ExprStmt {
110  .  .  .  .  .  .  .  .  .  X: *syntax.CallExpr {
111  .  .  .  .  .  .  .  .  .  .  Fun: f @ dumpsource.go:14:3
112  .  .  .  .  .  .  .  .  .  .  ArgList: []syntax.Expr (1 entries) {
113  .  .  .  .  .  .  .  .  .  .  .  0: t @ dumpsource.go:14:5
114  .  .  .  .  .  .  .  .  .  .  }
115  .  .  .  .  .  .  .  .  .  .  HasDots: false
116  .  .  .  .  .  .  .  .  .  }
117  .  .  .  .  .  .  .  .  }
118  .  .  .  .  .  .  .  }
119  .  .  .  .  .  .  .  Rbrace: syntax.Pos {}
120  .  .  .  .  .  .  }
121  .  .  .  .  .  }
122  .  .  .  .  .  1: *syntax.ReturnStmt {
123  .  .  .  .  .  .  Results: *syntax.BasicLit {
124  .  .  .  .  .  .  .  Value: “\”unexpected\“”
125  .  .  .  .  .  .  .  Kind: 4
126  .  .  .  .  .  .  .  Bad: false
127  .  .  .  .  .  .  }
128  .  .  .  .  .  }
129  .  .  .  .  }
130  .  .  .  .  Rbrace: syntax.Pos {}
131  .  .  .  }
132  .  .  }
133  .  }
134  .  EOF: syntax.Pos {}
135  }

但仔细查看我们所解析的代码，会发现其存在如下问题：

1. import 的库未使用

2. 常量 a, b 没有初始化

3. 变量 names 声明的类型与 make 中指定的类型不一致

4. iterate 声明中不需要返回值，但该函数却返回了一个字符串

但解析器依然成功完成了解析，这是因为此时解析器只是负责做语法分析，只要程序符合语言的文法规范，解析器就能够顺利完成；而上述问题是语义问题，或者是代码规范问题（import 的库未使用），不属于语法解析器的管理范围。想要处理这些问题，编译器还需要将语法树继续往后传递并进行进一步处理。