[TableGen] Add !getdagarg and !getdagname

[hliao]

Summary

• This patch proposes to add !getdagarg and !getdagnames bang operators as the inverse operation of !dag. They allow us to examine arguments of a given dag.

[hliao]

Rebase and ping for review

[simon_tatham]

It's not quite clear whether you mean this patch to be an alternative to D151457, or to go together with it. The two changes would clearly conflict, but one of your comments in the other change (https://reviews.llvm.org/D151457#4374848) made it sound as if you meant to do both?

If they're alternatives, then I prefer this one, because I love the extra feature of looking up a dag argument by its name instead of its index. I can see that being really useful.

llvm/lib/TableGen/Record.cpp

1301

This error message schema leads to the slightly weird error seen in your test:

error: !getdagarg index is out of range 0...3: 3

I'd normally interpret the notation "0...3" as being inclusive at both ends, so it's confusing to be told that 3 is not in the range 0...3.

To avoid this wording difficulty, perhaps it's better to break up the error so that a negative index gets its own message (it's illegal no matter how many arguments the dag has), and a positive one gets a message like "!getdagarg index 3 out of range (dag has 3 arguments)"?

llvm/lib/TableGen/TGLexer.h

53

It isn't clear why this section had to be reformatted at all in this patch, but if you are going to put each enum entry on its own line, you could at least break up the comments in the same way so that each one has a comment with its own symbol.

llvm/test/TableGen/getsetop.td

99

Needs some more tests:

• total mismatch of types, e.g. !getdagarg<int> applied to an argument that's a string, or !getdagarg<Foo> applied to a record type that's not an instance of class Foo at all.
• demonstrate retrieving a type by its superclass but not subclass

[hliao]

In D151602#4380256, @simon_tatham wrote:

It's not quite clear whether you mean this patch to be an alternative to D151457, or to go together with it. The two changes would clearly conflict, but one of your comments in the other change (https://reviews.llvm.org/D151457#4374848) made it sound as if you meant to do both?

If they're alternatives, then I prefer this one, because I love the extra feature of looking up a dag argument by its name instead of its index. I can see that being really useful.

Originally, I thought to provide this element access functionality as complementary to the !getdagargs. But, I realized later that the element accessor is more convenient to be used. Also, !getdagargs could be implemented through !getdagarg with the help of !forall and !size, even though a little bit verbose. That makes the D151457 redundant. I prefer this one and want to check your comment and suggestion. I will cancel D151457 once we all agree on that.

[hliao]

llvm/lib/TableGen/TGLexer.h

53

The pre-merge check fails now once clang-format generates different changes from my original change cause we add XDagGetArg and XDagGetName. I could revert that part of change or make such formatting NFC change in advance before this patch.

[hliao]

More tests

[hliao]

Revise the out-of-range error message. Now, the range is from 0 to (numargs-1).

[simon_tatham]

Thanks for the updates. I only have two nitpicks left now.

llvm/lib/TableGen/Record.cpp

1301

I see that you've done a simpler thing than I suggested, by just writing 0...(n-1) in place of 0...n.

But this leads to a bad error message when n=0. Remember that a dag node need not have any arguments at all:

<stdin>:1:14: error: !getdagarg index is out of range 0...4294967295: 0
def foo; def test { dag x = (foo); int y = !getdagarg<int>(x, 0); }
             ^

llvm/lib/TableGen/TGLexer.h

53

I don't mind whether you do it in this commit, or separately, or not at all. But if you do it, please convert line pairs like this

minus,
plus, // - +

into a form where the comments make sense:

minus, // -
plus, // +

[hliao]

Revise error message following reviewer's comment

[simon_tatham]

LGTM. Thanks for the fixes!

llvm/docs/TableGen/ProgRef.rst

 --------------
 
 TableGen provides "bang operators" that have a wide variety of uses:
 
 .. productionlist::
    BangOperator: one of
                : !add         !and         !cast        !con         !dag
                : !div         !empty       !eq          !exists      !filter
