[TableGen] Add the assert statement, step 1

[Paul-C-Anagnostopoulos]

Summary

This first step adds the assert statement and supports it at top level and in record definitions. Later steps will support it in class definitions and multiclasses.

I described it in the TableGen Programmer's Reference and added a test.

[craig.topper]

llvm/lib/TableGen/TGParser.cpp

3203

Put curly braces on this to be consistent with the elses

3204

Can we use a real error here? I assert(false) should usually be llvm_unreachable but since this is something the user can create it looks like its not truly unreachable.

3208

Drop this blank line

3311

Why is this line removed?

[Paul-C-Anagnostopoulos]

llvm/lib/TableGen/TGParser.cpp

3203

Will do.

3204

Will do.

3208

Will do.

3311

Because almost none of the comments have a blank comment line at the end and I was being compulsive. I'll put it back.

[Paul-C-Anagnostopoulos]

I made Craig's suggested changes. I also added one more test to the test file.

[Paul-C-Anagnostopoulos]

llvm/include/llvm/TableGen/Record.h

1570

Do I need to use std::move() here?

[craig.topper]

llvm/include/llvm/TableGen/Record.h

1570

Do I need to use std::move() here?

I don't think so. All of individual types are cheap to copy so it should be fine to just copy the tuple.

[Paul-C-Anagnostopoulos]

Bumping this for a final "looks good."

[lattner]

Looks like a great feature to me! I'd recommend requiring the message, I'd also consider requiring parens around the condition and message. This makes it more C like and makes it look less like a type definition:

def Rec14 : Cube<3> {

int double_result = !mul(result, 2);
assert(!eq(double_result, 53), "double_result should be 54");

}

llvm/docs/TableGen/ProgRef.rst

1258

Given that we don't have backwards compatibility issues, I'd just require the message.

[Paul-C-Anagnostopoulos]

I understand requiring the message, but I don't understand the parentheses. It makes the 'assert' statement syntactically incompatible with the 'if' and 'foreach' statements. Also, it makes it look like assert is a function.

[lattner]

Fair enough, good point. In C, it is a function, whereas in tblgen it is a declaration. I'm ok dropping the parens.

[Paul-C-Anagnostopoulos]

The message is now required in the assert statement.

[lattner]

llvm/docs/TableGen/ProgRef.rst

1258

nit, I think it can just be:

Assert: "assert" condition "," message ";"

llvm/docs/TableGen/ProgRef.rst

 
 Note that, unlike most languages, TableGen allows :token:`TokIdentifier` to
 begin with an integer. In case of ambiguity, a token is interpreted as a
 numeric literal rather than an identifier.
 
 TableGen has the following reserved keywords, which cannot be used as
 identifiers::
 
-   bit        bits          class         code          dag
-   def        else          false         foreach       defm
-   defset     defvar        field         if            in
-   include    int           let           list          multiclass
-   string     then          true
+   assert     bit           bits          class         code
+   dag        def           else          false         foreach
+   defm       defset        defvar        field         if
+   in         include       int           let           list
+   multiclass string        then          true
 
 .. warning::
   The ``field`` reserved word is deprecated.
 
 Bang operators
 --------------
 
 TableGen provides "bang operators" that have a wide variety of uses:

 Statements
 ==========
 
 The following statements may appear at the top level of TableGen source
 files.
 
 .. productionlist::
    TableGenFile: `Statement`*
-   Statement: `Class` | `Def` | `Defm` | `Defset` | `Defvar` | `Foreach`
-            :| `If` | `Let` | `MultiClass`
+   Statement: `Assert` | `Class` | `Def` | `Defm` | `Defset` | `Defvar`
+            :| `Foreach` | `If` | `Let` | `MultiClass`
 
 The following sections describe each of these top-level statements. 
 
 
 ``class`` --- define an abstract record class
 ---------------------------------------------
 
 A ``class`` statement defines an abstract record class from which other

 in the class list of a ``defm`` statement. In that case, the ID must be the
 name of a multiclass.
 
 .. productionlist::
    Body: ";" | "{" `BodyItem`* "}"
    BodyItem: (`Type` | "code") `TokIdentifier` ["=" `Value`] ";"
            :| "let" `TokIdentifier` ["{" `RangeList` "}"] "=" `Value` ";"
            :| "defvar" `TokIdentifier` "=" `Value` ";"
