编译器：类型系统的架构设计

类型系统是编译器内部最复杂、实现难度最高的模块。
类型系统负责分析变量类型、检测语义错误。
我花了半年时间研究整个类型系统的实现，现在整理一些研究成果，希望能对你有所帮助。
什么是类型

从最开始学编程时，书里就告诉我们，int 是一个内置类型，然后我们也可以通过 class 自定义类型，之后我们发现还可以通过 interface 和 enum 创建更多的类型。这是我们对类型的初步认知，它正确、但不完整。
每个变量都有一个类型，这个变量也只能赋予属于该类型的值。也就是说，我们把一个变量能保存的所有值组成的集合称为类型。
所以类型的本质就是数学里的集合。因此类型理论上也可以作集合运算，比如交集和并集。在有继承的语言里，子类本质上是父类的子集。
在实现编译器时，你不能简单把类型理解为就是一种 class 或  interface，而应该把它看成一种集合。
用户通过 class 定义了一种特定的集合，该集合的元素只能是该 class 的实例。
通过 interface 可以截取 class 中的任何子集。两个 class 即使互不包含，但仍可以存在公共交集，即两个 class 即使互不相干，但依然可以提取出一个公共 interface。
当一个类型 A 可以赋值给另一个类型 B，本质上就是 A 被包含于 B。
特殊类型

既然类型是一种集合，那就存在两个特殊的概念：全集和空集。
任何类型都是全集类型的子集。
在不同语言里，对全集的叫法可能不太一样。
在多数语言里，它叫 any。在 TypeScript 里，它叫 unknown。在 Java 和 C# 里，object 充当了全集类型的角色。
空集是任何类型的子集，表示一种不存在的类型。
在 TypeScript 里，它叫 never。
在 Kotlin 里，它叫  Nothing。
在 Rust 里，它叫 !。
当一个函数没有返回，而是直接抛出异常时，即这个函数永不返回，那么它的返回类型就是一种空集。
注意用来表示无返回值的 void 不是空集，它其实是一种大小为 0 的特殊类型，也可以称为空结构、空枚举。
void 和  never 的区别在于：前者表示返回了，但返回空值，后者表示永不返回。
为了方便理解，后文统一用 unknown 表示全集，用 never 表示空集。
可变类型

有一些类型并不代表固定的集合，而是集合可大可小，这种类型我们称为“泛型”。
泛型是一种类型变量，它的大小由使用时确定，但在编译期由于无法确定实际类型，我们需要将它理解为一种集合区间。
泛型可取的最大范围，称为泛型的约束类型。
在 C# 里，通过 where 子句指定约束。
泛型可取的最小范围，通常不提供语法设置（因为没实际用途），因此就是 never。
在从变量取值时，我们会将泛型替换为其可能的最大范围（如果最大范围都能赋值，那更小的范围就更能赋值）。
在给变量赋值时，我们会将泛型替换为其可能的最小范围（如果变量能赋值给最小范围，那一定能赋值给更大范围）。
在 TypeScript 中，any 本质上就是一种特殊泛型，它表示从 never 到  unknown 的所有类型。
在 C# 里，它叫 dynamic。
类型分类

无论类型系统有多复杂，所有类型都可以分成以下五类：

• 原生类型
  
• 字面量类型
  
• 对象类型
  
• 可实例化类型
  
• 复合类型
  

原生类型

原生类型有五种：

• any
  
• unknown
  
• never
  
• void
  
• null
  

多数语言只支持 unknown、never、void。（注意很多语言比如 Golang 里的 any 本质是 unknown）
传统语言比如 Java 和 C# 并没有将 null 单独处理，而是让它成为所有 class 的隐式子集。
现代注重 null 安全的语言则把它同 class 区分出来，但每个语言写法不同。
字面量类型

字面量类型有四种：

• 布尔
  
• 整数
  
• 浮点数
  
• 字符串
  

字面量类型表示特定常量值。比如 1 是一种整数字面量类型。
注意 int 不是字面量类型，它是一种 class，而不是一个固定的值。
目前，只有极少数语言支持字面量类型，比如 TypeScript。
对象类型

对象类型有三种：

• 类或接口
  
• 匿名对象
  
• 函数类型
  

对象类型表示一个真实的对象，只有对象类型可以定义很多属性。
当我们用 class 定义一个类，即定义一种对象类型。
有的语言支持匿名类，那它就是匿名对象类型。
有的语言支持函数也能作值使用，那函数的类型就是一种特殊对象类型。
可实例化类型

类型参数是一种可实例化类型。
如果类型系统支持计算，则所有包含类型参数的类型都需要等到类型参数确定后才能计算，这些类型则都是可实例化类型。
目前，只有极少数语言支持类型计算，比如 TypeScript。因此对多数语言来说，可实例化类型就单纯指类型参数本身。
复合类型

复合类型分两种:

• 联合（X | Y）
  
• 组合（X & Y）
  

联合类型，就是求两个类型并集。组合类型，就是求两个类型交集。
在 C 语言通过 union 定义联合类型。在多数语言都不支持联合类型。
在支持 struct 或 class 的语言里，可以通过组合字段实现组合类型。
泛型类的数据格式

我们将泛型类本身，称之为“泛型定义”，泛型定义拥有多个类型形参（type parameters）。
将类型形参替换成实际类型后，生成的类型，称之为“泛型实例”，泛型实例拥有多个类型实参（type arguments）。
泛型实例一定对应一个泛型定义（叫 origin），和一个类型替换器（叫 type substitutor）。
如果泛型实例的实参又包含类型参数，则可以再次实例化得到新泛型实例。
泛型定义和泛型实例统称为泛型（generic type）。但一个类型不可能同时是泛型定义和泛型实例。
因此，我们可以用不同类型区分泛型定义和泛型实例。
对于支持内嵌类的语言，泛型参数应该包括容器的类型参数，而不只是当前类本身的。比如：

1. class A<T> {
2.     class B<U> {}
3. }

复制代码

A.B 在内部应该表示为 A.B，拥有双类型参数。但在最终展示时，可以还原为 A.B<U>。
延时计算

由于类型可能存在递归，应该尽可能延时计算子属性。
比如：

1. type A = A[]

复制代码

A 是一个数组，数组或者是空数组，或者其元素也是数组。
这里 A 就是递归的，我们需要延时解析类型实参，以避免触发递归。
类型别名

类型别名分为透明类型别名和不透明类型别名。
透明类型别名即只创建新名称，但不创建新类型。
比如 type A = int，A 是一个透明类型别名，无论何时，A 和 int 都可以互换，因为它们是相同类型。
不透明类型别名则表示创建了新类型，只不过两者的内部数据刚好一样。
比如 Golang 用 type A int 定义不透明类型别名；用 type A = int 定义透明类型别名。
在类型系统内部，不透明类型别名应该等同于类或接口这些类型，并具备相同处理方式。而透明类型可以完全不存在特定的数据结构来保存。
但为了支持在 IDE 展示时，可以正确展示出别名信息（比如 type A = int; var a: A，当鼠标悬停在 a 是，可以展示 A，而不是 int），可以在类型中插入一个额外的别名字段。但不建议设置新类型数据结构，因为别名类型和原类型的处理方式总是相同。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！