[TableGen] Add new bang operator !format

[wangpc]

Summary

We can use # operator to concatenate strings, but it can be too
tedious sometimes and we can't use it to concatenate code strings.

A new bang operator !format is added to format strings (very limited
currently).

!format("{0} {1} ...", arg0, arg1, ...)

Its first operand is a format string, and followings are several
operands (can be none) to format. Currently, {i} where i is the
i-th format argument is the only placeholder format we support.

This bang operator can be used to format code string, which can
reduce a lot of duplicated code.

See D156432 for usages.

[michaelmaitland]

llvm/test/TableGen/format.td

24

Emit a warning? Probably an unintended usage of !format.

25

Emit a warning? Probably an unintended usage of !format.

67

Could be nice to add:

• Format string but not enough arguments
• Format string but too many arguments

[simon_tatham]

llvm/lib/TableGen/Record.cpp

2091–2093

I think it would at least be a good idea to add an escaping system, so that there's no literal text that can't be expressed at all.

Surely the right escaping system is the one that (as far as I can see) Python and std::format already agree on: {{ means a literal {, and }} means a literal }. In particular, {{{1}}} ought to expand to a literal {, then parameter 1, then a literal }.

If you do that, then the syntax has room for future enhancements (by putting more elaborate format specifiers inside the braces), but any format string that starts off valid will continue to be valid and do the same thing.

[fpetrogalli]

Thank you for implementing this. I have added just a couple of comments.

Francesco

llvm/docs/TableGen/ProgRef.rst

1731

This is really nitpicking. You allow (and I think it is correct) invocations without *args*:

string formatNoArg       = !format("");

... so maybe replace this with the suggestion? This is how it is done for printf-like variadic functions: https://en.cppreference.com/w/c/io/fprintf

llvm/include/llvm/TableGen/Record.h

1275–1276

Do we need this API? It doesn't seem to be used anywhere... (am I missing something?)

llvm/lib/TableGen/Record.cpp

1618

Found sounds like boolean to me. How about Pos?

2090

Avoid auto, cannot get the type information from the RHS.

2135

Same, no type info from the invocation of args(). Avoid the use of auto

llvm/test/TableGen/format.td

28

Nit: can we test these with values that do not correspond to the actual placeholder number? maybe replacements like the one suggested.

[Paul-C-Anagnostopoulos]

The documentation needs to be expanded to describe how each argument type is handled.

Would it be better to use a specific character as the escape character, rather than doubling the braces? For example, { and }

[simon_tatham]

In D156429#4539852, @Paul-C-Anagnostopoulos wrote:

Would it be better to use a specific character as the escape character, rather than doubling the braces? For example, `{ and `}

That's probably how I'd do it if I were designing a formatting/interpolation syntax from scratch. But in the case where two major languages already agree on a syntax looking very like the one we're adopting here, I'd say that a more important concern is to avoid being confusingly similar-but-incompatible.

[Paul-C-Anagnostopoulos]

In D156429#4541461, @simon_tatham wrote:

In D156429#4539852, @Paul-C-Anagnostopoulos wrote:

Would it be better to use a specific character as the escape character, rather than doubling the braces? For example, `{ and `}

That's probably how I'd do it if I were designing a formatting/interpolation syntax from scratch. But in the case where two major languages already agree on a syntax looking very like the one we're adopting here, I'd say that a more important concern is to avoid being confusingly similar-but-incompatible.

But in the case of Python, there is also a new string prefix. I don't know about other languages. Anyhoo, as long as we're convinced we won't eventually be doubling a third and fourth character (incompatibly), then I suppose it's okay. I like the extensible solution of a quoting character.

[simon_tatham]

"new string prefix": if you're talking about Python f-strings, then the brace-based formatting syntax predates those by a long way. You could write "{0} {1}".format(a, b) long before you could abbreviate it to f"{a} {b}". But both of those syntaxes agree on writing a literal { or } by doubling it.

