[mlir][ods] Support string literals in `custom` directives

[Mogball]

Summary

This patch adds support for string literals as custom directive
arguments. This can be useful for re-using custom parsers and printers
when arguments have a known value. For example:

ParseResult parseTypedAttr(AsmParser &parser, Attribute &attr, Type type) {
  return parser.parseAttribute(attr, type);
}

void printTypedAttr(AsmPrinter &printer, Attribute attr, Type type) {
  return parser.printAttributeWithoutType(attr);
}

And in TableGen:

def FooOp : ... {
  let arguments = (ins AnyAttr:$a);
  let assemblyFormat = [{ custom<TypedAttr>($a, "$_builder.getI1Type()")
                          attr-dict }];
}

def BarOp : ... {
  let arguments = (ins AnyAttr:$a);
  let assemblyFormat = [{ custom<TypedAttr>($a, "$_builder.getIndexType()")
                          attr-dict }];
}

Instead of writing two separate sets of custom parsers and printers.

[rriddle]

How often does this come up in practice?

[Mogball]

custom directives can proliferate quite quickly when used a lot in op definitions. Eventually, this leads to a lot of duplication between the parsers and printers which often only differ by a line of code or two. Mixing in C++ is just a way to "parameterize" these custom parsers and printers to improve their reuse.

[rriddle]

I'm quite concerned on how unsafe/open this is. This is also missing docs.

[Mogball]

What do you mean by unsafe? I suppose there's nothing stopping people from trying to refer to whatever local variables they want, but trying this will lead to C++ compiler errors in most cases anyways because of type mismatches with the parser and printers.

[Mogball]

Update operation and attribute/type docs.

[Mogball]

rebase

[Mogball]

add test case

[lattner]

These seems helpful to cut down on the number of "near variants" of the same custom format. Jeff, it might help to adopt this in tree. One random example I noticed are the ones in ViewLikeInterface:

void mlir::printOperandsOrIntegersOffsetsOrStridesList(OpAsmPrinter &p,
                                                       Operation *op,
                                                       OperandRange values,
                                                       ArrayAttr integers) {
  return printOperandsOrIntegersListImpl<ShapedType::kDynamicStrideOrOffset>(
      p, values, integers);
}

void mlir::printOperandsOrIntegersSizesList(OpAsmPrinter &p, Operation *op,
                                            OperandRange values,
                                            ArrayAttr integers) {
  return printOperandsOrIntegersListImpl<ShapedType::kDynamicSize>(p, values,
                                                                   integers);
}

printOperandsOrIntegersListImpl btw has no need to be a template, it could take the enum as an argument.

[Mogball]

Good idea. I added a in-tree use where you suggested

[rriddle]

mlir/lib/Interfaces/ViewLikeInterface.cpp

73 ↗

