Expect all expressions to have a type after type checking.

Rather than skipping expressions that have no type in post-type checking
verification, verify that they do have a type.

There is one exception to "all" expressions having a type. We serialize
the un-typechecked raw values of @objc enums, and thus after
deserialization we do not have types for these. We cannot distinguish
these in the verifier, though, so we just allow any integer literal
through without a type.

Author: rudkx

lib/AST/ASTVerifier.cpp

@@ -446,7 +446,19 @@ class Verifier : public ASTWalker {
     bool shouldVerify(Decl *S) { return true; }
 
     // Default cases for whether we should verify a checked subtree.
-    bool shouldVerifyChecked(Expr *E) { return !E->getType().isNull(); }
+    bool shouldVerifyChecked(Expr *E) {
+      if (!E->getType()) {
+        // For @objc enums, we serialize the pre-type-checked integer
+        // literal raw values, and thus when they are deserialized
+        // they do not have a type on them.
+        if (!isa<IntegerLiteralExpr>(E)) {
+          Out << "expression has no type\n";
+          E->print(Out);
+          abort();
+        }
+      }
+      return true;
+    }
     bool shouldVerifyChecked(Stmt *S) { return true; }
     bool shouldVerifyChecked(Pattern *S) { return S->hasType(); }
     bool shouldVerifyChecked(Decl *S) { return true; }
@@ -506,8 +518,9 @@ class Verifier : public ASTWalker {
       // Some imported expressions don't have types, even in checked mode.
       // TODO: eliminate all these
       if (!E->getType()) {
-        // The raw value of an imported EnumElementDecl doesn't seem to have
-        // a type for some reason.
+        // For @objc enums, we serialize the pre-type-checked integer
+        // literal raw values, and thus when they are deserialized
+        // they do not have a type on them.
         if (!isa<IntegerLiteralExpr>(E)) {
           Out << "expression has no type\n";
           E->print(Out);