(And yes, I think the idea is that only the braces will ever need to be escaped in literal text, because everything else that's interesting in one of these format strings happens inside the braces, where different rules apply.)

[Paul-C-Anagnostopoulos]

In D156429#4542473, @simon_tatham wrote:

"new string prefix": if you're talking about Python f-strings, then the brace-based formatting syntax predates those by a long way. You could write "{0} {1}".format(a, b) long before you could abbreviate it to f"{a} {b}". But both of those syntaxes agree on writing a literal { or } by doubling it.

(And yes, I think the idea is that only the braces will ever need to be escaped in literal text, because everything else that's interesting in one of these format strings happens inside the braces, where different rules apply.)

Yes, of course, the formatting syntax was invented before the f-strings. {{ and }} it is, then.

[michaelmaitland]

llvm/test/TableGen/format.td

23

What happens for something like:

!format("{}") or format!("{1} {} {0} {}", 1, 2);

[wangpc]

llvm/test/TableGen/format.td

23

!format("{}")->"{}"
!format("{1} {} {0} {}", 1, 2)->2 {} 1 {}

Currently, I haven't implemented the format specifier {}, the only supported one is {i}.
The implementation of this patch is very simple, I hope we can delegate formatting to std::vformat someday, but std::vformat needs C++ 20.

[michaelmaitland]

llvm/test/TableGen/format.td

23

Can we add a test case for now so it is clear how this behaves? I am fine with delaying the change of how these act to be closer to std::vformat in the future.

[tra]

Do we really need it at all?

Are there other use cases for it besides !dump() in D156420 ?

Can we just implement some sort or !repr(value) to give us textual representation of the value and then just do "some string" # !repr(some_value) # "some other string" ? That would be sufficient for debugging purposes.

[michaelmaitland]

In D156429#4567002, @tra wrote:

Do we really need it at all?

Are there other use cases for it besides !dump() in D156420 ?

Can we just implement some sort or !repr(value) to give us textual representation of the value and then just do "some string" # !repr(some_value) # "some other string" ? That would be sufficient for debugging purposes.

Here is a proposed use: https://reviews.llvm.org/D156432

[tra]

In D156429#4567049, @michaelmaitland wrote:

Here is a proposed use: https://reviews.llvm.org/D156432

I think we're overcomplicating things a bit too much here.
Specifically, this part: fmt can be a code fragment. . If you want to eval some code, that should probably be done with a lambda in D148915, though I'm not sure if we can define and invoke it like we could in C++ auto value = [](){ return "foo";} ()

When functions/lambdas are available, they would provide a better way to implement D156432 examples, IMO. I suspect it would obviate the need for !format.

[michaelmaitland]

In D156429#4567088, @tra wrote:

When functions/lambdas are available, they would provide a better way to implement D156432 examples, IMO. I suspect it would obviate the need for !format.

The purpose of this patch, as @wangpc states, is to capture the ability to concatenate code strings. IMO we should go with the simplest and most straightforward approach. Maybe we should prefer lambdas/functions over format since the semantics for format is a particularly complex and non-standard one when we look at different languages (i.e. escaping, named args, positional args, formatters), while lambdas and functions are relatively more universal.

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          !getdagarg
-               : !getdagname  !getdagop    !gt          !head        !if
-               : !interleave  !isa         !le          !listconcat  !listremove
-               : !listsplat   !logtwo      !lt          !mul         !ne
-               : !not         !or          !range       !setdagarg   !setdagname
-               : !setdagop    !shl         !size        !sra         !srl
-               : !strconcat   !sub         !subst       !substr      !tail
-               : !tolower     !toupper     !xor
+               : !find        !foldl       !foreach     !format      !ge
+               : !getdagarg   !getdagname  !getdagop    !gt          !head
+               : !if          !interleave  !isa         !le          !listconcat
+               : !listremove  !listsplat   !logtwo      !lt          !mul
+               : !ne          !not         !or          !range       !setdagarg
+               : !setdagname  !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.
``!foreach(``\ *var*\ ``,`` *sequence*\ ``,`` *expr*\ ``)``
     function of the corresponding element in the *sequence* ``list``/``dag``.
     To perform the function, TableGen binds the variable *var* to an element
     and then evaluates the expression. The expression presumably refers
     to the variable *var* and calculates the result value.
 
     If you simply want to create a list of a certain length containing
     the same value repeated multiple times, see ``!listsplat``.
 
+``!format(``\ *fmt*\ ``,`` *args*\ ``, ...)``
+    Format ``args`` according to the format string ``fmt``, and return the
+    result as a string. ``fmt`` can be a code fragment.
+    The placeholder are like ``{i}``, which means it will be replaced by the
+    ``i``-th argument.
+
 ``!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.

llvm/include/llvm/TableGen/Record.h

enum InitKind : uint8_t {
     IK_BinOpInit,
     IK_TernOpInit,
     IK_UnOpInit,
     IK_LastOpInit,
     IK_CondOpInit,
     IK_FoldOpInit,
     IK_IsAOpInit,
     IK_ExistsOpInit,
+    IK_FormatOpInit,
     IK_AnonymousNameInit,
     IK_StringInit,
     IK_VarInit,
     IK_VarBitInit,
     IK_VarDefInit,
     IK_LastTypedInit,
     IK_UnsetInit,
     IK_ArgumentInit,
public:
 
   Init *resolveReferences(Resolver &R) const override;
 
   Init *getBit(unsigned Bit) const override;
 
   std::string getAsString() const override;
 };
 
+/// !format(fmt, args, ...) - Format `args` according to `fmt`.
+class FormatOpInit final : public TypedInit,
+                           public FoldingSetNode,
+                           public TrailingObjects<FormatOpInit, Init *> {
+private:
+  Init *Fmt;
+  unsigned NumArgs;
+
+  FormatOpInit(Init *Fmt, unsigned NumArgs)
+      : TypedInit(IK_FormatOpInit, StringRecTy::get(Fmt->getRecordKeeper())),
+        Fmt(Fmt), NumArgs(NumArgs) {}
+
+public:
+  FormatOpInit(const FormatOpInit &) = delete;
+  FormatOpInit &operator=(const FormatOpInit &) = delete;
+
+  static bool classof(const Init *I) { return I->getKind() == IK_FormatOpInit; }
+
+  static FormatOpInit *get(Init *Fmt, ArrayRef<Init *> Args);
+
+  void Profile(FoldingSetNodeID &ID) const;
+  Init *Fold(Record *CurRec) const;
+
+  bool isComplete() const override;
+  bool isConcrete() const override;
+  Init *resolveReferences(Resolver &R) const override;
+  Init *getBit(unsigned Bit) const override;
+  std::string getAsString() const override;
+
+  Init *getArg(unsigned I) const {
+    assert(I < NumArgs && "Argument index out of range!");
+    return getTrailingObjects<Init *>()[I];
+  }
+
+  using const_iterator = Init *const *;
+
+  const_iterator args_begin() const { return getTrailingObjects<Init *>(); }
+  const_iterator args_end() const { return args_begin() + NumArgs; }
+
+  size_t args_size() const { return NumArgs; }
+  bool args_empty() const { return NumArgs == 0; }
+
+  ArrayRef<Init *> args() const { return ArrayRef(args_begin(), NumArgs); }
+};
+
 /// 'Opcode' - Represent a reference to an entire variable object.
 class VarInit : public TypedInit {
   Init *VarName;
 
   explicit VarInit(Init *VN, RecTy *T)
       : TypedInit(IK_VarInit, T), VarName(VN) {}
 
 public:

llvm/lib/TableGen/Record.cpp

struct RecordKeeperImpl {
   StringMap<StringInit *, BumpPtrAllocator &> StringInitCodePool;
   FoldingSet<ListInit> TheListInitPool;
   FoldingSet<UnOpInit> TheUnOpInitPool;
   FoldingSet<BinOpInit> TheBinOpInitPool;
   FoldingSet<TernOpInit> TheTernOpInitPool;
   FoldingSet<FoldOpInit> TheFoldOpInitPool;
   FoldingSet<IsAOpInit> TheIsAOpInitPool;
   FoldingSet<ExistsOpInit> TheExistsOpInitPool;
+  FoldingSet<FormatOpInit> TheFormatOpInitPool;
   DenseMap<std::pair<RecTy *, Init *>, VarInit *> TheVarInitPool;
   DenseMap<std::pair<TypedInit *, unsigned>, VarBitInit *> TheVarBitInitPool;
   FoldingSet<VarDefInit> TheVarDefInitPool;
   DenseMap<std::pair<Init *, StringInit *>, FieldInit *> TheFieldInitPool;
   FoldingSet<CondOpInit> TheCondOpInitPool;
   FoldingSet<DagInit> TheDagInitPool;
   FoldingSet<RecordRecTy> RecordTypePool;
 
for (Init *Item : MHSl->getValues()) {
       }
     }
     return ListInit::get(NewList, cast<ListRecTy>(Type)->getElementType());
   }
 
   return nullptr;
 }
 
+static std::string replaceAll(const std::string &Target, const std::string &Old,
+                              const std::string &New) {
+  std::string Res = std::string(Target);
+  std::string::size_type Found;
+  std::string::size_type Index = 0;
+  while (true) {
+    Found = Res.find(Old, Index);
+    if (Found == std::string::npos)
+      break;
+    Res.replace(Found, Old.size(), New);
+    Index = Found + New.size();
+  }
+  return Res;
+}
+
 Init *TernOpInit::Fold(Record *CurRec) const {
   RecordKeeper &RK = getRecordKeeper();
   switch (getOpcode()) {
   case SUBST: {
     DefInit *LHSd = dyn_cast<DefInit>(LHS);
     VarInit *LHSv = dyn_cast<VarInit>(LHS);
     StringInit *LHSs = dyn_cast<StringInit>(LHS);
 
if (LHSd && MHSd && RHSd) {
       return DefInit::get(Val);
     }
     if (LHSv && MHSv && RHSv) {
       std::string Val = std::string(RHSv->getName());
       if (LHSv->getAsString() == RHSv->getAsString())
         Val = std::string(MHSv->getName());
       return VarInit::get(Val, getType());
     }
-    if (LHSs && MHSs && RHSs) {
-      std::string Val = std::string(RHSs->getValue());
-
-      std::string::size_type found;
-      std::string::size_type idx = 0;
-      while (true) {
-        found = Val.find(std::string(LHSs->getValue()), idx);
-        if (found == std::string::npos)
-          break;
-        Val.replace(found, LHSs->getValue().size(),
-                    std::string(MHSs->getValue()));
-        idx = found + MHSs->getValue().size();
-      }
+    if (LHSs && MHSs && RHSs)
+      return StringInit::get(RK, replaceAll(std::string(RHSs->getValue()),
+                                            std::string(LHSs->getValue()),
+                                            std::string(MHSs->getValue())));
 
-      return StringInit::get(RK, Val);
-    }
     break;
   }
 
   case FOREACH: {
     if (Init *Result = ForeachHelper(LHS, MHS, RHS, getType(), CurRec))
       return Result;
     break;
   }

 }
 
 std::string ExistsOpInit::getAsString() const {
   return (Twine("!exists<") + CheckType->getAsString() + ">(" +
           Expr->getAsString() + ")")
       .str();
 }
 
+static void ProfileFormatOpInit(FoldingSetNodeID &ID, Init *Fmt,
+                                ArrayRef<Init *> Args) {
+  ID.AddPointer(Fmt);
+  for (auto *Arg : Args)
+    ID.AddPointer(Arg);
+}
+
+void FormatOpInit::Profile(FoldingSetNodeID &ID) const {
+  ProfileFormatOpInit(ID, Fmt, args());
+}
+
+FormatOpInit *FormatOpInit::get(Init *Fmt, ArrayRef<Init *> Args) {
+  FoldingSetNodeID ID;
+  ProfileFormatOpInit(ID, Fmt, Args);
+
+  detail::RecordKeeperImpl &RK = Fmt->getRecordKeeper().getImpl();
+  void *IP = nullptr;
+  if (FormatOpInit *I = RK.TheFormatOpInitPool.FindNodeOrInsertPos(ID, IP))
+    return I;
+
+  void *Mem = RK.Allocator.Allocate(totalSizeToAlloc<Init *>(Args.size()),
+                                    alignof(BitsInit));
+  FormatOpInit *I = new (Mem) FormatOpInit(Fmt, Args.size());
+
+  std::uninitialized_copy(Args.begin(), Args.end(),
+                          I->getTrailingObjects<Init *>());
+  RK.TheFormatOpInitPool.InsertNode(I, IP);
+  return I;
+}
+
+Init *FormatOpInit::Fold(Record *CurRec) const {
+  if (!isConcrete())
+    return const_cast<FormatOpInit *>(this);
+
+  if (auto *FmtStrInit = dyn_cast<StringInit>(Fmt)) {
+    std::string Res = FmtStrInit->getAsUnquotedString();
+    // Replace all placeholders with corresponding argment value.
+    for (unsigned I = 0; I < NumArgs; I++) {
+      auto *Arg = getArg(I);
+      // FIXME: This is a really simple string substitution. Shoule we make it
+      // just like std::format?
+      Res = replaceAll(Res, "{" + utostr(I) + "}", Arg->getAsUnquotedString());
+    }
+    return StringInit::get(getRecordKeeper(), Res, FmtStrInit->getFormat());
+  }
+  return const_cast<FormatOpInit *>(this);
+}
+
+Init *FormatOpInit::resolveReferences(Resolver &R) const {
+  bool Changed = false;
+  Init *NewFmt = Fmt->resolveReferences(R);
+  Changed |= NewFmt != Fmt;
+
+  SmallVector<Init *, 4> NewArgs;
+  for (auto *Arg : args()) {
+    Init *NewArg = Arg->resolveReferences(R);
+    NewArgs.push_back(NewArg);
+    Changed |= NewArg != Arg;
+  }
+
+  if (Changed)
+    return (FormatOpInit::get(NewFmt, NewArgs))->Fold(R.getCurrentRecord());
+
+  return const_cast<FormatOpInit *>(this);
+}
+
+bool FormatOpInit::isComplete() const {
+  for (auto *Arg : args())
+    if (!Arg->isComplete())
+      return false;
+  return Fmt->isComplete();
+}
+
+bool FormatOpInit::isConcrete() const {
+  for (auto *Arg : args())
+    if (!Arg->isConcrete())
+      return false;
+  return Fmt->isConcrete();
+}
+
+std::string FormatOpInit::getAsString() const {
+  std::string Result = "!format(";
+  Result += Fmt->getAsString();
+  for (auto *Arg : args())
+    Result += ", " + Arg->getAsString();
+  return Result + ")";
+}
+
+Init *FormatOpInit::getBit(unsigned Bit) const {
+  return VarBitInit::get(const_cast<FormatOpInit *>(this), Bit);
+}
+
 RecTy *TypedInit::getFieldType(StringInit *FieldName) const {
   if (RecordRecTy *RecordType = dyn_cast<RecordRecTy>(getType())) {
     for (Record *Rec : RecordType->getClasses()) {
       if (RecordVal *Field = Rec->getValue(FieldName))
         return Field->getType();
     }
   }
   return nullptr;

llvm/lib/TableGen/TGLexer.h

enum TokKind {
   XListRemove,
   XToLower,
   XToUpper,
   XRange,
   XGetDagArg,
   XGetDagName,
   XSetDagArg,
   XSetDagName,
+  XFormat,
 
   // Boolean literals.
   TrueVal,
   FalseVal,
 
   // Integer value.
   IntVal,
 

llvm/lib/TableGen/TGLexer.cpp

tgtok::TokKind Kind =
           .Cases("getdagop", "getop", tgtok::XGetDagOp) // !getop is deprecated.
           .Case("getdagarg", tgtok::XGetDagArg)
           .Case("getdagname", tgtok::XGetDagName)
           .Case("setdagarg", tgtok::XSetDagArg)
           .Case("setdagname", tgtok::XSetDagName)
           .Case("exists", tgtok::XExists)
           .Case("tolower", tgtok::XToLower)
           .Case("toupper", tgtok::XToUpper)
+          .Case("format", tgtok::XFormat)
           .Default(tgtok::Error);
 
   return Kind != tgtok::Error ? Kind : ReturnError(Start-1, "Unknown operator");
 }
 
 bool TGLexer::prepExitInclude(bool IncludeStackMustBeEmpty) {
   // Report an error, if preprocessor control stack for the current
   // file is not empty.

llvm/lib/TableGen/TGParser.cpp

case tgtok::XExists: {
     if (!consume(tgtok::r_paren)) {
       TokError("expected ')' in !exists");
       return nullptr;
     }
 
     return (ExistsOpInit::get(Type, Expr))->Fold(CurRec);
   }
 
+  case tgtok::XFormat: {
+    // Value ::= !format '(' fmt, args, ... ')'
+    Lex.Lex(); // eat the operation
+    if (!consume(tgtok::l_paren)) {
+      TokError("expected '(' after type of !format");
+      return nullptr;
+    }
+
+    SMLoc FmtLoc = Lex.getLoc();
+    Init *Fmt = ParseValue(CurRec);
+    if (!Fmt)
+      return nullptr;
+
+    TypedInit *FmtType = dyn_cast<TypedInit>(Fmt);
+    if (!FmtType) {
+      Error(FmtLoc, "expected a string value");
+      return nullptr;
+    }
+
+    StringRecTy *SType = dyn_cast<StringRecTy>(FmtType->getType());
+    if (!SType) {
+      Error(FmtLoc, "expected a string value");
+      return nullptr;
+    }
+
+    SmallVector<Init *, 2> Args;
+    while (!consume(tgtok::r_paren)) {
+      if (!consume(tgtok::comma)) {
+        TokError("expected ','");
+        return nullptr;
+      }
+      Init *Arg = ParseValue(CurRec);
+      Args.push_back(Arg);
+    }
+
+    return FormatOpInit::get(Fmt, Args)->Fold(CurRec);
+  }
+
   case tgtok::XConcat:
   case tgtok::XADD:
   case tgtok::XSUB:
   case tgtok::XMUL:
   case tgtok::XDIV:
   case tgtok::XAND:
   case tgtok::XOR:
   case tgtok::XXOR:
case tgtok::l_paren: {         // Value ::= '(' IDValue DagArgList ')'
     if (!consume(tgtok::r_paren)) {
       TokError("expected ')' in dag init");
       return nullptr;
     }
 
     return DagInit::get(Operator, OperatorName, DagArgs);
   }
 
+  case tgtok::XFormat:
   case tgtok::XHead:
   case tgtok::XTail:
   case tgtok::XSize:
   case tgtok::XEmpty:
   case tgtok::XCast:
   case tgtok::XToLower:
   case tgtok::XToUpper:
   case tgtok::XGetDagOp: // Value ::= !unop '(' Value ')'

llvm/test/TableGen/format.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
+
+class ClassType;
+def clz: ClassType;
+
+class BasicTest<bit bitValue, bits<5> bitsValue, int intValue,
+                string stringValue, code codeValue,
+                list<int> listValue, dag dagValue, ClassType classValue> {
+  string formatBit         = !format("{0}", bitValue);
+  string formatBits        = !format("{0}", bitsValue);
+  string formatInt         = !format("{0}", intValue);
+  string formatString      = !format("{0}", stringValue);
+  string formatCode        = !format("{0}", codeValue);
+  string formatList        = !format("{0}", listValue);
+  string formatDag         = !format("{0}", dagValue);
+  string formatClass       = !format("{0}", classValue);
+  string formatUnset       = !format("{0}", ?);
+  string formatMultiTimes  = !format("{0} {0}", 0);
+  string formatMultiArgs   = !format("{0} {1}", 0, 1);
+  string formatInterleave  = !format("{0} {1} {0}", 0, 1);
+  string formatNoArg       = !format("");
+  string formatLessArgs    = !format("{0} {1}", 0);
+  string formatMoreArgs    = !format("{0} {1}", 0, 1, 2);
+  string formatOperatorArg = !format("{0}", !if(bitValue, 1, 0));
+  string formatOperatorFmt = !format(!if(!not(bitValue), "{0} {1}", "{1} {0}"), 0, 1);
+  string formatPasteFmt    = !format("{" # "0" # "}", 0);
+  code   formatCodeFmt     = !format([{
+    int {0}() {return {1};}
+  }], "test", 2333);
+}
+
+// CHECK:      def test {
+// CHECK-NEXT:   string formatBit = "1";
+// CHECK-NEXT:   string formatBits = "{ 1, 1, 1, 1, 1 }";
+// CHECK-NEXT:   string formatInt = "255";
+// CHECK-NEXT:   string formatString = "1";
+// CHECK-NEXT:   string formatCode = "";
+// CHECK-NEXT:   string formatList = "[1]";
+// CHECK-NEXT:   string formatDag = "(test ?, ?)";
+// CHECK-NEXT:   string formatClass = "clz";
+// CHECK-NEXT:   string formatUnset = "?";
+// CHECK-NEXT:   string formatMultiTimes = "0 0";
+// CHECK-NEXT:   string formatMultiArgs = "0 1";
+// CHECK-NEXT:   string formatInterleave = "0 1 0";
+// CHECK-NEXT:   string formatNoArg = "";
+// CHECK-NEXT:   string formatLessArgs = "0 {1}";
+// CHECK-NEXT:   string formatMoreArgs = "0 1";
+// CHECK-NEXT:   string formatOperatorArg = "1";
+// CHECK-NEXT:   string formatOperatorFmt = "1 0";
+// CHECK-NEXT:   string formatPasteFmt = "0";
+// CHECK-NEXT:   code formatCodeFmt = [{
+// CHECK-NEXT:     int test() {return 2333;}
+// CHECK-NEXT:   }];
+// CHECK-NEXT: }
+def test: BasicTest<1, 0b11111, 0xFF, "1", [{}], [1], (test ?, ?), clz>;
+
+#ifdef ERROR1
+// ERROR1: error: expected a string value
+defvar error = !format(?)
+#endif
+
+#ifdef ERROR2
+// ERROR2: error: expected a string value
+defvar error = !format(1)
+#endif