(On Diff #451938)

Can we put this in a namespace or rename? The name here is a bit too general for something provided by an interface

mlir/test/mlir-tblgen/op-format.td

19

Can you add a test with escaped characters? e.g. an inner string or something?

[Mogball]

review comments

[mehdi_amini]

mlir/lib/Interfaces/ViewLikeInterface.cpp

167 ↗

(On Diff #452341)

I would prefer if we keep in two different revision the introduction of the ODS feature and the update of the codebase: changes to this file weren't necessary to be coupled I believe.
It makes it a bit harder to track changes through the commit list ("why is my existing custom<OperandsOrIntegersOffsetsOrStridesList> broken by a commit titled [mlir][ods] Support string literals in custom` directives`? Why when I git blame changes I end up with this huge diff?).

mlir/docs/AttributesAndTypes.md

 LogicalResult parseStringParam(AsmParser &parser,
                                FailureOr<std::string> &value);
 void printStringParam(AsmPrinter &printer, StringRef value);
 ```
 
 The custom parser is considered to have failed if it returns failure or if any
 bound parameters have failure values afterwards.
 
+A string of C++ code can be used as a `custom` directive argument. When
+generating the custom parser and printer call, the string is pasted as a
+function argument. For example, `parseBar` and `printBar` can be re-used with
+a constant integer:
+
+```tablegen
+let parameters = (ins "int":$bar);
+let assemblyFormat = [{ custom<Bar>($foo, "1") }];
+```
+
+The string is pasted verbatim but with substitutions for `$_builder` and
+`$_ctxt`. String literals can be used to parameterize custom directives.
+
 ### Verification
 
 If the `genVerifyDecl` field is set, additional verification methods are
 generated on the class.
 
 - `static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError, parameters...)`
 
 These methods are used to verify the parameters provided to the attribute or

mlir/docs/OpDefinitions.md

 ```
 
 A custom directive has two main parts: The `UserDirective` and the `Params`. A
 custom directive is transformed into a call to a `print*` and a `parse*` method
 when generating the C++ code for the format. The `UserDirective` is an
 identifier used as a suffix to these two calls, i.e., `custom<MyDirective>(...)`
 would result in calls to `parseMyDirective` and `printMyDirective` within the
 parser and printer respectively. `Params` may be any combination of variables
-(i.e. Attribute, Operand, Successor, etc.), type directives, and `attr-dict`.
-The type directives must refer to a variable, but that variable need not also be
-a parameter to the custom directive.
+(i.e. Attribute, Operand, Successor, etc.), type directives, `attr-dict`, and
+strings of C++ code. The type directives must refer to a variable, but that
+variable need not also be a parameter to the custom directive.
 
 The arguments to the `parse<UserDirective>` method are firstly a reference to
 the `OpAsmParser`(`OpAsmParser &`), and secondly a set of output parameters
 corresponding to the parameters specified in the format. The mapping of
 declarative parameter to `parse` method argument is detailed below:
 
 *   Attribute Variables
     -   Single: `<Attribute-Storage-Type>(e.g. Attribute) &`
*   Successor Variables
     -   Variadic: `SuccessorRange`
 *   Type Directives
     -   Single: `Type`
     -   Optional: `Type`
     -   Variadic: `TypeRange`
     -   VariadicOfVariadic: `TypeRangeRange`
 *   `attr-dict` Directive: `DictionaryAttr`
 
-When a variable is optional, the provided value may be null.
+When a variable is optional, the provided value may be null. When a variable is
+referenced in a custom directive parameter using `ref`, it is passed in by
+value. Referenced variables to `print<UserDirective>` are passed as the same as
+bound variables, but referenced variables to `parse<UserDirective>` are passed
+like to the printer.
+
+A custom directive can take a string of C++ code as a parameter. The code is
+pasted verbatim in the calls to the custom parser and printers, with the
+substitutions `$_builder` and `$_ctxt`. String literals can be used to
+parameterize custom directives.
 
 #### Optional Groups
 
 In certain situations operations may have "optional" information, e.g.
 attributes or an empty set of variadic operands. In these situations a section
 of the assembly format can be marked as `optional` based on the presence of this
 information. An optional group is defined as follows:
 
std::string stringifyMyBitEnum(MyBitEnum symbol) {
   assert(15u == (15u | val) && "invalid bits set in bit enum");
   // Special case for all bits unset.
   if (val == 0) return "None";
   llvm::SmallVector<llvm::StringRef, 2> strs;
   if (1u == (1u & val)) { strs.push_back("Bit0"); }
   if (2u == (2u & val)) { strs.push_back("Bit1"); }
   if (4u == (4u & val)) { strs.push_back("Bit2"); }
   if (8u == (8u & val)) { strs.push_back("Bit3"); }
-  
   return llvm::join(strs, "|");
 }
 
 llvm::Optional<MyBitEnum> symbolizeMyBitEnum(llvm::StringRef str) {
   // Special case for all bits unset.
   if (str == "None") return MyBitEnum::None;
 
   llvm::SmallVector<llvm::StringRef, 2> symbols;

mlir/test/mlir-tblgen/attr-or-type-format.td

def ConvertFromStorageParameter : TypeParameter<"int", ""> {
   let convertFromStorage = "static_cast<int>($_self)";
 }
 
 def TypeK : TestType<"TestM"> {
   let parameters = (ins ConvertFromStorageParameter:$a);
   let mnemonic = "type_k";
   let assemblyFormat = "$a";
 }
+
+// TYPE-LABEL: ::mlir::Type TestNType::parse
+// TYPE: parseFoo(
+// TYPE-NEXT: _result_a,
+// TYPE-NEXT: 1);
+
+// TYPE-LABEL: void TestNType::print
+// TYPE: printFoo(
+// TYPE-NEXT: getA(),
+// TYPE-NEXT: 1);
+
+def TypeL : TestType<"TestN"> {
+  let parameters = (ins "int":$a);
+  let mnemonic = "type_l";
+  let assemblyFormat = [{ custom<Foo>($a, "1") }];
+}

mlir/test/mlir-tblgen/op-format-invalid.td

def OptionalInvalidO : TestFormat_Op<[{
   ($arg^):(`test`
 }]>, Arguments<(ins Variadic<I64>:$arg)>;
 // CHECK: error: expected '?' after optional group
 def OptionalInvalidP : TestFormat_Op<[{
   ($arg^):(`test`)
 }]>, Arguments<(ins Variadic<I64>:$arg)>;
 
 //===----------------------------------------------------------------------===//
+// Strings
+//===----------------------------------------------------------------------===//
+
+// CHECK: error: strings may only be used as 'custom' directive arguments
+def StringInvalidA : TestFormat_Op<[{ "foo" }]>;
+
+//===----------------------------------------------------------------------===//
 // Variables
 //===----------------------------------------------------------------------===//
 
 // CHECK: error: expected variable to refer to an argument, region, result, or successor
 def VariableInvalidA : TestFormat_Op<[{
   $unknown_arg attr-dict
 }]>;
 // CHECK: error: attribute 'attr' is already bound

mlir/test/mlir-tblgen/op-format-spec.td

 //===----------------------------------------------------------------------===//
 
 // CHECK-NOT: error
 def OptionalValidA : TestFormat_Op<[{
   (` ` `` $arg^)? attr-dict
 }]>, Arguments<(ins Optional<I32>:$arg)>;
 
 //===----------------------------------------------------------------------===//
+// Strings
+//===----------------------------------------------------------------------===//
+
+// CHECK-NOT: error
+def StringInvalidA : TestFormat_Op<[{ custom<Foo>("foo") attr-dict }]>;
+
+//===----------------------------------------------------------------------===//
 // Variables
 //===----------------------------------------------------------------------===//
 
 // CHECK-NOT: error:
 def VariableValidA : TestFormat_Op<[{
   $attr `:` attr-dict
 }]>, Arguments<(ins OptionalAttr<I1Attr>:$attr)>;
 def VariableValidB : TestFormat_Op<[{

mlir/test/mlir-tblgen/op-format.td

+// RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s
+
+include "mlir/IR/OpBase.td"
+
+def TestDialect : Dialect {
+  let name = "test";
+}
+class TestFormat_Op<string fmt, list<Trait> traits = []>
+    : Op<TestDialect, "format_op", traits> {
+  let assemblyFormat = fmt;
+}
+
+//===----------------------------------------------------------------------===//
+// Directives
+//===----------------------------------------------------------------------===//
+
+//===----------------------------------------------------------------------===//
+// custom
+
+// CHECK-LABEL: CustomStringLiteralA::parse
+// CHECK: parseFoo({{.*}}, parser.getBuilder().getI1Type())
+// CHECK-LABEL: CustomStringLiteralA::print
+// CHECK: printFoo({{.*}}, parser.getBuilder().getI1Type())
+def CustomStringLiteralA : TestFormat_Op<[{
+  custom<Foo>("$_builder.getI1Type()") attr-dict
+}]>;
+
+// CHECK-LABEL: CustomStringLiteralB::parse
+// CHECK: parseFoo({{.*}}, IndexType::get(parser.getContext()))
+// CHECK-LABEL: CustomStringLiteralB::print
+// CHECK: printFoo({{.*}}, IndexType::get(parser.getContext()))
+def CustomStringLiteralB : TestFormat_Op<[{
+  custom<Foo>("IndexType::get($_ctxt)") attr-dict
+}]>;

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

void DefFormat::genCustomParser(CustomDirective *el, FmtContext &ctx,
   // Referenced variables are passed as `T`. The custom parser fails if it
   // returns failure or if any of the required parameters failed.
   os << tgfmt("auto odsCustomLoc = $_parser.getCurrentLocation();\n", &ctx);
   os << "(void)odsCustomLoc;\n";
   os << tgfmt("auto odsCustomResult = parse$0($_parser", &ctx, el->getName());
   os.indent();
   for (FormatElement *arg : el->getArguments()) {
     os << ",\n";
-    FormatElement *param;
-    if (auto *ref = dyn_cast<RefDirective>(arg)) {
-      os << "*";
-      param = ref->getArg();
-    } else {
-      param = arg;
-    }
-    os << "_result_" << cast<ParameterElement>(param)->getName();
+    if (auto *param = dyn_cast<ParameterElement>(arg))
+      os << "_result_" << param->getName();
+    else if (auto *ref = dyn_cast<RefDirective>(arg))
+      os << "*_result_" << cast<ParameterElement>(ref->getArg())->getName();
+    else
+      os << tgfmt(cast<StringElement>(arg)->getValue(), &ctx);
   }
   os.unindent() << ");\n";
   os << "if (::mlir::failed(odsCustomResult)) return {};\n";
   for (FormatElement *arg : el->getArguments()) {
     if (auto *param = dyn_cast<ParameterElement>(arg)) {
       if (param->isOptional())
         continue;
       os << formatv("if (::mlir::failed(_result_{0})) {{\n", param->getName());
genCommaSeparatedPrinter(
       });
 }
 
 void DefFormat::genCustomPrinter(CustomDirective *el, FmtContext &ctx,
                                  MethodBody &os) {
   os << tgfmt("print$0($_printer", &ctx, el->getName());
   os.indent();
   for (FormatElement *arg : el->getArguments()) {
-    FormatElement *param = arg;
-    if (auto *ref = dyn_cast<RefDirective>(arg))
-      param = ref->getArg();
-    os << ",\n"
-       << cast<ParameterElement>(param)->getParam().getAccessorName() << "()";
+    os << ",\n";
+    if (auto *param = dyn_cast<ParameterElement>(arg)) {
+      os << param->getParam().getAccessorName() << "()";
+    } else if (auto *ref = dyn_cast<RefDirective>(arg)) {
+      os << cast<ParameterElement>(ref->getArg())->getParam().getAccessorName()
+         << "()";
+    } else {
+      os << tgfmt(cast<StringElement>(arg)->getValue(), &ctx);
+    }
   }
   os.unindent() << ");\n";
 }
 
 void DefFormat::genOptionalGroupPrinter(OptionalElement *el, FmtContext &ctx,
                                         MethodBody &os) {
   FormatElement *anchor = el->getAnchor();
   if (auto *param = dyn_cast<ParameterElement>(anchor)) {

mlir/tools/mlir-tblgen/FormatGen.h

enum Kind {
     kw_successors,
     kw_type,
     keyword_end,
 
     // String valued tokens.
     identifier,
     literal,
     variable,
+    string,
   };
 
   FormatToken(Kind kind, StringRef spelling) : kind(kind), spelling(spelling) {}
 
   /// Return the bytes that make up this token.
   StringRef getSpelling() const { return spelling; }
 
   /// Return the kind of this token.
public:
   FormatToken emitError(const char *loc, const Twine &msg);
 
   FormatToken emitErrorAndNote(SMLoc loc, const Twine &msg, const Twine &note);
 
 private:
   /// Return the next character in the stream.
   int getNextChar();
 
-  /// Lex an identifier, literal, or variable.
+  /// Lex an identifier, literal, variable, or string.
   FormatToken lexIdentifier(const char *tokStart);
   FormatToken lexLiteral(const char *tokStart);
   FormatToken lexVariable(const char *tokStart);
+  FormatToken lexString(const char *tokStart);
 
   /// Create a token with the current pointer and a start pointer.
   FormatToken formToken(FormatToken::Kind kind, const char *tokStart) {
     return FormatToken(kind, StringRef(tokStart, curPtr - tokStart));
   }
 
   /// The source manager containing the format string.
   llvm::SourceMgr &mgr;

 ///
 /// If you squint and take a close look, you can see the outline of a `Format`
 /// dialect.
 class FormatElement {
 public:
   virtual ~FormatElement();
 
   // The top-level kinds of format elements.
-  enum Kind { Literal, Variable, Whitespace, Directive, Optional };
+  enum Kind { Literal, String, Variable, Whitespace, Directive, Optional };
 
   /// Support LLVM-style RTTI.
   static bool classof(const FormatElement *el) { return true; }
 
   /// Get the element kind.
   Kind getKind() const { return kind; }
 
 protected:
public:
   StringRef getSpelling() const { return spelling; }
 
 private:
   /// The spelling of the variable, i.e. the string contained within the
   /// backticks.
   StringRef spelling;
 };
 
+/// This class represents a raw string that can contain arbitrary C++ code.
+class StringElement : public FormatElementBase<FormatElement::String> {
+public:
+  /// Create a string element with the given contents.
+  explicit StringElement(StringRef value) : value(value) {}
+
+  /// Get the value of the string element.
+  StringRef getValue() const { return value; }
+
+private:
+  /// The contents of the string.
+  StringRef value;
+};
+
 /// This class represents a variable element. A variable refers to some part of
 /// the object being parsed, e.g. an attribute or operand on an operation or a
 /// parameter on an attribute.
 class VariableElement : public FormatElementBase<FormatElement::Variable> {
 public:
   /// These are the kinds of variables.
   enum Kind { Attribute, Operand, Region, Result, Successor, Parameter };
 
protected:
 
   //===--------------------------------------------------------------------===//
   // Element Parsing
 
   /// Parse a single element of any kind.
   FailureOr<FormatElement *> parseElement(Context ctx);
   /// Parse a literal.
   FailureOr<FormatElement *> parseLiteral(Context ctx);
+  /// Parse a string.
+  FailureOr<FormatElement *> parseString(Context ctx);
   /// Parse a variable.
   FailureOr<FormatElement *> parseVariable(Context ctx);
   /// Parse a directive.
   FailureOr<FormatElement *> parseDirective(Context ctx);
   /// Parse an optional group.
   FailureOr<FormatElement *> parseOptionalGroup(Context ctx);
 
   /// Parse a custom directive.

mlir/tools/mlir-tblgen/FormatGen.cpp

FormatToken FormatLexer::lexToken() {
   case '\t':
   case '\n':
     return lexToken();
 
   case '`':
     return lexLiteral(tokStart);
   case '$':
     return lexVariable(tokStart);
+  case '"':
+    return lexString(tokStart);
   }
 }
 
 FormatToken FormatLexer::lexLiteral(const char *tokStart) {
   assert(curPtr[-1] == '`');
 
   // Lex a literal surrounded by ``.
   while (const char curChar = *curPtr++) {
     if (curChar == '`')
       return formToken(FormatToken::literal, tokStart);
   }
   return emitError(curPtr - 1, "unexpected end of file in literal");
 }
 
 FormatToken FormatLexer::lexVariable(const char *tokStart) {
   if (!isalpha(curPtr[0]) && curPtr[0] != '_')
     return emitError(curPtr - 1, "expected variable name");
 
   // Otherwise, consume the rest of the characters.
   while (isalnum(*curPtr) || *curPtr == '_')
     ++curPtr;
   return formToken(FormatToken::variable, tokStart);
 }
 
+FormatToken FormatLexer::lexString(const char *tokStart) {
+  // Lex until another quote, respecting escapes.
+  bool escape = false;
+  while (const char curChar = *curPtr++) {
+    if (!escape && curChar == '"')
+      return formToken(FormatToken::string, tokStart);
+    escape = curChar == '\\';
+  }
+  return emitError(curPtr - 1, "unexpected end of file in string");
+}
+
 FormatToken FormatLexer::lexIdentifier(const char *tokStart) {
   // Match the rest of the identifier regex: [0-9a-zA-Z_\-]*
   while (isalnum(*curPtr) || *curPtr == '_' || *curPtr == '-')
     ++curPtr;
 
   // Check to see if this identifier is a keyword.
   StringRef str(tokStart, curPtr - tokStart);
   auto kind =

 }
 
 //===----------------------------------------------------------------------===//
 // Element Parsing
 
 FailureOr<FormatElement *> FormatParser::parseElement(Context ctx) {
   if (curToken.is(FormatToken::literal))
     return parseLiteral(ctx);
+  if (curToken.is(FormatToken::string))
+    return parseString(ctx);
   if (curToken.is(FormatToken::variable))
     return parseVariable(ctx);
   if (curToken.isKeyword())
     return parseDirective(ctx);
   if (curToken.is(FormatToken::l_paren))
     return parseOptionalGroup(ctx);
   return emitError(curToken.getLoc(),
                    "expected literal, variable, directive, or optional group");
FailureOr<FormatElement *> FormatParser::parseLiteral(Context ctx) {
   if (!isValidLiteral(value, [&](Twine msg) {
         (void)emitError(loc, "expected valid literal but got '" + value +
                                  "': " + msg);
       }))
     return failure();
   return create<LiteralElement>(value);
 }
 
+FailureOr<FormatElement *> FormatParser::parseString(Context ctx) {
+  FormatToken tok = curToken;
+  SMLoc loc = tok.getLoc();
+  consumeToken();
+
+  if (ctx != CustomDirectiveContext) {
+    return emitError(
+        loc, "strings may only be used as 'custom' directive arguments");
+  }
+  return create<StringElement>(tok.getSpelling().drop_front().drop_back());
+}
+
 FailureOr<FormatElement *> FormatParser::parseVariable(Context ctx) {
   FormatToken tok = curToken;
   SMLoc loc = tok.getLoc();
   consumeToken();
 
   // Get the name of the variable without the leading `$`.
   StringRef name = tok.getSpelling().drop_front();
   return parseVariableImpl(loc, name, ctx);

mlir/tools/mlir-tblgen/OpFormatGen.cpp

if (auto *attr = dyn_cast<AttributeVariable>(param)) {
     if (lengthKind == ArgumentLengthKind::VariadicOfVariadic)
       body << llvm::formatv("{0}TypeGroups", listName);
     else if (lengthKind == ArgumentLengthKind::Variadic)
       body << llvm::formatv("{0}Types", listName);
     else if (lengthKind == ArgumentLengthKind::Optional)
       body << llvm::formatv("{0}Type", listName);
     else
       body << formatv("{0}RawTypes[0]", listName);
+
+  } else if (auto *string = dyn_cast<StringElement>(param)) {
+    FmtContext ctx;
+    ctx.withBuilder("parser.getBuilder()");
+    ctx.addSubst("_ctxt", "parser.getContext()");
+    body << tgfmt(string->getValue(), &ctx);
+
   } else {
     llvm_unreachable("unknown custom directive parameter");
   }
 }
 
 /// Generate the parser for a custom directive.
 static void genCustomDirectiveParser(CustomDirective *dir, MethodBody &body) {
   body << "  {\n";
auto *var = operand ? operand->getVar()
                         : cast<ResultVariable>(typeOperand)->getVar();
     std::string name = op.getGetterName(var->name);
     if (var->isVariadic())
       body << name << "().getTypes()";
     else if (var->isOptional())
       body << llvm::formatv("({0}() ? {0}().getType() : Type())", name);
     else
       body << name << "().getType()";
+
+  } else if (auto *string = dyn_cast<StringElement>(element)) {
+    FmtContext ctx;
+    ctx.withBuilder("parser.getBuilder()");
+    ctx.addSubst("_ctxt", "parser.getContext()");
+    body << tgfmt(string->getValue(), &ctx);
+
   } else {
     llvm_unreachable("unknown custom directive parameter");
   }
 }
 
 /// Generate the printer for a custom directive.
 static void genCustomDirectivePrinter(CustomDirective *customDir,
                                       const Operator &op, MethodBody &body) {
OpFormatParser::parseAttrDictDirective(SMLoc loc, Context context,
   }
 
   return create<AttrDictDirective>(withKeyword);
 }
 
 LogicalResult OpFormatParser::verifyCustomDirectiveArguments(
     SMLoc loc, ArrayRef<FormatElement *> arguments) {
   for (FormatElement *argument : arguments) {
-    if (!isa<RefDirective, TypeDirective, AttrDictDirective, AttributeVariable,
-             OperandVariable, RegionVariable, SuccessorVariable>(argument)) {
+    if (!isa<StringElement, RefDirective, TypeDirective, AttrDictDirective,
+             AttributeVariable, OperandVariable, RegionVariable,
+             SuccessorVariable>(argument)) {
       // TODO: FormatElement should have location info attached.
       return emitError(loc, "only variables and types may be used as "
                             "parameters to a custom directive");
     }
     if (auto *type = dyn_cast<TypeDirective>(argument)) {
       if (!isa<OperandVariable, ResultVariable>(type->getArg())) {
         return emitError(loc, "type directives within a custom directive may "
                               "only refer to variables");