+           :| `Assert`
 
 A field definition in the body specifies a field to be included in the class
 or record. If no initial value is specified, then the field's value is
 uninitialized. The type must be specified; TableGen will not infer it from
 the value. The keyword ``code`` may be used to emphasize that the field
 has a string value that is code.
 
 The ``let`` form is used to reset a field to a new value. This can be done

 
 The :token:`IfBody` of the then and else arms of the ``if`` establish an
 inner scope. Any ``defvar`` variables defined in the bodies go out of scope
 when the bodies are finished (see `Defvar in a Record Body`_ for more details).
 
 The ``if`` statement can also be used in a record :token:`Body`.
 
 
+``assert`` --- check that a condition is true
+---------------------------------------------
+
+The ``assert`` statement checks a boolean condition to be sure that it is true
+and prints an error message if it is not. The message is not fatal.
+
+.. productionlist::
+   Assert: "assert" `condition` ["," `message`] ";"
+
+If the boolean condition is true, the statement does nothing. If the
+condition is false, it prints an error message. If present, the message,
+which can be an arbitrary string expression, is included in the error
+message as a note. The exact behavior of the ``assert`` statement depends on
+its placement.
+
+* At top level, the assertion is checked immediately.
+
+* In a record definition, the statement is saved and all assertions are
+  checked after the record is completely built.
+
+* In a class definition, the assertions are saved and inherited by all
+  the record definitions that inherit from the class. The assertions are
+  then checked when the records are completely built. [this placement is not
+  yet available]
+
+* In a multiclass definition, ... [this placement is not yet available]
+
+
 Additional Details
 ==================
 
 Directed acyclic graphs (DAGs)
 ------------------------------
 
 A directed acyclic graph can be represented directly in TableGen using the
 ``dag`` datatype. A DAG node consists of an operator and zero or more

llvm/include/llvm/TableGen/Record.h

class Record {
   static unsigned LastID;
 
   Init *Name;
   // Location where record was instantiated, followed by the location of
   // multiclass prototypes used.
   SmallVector<SMLoc, 4> Locs;
   SmallVector<Init *, 0> TemplateArgs;
   SmallVector<RecordVal, 0> Values;
+  // Vector of [source location, condition Init, message Init].
+  SmallVector<std::tuple<SMLoc, Init *, Init *>, 0> Assertions;
 
   // All superclasses in the inheritance forest in post-order (yes, it
   // must be a forest; diamond-shaped inheritance is not allowed).
   SmallVector<std::pair<Record *, SMRange>, 0> SuperClasses;
 
   // Tracks Record instances. Not owned by Record.
   RecordKeeper &TrackedRecords;
 
public:
   bool isClass() const { return IsClass; }
 
   ArrayRef<Init *> getTemplateArgs() const {
     return TemplateArgs;
   }
 
   ArrayRef<RecordVal> getValues() const { return Values; }
 
+  ArrayRef<std::tuple<SMLoc, Init *, Init *>> getAssertions() const {
+    return Assertions;
+  }
+
   ArrayRef<std::pair<Record *, SMRange>>  getSuperClasses() const {
     return SuperClasses;
   }
 
   /// Determine whether this record has the specified direct superclass.
   bool hasDirectSuperClass(const Record *SuperClass) const;
 
   /// Append the direct superclasses of this record to Classes.
for (unsigned i = 0, e = Values.size(); i != e; ++i)
       }
     llvm_unreachable("Cannot remove an entry that does not exist!");
   }
 
   void removeValue(StringRef Name) {
     removeValue(StringInit::get(Name));
   }
 
