[TableGen] Add optional default value for !cast

[• pcwang-thead]

Summary

Sometimes we want to get a default value instead of error
raised by TableGen when casting a string to a record, so
we add an optional second parameter to !cast operator as
default value.

If casting fails and default value is specified, we will
get default value and TableGen won't raise any error. If
there is no specified default value, the behivior is the
same as before.

[nhaehnle]

Can this be abandoned in favor of the !instanceof change?

[• pcwang-thead]

Prefer to D127948.

llvm/docs/TableGen/ProgRef.rst

 ``!add(``\ *a*\ ``,`` *b*\ ``, ...)``
     This operator adds *a*, *b*, etc., and produces the sum.
 
 ``!and(``\ *a*\ ``,`` *b*\ ``, ...)``
     This operator does a bitwise AND on *a*, *b*, etc., and produces the
     result. A logical AND can be performed if all the arguments are either
     0 or 1.
 
-``!cast<``\ *type*\ ``>(``\ *a*\ ``)``
+``!cast<``\ *type*\ ``>(``\ *a*\ [``,`` *default_value*] ``)``
     This operator performs a cast on *a* and produces the result.
     If *a* is not a string, then a straightforward cast is performed, say
     between an ``int`` and a ``bit``, or between record types. This allows
     casting a record to a class. If a record is cast to ``string``, the
     record's name is produced.
 
     If *a* is a string, then it is treated as a record name and looked up in
     the list of all defined records. The resulting record is expected to be of
-    the specified *type*.
+    the specified *type*. Optionally, we can specify a *default_value* of the
+    specified *type* and get the *default_value* if we can't find the record
+    with the name *a*; Or TableGen will raise an error.
 
     For example, if ``!cast<``\ *type*\ ``>(``\ *name*\ ``)``
     appears in a multiclass definition, or in a
     class instantiated inside a multiclass definition, and the *name* does not
     reference any template arguments of the multiclass, then a record by
     that name must have been instantiated earlier
     in the source file. If *name* does reference
     a template argument, then the lookup is delayed until ``defm`` statements

llvm/include/llvm/TableGen/Record.h

enum InitKind : uint8_t {
     IK_ListInit,
     IK_FirstOpInit,
     IK_BinOpInit,
     IK_TernOpInit,
     IK_UnOpInit,
     IK_LastOpInit,
     IK_CondOpInit,
     IK_FoldOpInit,
+    IK_CastOpInit,
     IK_IsAOpInit,
     IK_AnonymousNameInit,
     IK_StringInit,
     IK_VarInit,
     IK_VarListElementInit,
     IK_VarBitInit,
     IK_VarDefInit,
     IK_LastTypedInit,
public:
 
   Init *getBit(unsigned Bit) const override;
 };
 
 /// !op (X) - Transform an init.
 ///
 class UnOpInit : public OpInit, public FoldingSetNode {
 public:
-  enum UnaryOp : uint8_t { CAST, NOT, HEAD, TAIL, SIZE, EMPTY, GETDAGOP };
+  enum UnaryOp : uint8_t { NOT, HEAD, TAIL, SIZE, EMPTY, GETDAGOP };
 
 private:
   Init *LHS;
 
   UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type)
     : OpInit(IK_UnOpInit, Type, opc), LHS(lhs) {}
 
 public:
Init *getOperand(unsigned i) const override {
     return getOperand();
   }
 
   UnaryOp getOpcode() const { return (UnaryOp)Opc; }
   Init *getOperand() const { return LHS; }
 
   // Fold - If possible, fold this to a simpler init.  Return this if not
   // possible to fold.
-  Init *Fold(Record *CurRec, bool IsFinal = false) const;
+  Init *Fold(Record *CurRec) const;
 
   Init *resolveReferences(Resolver &R) const override;
 
   std::string getAsString() const override;
 };
 
 /// !op (X, Y) - Combine two inits.
 class BinOpInit : public OpInit, public FoldingSetNode {
public:
 
   Init *resolveReferences(Resolver &R) const override;
 
   Init *getBit(unsigned Bit) const override;
 
   std::string getAsString() const override;
 };
 
