Lecture 7

1.0 - Static Checker

Performs static semantics checks on the abstract syntax tree using a visitor pattern to traverse the tree.

1.1 - Expressions in the Static Checker.

How do we perform type coercions and all of these other operations on Expression Nodes?

1.1.1 - Visiting an Error Expression Node

Error expression nodes may have been introduced in the parse tree, how do we deal with them?

public ExpNode visitErrorExpNode(ExpNode.ErrorNode node) {
    beginCheck("ErrorExp");
    // Nothing to do - already invalid.
    endCheck("ErrorExp");
    return node;
}

1.1.2 - Visiting an Identifier Node

public ExpNode visitIdentifierNode(ExpNode.IdentifierNode node) {
    beginCheck("Identifier");
    // First we look up the identifier in the symbol table.
    ExpNode newNode;
    SymEntry entry = currentScope.lookup(node.getId());
    if (entry instanceof SymEntry.ConstantEntry) {
        SymEntry.ConstantEntry constEntry = (SymEntry.ConstantEntry) entry;
        // Set up a new node which is a constant.
        debugMessage("Transformed " + node.getId() + " to Constant");
        newNode = new ExpNode.ConstNode(node.getLocation(),
                constEntry.getType(), constEntry.getValue());
    } else if (entry instanceof SymEntry.VarEntry) {
        SymEntry.VarEntry varEntry = (SymEntry.VarEntry) entry;
        debugMessage("Transformed " + node.getId() + " to Variable");
        // Set up a new node which is a variable.
        newNode = new ExpNode.VariableNode(node.getLocation(), varEntry);
    } else {
        // Undefined identifier or a type or procedure identifier.
        // Set up new node to be an error node.
        newNode = new ExpNode.ErrorNode(node.getLocation());
        //System.out.println("Entry = " + entry);
        staticError("Constant or variable identifier required", node.getLocation());
    }
    endCheck("Identifier");
    return newNode;
}
Symbolic Constant Rule Variable Identifier Rule
id∈dom(syms)syms(id) = ConstEntry(T,v)‾syms⊢id : T\text{id}\in\text{dom(syms)}\\\text{\underline{syms(id) = ConstEntry(T,v)}}\\\text{syms}\vdash \text{id : T} id∈dom(syms)syms(id)=VarEntry(T)‾syms⊢id : T\text{id}\in\text{dom(syms)}\\\text{\underline{syms(id)=VarEntry(T)}}\\\text{syms}\vdash\text{id : T}

1.1.3 - Visiting Unary Nodes

1.1.4 - Visiting a Binary Node

1.1.5 - Visiting an Assignment Node

How do we type check an assignment node?

1.1.16 - Visiting a Write Node

public void visitWriteNode(StatementNode.WriteNode node) {
        beginCheck("Write");
        // check type correctness
    ExpNode exp = node.getExp().transform(this);
        node.setExp(Predefined.INTEGER_TYPE.coerceExp(exp));
        endCheck("Write");
}

1.1.17 - Visiting a Procedure Call

public void visitCallNode(StatementNode.CallNode node) {
    beginCheck("Call");
      // Check that the symbol is in the symboltable.
    SymEntry entry = currentScope.lookup(node.getId());
    if (entry instanceof SymEntry.ProcedureEntry) {
                // if entry is instanceof Sym>Entry.ProcedureEntry then it's type correct.
        SymEntry.ProcedureEntry procEntry = (SymEntry.ProcedureEntry) entry;
        node.setEntry(procEntry);
    } else {
        staticError("Procedure identifier required", node.getLocation());
    }
    endCheck("Call");
}

1.1.18 - Visiting a Statement List

1.1.19 - Visiting a Conditional Node

1.1.20 - Visiting a While Node / Iteration Node

1.2 - The coerceExp() method

The checkCondition method uses the coerceExp method, but how does it actually work:

private ExpNode checkCondition(ExpNode cond) {
  // Check and transform the condition
  cond = cond.transform(this);
  /* Validate that the condition is boolean, which may require
   * coercing the condition to be of type boolean. */
  return Predefined.BOOLEAN_TYPE.coerceExp(cond);
}

public ExpNode coerceExp(ExpNode exp) {
  /* Try coercing the expression. */
  try {
    return this.coerceToType(exp);
  } catch (IncompatibleTypes e) {
    /* At this point the coercion has failed. */
        // Report 
    errors.debugMessage("******" + e.getMessage());
    errors.error(e.getMessage(), e.getLocation());
    return new ExpNode.ErrorNode(e.getLocation());
  }
}

1.2.1 - How does the coerceToType method work?

