编译器静态类型检查“复杂”表达式时，常用的程序是什么？

注意：在标题中使用“复杂”时，是指该表达式具有许多运算符和操作数。表达式本身并不复杂。

我最近一直在研究一个简单的x86-64汇编程序。我已经完成了编译器的主要前端-词法分析器和解析器-现在可以生成程序的抽象语法树表示形式。由于我的语言将是静态类型的，因此我现在进入下一阶段：类型检查源代码。但是，我遇到了一个问题，而自己却无法合理解决。

考虑以下示例：

我的编译器的解析器已阅读以下代码行：

int a = 1 + 2 - 3 * 4 - 5

并将其转换为以下AST：

       =
     /   \
  a(int)  \
           -
         /   \
        -     5
      /   \
     +     *
    / \   / \
   1   2 3   4

现在，它必须键入检查AST。首先检查=操作员的类型。首先检查操作员的左侧。可以看到该变量a被声明为整数。因此，它现在必须验证右侧表达式为整数。

我了解如果表达式只是一个值（例如1或），该怎么办'a'？但是，对于具有多个值和操作数的表达式（一个复杂的表达式）（例如上述表达式），该如何处理呢？为了正确确定表达式的值，似乎类型检查器实际上必须执行表达式本身并记录结果。但这显然似乎破坏了将编译和执行阶段分开的目的。

我想可以做到的唯一另一种方法是递归检查AST中每个子表达式的叶子，并验证所有叶子的类型都与期望的运算符类型匹配。因此，从=运算符开始，类型检查器将扫描左侧的所有AST并验证叶子都是整数。然后，它将对子表达式中的每个运算符重复此操作。

我曾尝试在《龙书》的副本中研究该主题，但似乎没有涉及太多细节，只是重申了我已经知道的内容。

当编译器对具有多个运算符和操作数的表达式进行类型检查时，通常使用的方法是什么？我上面提到的任何方法都使用吗？如果没有，那么方法是什么，它们将如何工作？

递归就是答案，但是您在执行操作之前先进入每个子树：

int a = 1 + 2 - 3 * 4 - 5

以树的形式：