+  void addAssertion(SMLoc Loc, Init *Condition, Init *Message) {
+    Assertions.push_back(std::make_tuple(Loc, Condition, Message));
+  }
+
   bool isSubClassOf(const Record *R) const {
     for (const auto &SCPair : SuperClasses)
       if (SCPair.first == R)
         return true;
     return false;
   }
 
   bool isSubClassOf(StringRef Name) const {

llvm/lib/TableGen/TGLexer.h

enum TokKind {
     colon, semi,        // : ;
     comma, dot,         // , .
     equal, question,    // = ?
     paste,              // #
     dotdotdot,          // ...
 
     // Reserved keywords. ('ElseKW' is named to distinguish it from the
     // existing 'Else' that means the preprocessor #else.)
-    Bit, Bits, Class, Code, Dag, Def, Defm, Defset, Defvar, ElseKW, FalseKW,
-    Field, Foreach, If, In, Include, Int, Let, List, MultiClass,
+    Assert, Bit, Bits, Class, Code, Dag, Def, Defm, Defset, Defvar, ElseKW,
+    FalseKW, Field, Foreach, If, In, Include, Int, Let, List, MultiClass,
     String, Then, TrueKW,
 
     // Bang operators.
     XConcat, XADD, XSUB, XMUL, XNOT, XAND, XOR, XXOR, XSRA, XSRL, XSHL,
     XListConcat, XListSplat, XStrConcat, XInterleave, XSubstr, XCast,
     XSubst, XForEach, XFilter, XFoldl, XHead, XTail, XSize, XEmpty, XIf,
     XCond, XEq, XIsA, XDag, XNe, XLe, XLt, XGe, XGt, XSetDagOp, XGetDagOp,
 

llvm/lib/TableGen/TGLexer.cpp

tgtok::TokKind Kind = StringSwitch<tgtok::TokKind>(Str)
     .Case("field", tgtok::Field)
     .Case("let", tgtok::Let)
     .Case("in", tgtok::In)
     .Case("defvar", tgtok::Defvar)
     .Case("include", tgtok::Include)
     .Case("if", tgtok::If)
     .Case("then", tgtok::Then)
     .Case("else", tgtok::ElseKW)
+    .Case("assert", tgtok::Assert)
     .Default(tgtok::Id);
 
   // A couple of tokens require special processing.
   switch (Kind) {
     case tgtok::Include:
       if (LexInclude()) return tgtok::Error;
       return Lex();
     case tgtok::Id:

llvm/lib/TableGen/TGParser.h

private:  // Parser methods.
   bool ParseMultiClass();
   bool ParseDefm(MultiClass *CurMultiClass);
   bool ParseDef(MultiClass *CurMultiClass);
   bool ParseDefset();
   bool ParseDefvar();
   bool ParseForeach(MultiClass *CurMultiClass);
   bool ParseIf(MultiClass *CurMultiClass);
   bool ParseIfBody(MultiClass *CurMultiClass, StringRef Kind);
+  bool ParseAssert(MultiClass *CurMultiClass, Record *CurRec);
   bool ParseTopLevelLet(MultiClass *CurMultiClass);
   void ParseLetList(SmallVectorImpl<LetRecord> &Result);
 
   bool ParseObjectBody(Record *CurRec);
   bool ParseBody(Record *CurRec);
   bool ParseBodyItem(Record *CurRec);
 
   bool ParseTemplateArgList(Record *CurRec);
private:  // Parser methods.
   Init *ParseOperationForEachFilter(Record *CurRec, RecTy *ItemType);
   Init *ParseOperationCond(Record *CurRec, RecTy *ItemType);
   RecTy *ParseOperatorType();
   Init *ParseObjectName(MultiClass *CurMultiClass);
   Record *ParseClassID();
   MultiClass *ParseMultiClassID();
   bool ApplyLetStack(Record *CurRec);
   bool ApplyLetStack(RecordsEntry &Entry);
+  void CheckAssert(SMLoc Loc, Init *Condition, Init *Message);
+  void CheckRecordAsserts(Record &Rec);
 };
 
 } // end namespace llvm
 
 #endif

llvm/lib/TableGen/TGParser.cpp

if (!Rec->isAnonymous()) {
       return true;
     }
     Rec->setName(Records.getNewAnonymousName());
   }
 
   Rec->resolveReferences();
   checkConcrete(*Rec);
 
+  CheckRecordAsserts(*Rec);
+
   if (!isa<StringInit>(Rec->getNameInit())) {
     PrintError(Rec->getLoc(), Twine("record name '") +
                                   Rec->getNameInit()->getAsString() +
                                   "' could not be fully resolved");
     return true;
   }
 
   // If ObjectBody has template arguments, it's an error.