public ExpNode coerceToType(ExpNode exp) throws IncompatibleTypes {
    errors.debugMessage("Coercing " + exp + ":" + exp.getType().getName() +
            " to " + this.getName());
    errors.incDebug();
    ExpNode newExp = exp;
    /* Unless this type is a reference type, optionally dereference
     * the expression to get its base type.
     */
    if (!(this instanceof ReferenceType)) {
        newExp = optDereferenceExp(newExp); // Try to dereference it.
    }
    Type fromType = newExp.getType();
    /* No need to coerce if already the same type or
     * fromType is ERROR_TYPE and hence an error message has already been given.
     */
    if (!this.equals(fromType) && fromType != ERROR_TYPE) {
        /* Try coercing the expression. Dynamic dispatch on the desired
         * type is used to control the coercion process.
         */
        try {
            newExp = this.coerce(newExp);
        } catch (IncompatibleTypes e) {
            errors.debugMessage("Failed to coerce " + newExp + " to " +
                    this.getName());
            errors.decDebug();
            /* Throw an error to allow the caller to decide whether an error
             * message needs to be generated.
             */
            throw e;
        }
    }
    errors.debugMessage("Succeeded");
    errors.decDebug();
    return newExp;
}

  1. First, we check if the type that we’re calling this method is a reference type

    if (!(this instanceof ReferenceType)) {
    newExp = optDereferenceExp(newExp); // Try to dereference it.
}
    • If it is NOT a reference type, our argument might have a reference type
    • I.e. we may be able to coerce it by dereferencing it using the optDereferenceExp method

  2. If the types still don’t match after dereferencing (and it isn’t an error type), we have to perform more coercion

    • If the types match, we skip this block and return the dereferenced value
    • We use the coerce method as our last attempt to coerce the node.
    if (!this.equals(fromType) && fromType != ERROR_TYPE) {
    /* Try coercing the expression. Dynamic dispatch on the desired
     * type is used to control the coercion process.
     */
    try {
        newExp = this.coerce(newExp);
    } catch (IncompatibleTypes e) {
        errors.debugMessage("Failed to coerce " + newExp + " to " +
                this.getName());
        errors.decDebug();
        /* Throw an error to allow the caller to decide whether an error
         * message needs to be generated.
         */
        throw e;
    }
}

1.2.2 - optDereferenceExp Method

"Optional Dereference Expression", try to dereference an expression

public static ExpNode optDereferenceExp(ExpNode exp) {
    Type fromType = exp.getType();
    if (fromType instanceof ReferenceType) {
        errors.debugMessage("Coerce dereference " + fromType.getName());
        return new ExpNode.DereferenceNode(exp);
    } else {
        return exp;
    }
}
  1. If the expression’s type is a reference type
    • We return the expression wrapped in a dereference node
  2. If the expression’s type is not a reference type:
    • We just return the expression

1.2.3 - coerce Method

Last attempt to coerce. Every expression node has a coerce method defined.

/** 
 * Default/generic implementation of the coerce method throws an IncompatibleType error
 */
ExpNode coerce(ExpNode exp) throws IncompatibleTypes {
    throw new IncompatibleTypes(
            "cannot treat " + exp.getType().getName() + " as " + this.getName(),
            exp.getLocation());
}

Coerce Method for ScalarType

@Override
protected ExpNode coerce(ExpNode exp) throws IncompatibleTypes {
    Type fromType = exp.getType();
    if (fromType instanceof SubrangeType) {
        /* This code implements Rule Widen subrange.
         * If the types do not match, the only other possible type
         * for the expression which can be coerced to 'this' scalar type
         * is a subrange type, provided its base type matches
         * 'this' type. If that is the case we insert a WidenSubrangeNode
         * of 'this' type with the expression as a subtree.
         */
        Type baseType = ((SubrangeType) fromType).getBaseType();
        if (this.equals(baseType)) {
            errors.debugMessage("Widened " + fromType.getName() +
                    " to " + baseType.getName());
            return new ExpNode.WidenSubrangeNode(exp);
        }
    }
    /* Otherwise we report the failure to coerce the expression via
     * an IncompatibleTypes exception.
     */
    throw new IncompatibleTypes("cannot coerce " +
            exp.getType().getName() + " to " + this.getName(),
            exp.getLocation());
}

Coerce Method for SubrangeType

@Override
protected ExpNode coerce(ExpNode exp) throws IncompatibleTypes {
    /* This implements Rule Narrow subrange in the static semantics.
     * If the types do not match, we can try coercing the expression
     * to the base type of 'this' subrange, and then narrow that
     * to 'this' type. If the coercion to the base type fails it will
     * generate an exception, which is allowed to pass up to the caller.
     */
    ExpNode coerceExp = baseType.coerceToType(exp);
    /* If we get here, coerceExp is of the same type as the base
     * type of 'this' subrange type. We just need to narrow it
     * down to 'this' subrange.
     */
    errors.debugMessage("Narrowed " + exp.getType().getName() +
            " to " + this.getName());
    return new ExpNode.NarrowSubrangeNode(this, coerceExp);
}