《Language Implementation Patterns》之 强类型规则

语句的语义取决于其语法结构和相关符号；前者说明了了要“做什么”，后者说明了操作“什么对象”。所以即使语法结构正确的，如果被操作的对象不合法，语句也是不合法的。语言一般有很多语义规则，有些是运行时的(dynamic semantics)，比如“不能除以零”、“不能越界访问数组”；有些是编译时的(static semantics)。运行时&编译时的界限取决于具体的语言，python是动态类型的语言，所有的值编译时都不会指定类型，解释器在运行时检查类型和执行语义规则；C++则是另一个极端，所有的值必须有静态的类型，运行时不做检查；java既有静态类型检查，又在运行时检查类型。无论动态的或静态的类型检查，只要能阻止不相容的类型操作，语言就是“类型安全”的。

本章讲述了如何实施静态类型规则，将会讨论一下几种模式：

• Pattern 20 Computing Static Expression Types，保证类型安全的第一步是计算表达式的类型；
• Pattern 21 Automatic Type Promotion, 将操作数的类型提升至相同或相容的类型；
• Pattern 22 Enforcing Static Type Safety，检查类型相容性，保证类型安全；
• Pattern 23 Enforcing Polymorphic Type Safety, 面向对象类型语言里面的对象类型相容，多态的引用类型；
  下面分别讲述这些模式，以类c语言的规则为样例。

Pattern 20 Computing Static Expression Types

展示了在显示声明类型的语言，比如C，如何计算表达式的类型
下面的表格说明了类型计算规则。

Subexpression	Result Type
true,false	boolean
!«expr »	boolean
f(«args»)	函数f的返回类型
«expr» bop «expr»	bop代表二元运算符，因为两侧的操作数的类型是一致的，所以可以选取左侧操作数的类型为表达式类型
«expr» relop «expr»	boolean，relop是代表关系操作符

实现
假设我们已经构建了AST，和scope tree，进行类型计算就是另一轮AST遍历，可以通过Tree Pattern Matcher技术来寻找表达式节点并计算类型。
具体的实现代码请参考原书。

Pattern 21 Automatic Type Promotion

描述了如何自动、安全地提升数学运算操作数的类型
类型提升将单个运算符的所有操作数提升至相同类型或相容类型，这本质上是CPU对操作数的要求。编程语言能够自动地转换类型，只要“转换“不丢失信息；比如4可以安全地转换成4.0，而4.5不能转换成4；这种安全的类型转换被称之为”类型提升”，因为它拓宽了类型。
这里有一个简单的方式描述类型提升规则；首先将类型按最“窄”到最“宽”进行排序，然后如果i&ltj,我们可以进行从TYPEi到TYPEj的提升。

为了实现类型提升，需要两个函数，第一个是根据运算符和运算数类型返回结果类型；第二个从运算符和目标类型判断是否需要对操作数执行类型提升。

resultType(type1, op, type2)
resultType(char, "<", int) == boolean
resultType(char, "+", int) == int
resultType(boolean, "<", boolean) == void

promoteFromTo(type, op, destination-type)
promoteFromTo(char, "+", int) == int
promoteFromTo(int, "+", int) == null

结果void意味着该表达式不合法，null意味着不需要类型转换。按这个规则，表达式’a’+3+4.2的类型提升可以表示为(float)((int)’a’+3)+4.2，AST如图：

每个节点都知道自己的求值类型，提升类型。
具体的java实现代码，请参考原书。

Pattern 22 Enforcing Static Type Safety

通过静态检查，发现表达式或语句里面类型不相容的类型
概括起来，类型相容包含两个方面：

• 对操作数类型，操作符是有定义的，即resultType(operandtype1, op, operandtype2) != void；
• 如果我们需要一个类型T的值，那么提供的值必须是T或可以被提升为T。

在Pattern 21的基础上增加类型检查不是困难，只要出现void都意味着类型不相容；对于点操作符，函数调用，return语句等需要特殊处理。
具体的实现代码，请参考原书。

Pattern 23 Enforcing Polymorphic Type Safety

检查对象引用赋值的类型相容性
对象类型引用赋值的相容性判断如下：

public class PointerType extends Symbol implements Type {
    public boolean canAssignTo(Type destType) {
        // if not a pointer, return false
        if ( !(destType instanceof PointerType) ) return false;
        // What type is the target pointing at?
        Type destTargetType = ((PointerType)destType).targetType;
        Type srcTargetType = this.targetType;
        // if this and target are object pointers, check polymorphism
        if ( destTargetType instanceof ClassSymbol &&
             this.targetType instanceof ClassSymbol )
        {
            ClassSymbol thisClass   = (ClassSymbol)srcTargetType;
            ClassSymbol targetClass = (ClassSymbol)destTargetType;
            // Finally!  Here it is: the polymorphic type check :)
            return thisClass.isInstanceof(targetClass);
        }
        // not comparing object pointers; types we point at must be the same
        // For example: int *p; int *q; p = q;
        return srcTargetType == destTargetType;
    }
}
/** Return true if 'ancestor' is this class or above in hierarchy */
public boolean isInstanceof(ClassSymbol ancestor) { 
    ClassSymbol t = this;
    while ( t!=null ) {
        if ( t == ancestor ) return true;
        t = t.superClass;
    }
    return false; 
}