+/// !cast<type>(expr[, default_value]) - Cast input to specified type.
+class CastOpInit : public TypedInit, public FoldingSetNode {
+private:
+  RecTy *CastType;
+  Init *Expr, *DefaultValue;
+
+  CastOpInit(RecTy *CastType, Init *Expr, Init *DefaultValue)
+      : TypedInit(IK_CastOpInit, CastType), CastType(CastType), Expr(Expr),
+        DefaultValue(DefaultValue) {}
+
+public:
+  CastOpInit(const CastOpInit &) = delete;
+  CastOpInit &operator=(const CastOpInit &) = delete;
+
+  static bool classof(const Init *I) { return I->getKind() == IK_CastOpInit; }
+
+  static CastOpInit *get(RecTy *CastType, Init *Expr,
+                         Init *DefaultValue = nullptr);
+
+  void Profile(FoldingSetNodeID &ID) const;
+
+  // Fold - If possible, fold this to a simpler init.  Return this if not
+  // possible to fold.
+  Init *Fold(Record *CurRec, bool IsFinal = false) const;
+
+  Init *resolveReferences(Resolver &R) const override;
+
+  Init *getBit(unsigned Bit) const override;
+
+  std::string getAsString() const override;
+};
+
 /// !isa<type>(expr) - Dynamically determine the type of an expression.
 class IsAOpInit : public TypedInit, public FoldingSetNode {
 private:
   RecTy *CheckType;
   Init *Expr;
 
   IsAOpInit(RecTy *CheckType, Init *Expr)
       : TypedInit(IK_IsAOpInit, IntRecTy::get(CheckType->getRecordKeeper())),

llvm/lib/TableGen/Record.cpp

struct RecordKeeperImpl {
   std::map<int64_t, IntInit *> TheIntInitPool;
   StringMap<StringInit *, BumpPtrAllocator &> StringInitStringPool;
   StringMap<StringInit *, BumpPtrAllocator &> StringInitCodePool;
   FoldingSet<ListInit> TheListInitPool;
   FoldingSet<UnOpInit> TheUnOpInitPool;
   FoldingSet<BinOpInit> TheBinOpInitPool;
   FoldingSet<TernOpInit> TheTernOpInitPool;
   FoldingSet<FoldOpInit> TheFoldOpInitPool;
+  FoldingSet<CastOpInit> TheCastOpInitPool;
   FoldingSet<IsAOpInit> TheIsAOpInitPool;
   DenseMap<std::pair<RecTy *, Init *>, VarInit *> TheVarInitPool;
   DenseMap<std::pair<TypedInit *, unsigned>, VarBitInit *> TheVarBitInitPool;
   DenseMap<std::pair<TypedInit *, unsigned>, VarListElementInit *>
       TheVarListElementInitPool;
   FoldingSet<VarDefInit> TheVarDefInitPool;
   DenseMap<std::pair<Init *, StringInit *>, FieldInit *> TheFieldInitPool;
   FoldingSet<CondOpInit> TheCondOpInitPool;
UnOpInit *UnOpInit::get(UnaryOp Opc, Init *LHS, RecTy *Type) {
   RK.TheUnOpInitPool.InsertNode(I, IP);
   return I;
 }
 
 void UnOpInit::Profile(FoldingSetNodeID &ID) const {
   ProfileUnOpInit(ID, getOpcode(), getOperand(), getType());
 }
 
-Init *UnOpInit::Fold(Record *CurRec, bool IsFinal) const {
+Init *UnOpInit::Fold(Record *CurRec) const {
   RecordKeeper &RK = getRecordKeeper();
   switch (getOpcode()) {
-  case CAST:
-    if (isa<StringRecTy>(getType())) {
-      if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
-        return LHSs;
-
-      if (DefInit *LHSd = dyn_cast<DefInit>(LHS))
-        return StringInit::get(RK, LHSd->getAsString());
-
-      if (IntInit *LHSi = dyn_cast_or_null<IntInit>(
-              LHS->convertInitializerTo(IntRecTy::get(RK))))
-        return StringInit::get(RK, LHSi->getAsString());
-
-    } else if (isa<RecordRecTy>(getType())) {
-      if (StringInit *Name = dyn_cast<StringInit>(LHS)) {
-        if (!CurRec && !IsFinal)
-          break;
-        assert(CurRec && "NULL pointer");
-        Record *D;
-
-        // Self-references are allowed, but their resolution is delayed until
-        // the final resolve to ensure that we get the correct type for them.
-        auto *Anonymous = dyn_cast<AnonymousNameInit>(CurRec->getNameInit());
-        if (Name == CurRec->getNameInit() ||
-            (Anonymous && Name == Anonymous->getNameInit())) {
-          if (!IsFinal)
-            break;
-          D = CurRec;
-        } else {
-          D = CurRec->getRecords().getDef(Name->getValue());
-          if (!D) {
-            if (IsFinal)
-              PrintFatalError(CurRec->getLoc(),
-                              Twine("Undefined reference to record: '") +
-                              Name->getValue() + "'\n");
-            break;
-          }
-        }
-
-        DefInit *DI = DefInit::get(D);
-        if (!DI->getType()->typeIsA(getType())) {
-          PrintFatalError(CurRec->getLoc(),
-                          Twine("Expected type '") +
-                          getType()->getAsString() + "', got '" +
-                          DI->getType()->getAsString() + "' in: " +
-                          getAsString() + "\n");
-        }
-        return DI;
-      }
-    }
-
-    if (Init *NewInit = LHS->convertInitializerTo(getType()))
-      return NewInit;
-    break;
-
   case NOT:
     if (IntInit *LHSi = dyn_cast_or_null<IntInit>(
             LHS->convertInitializerTo(IntRecTy::get(RK))))
       return IntInit::get(RK, LHSi->getValue() ? 0 : 1);
     break;
 
   case HEAD:
     if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) {
case GETDAGOP:
     break;
   }
   return const_cast<UnOpInit *>(this);
 }
 
 Init *UnOpInit::resolveReferences(Resolver &R) const {
   Init *lhs = LHS->resolveReferences(R);
 
-  if (LHS != lhs || (R.isFinal() && getOpcode() == CAST))
+  if (LHS != lhs)
     return (UnOpInit::get(getOpcode(), lhs, getType()))
-        ->Fold(R.getCurrentRecord(), R.isFinal());
+        ->Fold(R.getCurrentRecord());
   return const_cast<UnOpInit *>(this);
 }
 
 std::string UnOpInit::getAsString() const {
   std::string Result;
   switch (getOpcode()) {
-  case CAST: Result = "!cast<" + getType()->getAsString() + ">"; break;
   case NOT: Result = "!not"; break;
   case HEAD: Result = "!head"; break;
   case TAIL: Result = "!tail"; break;
   case SIZE: Result = "!size"; break;
   case EMPTY: Result = "!empty"; break;
   case GETDAGOP: Result = "!getdagop"; break;
   }
   return Result + "(" + LHS->getAsString() + ")";

 
 std::string FoldOpInit::getAsString() const {
   return (Twine("!foldl(") + Start->getAsString() + ", " + List->getAsString() +
           ", " + A->getAsUnquotedString() + ", " + B->getAsUnquotedString() +
           ", " + Expr->getAsString() + ")")
       .str();
 }
 
+static void ProfileCastOpInit(FoldingSetNodeID &ID, RecTy *CastType, Init *Expr,
+                              Init *DefaultValue) {
+  ID.AddPointer(CastType);
+  ID.AddPointer(Expr);
+  if (DefaultValue)
+    ID.AddPointer(DefaultValue);
+}
+
+CastOpInit *CastOpInit::get(RecTy *CastType, Init *Expr, Init *DefaultValue) {
+  FoldingSetNodeID ID;
+  ProfileCastOpInit(ID, CastType, Expr, DefaultValue);
+
+  detail::RecordKeeperImpl &RK = CastType->getRecordKeeper().getImpl();
+  void *IP = nullptr;
+  if (CastOpInit *I = RK.TheCastOpInitPool.FindNodeOrInsertPos(ID, IP))
+    return I;
+
+  CastOpInit *I = new (RK.Allocator) CastOpInit(CastType, Expr, DefaultValue);
+  RK.TheCastOpInitPool.InsertNode(I, IP);
+  return I;
+}
+
+void CastOpInit::Profile(FoldingSetNodeID &ID) const {
+  ProfileCastOpInit(ID, CastType, Expr, DefaultValue);
+}
+
+Init *CastOpInit::Fold(Record *CurRec, bool IsFinal) const {
+  RecordKeeper &RK = getRecordKeeper();
+  if (isa<StringRecTy>(getType())) {
+    if (StringInit *LHSs = dyn_cast<StringInit>(Expr))
+      return LHSs;
+
+    if (DefInit *LHSd = dyn_cast<DefInit>(Expr))
+      return StringInit::get(RK, LHSd->getAsString());
+
+    if (IntInit *LHSi = dyn_cast_or_null<IntInit>(
+            Expr->convertInitializerTo(IntRecTy::get(RK))))
+      return StringInit::get(RK, LHSi->getAsString());
+
+  } else if (isa<RecordRecTy>(getType())) {
+    if (StringInit *Name = dyn_cast<StringInit>(Expr)) {
+      if (!CurRec && !IsFinal)
+        return const_cast<CastOpInit *>(this);
+      assert(CurRec && "NULL pointer");
+      Record *D;
+
+      // Self-references are allowed, but their resolution is delayed until
+      // the final resolve to ensure that we get the correct type for them.
+      auto *Anonymous = dyn_cast<AnonymousNameInit>(CurRec->getNameInit());
+      if (Name == CurRec->getNameInit() ||
+          (Anonymous && Name == Anonymous->getNameInit())) {
+        if (!IsFinal)
+          return const_cast<CastOpInit *>(this);
+        D = CurRec;
+      } else {
+        D = CurRec->getRecords().getDef(Name->getValue());
+        if (!D) {
+          if (IsFinal) {
+            if (!DefaultValue) {
+              PrintFatalError(CurRec->getLoc(),
+                              Twine("Undefined reference to record: '") +
+                                  Name->getValue() + "'\n");
+            }
+            if (auto *TI = dyn_cast<TypedInit>(DefaultValue)) {
+              if (!TI->getType()->typeIsConvertibleTo(CastType))
+                PrintFatalError(
+                    CurRec->getLoc(),
+                    Twine("Default value of !cast should be of type '") +
+                        CastType->getAsString() + "'\n");
+            }
+            return DefaultValue;
+          }
+          return const_cast<CastOpInit *>(this);
+        }
+      }
+
+      DefInit *DI = DefInit::get(D);
+      if (!DI->getType()->typeIsA(getType())) {
+        PrintFatalError(CurRec->getLoc(),
+                        Twine("Expected type '") + getType()->getAsString() +
+                            "', got '" + DI->getType()->getAsString() +
+                            "' in: " + getAsString() + "\n");
+      }
+      return DI;
+    }
+  }
+
+  if (Init *NewInit = Expr->convertInitializerTo(getType()))
+    return NewInit;
+
+  return const_cast<CastOpInit *>(this);
+}
+
+Init *CastOpInit::resolveReferences(Resolver &R) const {
+  Init *NewExpr = Expr->resolveReferences(R);
+  Init *NewDefaultValue = nullptr;
+  if (DefaultValue)
+    NewDefaultValue = DefaultValue->resolveReferences(R);
+  if (Expr != NewExpr || DefaultValue != NewDefaultValue || R.isFinal())
+    return get(CastType, NewExpr, NewDefaultValue)
+        ->Fold(R.getCurrentRecord(), R.isFinal());
+  return const_cast<CastOpInit *>(this);
+}
+
+Init *CastOpInit::getBit(unsigned Bit) const {
+  if (getType() == BitRecTy::get(getRecordKeeper()))
+    return const_cast<CastOpInit *>(this);
+  return VarBitInit::get(const_cast<CastOpInit *>(this), Bit);
+}
+
+std::string CastOpInit::getAsString() const {
+  std::string Result =
+      "!cast<" + getType()->getAsString() + ">(" + Expr->getAsString();
+  if (DefaultValue)
+    Result += "," + DefaultValue->getAsString();
+  return Result + ")";
+}
+
 static void ProfileIsAOpInit(FoldingSetNodeID &ID, RecTy *CheckType,
                              Init *Expr) {
   ID.AddPointer(CheckType);
   ID.AddPointer(Expr);
 }
 
 IsAOpInit *IsAOpInit::get(RecTy *CheckType, Init *Expr) {
 
if (Init *Converted = convertInitializerTo(Ty)) {
     assert(!isa<TypedInit>(Converted) ||
            cast<TypedInit>(Converted)->getType()->typeIsA(Ty));
     return Converted;
   }
 
   if (!getType()->typeIsConvertibleTo(Ty))
     return nullptr;
 
-  return UnOpInit::get(UnOpInit::CAST, const_cast<TypedInit *>(this), Ty)
-      ->Fold(nullptr);
+  return CastOpInit::get(Ty, const_cast<TypedInit *>(this))->Fold(nullptr);
 }
 
 Init *TypedInit::convertInitListSlice(ArrayRef<unsigned> Elements) const {
   ListRecTy *T = dyn_cast<ListRecTy>(getType());
   if (!T) return nullptr;  // Cannot subscript a non-list variable.
 
   if (Elements.size() == 1)
     return VarListElementInit::get(const_cast<TypedInit *>(this), Elements[0]);

llvm/lib/TableGen/TGParser.cpp

Init *TGParser::ParseIDValue(Record *CurRec, StringInit *Name, SMLoc NameLoc,
 
   if (Init *I = Records.getGlobal(Name->getValue()))
     return I;
 
   // Allow self-references of concrete defs, but delay the lookup so that we
   // get the correct type.
   if (CurRec && !CurRec->isClass() && !CurMultiClass &&
       CurRec->getNameInit() == Name)
-    return UnOpInit::get(UnOpInit::CAST, Name, CurRec->getType());
+    return CastOpInit::get(CurRec->getType(), Name);
 
   Error(NameLoc, "Variable not defined: '" + Name->getValue() + "'");
   return nullptr;
 }
 
 /// ParseOperation - Parse an operator.  This returns null on error.
 ///
 /// Operation ::= XOperator ['<' Type '>'] '(' Args ')'
 ///
 Init *TGParser::ParseOperation(Record *CurRec, RecTy *ItemType) {
   switch (Lex.getCode()) {
   default:
     TokError("unknown bang operator");
     return nullptr;
   case tgtok::XNOT:
   case tgtok::XHead:
   case tgtok::XTail:
   case tgtok::XSize:
   case tgtok::XEmpty:
-  case tgtok::XCast:
   case tgtok::XGetDagOp: { // Value ::= !unop '(' Value ')'
     UnOpInit::UnaryOp Code;
     RecTy *Type = nullptr;
 
     switch (Lex.getCode()) {
-    default: llvm_unreachable("Unhandled code!");
-    case tgtok::XCast:
-      Lex.Lex();  // eat the operation
-      Code = UnOpInit::CAST;
-
-      Type = ParseOperatorType();
-
-      if (!Type) {
-        TokError("did not get type for unary operator");
-        return nullptr;
-      }
-
-      break;
+    default:
+      llvm_unreachable("Unhandled code!");
     case tgtok::XNOT:
       Lex.Lex();  // eat the operation
       Code = UnOpInit::NOT;
       Type = IntRecTy::get(Records);
       break;
     case tgtok::XHead:
       Lex.Lex();  // eat the operation
       Code = UnOpInit::HEAD;
case tgtok::XGetDagOp: { // Value ::= !unop '(' Value ')'
     }
 
     if (!consume(tgtok::r_paren)) {
       TokError("expected ')' in unary operator");
       return nullptr;
     }
     return (UnOpInit::get(Code, LHS, Type))->Fold(CurRec);
   }
+  case tgtok::XCast: {
+    // Value ::= !cast '<' Type '>' '(' Value [',' Value] ')'
+    Lex.Lex(); // eat the operation
+    RecTy *Type = ParseOperatorType();
+    if (!Type) {
+      TokError("did not get type for !cast");
+      return nullptr;
+    }
+    if (!consume(tgtok::l_paren)) {
+      TokError("expected '(' after type of !cast");
+      return nullptr;
+    }
+    Init *Expr = ParseValue(CurRec);
+    Init *DefaultValue = consume(tgtok::comma) ? ParseValue(CurRec) : nullptr;
 
+    if (!consume(tgtok::r_paren)) {
+      TokError("expected ')' in !cast");
+      return nullptr;
+    }
+    return (CastOpInit::get(Type, Expr, DefaultValue))->Fold(CurRec);
+  }
   case tgtok::XIsA: {
     // Value ::= !isa '<' Type '>' '(' Value ')'
     Lex.Lex(); // eat the operation
 
     RecTy *Type = ParseOperatorType();
     if (!Type)
       return nullptr;
 
case tgtok::paste:
         }
         break;
       }
 
       // Create a !strconcat() operation, first casting each operand to
       // a string if necessary.
       if (LHS->getType() != StringRecTy::get(Records)) {
         auto CastLHS = dyn_cast<TypedInit>(
-            UnOpInit::get(UnOpInit::CAST, LHS, StringRecTy::get(Records))
-                ->Fold(CurRec));
+            CastOpInit::get(StringRecTy::get(Records), LHS)->Fold(CurRec));
         if (!CastLHS) {
           Error(PasteLoc,
                 Twine("can't cast '") + LHS->getAsString() + "' to string");
           return nullptr;
         }
         LHS = CastLHS;
       }
 
case tgtok::paste:
         RHS = dyn_cast<TypedInit>(RHSResult);
         if (!RHS) {
           Error(PasteLoc, "RHS of paste is not typed!");
           return nullptr;
         }
 
         if (RHS->getType() != StringRecTy::get(Records)) {
           auto CastRHS = dyn_cast<TypedInit>(
-              UnOpInit::get(UnOpInit::CAST, RHS, StringRecTy::get(Records))
-                  ->Fold(CurRec));
+              CastOpInit::get(StringRecTy::get(Records), RHS)->Fold(CurRec));
           if (!CastRHS) {
             Error(PasteLoc,
                   Twine("can't cast '") + RHS->getAsString() + "' to string");
             return nullptr;
           }
           RHS = CastRHS;
         }
 

llvm/test/TableGen/cast-with-default-value-of-wrong-type.td

+// RUN: not llvm-tblgen --no-warn-on-unused-template-args %s 2>&1 | FileCheck %s
+// XFAIL: vg_leak
+
+// CHECK: Default value of !cast should be of type 'X'
+
+class X<int v> {
+  int value = v;
+}
+
+class A<int v> {
+  int value = v;
+}
+
+def NonSub : A<0>;
+
+def NULL : X<-1>;
+
+class Y<int id> {
+  int value = !cast<X>("X" # id, NonSub).value;
+}
+
+def X0   : X<0>;
+def X1   : X<1>;
+
+def Y0: Y<0>;
+def Y1: Y<1>;
+def Y2: Y<2>;

llvm/test/TableGen/cast-with-default-value.td

+// RUN: llvm-tblgen --no-warn-on-unused-template-args %s | FileCheck %s
+// XFAIL: vg_leak
+
+// CHECK: def NULL {
+// CHECK:   int value = -1;
+// CHECK: }
+
+// CHECK: def Sub {
+// CHECK:   int value = -1;
+// CHECK: }
+
+// CHECK: def X0 {
+// CHECK:   int value = 0;
+// CHECK: }
+
+// CHECK: def X1 {
+// CHECK:   int value = 1;
+// CHECK: }
+
+// CHECK: def Y0 {
+// CHECK:   int value1 = 0;
+// CHECK:   int value2 = 0;
+// CHECK:   X x = X0;
+// CHECK: }
+
+// CHECK: def Y1 {
+// CHECK:   int value1 = 1;
+// CHECK:   int value2 = 1;
+// CHECK:   X x = X1;
+// CHECK: }
+
+// CHECK: def Y2 {
+// CHECK:   int value1 = -1;
+// CHECK:   int value2 = -1;
+// CHECK:   X x = ?;
+// CHECK: }
+
+class X<int v> {
+  int value = v;
+}
+
+class A<int v>: X<v>;
+
+def Sub : A<-1>;
+
+def NULL : X<-1>;
+
+class Y<int id> {
+  int value1 = !cast<X>("X" # id, NULL).value;
+  int value2 = !cast<X>("X" # id, Sub).value;
+  X x = !cast<X>("X" # id, ?);
+}
+
+def X0   : X<0>;
+def X1   : X<1>;
+
+def Y0: Y<0>;
+def Y1: Y<1>;
+def Y2: Y<2>;

llvm/test/TableGen/cast-without-default-value.td

+// RUN: not llvm-tblgen --no-warn-on-unused-template-args %s 2>&1 | FileCheck %s
+// XFAIL: vg_leak
+
+// CHECK: Undefined reference to record: 'X2'
+
+class X<int v> {
+  int value = v;
+}
+
+class Y<int id> {
+  int value = !cast<X>("X" # id).value;
+}
+
+def X0   : X<0>;
+def X1   : X<1>;
+
+def Y0: Y<0>;
+def Y1: Y<1>;
+def Y2: Y<2>;