bool TGParser::addDefOne(std::unique_ptr<Record> Rec) {
   Records.addDef(std::move(Rec));
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // Parser Code
 //===----------------------------------------------------------------------===//
 
-/// isObjectStart - Return true if this is a valid first token for an Object.
+/// isObjectStart - Return true if this is a valid first token for a statement.
 static bool isObjectStart(tgtok::TokKind K) {
-  return K == tgtok::Class || K == tgtok::Def || K == tgtok::Defm ||
-         K == tgtok::Let || K == tgtok::MultiClass || K == tgtok::Foreach ||
-         K == tgtok::Defset || K == tgtok::Defvar || K == tgtok::If;
+  return K == tgtok::Assert || K == tgtok::Class || K == tgtok::Def ||
+         K == tgtok::Defm || K == tgtok::Defset || K == tgtok::Defvar ||
+         K == tgtok::Foreach || K == tgtok::If || K == tgtok::Let ||
+         K == tgtok::MultiClass;
 }
 
 bool TGParser::consume(tgtok::TokKind K) {
   if (Lex.getCode() == K) {
     Lex.Lex();
     return true;
   }
   return false;
if (!consume(tgtok::greater)) {
       TokError("expected '>' at end of list<ty> type");
       return nullptr;
     }
     return ListRecTy::get(SubType);
   }
   }
 }
 
-/// ParseIDValue - This is just like ParseIDValue above, but it assumes the ID
-/// has already been read.
+/// ParseIDValue
 Init *TGParser::ParseIDValue(Record *CurRec, StringInit *Name, SMLoc NameLoc,
                              IDParseMode Mode) {
   if (CurRec) {
     if (const RecordVal *RV = CurRec->getValue(Name))
       return VarInit::get(Name, RV->getType());
   }
 
   if ((CurRec && CurRec->isClass()) || CurMultiClass) {
Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
   case tgtok::XSubstr: { // Value ::= !ternop '(' Value ',' Value ',' Value ')'
     return ParseOperation(CurRec, ItemType);
   }
   }
 
   return R;
 }
 
-/// ParseValue - Parse a tblgen value.  This returns null on error.
+/// ParseValue - Parse a TableGen value. This returns null on error.
 ///
 ///   Value       ::= SimpleValue ValueSuffix*
 ///   ValueSuffix ::= '{' BitList '}'
 ///   ValueSuffix ::= '[' BitList ']'
 ///   ValueSuffix ::= '.' ID
 ///
 Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) {
   Init *Result = ParseSimpleValue(CurRec, ItemType, Mode);
while (consume(tgtok::comma)) {
     TheRecToAddTo->addTemplateArg(TemplArg);
   }
 
   if (!consume(tgtok::greater))
     return TokError("expected '>' at end of template argument list");
   return false;
 }
 
-/// ParseBodyItem - Parse a single item at within the body of a def or class.
+/// ParseBodyItem - Parse a single item within the body of a def or class.
 ///
 ///   BodyItem ::= Declaration ';'
 ///   BodyItem ::= LET ID OptionalBitList '=' Value ';'
 ///   BodyItem ::= Defvar
+///   BodyItem ::= Assert
 bool TGParser::ParseBodyItem(Record *CurRec) {
+  if (Lex.getCode() == tgtok::Assert)
+    return ParseAssert(nullptr, CurRec);
+
   if (Lex.getCode() == tgtok::Defvar)
     return ParseDefvar();
 
   if (Lex.getCode() != tgtok::Let) {
     if (!ParseDeclaration(CurRec, false))
       return true;
 
     if (!consume(tgtok::semi))
if (!consume(tgtok::r_brace)) {
       return Error(BraceLoc, "to match this '{'");
     }
   }
 
   PopLocalScope(BodyScope);
   return false;
 }
 