(assign (a) (sub (sub (add (1) (2)) (mul (3) (4))) (5))

通过先走左手，然后走右手，然后在推断出操作数的类型后立即对运算符进行处理，即可推断出类型：

(assign*(a) (sub (sub (add (1) (2)) (mul (3) (4))) (5))

->进入lhs

(assign (a*) (sub (sub (add (1) (2)) (mul (3) (4))) (5))

->推断a。a众所周知是int。现在回到assign节点：

(assign (int:a)*(sub (sub (add (1) (2)) (mul (3) (4))) (5))

->下降到rhs，然后下降到内部运算符的lhs，直到我们遇到有趣的东西

(assign (int:a) (sub*(sub (add (1) (2)) (mul (3) (4))) (5))
(assign (int:a) (sub (sub*(add (1) (2)) (mul (3) (4))) (5))
(assign (int:a) (sub (sub (add*(1) (2)) (mul (3) (4))) (5))
(assign (int:a) (sub (sub (add (1*) (2)) (mul (3) (4))) (5))

->推断的类型1，即int，并返回到父级

(assign (int:a) (sub (sub (add (int:1)*(2)) (mul (3) (4))) (5))

->进入RHS

(assign (int:a) (sub (sub (add (int:1) (2*)) (mul (3) (4))) (5))

->推断的类型2，即int，并返回到父级

(assign (int:a) (sub (sub (add (int:1) (int:2)*) (mul (3) (4))) (5))

->推断的类型add(int, int)，即int，并返回到父级

(assign (int:a) (sub (sub (int:add (int:1) (int:2))*(mul (3) (4))) (5))

->下降到RHS

(assign (int:a) (sub (sub (int:add (int:1) (int:2)) (mul*(3) (4))) (5))

等等，直到最终

(assign (int:a) (int:sub (int:sub (int:add (int:1) (int:2)) (int:mul (int:3) (int:4))) (int:5))*

赋值本身是否也是带有类型的表达式取决于您的语言。

重要的要点：确定树中任何运算符节点的类型，您只需查看其直接子代，这些子代需要已经为其分配了类型。

当编译器对具有许多运算符和操作数的表达式进行类型检查时，通常使用的方法是什么。

阅读有关类型系统和类型推断以及使用统一的Hindley-Milner类型系统的Wikipage。另请阅读有关指称语义和操作语义的信息。

在以下情况下，类型检查可以更简单：

• 所有您喜欢的变量a都用类型明确声明。这就像C或Pascal或C ++ 98，但不像C ++ 11具有与的某种类型推断auto。
• 所有文字值（例如1，2或）'c'都具有固有类型：int文字始终具有type int，而字符文字始终具有type char…。
• 函数和运算符不会重载，例如，+运算符始终为type (int, int) -> int。C对运算符具有重载（+适用于有符号和无符号整数类型以及双精度），但没有函数重载。

在这些约束下，自底向上递归AST类型修饰算法就足够了（这仅在乎类型，而不在乎具体的值，因此是一种编译时方法）：

• 对于每个作用域，您都保留一个表，其中包含所有可见变量的类型（称为环境）。声明之后int a，您可以将条目添加a: int到表中。

• 叶子的键入是简单的递归基本情况：像这样的文字类型1是已知的，而像这样的变量类型a可以在环境中查找。

• 要根据先前计算的（嵌套子表达式）操作数的类型键入带有一些运算符和操作数的表达式，我们对操作数使用递归（因此我们首先键入这些子表达式）并遵循与该运算符相关的键入规则。

因此，在您的示例中， 4 * 3and 1 + 2被键入，int因为4＆3和1＆2之前已被键入，int并且您的键入规则说2的总和或乘积int是an int，以此类推(4 * 3) - (1 + 2)。

然后阅读皮尔斯的《类型和编程语言》一书。我建议学习一点Ocaml和λ微积分

对于更动态的类型化语言（类似Lisp），请阅读Queinnec的Lisp In Small Pieces

另请阅读Scott的《编程语言实用》一书

顺便说一句，您不能拥有与语言无关的类型代码，因为类型系统是语言语义中不可或缺的一部分。

在C语言中（坦率地说，是大多数基于C的静态类型语言），每个运算符都可以看作是函数调用的语法糖。

因此，您的表达式可以重写为：

int a{operator-(operator-(operator+(1,2),operator*(3,4)),5)};

然后将执行重载解析，并确定每个函数都是(int, int)或(const int&, const int&)类型的。

这种方式使类型解析易于理解和遵循，并且（更重要的是）易于实现。有关类型的信息仅以一种方式流动（从内部表达式向外）。

这就是为什么double x = 1/2;会产生x == 0，因为1/2作为一个int表达式。

关注您的算法，尝试将其更改为自下而上。您知道类型pf的变量和常量。用结果类型标记带有运算符的节点。让叶子确定操作员的类型，这也与您的想法相反。

实际上，这很容易，只要您认为+它是多种功能而不是单个概念即可。

    int operator=(int)
     /   \
  a(int)  \
        int operator-(int,int)
         /                  \
    int operator-(int,int)    5
         /              \
int operator+(int,int) int operator*(int,int)
    / \                      / \
   1   2                    3   4

在右侧的解析阶段，解析器检索1，知道是an int，然后解析+，并将其存储为“未解析的函数名”，然后解析2，知道是an int，然后将其返回堆栈。+现在，函数节点知道两种参数类型，因此可以解析+into int operator+(int, int)，因此现在知道该子表达式的类型，并且解析器以一种很快乐的方式继续进行。

如您所见，树完全构建后，每个节点（包括函数调用）都知道其类型。这很关键，因为它允许函数返回与其参数不同的类型。

char* ptr = itoa(3);

这里的树是：

    char* itoa(int)
     /           \
  ptr(char*)      3

类型检查的基础不是编译器做什么，而是语言定义的。

在C语言中，每个操作数都有一个类型。“ abc”的类型为“ const char数组”。1具有类型“ int”。1L的类型为“ long”。如果x和y是表达式，则存在有关x + y类型的规则，依此类推。因此，编译器显然必须遵循该语言的规则。

在像Swift这样的现代语言上，规则要复杂得多。有些情况很简单，例如C语言。在其他情况下，编译器将看到一个表达式，并事先被告知该表达式应具有的类型，然后根据该表达式确定子表达式的类型。如果x和y是不同类型的变量，并且分配了相同的表达式，则该表达式可能以不同的方式求值。例如，分配12 *（2/3）会将8.0分配给Double，将0分配给Int。在某些情况下，编译器知道两种类型是相关的，并指出了它们基于什么类型。

迅捷的例子：

var x: Double
var y: Int

x = 12 * (2 / 3)
y = 12 * (2 / 3)

print (x, y)

打印“ 8.0，0”。

在分配中x = 12 *（2/3）：左侧为Double类型，因此右侧必须为Double类型。返回“ Double”的“ *”运算符只有一个重载，即Double * Double-> Double。因此12必须具有Double类型以及2 /3。12支持“ IntegerLiteralConvertible”协议。Double的初始化程序采用类型为“ IntegerLiteralConvertible”的参数，因此将12转换为Double。2/3必须具有Double类型。返回“ Double”的“ /”运算符只有一个重载，即Double / Double-> Double。2和3转换为Double。2/3的结果是0.6666666。12 *（2/3）的结果是8.0。8.0被分配给x。

在分配y = 12 *（2/3）中，左侧的y具有类型Int，因此右侧的类型必须具有Int类型，因此将12、2、3转换为Int，结果为2/3 = 0，12 *（2/3）= 0。