|
|
# 25｜增强编译器前端功能第4步：综合运用多种语义分析技术
|
|
|
|
|
|
你好，我是宫文学。
|
|
|
|
|
|
在上一节课，我们比较全面地分析了怎么用集合运算的算法思路实现类型计算。不过，在实际的语义分析过程中，我们往往需要综合运用多种技术。
|
|
|
|
|
|
不知道你还记不记得，我们上一节课举了一个例子，里面涉及了数据流分析和类型计算技术。不过这还不够，今天这节课，我们还要多举几个例子，来看看如何综合运用各种技术来达到语义分析的目的。在这个过程中，你还会加深对类型计算的理解、了解常量折叠和常量传播技术，以及实现更精准的类型推导。
|
|
|
|
|
|
好，我们首先接着上一节课的思路，看一看怎么把数据流分析与类型计算结合起来。
|
|
|
|
|
|
## 在类型计算中使用数据流分析技术
|
|
|
|
|
|
我们再用一下上节课的示例程序foo7。在这个程序中，age的类型是number|null，age1的类型是string|number。我们先让age=18，这时候把age赋给age1是合法的。之后又给age赋值为null，然后再把age赋给age1，这时编译器就会报错。
|
|
|
|
|
|
```plain
|
|
|
function foo7(age : number|null){
|
|
|
let age1 : string|number;
|
|
|
age = 18; //age的值域现在变成了一个值类型：18
|
|
|
age1 = age; //OK
|
|
|
age = null; //age的值域现在变成了null
|
|
|
age1 = age; //错误！
|
|
|
console.log(age1);
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
在这个过程中，age的值域是动态变化的。在这里，我用了“值域”这个词。它其实跟类型是同一个意思。我这里用值域这个词，是强调动态变化的特征。毕竟，如果说到类型，你通常会觉得变量的类型是不变的。如果你愿意，也可以直接把它叫做类型。
|
|
|
|
|
|
你马上就会想到，数据流分析技术很擅长处理这种情况。具体来说，就是在扫描程序代码的过程中，某个值会不断地变化。
|
|
|
|
|
|
提到数据流分析，那自然我们就要先来识别它的5大关键要素了。我们来分析一下。
|
|
|
|
|
|
**首先是分析方向。**这个场景中，分析方向显然是自上而下的。
|
|
|
|
|
|
**第二，是数据流分析针对的变量。**在这个场景中，我们需要分析的是变量的值域。所以，我用了一个varRanges变量，来保存每个变量的值域。varRanges是一个map，每个变量在里面有一个key。
|
|
|
|
|
|
```plain
|
|
|
varRanges:Map<VarSymbol, Type> = new Map();
|
|
|
|
|
|
```
|
|
|
|
|
|
**第三，我们要确定varRanges的初始值。**在这个例子中，每个变量的值域的初始值就是它原来的类型。比如age一开始的值域就是number|null。
|
|
|
|
|
|
**第四，我们要确定转换函数，也就是在什么情况下，变量的值域会发生变化。**在当前的例子中，我们只需要搞清楚变量赋值的情况就可以了。如果我们要在变量声明中进行初始化，那也可以看做是变量赋值。
|
|
|
|
|
|
在变量赋值时，如果=号右边的值是一个常量，那么变量的值域都会变成一个值对象，这种情况我们已经在前一节课分析过了。
|
|
|
|
|
|
那如果=号右边的值不是常量，而是另一个变量呢？比如下面一个例子foo10，x的类型是number|string，y的类型是string。然后把y赋给x。我相信你也看出来，现在x的值域就应该跟y的一样了，都是string。
|
|
|
|
|
|
```plain
|
|
|
function foo10(x : number|string, y : string){
|
|
|
x = y; //x的值域变成了string
|
|
|
if (typeof x == 'string'){ //其实这个条件一定为true
|
|
|
println("x is string");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
研究一下这个例子，你会发现通过赋值操作，我们把x的值域收窄了。在TypeScript的文档中，这被叫做"[Narrowing](https://www.typescriptlang.org/docs/handbook/2/narrowing.html)"。翻译成汉语的话，我们姑且称之为“窄化”吧。
|
|
|
|
|
|
不过，除了赋值语句，还有其他情况可以让变量的值域窄化，包括使用typeof运算符、真值判断、等值判断、instanceof运算符，以及使用类型断言等等。其中最后两种方法，涉及到对象，我们目前还没有支持对象特性，所以先不讨论了。我们就讨论一下typeof运算符、真值判断和等值判断这三种情况。
|
|
|
|
|
|
首先讨论一下**typeof运算符**。其实在前面的例子foo10中，我们就使用了typeof运算符。typeof是一个类型运算符，它能返回代表变量类型的字符串。不过它的结果只有少量几个值，包括number、string、boolean、object、undefined、symbol和bigint。
|
|
|
|
|
|
我们再举一个例子foo11，看看typeof是如何影响变量的值域的。
|
|
|
|
|
|
```plain
|
|
|
function foo11(x : number|string){
|
|
|
let y: string;
|
|
|
if (typeof x === 'string'){ //x的值域变为string
|
|
|
y = x; //OK。
|
|
|
}
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
你可以看到，在示例程序foo11中，x原来的类型是number|string。但在if条件中，我们用typeof进行了类型的检测，只有当x的类型是string的时候，才会进入if块。所以，在if块中，我们用x给string类型的变量y赋值是没有错的。
|
|
|
|
|
|
在使用typeof的表达式中，你可以用四个运算符：===、!==、==和!=。其中===和==的效果是一样的，只不过前者的性能更高。同样，!==和!=也是等价的。
|
|
|
|
|
|
接着，我们看看真值判断。什么是真值判断呢？我们还是举一个例子，这样理解起来更直观一些。
|
|
|
|
|
|
```plain
|
|
|
function foo12(x : string|null){
|
|
|
let y: string;
|
|
|
if (x){ //x的值域变为string & !""
|
|
|
y = x; //OK。
|
|
|
}
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
在这个例子中，x的类型是string|null。但在if语句中，通过判断x是否为真，把x=null这个选项去掉了，这样就可以把x赋给string类型的y了。
|
|
|
|
|
|
这里，我还要给你补充点背景知识。在TypeScript/JavaScript中，我们其实可以把其他类型的值放入需要boolean值的地方，比如string、number、object等，它们会被自动转化成boolean值。不过，其中有一些值会被转化成false，它们是：0、NaN、“” (空字符串)、0n (bigint类型中的0)、null，以及undefined。
|
|
|
|
|
|
除此之外的值，转化为boolean值以后都是true。所以，在上面foo12示例程序的if条件中，x是true，那它就不可能是null值了，也不可能是空字符串。这样，最后的形成的值域就是string & !“”。
|
|
|
|
|
|
最后，我们再看看**等值判断**。其实我们在上一节就见过等值判断的例子，我们把那个例子程序再拿过来看一下。
|
|
|
|
|
|
```plain
|
|
|
function foo9(age : number|null){
|
|
|
if (age == 18 || age == 81){ //age的值域现在是 18|81
|
|
|
console.log("18 or 81");
|
|
|
}
|
|
|
else{ //age的值域是 !18 & !81 & (number | null)
|
|
|
console.log("age is empty!")
|
|
|
}
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
在这个例子中有一个if语句，其中的条件表达式会生成一个值域，“18|81”。而对于else块，则需要先把“18|81”取补集，然后再跟age原来的值域求交集。
|
|
|
|
|
|
好了，现在我们就分析完了数据流分析中的第四个要素，也就是转换函数。**接下来我们看看最后一个要素，就是汇聚函数**。
|
|
|
|
|
|
什么时候需要用到汇聚函数呢？对于if语句来说，如果程序在if块和else块中都修改了某个变量的值域，那在if语句后面，变量的值域就需要做汇聚。我们还是通过一个例子来说明一下。
|
|
|
|
|
|
在下面的例子foo13中有一个if语句。在这个if语句中，if块和else块分别都有一个对y赋值的语句。在if块中赋值语句是y=x。在这里，x的值域是number，所以y的值域也是number。在else块中，赋值语句是y = 18，那y的值域就是18。
|
|
|
|
|
|
```plain
|
|
|
function foo13(x : number|null){
|
|
|
let y:number|string;
|
|
|
let z:number;
|
|
|
if (x != null){ //x的值域是number
|
|
|
y = x; //y的值域是number
|
|
|
}
|
|
|
else{
|
|
|
y = 18; //y的值域是18
|
|
|
} //if语句之后，y的值域是number
|
|
|
z = y; //OK
|
|
|
return z;
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
那么，在退出if语句的时候，y的值域应该是什么呢？你稍微分析一下就能看出来，这里应该取两个分支的并集，也就是number。所以把y赋给z是可以的。
|
|
|
|
|
|
你可以把这个例子稍微修改一下，把else块中的赋值语句改为y = “eighteen”。那当退出if语句以后，y的值域是number|“eighteen”。这样你再把y赋给z，编译器就会报错。
|
|
|
|
|
|
```plain
|
|
|
function foo14(x : number|null){
|
|
|
let y:number|string;
|
|
|
let z:number;
|
|
|
if (x != null){ //x的值域是number
|
|
|
y = x; //y的值域是number
|
|
|
}
|
|
|
else{
|
|
|
y = "eighteen"; //y的值域是18
|
|
|
} //if语句之后，y的值域是number|"eighteen"
|
|
|
z = y; //编译器报错！
|
|
|
return z;
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
好了，到目前为止，我已经把数据流分析的5个要素都识别清楚了。思路清楚以后，你就可以去实现了。至于我的参考实现，你可以看一下[TypeChecker](https://gitee.com/richard-gong/craft-a-language/blob/master/25/semantic.ts#L506)。
|
|
|
|
|
|
在这里，我要再分享一点心得。你会发现，即使我们已经多次使用数据流分析技术了，每次我还要把5个要素都过一遍。这是因为，我们做研发的时候，有个思维框架很重要，它可以引导你的思路，避免一些思维盲区。
|
|
|
|
|
|
比如，我在类型计算中使用数据流分析的时候，一开始注意力被其他技术点吸引了，忘记了用整个分析框架检查一遍，结果就忘记了实现汇聚函数，这就会导致一些功能缺失。后来用框架一检查，马上就补上了这个功能。
|
|
|
|
|
|
好了，到这里，我们已经基本介绍清楚了如何使用数据流分析技术来做类型计算。不过，类型计算还可能受到其他技术的影响。接下来我就介绍一下常量折叠（Constant Folding）和常量传播（Constant Propagation）。常量折叠和常量传播的结果，会进一步影响到类型计算的结果。
|
|
|
|
|
|
## 常量折叠和常量传播
|
|
|
|
|
|
我们还是先看一个例子来理解一下这两个概念。这个例子中有x1，x2和x3三个变量。我们首先给x2赋予常量10。接着，我们把x2+8赋给x3。从这里你能计算出，其实x3的值也是一个常量，它的值是18。
|
|
|
|
|
|
```plain
|
|
|
function foo15(x1:number|null):number{
|
|
|
let x2 = 10; //x2是常量10
|
|
|
let x3 = x2 + 8; //x3是常量18
|
|
|
if (x1 == x3 ){ //x1的值域是18
|
|
|
return x1; //OK!
|
|
|
}
|
|
|
return x2;
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
你看，执行到这里，我们其实在编译期就把x2+8的值计算出来。这样，在生成汇编代码的时候，我们就不需要进行相应的计算了，直接给x3赋值为18就行了。这个技术就叫做**常量折叠**。它能让一些常量的计算在编译期完成，这样就能提高程序在运行期的性能。
|
|
|
|
|
|
同时，在x3 = x2+8这行程序中，还有一个现象，叫做**常量传播**。什么意思呢？在这行中，x2的值已经是一个常量10了，它的常量值被传播到了x2+8这个表达式中，从而计算出了一个新的常量x3。
|
|
|
|
|
|
再接下来是一个if语句。这个时候，x3的值传播到了if条件中。这就影响到了x1的值域。现在x1的值域就变成18了。所以，当我们在if块中执行return x1的时候，代码是正确的，满足返回值必须是number的要求。
|
|
|
|
|
|
那常量传播具体怎么实现呢？
|
|
|
|
|
|
在PlayScript的实现中，我们给每个表达式都添加了一个constValue属性。通过遍历树的方式，就可以求出每个表达式的常量值，并记录到constValue属性。在生成目标代码的时候，就可以直接使用这个常量值，不需要在运行期做计算。
|
|
|
|
|
|
好了，现在我们已经了解了常量折叠和常量传播技术，也分析了它对类型计算的影响。
|
|
|
|
|
|
不过，到目前为止，对于类型计算的结果，我们都是用在类型检查的场景里。其实，类型计算的结果也能用于类型推导，能够提高类型推导的准确程度。而常量折叠和传播，也会在其中起到作用。
|
|
|
|
|
|
## 类型推导
|
|
|
|
|
|
在之前PlayScript版本中，我们也实现了基本的类型推导功能。但那个时候，类型推导都是基于变量声明时的类型，而不是基于数据流分析来获得变量动态的值域，再根据这个值域做类型推导。基于变量声明进行推导的结果肯定是不够精准的。
|
|
|
|
|
|
同样，我们举个例子看一下。在这个例子中，变量a的类型是number|string，我们再给a赋值为“hello”，现在a的值域是“hello”。再然后呢，我们声明了一个变量b，并把变量a作为它的初始化值。
|
|
|
|
|
|
```plain
|
|
|
function foo16(a:number|string){
|
|
|
a = "hello"; //a的值域是"hello"
|
|
|
let b = a; //推导出b的类型是string
|
|
|
console.log(typeof b);
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
那么问题来了，现在b应该是什么类型呢？我给你两个候选答案，让你选一下：
|
|
|
|
|
|
选项1：b的类型a原来的类型是一样的，都是number|string。
|
|
|
|
|
|
选项2：b的类型是string，因为采用常量传播技术，我们已经知道a的值是“hello”了。
|
|
|
|
|
|
我估计你应该会选出正确的答案，就是选项2。其实，上面的“let b = a”这个语句，就等价于“let b = “hello””，所以你应该能够推导出b的类型是string。
|
|
|
|
|
|
不过，这里要注意，我们不能因为a当前的值域是“hello”，就推导出变量b的类型也是值类型“hello”，这就把变量b限制得太死了。TypeScript会采用“hello”的基础类型string。
|
|
|
|
|
|
类型推导还有更复杂一点的场景。比如，在下面的例子中，我们仍然用a来初始化变量b。不过，现在a的值域是10|null。
|
|
|
|
|
|
```plain
|
|
|
function foo17(a:number|string|null){
|
|
|
if(a == 10 || a == null){ //a的值域是10|null
|
|
|
let b = a; //推导出b的类型是number|null
|
|
|
if (b == "hello"){ //编译器报错！
|
|
|
console.log("whoops");
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
基于a的值域，编译器会把b的类型推导为number|null。所以，这个时候如果我们用b=="hello"让b跟字符串做比较，编译器就会报错，指出类型number|null和string之间没有重叠，所以不能进行==运算。
|
|
|
|
|
|
|
|
|
|
|
|
好了，通过刚才的分析，相信你对类型计算的在类型推导中的作用，也有了一些直观的了解。
|
|
|
|
|
|
## 课程小结
|
|
|
|
|
|
今天的内容就是这些。在今天这节课，我希望你能在以下几个方面有所收获。
|
|
|
|
|
|
首先，我们采用数据流分析的框架，可以动态地计算变量在每行代码处的值域，或者叫做类型。通过变量赋值、typeof运算符、真值判断和等值判断等操作，变量的值域会不停地被窄化。不过，在多个条件分支汇聚的地方，又会通过求并集而把值域变宽。
|
|
|
|
|
|
第二，常量折叠技术能够在编译期提前计算出常量，这样我们就不需要在运行期再计算了，从而提高程序性能。而常数传播技术，能够把常数随着代码传播到其他地方，从而计算出更多的常量。这些传播出去的常量，还会让类型计算的结果更加准确。
|
|
|
|
|
|
第三，类型计算的结果不仅可以用于类型检查，还可以用于类型推导，让类型推导的结果更加准确。
|
|
|
|
|
|
今天这节课实现的功能，你仍然可以参考[TypeUtil](https://gitee.com/richard-gong/craft-a-language/blob/master/25/types.ts#L7)和[TypeChecker](https://gitee.com/richard-gong/craft-a-language/blob/master/25/semantic.ts#L506)的实现，并且运行[example\_type2.ts](https://gitee.com/richard-gong/craft-a-language/blob/master/25/semantic.ts#L506)示例程序。
|
|
|
|
|
|
为了更好地支持类型计算的功能，我还给编译器增加了对typeof语法的支持。增加的新语法规则叫做typeOfExp。
|
|
|
|
|
|
```plain
|
|
|
primary: literal | functionCall | '(' expression ')' | typeOfExp ;
|
|
|
typeOfExp : 'typeof' primary;
|
|
|
|
|
|
```
|
|
|
|
|
|
另外，我还增加了对于===和!==的支持。现在你对于支持新的语法规则应该已经驾轻就熟了，所以我在这里就不多展开了。你可以去看看[示例程序的源代码](https://gitee.com/richard-gong/craft-a-language/blob/master/25/parser.ts#L948)。
|
|
|
|
|
|
那么，对TypeScript的类型系统和其他编译器前端功能的实现，我们到此就告一个段落了。这些功能将会给我们后面实现编译器后端特性提供很好的支撑！
|
|
|
|
|
|
## 思考题
|
|
|
|
|
|
今天的思考题是关于类型推导的。如果b的值域是0 | 1 | true | false，那么在“let a = b”这样一个变量声明语句中，编译器推导出的a的类型应该是什么呢？
|
|
|
|
|
|
欢迎你把这节课分享给更多对编译器前端感兴趣的朋友。我是宫文学，我们下节课见。
|
|
|
|
|
|
## 资源链接
|
|
|
|
|
|
1.这节课示例代码的[目录](https://gitee.com/richard-gong/craft-a-language/tree/master/25)；
|
|
|
2.这节课你仍然需要关注[TypeChecker](https://gitee.com/richard-gong/craft-a-language/blob/master/25/semantic.ts#L506)和[TypeUtil](https://gitee.com/richard-gong/craft-a-language/blob/master/25/types.ts#L7)的代码；
|
|
|
3.Parser中解析[TypeOfExp](https://gitee.com/richard-gong/craft-a-language/blob/master/25/parser.ts#L948)的代码，非常简单；
|
|
|
4.测试程序仍然是放在[example\_types.ts](https://gitee.com/richard-gong/craft-a-language/blob/master/25/example_type2.ts)中，不过例子更多了。你每次可以注释掉其他的例子，只运行其中的一个，测试编译器的行为。
|
|
|
|