+/// ParseAssert - Parse an assert statement.
+///
+///   Assert ::= ASSERT condition , message ;
+bool TGParser::ParseAssert(MultiClass *CurMultiClass, Record *CurRec) {
+  SMLoc Loc = Lex.getLoc();
+  assert(Lex.getCode() == tgtok::Assert && "Unknown tok");
+  Lex.Lex(); // Eat the 'assert' token.
+
+  SMLoc ConditionLoc = Lex.getLoc();
+  Init *Condition = ParseValue(CurRec);
+  if (!Condition)
+    return true;
+
+  if (!consume(tgtok::comma)) {
+    TokError("expected ',' in assert statement");
+    return true;
+  }
+
+  Init *Message = ParseValue(CurRec);
+  if (!Message)
+    return true;
+
+  if (!consume(tgtok::semi))
+    return TokError("expected ';'");
+
+  if (CurMultiClass) {
+    assert(false && "assert in multiclass not yet supported");
+  } else if (CurRec) {
+    CurRec->addAssertion(ConditionLoc, Condition, Message);
+  } else { // at top level
+    RecordResolver R(*CurRec);
+    Init *Value = Condition->resolveReferences(R);
+    Init *Text = Message->resolveReferences(R);
+    CheckAssert(ConditionLoc, Value, Text);
+  }
+ 
+  return false;
+}
+
 /// ParseClass - Parse a tblgen class definition.
 ///
 ///   ClassInst ::= CLASS ID TemplateArgList? ObjectBody
 ///
 bool TGParser::ParseClass() {
   assert(Lex.getCode() == tgtok::Class && "Unexpected token!");
   Lex.Lex();
 

 ///
 ///  MultiClassInst ::= MULTICLASS ID TemplateArgList?
 ///                     ':' BaseMultiClassList '{' MultiClassObject+ '}'
 ///  MultiClassObject ::= DefInst
 ///  MultiClassObject ::= MultiClassInst
 ///  MultiClassObject ::= DefMInst
 ///  MultiClassObject ::= LETCommand '{' ObjectList '}'
 ///  MultiClassObject ::= LETCommand Object
 ///
 bool TGParser::ParseMultiClass() {
   assert(Lex.getCode() == tgtok::MultiClass && "Unexpected token");
   Lex.Lex();  // Eat the multiclass token.
 
   if (Lex.getCode() != tgtok::Id)
     return TokError("expected identifier after multiclass for name");
   std::string Name = Lex.getCurStrVal();
 
if (Lex.Lex() == tgtok::r_brace)  // eat the '{'.
       return TokError("multiclass must contain at least one def");
 
     // A multiclass body introduces a new scope for local variables.
     TGLocalVarScope *MulticlassScope = PushLocalScope();
 
     while (Lex.getCode() != tgtok::r_brace) {
       switch (Lex.getCode()) {
       default:
-        return TokError("expected 'let', 'def', 'defm', 'defvar', 'foreach' "
-                        "or 'if' in multiclass body");
-      case tgtok::Let:
+        return TokError("expected 'assert', 'def', 'defm', 'defvar', "
+                        "'foreach', 'if', or 'let' in multiclass body");
+      case tgtok::Assert:
+        return TokError("an assert statement in a multiclass is not yet supported");
+
       case tgtok::Def:
       case tgtok::Defm:
       case tgtok::Defvar:
       case tgtok::Foreach:
       case tgtok::If:
+      case tgtok::Let:
         if (ParseObject(CurMultiClass))
           return true;
         break;
       }
     }
     Lex.Lex();  // eat the '}'.
 
     PopLocalScope(MulticlassScope);

 ///   Object ::= ClassInst
 ///   Object ::= DefInst
 ///   Object ::= MultiClassInst
 ///   Object ::= DefMInst
 ///   Object ::= LETCommand '{' ObjectList '}'
 ///   Object ::= LETCommand Object
 ///   Object ::= Defset
 ///   Object ::= Defvar
+///   Object ::= Assert
 bool TGParser::ParseObject(MultiClass *MC) {
   switch (Lex.getCode()) {
   default:
-    return TokError("Expected class, def, defm, defset, multiclass, let, "
-                    "foreach or if");
-  case tgtok::Let:   return ParseTopLevelLet(MC);
-  case tgtok::Def:   return ParseDef(MC);
-  case tgtok::Foreach:   return ParseForeach(MC);
-  case tgtok::If:    return ParseIf(MC);
-  case tgtok::Defm:  return ParseDefm(MC);
+    return TokError(
+               "Expected assert, class, def, defm, defset, foreach, if, or let");
+  case tgtok::Assert:  return ParseAssert(MC, nullptr);
+  case tgtok::Def:     return ParseDef(MC);
+  case tgtok::Defm:    return ParseDefm(MC);
+  case tgtok::Defvar:  return ParseDefvar();
+  case tgtok::Foreach: return ParseForeach(MC);
+  case tgtok::If:      return ParseIf(MC);
+  case tgtok::Let:     return ParseTopLevelLet(MC);
   case tgtok::Defset:
     if (MC)
       return TokError("defset is not allowed inside multiclass");
     return ParseDefset();
-  case tgtok::Defvar:
-    return ParseDefvar();
   case tgtok::Class:
     if (MC)
       return TokError("class is not allowed inside multiclass");
     if (!Loops.empty())
       return TokError("class is not allowed inside foreach loop");
     return ParseClass();
   case tgtok::MultiClass:
     if (!Loops.empty())
bool TGParser::ParseFile() {
 
   // If we have unread input at the end of the file, report it.
   if (Lex.getCode() == tgtok::Eof)
     return false;
 
   return TokError("Unexpected input at top level");
 }
 
+// Check an assertion: Obtain the condition value and be sure it is true.
+// If not, print a nonfatal error along with the message.
+void TGParser::CheckAssert(SMLoc Loc, Init *Condition, Init *Message) {
+  auto *CondValue = dyn_cast_or_null<IntInit>(
+                        Condition->convertInitializerTo(IntRecTy::get()));
+  if (CondValue) {
+    if (!CondValue->getValue()) {
+      PrintError(Loc, "assertion failed");
+      if (auto *MessageInit = dyn_cast<StringInit>(Message))
+        PrintNote(MessageInit->getValue());
+      else
+        PrintNote("(assert message is not a string)");
+    }
+  } else {
+    PrintError(Loc, "assert condition must of type bit, bits, or int.");
+  }
+}
+
+// Check all record assertions: For each one, resolve the condition
+// and message, then call CheckAssert().
+void TGParser::CheckRecordAsserts(Record &Rec) {
+  RecordResolver R(Rec);
+  R.setFinal(true);
+
+  for (auto Assertion : Rec.getAssertions()) {
+    Init *Condition = std::get<1>(Assertion)->resolveReferences(R);
+    Init *Message = std::get<2>(Assertion)->resolveReferences(R);
+    CheckAssert(std::get<0>(Assertion), Condition, Message);
+  }
+}
+
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void RecordsEntry::dump() const {
   if (Loop)
     Loop->dump();
   if (Rec)
     Rec->dump();
 }
 

llvm/test/TableGen/assert.td

+// RUN: not llvm-tblgen %s 2>&1 | FileCheck %s
+
+// Test the assert statement at top level.
+
+// CHECK: assertion failed
+// CHECK-NOT: note: primary name is too short
+// CHECK: note: primary name is too long
+
+defvar Name = "Grace Brewster Murray Hopper";
+
+assert !ge(!size(Name), 20), "primary name is too short: " # Name;
+assert !le(!size(Name), 20), "primary name is too long: " # Name;
+
+// CHECK: assertion failed
+// CHECK: note: first name is incorrect
+
+def Rec1 {
+  string name = "Fred Smith";
+}
+
+assert !eq(!substr(Rec1.name, 0, 3), "Jane"),
+       !strconcat("first name is incorrect: ", Rec1.name);
+
+// CHECK: assertion failed
+// CHECK: note: record Rec2 is broken
+
+def Rec2 {
+  bit broken = true;
+}
+
+assert !not(Rec2.broken), "record Rec2 is broken";
+
+// CHECK: assertion failed
+// CHECK: note: cube of 9
+
+class Cube<int n> {
+  int result = !mul(n, n, n);
+}
+
+assert !eq(Cube<9>.result, 81), "cube of 9 should be 729";
+
+// Test the assert statement in a record definition.
+
+// CHECK: assertion failed
+// CHECK-NOT: primary first name is not "Grace"
+// CHECK: primary first name is not "Grack"
+// CHECK: assertion failed
+// CHECK: foo field should be
+
+def Rec10 {
+  assert !eq(!substr(Name, 0, 5), "Grace"), "primary first name is not \"Grace\"";
+  assert !eq(!substr(Name, 0, 5), "Grack"), "primary first name is not \"Grack\"";
+  string foo = "Foo";
+  assert !eq(foo, "foo"), "foo field should be \"Foo\"";
+}
+
+// CHECK: assertion failed
+// CHECK: note: magic field is incorrect: 42
+
+def Rec11 {
+  int magic = 13;
+  assert !eq(magic, 13), "magic field is incorrect: " # magic;
+  let magic = 42;       
+}
+
+// CHECK: assertion failed
+// CHECK: note: var field has wrong value
+
+def Rec12 {
+  defvar prefix = "foo_";
+  string var = prefix # "snork";
+  assert !eq(var, "foo_snorx"), "var field has wrong value: " # var;
+}
+
+// CHECK: assertion failed
+// CHECK: note: kind field has wrong value
+
+class Kind {
+  int kind = 7;
+}
+
+def Rec13 : Kind {
+  let kind = 8;
+  assert !eq(kind, 7), "kind field has wrong value: " # kind;
+}
+
+// CHECK: assertion failed
+// CHECK: note: double_result should be
+
+def Rec14 : Cube<3> {
+  int double_result = !mul(result, 2);
+  assert !eq(double_result, 53), "double_result should be 54";
+}
+
+// Test the assert statement in a class definition.
+
+// Test the assert statement in a multiclass.
+