-               : !find        !foldl       !foreach     !ge          !getdagop
-               : !gt          !head        !if          !interleave  !isa
-               : !le          !listconcat  !listremove  !listsplat   !logtwo
-               : !lt          !mul         !ne          !not         !or
-               : !range       !setdagop    !shl         !size        !sra
-               : !srl         !strconcat   !sub         !subst       !substr
-               : !tail        !tolower     !toupper     !xor
+               : !find        !foldl       !foreach     !ge          !getdagarg
+               : !getdagname  !getdagop    !gt          !head        !if
+               : !interleave  !isa         !le          !listconcat  !listremove
+               : !listsplat   !logtwo      !lt          !mul         !ne
+               : !not         !or          !range       !setdagop    !shl
+               : !size        !sra         !srl         !strconcat   !sub
+               : !subst       !substr      !tail        !tolower     !toupper
+               : !xor
 
 The ``!cond`` operator has a slightly different
 syntax compared to other bang operators, so it is defined separately:
 
 .. productionlist::
    CondOperator: !cond
 
 See `Appendix A: Bang Operators`_ for a description of each bang operator.

 
 The *value* can be any TableGen value. The *name*, if present, must be a
 :token:`TokVarName`, which starts with a dollar sign (``$``). The purpose of
 a name is to tag an operator or argument in a DAG with a particular meaning,
 or to associate an argument in one DAG with a like-named argument in another
 DAG.
 
 The following bang operators are useful for working with DAGs:
-``!con``, ``!dag``, ``!empty``, ``!foreach``, ``!getdagop``, ``!setdagop``, ``!size``.
+``!con``, ``!dag``, ``!empty``, ``!foreach``, ``!getdagarg``, ``!getdagname``,
+``!getdagop``, ``!setdagop``, ``!size``.
 
 Defvar in a record body
 -----------------------
 
 In addition to defining global variables, the ``defvar`` statement can
 be used inside the :token:`Body` of a class or record definition to define
 local variables. Template arguments of ``class`` or ``multiclass`` can be
 used in the value expression. The scope of the variable extends from the
``!foreach(``\ *var*\ ``,`` *sequence*\ ``,`` *expr*\ ``)``
 
     If you simply want to create a list of a certain length containing
     the same value repeated multiple times, see ``!listsplat``.
 
 ``!ge(``\ *a*\ `,` *b*\ ``)``
     This operator produces 1 if *a* is greater than or equal to *b*; 0 otherwise.
     The arguments must be ``bit``, ``bits``, ``int``, or ``string`` values.
 
+``!getdagarg<``\ *type*\ ``>(``\ *dag*\ ``,``\ *key*\ ``)``
+    This operator retrieves the argument from the given *dag* node by the
+    specified *key*, which is either an integer index or a string name. If that
+    argument is not convertible to the specified *type*, ``?`` is returned.
+
+``!getdagname(``\ *dag*\ ``,``\ *index*\ ``)``
+    This operator retrieves the argument name from the given *dag* node by the
+    specified *index*. If that argument has no name associated, ``?`` is
+    returned.
+
 ``!getdagop(``\ *dag*\ ``)`` --or-- ``!getdagop<``\ *type*\ ``>(``\ *dag*\ ``)``
     This operator produces the operator of the given *dag* node.
     Example: ``!getdagop((foo 1, 2))`` results in ``foo``. Recall that
     DAG operators are always records.
 
     The result of ``!getdagop`` can be used directly in a context where
     any record class at all is acceptable (typically placing it into
     another dag value). But in other contexts, it must be explicitly

llvm/include/llvm/TableGen/Record.h

enum BinaryOp : uint8_t {
     INTERLEAVE,
     CONCAT,
     EQ,
     NE,
     LE,
     LT,
     GE,
     GT,
-    SETDAGOP
+    GETDAGARG,
+    GETDAGNAME,
+    SETDAGOP,
   };
 
 private:
   Init *LHS, *RHS;
 
   BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) :
       OpInit(IK_BinOpInit, Type, opc), LHS(lhs), RHS(rhs) {}
 

llvm/lib/TableGen/Record.cpp

Init *BinOpInit::Fold(Record *CurRec) const {
   case LE:
   case LT:
   case GE:
   case GT: {
     if (std::optional<bool> Result = CompareInit(getOpcode(), LHS, RHS))
       return BitInit::get(getRecordKeeper(), *Result);
     break;
   }
+  case GETDAGARG: {
+    DagInit *Dag = dyn_cast<DagInit>(LHS);
+    if (!Dag)
+      break;
+
+    // Helper returning the specified argument.
+    auto getDagArgAsType = [](DagInit *Dag, unsigned Pos,
+                              RecTy *Type) -> Init * {
+      assert(Pos < Dag->getNumArgs());
+      Init *Arg = Dag->getArg(Pos);
+      if (auto *TI = dyn_cast<TypedInit>(Arg))
+        if (!TI->getType()->typeIsConvertibleTo(Type))
+          return UnsetInit::get(Dag->getRecordKeeper());
+      return Arg;
+    };
+
+    // Accessor by index
+    if (IntInit *Idx = dyn_cast<IntInit>(RHS)) {
+      int64_t Pos = Idx->getValue();
+      if (Pos < 0) {
+        // The index is negative.
+        PrintFatalError(CurRec->getLoc(), Twine("!getdagarg index ") +
+                                              std::to_string(Pos) +
+                                              Twine(" is negative"));
+      }
+      if (Pos >= Dag->getNumArgs()) {
+        // The index is out-of-range.
+        PrintFatalError(CurRec->getLoc(),
+                        Twine("!getdagarg index ") + std::to_string(Pos) +
+                            " is out of range (dag has " +
+                            std::to_string(Dag->getNumArgs()) + " arguments)");
+      }
+      return getDagArgAsType(Dag, Pos, getType());
+    }
+    // Accessor by name
+    if (StringInit *Key = dyn_cast<StringInit>(RHS)) {
+      for (unsigned i = 0, e = Dag->getNumArgs(); i < e; ++i) {
+        StringInit *ArgName = Dag->getArgName(i);
+        if (!ArgName || ArgName->getValue() != Key->getValue())
+          continue;
+        // Found
+        return getDagArgAsType(Dag, i, getType());
+      }
+      // The key is not found.
+      PrintFatalError(CurRec->getLoc(), Twine("!getdagarg key '") +
+                                            Key->getValue() +
+                                            Twine("' is not found"));
+    }
+    break;
+  }
+  case GETDAGNAME: {
+    DagInit *Dag = dyn_cast<DagInit>(LHS);
+    IntInit *Idx = dyn_cast<IntInit>(RHS);
+    if (Dag && Idx) {
+      int64_t Pos = Idx->getValue();
+      if (Pos < 0 || Pos >= Dag->getNumArgs()) {
+        // The index is out-of-range.
+        PrintError(CurRec->getLoc(),
+                   Twine("!getdagname index is out of range 0...") +
+                       std::to_string(Dag->getNumArgs() - 1) + ": " +
+                       std::to_string(Pos));
+      }
+      Init *ArgName = Dag->getArgName(Pos);
+      if (!ArgName)
+        return UnsetInit::get(getRecordKeeper());
+      return ArgName;
+    }
+    break;
+  }
   case SETDAGOP: {
     DagInit *Dag = dyn_cast<DagInit>(LHS);
     DefInit *Op = dyn_cast<DefInit>(RHS);
     if (Dag && Op) {
       SmallVector<Init*, 8> Args;
       SmallVector<StringInit*, 8> ArgNames;
       for (unsigned i = 0, e = Dag->getNumArgs(); i != e; ++i) {
         Args.push_back(Dag->getArg(i));
std::string BinOpInit::getAsString() const {
   case GT: Result = "!gt"; break;
   case LISTCONCAT: Result = "!listconcat"; break;
   case LISTSPLAT: Result = "!listsplat"; break;
   case LISTREMOVE: Result = "!listremove"; break;
   case RANGE: Result = "!range"; break;
   case STRCONCAT: Result = "!strconcat"; break;
   case INTERLEAVE: Result = "!interleave"; break;
   case SETDAGOP: Result = "!setdagop"; break;
+  case GETDAGARG:
+    Result = "!getdagarg<" + getType()->getAsString() + ">";
+    break;
+  case GETDAGNAME:
+    Result = "!getdagname";
+    break;
   }
   return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")";
 }
 
 static void
 ProfileTernOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *LHS, Init *MHS,
                   Init *RHS, RecTy *Type) {
   ID.AddInteger(Opcode);

llvm/lib/TableGen/TGLexer.h

 namespace llvm {
 template <typename T> class ArrayRef;
 class SourceMgr;
 class Twine;
 
 namespace tgtok {
 enum TokKind {
   // Markers
-    Eof, Error,
+  Eof,
+  Error,
 
   // Tokens with no info.
-    minus, plus,        // - +
-    l_square, r_square, // [ ]
-    l_brace, r_brace,   // { }
-    l_paren, r_paren,   // ( )
-    less, greater,      // < >
-    colon, semi,        // : ;
-    comma, dot,         // , .
-    equal, question,    // = ?
-    paste,              // #
-    dotdotdot,          // ...
+  minus,     // -
+  plus,      // +
+  l_square,  // [
+  r_square,  // ]
+  l_brace,   // {
+  r_brace,   // }
+  l_paren,   // (
+  r_paren,   // )
+  less,      // <
+  greater,   // >
+  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.)
-    Assert, Bit, Bits, Class, Code, Dag, Def, Defm, Defset, Defvar, ElseKW,
-    FalseKW, Field, Foreach, If, In, Include, Int, Let, List, MultiClass,
-    String, Then, TrueKW,
+  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, XDIV, XNOT, XLOG2, XAND, XOR, XXOR, XSRA, XSRL,
-    XSHL, XListConcat, XListSplat, XStrConcat, XInterleave, XSubstr, XFind,
-    XCast, XSubst, XForEach, XFilter, XFoldl, XHead, XTail, XSize, XEmpty, XIf,
-    XCond, XEq, XIsA, XDag, XNe, XLe, XLt, XGe, XGt, XSetDagOp, XGetDagOp,
-    XExists, XListRemove, XToLower, XToUpper, XRange,
+  XConcat,
+  XADD,
+  XSUB,
+  XMUL,
+  XDIV,
+  XNOT,
+  XLOG2,
+  XAND,
+  XOR,
+  XXOR,
+  XSRA,
+  XSRL,
+  XSHL,
+  XListConcat,
+  XListSplat,
+  XStrConcat,
+  XInterleave,
+  XSubstr,
+  XFind,
+  XCast,
+  XSubst,
+  XForEach,
+  XFilter,
+  XFoldl,
+  XHead,
+  XTail,
+  XSize,
+  XEmpty,
+  XIf,
+  XCond,
+  XEq,
+  XIsA,
+  XDag,
+  XNe,
+  XLe,
+  XLt,
+  XGe,
+  XGt,
+  XSetDagOp,
+  XGetDagOp,
+  XExists,
+  XListRemove,
+  XToLower,
+  XToUpper,
+  XRange,
+  XGetDagArg,
+  XGetDagName,
 
   // Boolean literals.
-    TrueVal, FalseVal,
+  TrueVal,
+  FalseVal,
 
   // Integer value.
   IntVal,
 
   // Binary constant.  Note that these are sized according to the number of
   // bits given.
   BinaryIntVal,
 
   // String valued tokens.
-    Id, StrVal, VarName, CodeFragment,
+  Id,
+  StrVal,
+  VarName,
+  CodeFragment,
 
   // Preprocessing tokens for internal usage by the lexer.
   // They are never returned as a result of Lex().
-    Ifdef, Ifndef, Else, Endif, Define
+  Ifdef,
+  Ifndef,
+  Else,
+  Endif,
+  Define
 };
 }
 
 /// TGLexer - TableGen Lexer class.
 class TGLexer {
   SourceMgr &SrcMgr;
 
   const char *CurPtr = nullptr;

llvm/lib/TableGen/TGLexer.cpp

tgtok::TokKind Kind =
           .Case("listremove", tgtok::XListRemove)
           .Case("range", tgtok::XRange)
           .Case("strconcat", tgtok::XStrConcat)
           .Case("interleave", tgtok::XInterleave)
           .Case("substr", tgtok::XSubstr)
           .Case("find", tgtok::XFind)
           .Cases("setdagop", "setop", tgtok::XSetDagOp) // !setop is deprecated.
           .Cases("getdagop", "getop", tgtok::XGetDagOp) // !getop is deprecated.
+          .Case("getdagarg", tgtok::XGetDagArg)
+          .Case("getdagname", tgtok::XGetDagName)
           .Case("exists", tgtok::XExists)
           .Case("tolower", tgtok::XToLower)
           .Case("toupper", tgtok::XToUpper)
           .Default(tgtok::Error);
 
   return Kind != tgtok::Error ? Kind : ReturnError(Start-1, "Unknown operator");
 }
 

llvm/lib/TableGen/TGParser.cpp

Init *TGParser::ParseOperation(Record *CurRec, RecTy *ItemType) {
   case tgtok::XGe:
   case tgtok::XGt:
   case tgtok::XListConcat:
   case tgtok::XListSplat:
   case tgtok::XListRemove:
   case tgtok::XRange:
   case tgtok::XStrConcat:
   case tgtok::XInterleave:
+  case tgtok::XGetDagArg:
+  case tgtok::XGetDagName:
   case tgtok::XSetDagOp: { // Value ::= !binop '(' Value ',' Value ')'
     tgtok::TokKind OpTok = Lex.getCode();
     SMLoc OpLoc = Lex.getLoc();
     Lex.Lex();  // eat the operation
 
     BinOpInit::BinaryOp Code;
     switch (OpTok) {
     default: llvm_unreachable("Unhandled code!");
case tgtok::XSetDagOp: { // Value ::= !binop '(' Value ',' Value ')'
     case tgtok::XGt:     Code = BinOpInit::GT; break;
     case tgtok::XListConcat: Code = BinOpInit::LISTCONCAT; break;
     case tgtok::XListSplat:  Code = BinOpInit::LISTSPLAT; break;
     case tgtok::XListRemove: Code = BinOpInit::LISTREMOVE; break;
     case tgtok::XRange:      Code = BinOpInit::RANGE; break;
     case tgtok::XStrConcat:  Code = BinOpInit::STRCONCAT; break;
     case tgtok::XInterleave: Code = BinOpInit::INTERLEAVE; break;
     case tgtok::XSetDagOp:   Code = BinOpInit::SETDAGOP; break;
+    case tgtok::XGetDagArg:
+      Code = BinOpInit::GETDAGARG;
+      break;
+    case tgtok::XGetDagName:
+      Code = BinOpInit::GETDAGNAME;
+      break;
     }
 
     RecTy *Type = nullptr;
     RecTy *ArgType = nullptr;
     switch (OpTok) {
     default:
       llvm_unreachable("Unhandled code!");
     case tgtok::XConcat:
     case tgtok::XSetDagOp:
       Type = DagRecTy::get(Records);
       ArgType = DagRecTy::get(Records);
       break;
+    case tgtok::XGetDagArg:
+      Type = ParseOperatorType();
+      if (!Type) {
+        TokError("did not get type for !getdagarg operator");
+        return nullptr;
+      }
+      ArgType = DagRecTy::get(Records);
+      break;
+    case tgtok::XGetDagName:
+      Type = StringRecTy::get(Records);
+      ArgType = DagRecTy::get(Records);
+      break;
     case tgtok::XAND:
     case tgtok::XOR:
     case tgtok::XXOR:
     case tgtok::XSRA:
     case tgtok::XSRL:
     case tgtok::XSHL:
     case tgtok::XADD:
     case tgtok::XSUB:
for (;;) {
               !ArgType->typeIsConvertibleTo(StringRecTy::get(Records)) &&
               !ArgType->typeIsConvertibleTo(RecordRecTy::get(Records, {}))) {
             Error(InitLoc, Twine("expected bit, bits, int, string, or record; "
                                  "got value of type '") + ArgType->getAsString() + 
                                  "'");
             return nullptr;
           }
           break;
+        case BinOpInit::GETDAGARG: // The 2nd argument of !getdagarg could be
+                                   // index or name.
         case BinOpInit::LE:
         case BinOpInit::LT:
         case BinOpInit::GE:
         case BinOpInit::GT:
           if (!ArgType->typeIsConvertibleTo(IntRecTy::get(Records)) &&
               !ArgType->typeIsConvertibleTo(StringRecTy::get(Records))) {
             Error(InitLoc, Twine("expected bit, bits, int, or string; "
                                  "got value of type '") + ArgType->getAsString() + 
for (;;) {
       // Deal with BinOps whose arguments have different types, by
       // rewriting ArgType in between them.
       switch (Code) {
         case BinOpInit::SETDAGOP:
           // After parsing the first dag argument, switch to expecting
           // a record, with no restriction on its superclasses.
           ArgType = RecordRecTy::get(Records, {});
           break;
+        case BinOpInit::GETDAGARG:
+          // After parsing the first dag argument, expect an index integer or a
+          // name string.
+          ArgType = nullptr;
+          break;
+        case BinOpInit::GETDAGNAME:
+          // After parsing the first dag argument, expect an index integer.
+          ArgType = IntRecTy::get(Records);
+          break;
         default:
           break;
       }
 
       if (!consume(tgtok::comma))
         break;
     }
 
Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
   case tgtok::XGe:
   case tgtok::XGt:
   case tgtok::XListConcat:
   case tgtok::XListSplat:
   case tgtok::XListRemove:
   case tgtok::XRange:
   case tgtok::XStrConcat:
   case tgtok::XInterleave:
+  case tgtok::XGetDagArg:
+  case tgtok::XGetDagName:
   case tgtok::XSetDagOp: // Value ::= !binop '(' Value ',' Value ')'
   case tgtok::XIf:
   case tgtok::XCond:
   case tgtok::XFoldl:
   case tgtok::XForEach:
   case tgtok::XFilter:
   case tgtok::XSubst:
   case tgtok::XSubstr:

llvm/test/TableGen/getsetop.td

 // RUN: llvm-tblgen %s | FileCheck %s
 // RUN: not llvm-tblgen -DERROR1 %s 2>&1 | FileCheck --check-prefix=ERROR1 %s
 // RUN: not llvm-tblgen -DERROR2 %s 2>&1 | FileCheck --check-prefix=ERROR2 %s
 // RUN: not llvm-tblgen -DERROR3 %s 2>&1 | FileCheck --check-prefix=ERROR3 %s
+// RUN: not llvm-tblgen -DERROR4 %s 2>&1 | FileCheck --check-prefix=ERROR4 %s
+// RUN: not llvm-tblgen -DERROR5 %s 2>&1 | FileCheck --check-prefix=ERROR5 %s
+// RUN: not llvm-tblgen -DERROR6 %s 2>&1 | FileCheck --check-prefix=ERROR6 %s
 
 // !setop and !getop are deprecated in favor of !setdagop and !getdagop.
 // Two tests retain the old names just to be sure they are still supported.
 
 class Base;
 class OtherBase;
 
+class Super : Base;
+
 def foo: Base;
 def bar: Base;
 def qux: OtherBase;
 
+def alice : Super;
+def bob : Super;
+
 def test {
   dag orig = (foo 1, 2:$a, $b);
   dag another = (qux "hello", $world);
 
   // CHECK: dag replaceWithBar = (bar 1, 2:$a, ?:$b);
   dag replaceWithBar = !setop(orig, bar);
 
   // CHECK: dag replaceWithBaz = (qux 1, 2:$a, ?:$b);

 
 #ifdef ERROR3
   // Obviously, you shouldn't be able to give any type to !getdagop that
   // isn't a class type.
 
   // ERROR3: error: type for !getdagop must be a record type
   int ridiculousCast = !getdagop<int>(orig);
 #endif
+
+  dag in1 = (foo 1:$a, 2:$b, 3:$c);
+  // CHECK: list<string> in1Names = ["a", "b", "c"];
+  list<string> in1Names = !foreach(i, !range(!size(in1)), !getdagname(in1, i));
+  // CHECK: list<int> in1Args = [1, 2, 3];
+  list<int> in1Args = !foreach(i, !range(!size(in1)), !getdagarg<int>(in1, i));
+
+  dag in2 = (foo 1:$a, (bar "x":$x, (qux foo:$s1, bar:$s2):$y, 7:$z):$b, 3:$c);
+  // CHECK: dag in2NestedDag = (qux foo:$s1, bar:$s2);
+  dag in2NestedDag = !getdagarg<dag>(!getdagarg<dag>(in2, 1), "y");
+  // CHECK: Base in2NestedArg = foo;
+  Base in2NestedArg = !getdagarg<Base>(!getdagarg<dag>(!getdagarg<dag>(in2, 1), "y"), "s1");
+
+  dag in3 = (foo 1:$a, ?:$b, 3);
+  // CHECK: list<string> in3Names = ["a", "b", ?];
+  list<string> in3Names = !foreach(i, !range(!size(in3)), !getdagname(in3, i));
+  // CHECK: list<int> in3Args = [1, ?, 3];
+  list<int> in3Args = !foreach(i, !range(!size(in3)), !getdagarg<int>(in3, i));
+
+#ifdef ERROR4
+  // ERROR4: error: !getdagarg index -1 is negative
+  int outOfRange = !getdagarg<int>(in1, -1);
+#endif
+
+#ifdef ERROR5
+  // ERROR5: error: !getdagarg index 3 is out of range (dag has 3 arguments)
+  int outOfRange = !getdagarg<int>(in1, 3);
+#endif
+
+#ifdef ERROR6
+  // ERROR6: error: !getdagarg key 'x' is not found
+  int notFound = !getdagarg<int>(in1, "x");
+#endif
+
+  dag in4 = (foo "arg1":$a, "arg2":$b, "arg3":$c);
+  // CHECK: int misMatchType1 = ?;
+  int misMatchType1 = !getdagarg<int>(in4, 0);
+
+  dag in5 = (foo foo:$a, bar:$b, foo:$c);
+  // CHECK: OtherBase misMatchType2 = ?;
+  OtherBase misMatchType2 = !getdagarg<OtherBase>(in5, 1);
+
+  dag in6 = (foo alice:$a, bob:$b);
+  // CHECK: Base base = bob;
+  Base base = !getdagarg<Base>(in6, 1);
 }