[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

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

18

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

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/include/mlir/Dialect/Linalg/IR/LinalgOps.td

def Linalg_InitTensorOp : Linalg_Op<"init_tensor",
   }];
 
   let arguments =
     (ins Variadic<Index>:$sizes, I64ArrayAttr:$static_sizes);
 
   let results = (outs AnyTensor:$result);
 
   let assemblyFormat = [{
-    custom<OperandsOrIntegersSizesList>($sizes, $static_sizes) attr-dict
-    `:` type($result)
+    custom<OperandsOrIntegers>($sizes, $static_sizes,
+                               "ShapedType::kDynamicSize")
+    attr-dict `:` type($result)
   }];
 
   let extraClassDeclaration = [{
     static StringRef getStaticSizesAttrStrName() {
       return "static_sizes";
     }
 
     RankedTensorType getType() {

mlir/include/mlir/Dialect/MemRef/IR/MemRefOps.td

let arguments = (ins Arg<AnyRankedOrUnrankedMemRef, "", []>:$source,
                        Variadic<Index>:$strides,
                        I64ArrayAttr:$static_offsets,
                        I64ArrayAttr:$static_sizes,
                        I64ArrayAttr:$static_strides);
   let results = (outs AnyMemRef:$result);
 
   let assemblyFormat = [{
     $source `to` `offset` `` `:`
-    custom<OperandsOrIntegersOffsetsOrStridesList>($offsets, $static_offsets)
+    custom<OperandsOrIntegers>($offsets, $static_offsets,
+                               "ShapedType::kDynamicStrideOrOffset")
     `` `,` `sizes` `` `:`
-    custom<OperandsOrIntegersSizesList>($sizes, $static_sizes) `` `,` `strides`
-    `` `:`
-    custom<OperandsOrIntegersOffsetsOrStridesList>($strides, $static_strides)
+    custom<OperandsOrIntegers>($sizes, $static_sizes,
+                               "ShapedType::kDynamicSize")
+    `` `,` `strides` `` `:`
+    custom<OperandsOrIntegers>($strides, $static_strides,
+                               "ShapedType::kDynamicStrideOrOffset")
     attr-dict `:` type($source) `to` type($result)
   }];
 
   let hasVerifier = 1;
 
   let builders = [
     // Build a ReinterpretCastOp with mixed static and dynamic entries.
     OpBuilder<(ins "MemRefType":$resultType, "Value":$source,
let arguments = (ins AnyMemRef:$source,
                        Variadic<Index>:$strides,
                        I64ArrayAttr:$static_offsets,
                        I64ArrayAttr:$static_sizes,
                        I64ArrayAttr:$static_strides);
   let results = (outs AnyMemRef:$result);
 
   let assemblyFormat = [{
     $source ``
-    custom<OperandsOrIntegersOffsetsOrStridesList>($offsets, $static_offsets)
-    custom<OperandsOrIntegersSizesList>($sizes, $static_sizes)
-    custom<OperandsOrIntegersOffsetsOrStridesList>($strides, $static_strides)
+    custom<OperandsOrIntegers>($offsets, $static_offsets,
+                               "ShapedType::kDynamicStrideOrOffset")
+    custom<OperandsOrIntegers>($sizes, $static_sizes,
+                               "ShapedType::kDynamicSize")
+    custom<OperandsOrIntegers>($strides, $static_strides,
+                               "ShapedType::kDynamicStrideOrOffset")
     attr-dict `:` type($source) `to` type($result)
   }];
 
   let builders = [
     // Build a SubViewOp with mixed static and dynamic entries and custom
     // result type. If the type passed is nullptr, it is inferred.
     OpBuilder<(ins "Value":$source, "ArrayRef<OpFoldResult>":$offsets,
       "ArrayRef<OpFoldResult>":$sizes, "ArrayRef<OpFoldResult>":$strides,

mlir/include/mlir/Dialect/Tensor/IR/TensorOps.td

let description = [{
     Verification vs Inference in the rank-reduced case:
     ===================================================
     Note that there may be multiple ways to infer a resulting rank-reduced type.
       e.g. 1x6x1 could potentially rank-reduce to either 1x6 or 6x1 2-D shapes.
 
     To disambiguate, the inference helpers `inferCanonicalRankReducedResultType`
     only drop the first unit dimensions, in order:
       e.g. 1x6x1 rank-reduced to 2-D will infer the 6x1 2-D shape, but not 1x6.
-    
     Verification however has access to result type and does not need to infer.
-    The verifier calls `isRankReducedType(getSource(), getResult())` to 
+    The verifier calls `isRankReducedType(getSource(), getResult())` to
     determine whether the result type is rank-reduced from the source type.
-    This computes a so-called rank-reduction mask, consisting of dropped unit 
+    This computes a so-called rank-reduction mask, consisting of dropped unit
     dims, to map the rank-reduced type to the source type by dropping ones:
       e.g. 1x6 is a rank-reduced version of 1x6x1 by mask {2}
            6x1 is a rank-reduced version of 1x6x1 by mask {0}
            1x2x1x4 is a rank-reduced version of 1x1x2x1x1x4x1 by mask {1, 4, 6}
              (remaining common 1 dimensions are matched eagerly)
 
     Example:
 
let arguments = (ins
     I64ArrayAttr:$static_offsets,
     I64ArrayAttr:$static_sizes,
     I64ArrayAttr:$static_strides
   );
   let results = (outs AnyRankedTensor:$result);
 
   let assemblyFormat = [{
     $source ``
-    custom<OperandsOrIntegersOffsetsOrStridesList>($offsets, $static_offsets)
-    custom<OperandsOrIntegersSizesList>($sizes, $static_sizes)
-    custom<OperandsOrIntegersOffsetsOrStridesList>($strides, $static_strides)
+    custom<OperandsOrIntegers>($offsets, $static_offsets,
+                               "ShapedType::kDynamicStrideOrOffset")
+    custom<OperandsOrIntegers>($sizes, $static_sizes,
+                               "ShapedType::kDynamicSize")
+    custom<OperandsOrIntegers>($strides, $static_strides,
+                               "ShapedType::kDynamicStrideOrOffset")
     attr-dict `:` type($source) `to` type($result)
   }];
 
   let builders = [
     // Build an ExtractSliceOp with mixed static and dynamic entries and
     // inferred result type.
     OpBuilder<(ins "Value":$source, "ArrayRef<OpFoldResult>":$offsets,
       "ArrayRef<OpFoldResult>":$sizes, "ArrayRef<OpFoldResult>":$strides,
let extraClassDeclaration = extraBaseClassDeclaration # [{
     RankedTensorType getType() {
       return getResult().getType().cast<RankedTensorType>();
     }
 
     /// Compute the rank-reduction mask that can be applied to map the source
     /// tensor type to the result tensor type by dropping unit dims.
     llvm::Optional<llvm::SmallDenseSet<unsigned>>
     computeRankReductionMask() {
-      return ::mlir::computeRankReductionMask(getSourceType().getShape(), 
+      return ::mlir::computeRankReductionMask(getSourceType().getShape(),
                                               getType().getShape());
     };
 
     /// An extract_slice result type can be inferred, when it is not
-    /// rank-reduced, from the source type and the static representation of 
+    /// rank-reduced, from the source type and the static representation of
     /// offsets, sizes and strides. Special sentinels encode the dynamic case.
     static RankedTensorType inferResultType(
       ShapedType sourceShapedTensorType,
       ArrayRef<int64_t> staticOffsets,
       ArrayRef<int64_t> staticSizes,
       ArrayRef<int64_t> staticStrides);
     static RankedTensorType inferResultType(
       ShapedType sourceShapedTensorType,
let arguments = (ins
     I64ArrayAttr:$static_offsets,
     I64ArrayAttr:$static_sizes,
     I64ArrayAttr:$static_strides
   );
   let results = (outs AnyRankedTensor:$result);
 
   let assemblyFormat = [{
     $source `into` $dest ``
-    custom<OperandsOrIntegersOffsetsOrStridesList>($offsets, $static_offsets)
-    custom<OperandsOrIntegersSizesList>($sizes, $static_sizes)
-    custom<OperandsOrIntegersOffsetsOrStridesList>($strides, $static_strides)
+    custom<OperandsOrIntegers>($offsets, $static_offsets,
+                               "ShapedType::kDynamicStrideOrOffset")
+    custom<OperandsOrIntegers>($sizes, $static_sizes,
+                               "ShapedType::kDynamicSize")
+    custom<OperandsOrIntegers>($strides, $static_strides,
+                               "ShapedType::kDynamicStrideOrOffset")
     attr-dict `:` type($source) `into` type($dest)
   }];
 
   let builders = [
     // Build a InsertSliceOp with mixed static and dynamic entries.
     OpBuilder<(ins "Value":$source, "Value":$dest,
       "ArrayRef<OpFoldResult>":$offsets, "ArrayRef<OpFoldResult>":$sizes,
       "ArrayRef<OpFoldResult>":$strides,
let extraClassDeclaration = extraBaseClassDeclaration # [{
     RankedTensorType getSourceType() {
       return getSource().getType().cast<RankedTensorType>();
     }
 
     /// The result of a insert_slice is always a tensor.
     RankedTensorType getType() {
       return getResult().getType().cast<RankedTensorType>();
     }
-    
     /// The `dest` type is the same as the result type.
     RankedTensorType getDestType() {
       return getType();
     }
 
     /// Return the expected rank of each of the`static_offsets`, `static_sizes`
     /// and `static_strides` attributes.
     std::array<unsigned, 3> getArrayAttrMaxRanks() {
def Tensor_PadOp : Tensor_Op<"pad", [AttrSizedOperandSegments, NoSideEffect,
   let regions = (region SizedRegion<1>:$region);
 
   let results = (outs AnyTensor:$result);
 
   // TODO: Remove custom<InferType> when AllTypesMatch supports opt. operands.
   let assemblyFormat = [{
     $source
     (`nofold` $nofold^)?
-    `low` `` custom<OperandsOrIntegersSizesList>($low, $static_low)
-    `high` `` custom<OperandsOrIntegersSizesList>($high, $static_high)
+    `low` `` custom<OperandsOrIntegers>($low, $static_low,
+                                        "ShapedType::kDynamicSize")
+    `high` `` custom<OperandsOrIntegers>($high, $static_high,
+                                         "ShapedType::kDynamicSize")
     $region attr-dict `:` type($source) `to` type($result)
   }];
 
   let extraClassDeclaration = [{
     static StringRef getStaticLowAttrStrName() {
       return "static_low";
     }
 

 // TODO: Implement PerformConcurrentlyOpInterface.
 def Tensor_ParallelInsertSliceOp : Tensor_Op<"parallel_insert_slice", [
        AttrSizedOperandSegments,
        OffsetSizeAndStrideOpInterface,
        // TODO: Cannot use an interface here atm, verify this manually for now.
        // HasParent<"ParallelCombiningOpInterface">
   ]> {
   let summary = [{
-    Specify the tensor slice update of a single thread of a parent 
+    Specify the tensor slice update of a single thread of a parent
     ParallelCombiningOpInterface op.
   }];
   let description = [{
-    The `parallel_insert_slice` yields a subset tensor value to its parent 
+    The `parallel_insert_slice` yields a subset tensor value to its parent
     ParallelCombiningOpInterface. These subset tensor values are aggregated to
-    in some unspecified order into a full tensor value returned by the parent 
-    parallel iterating op. 
-    The `parallel_insert_slice` is one such op allowed in the 
+    in some unspecified order into a full tensor value returned by the parent
+    parallel iterating op.
+    The `parallel_insert_slice` is one such op allowed in the
     ParallelCombiningOpInterface op.
 
     Conflicting writes result in undefined semantics, in that the indices written
     to by multiple parallel updates might contain data from any of the updates,
     or even a malformed bit pattern.
 
     If an index is updated exactly once, the value contained at that index
     in the resulting tensor will be equal to the value at a corresponding index
let description = [{
     sentinel value ShapedType::kDynamicSize and
     ShapedType::kDynamicStrideOrOffset encodes that the corresponding entry has
     a dynamic value.
 
     After buffer allocation, the "parallel_insert_slice" op is expected to lower
     into a memref.subview op.
 
     A parallel_insert_slice operation may additionally specify insertion into a
-    tensor of higher rank than the source tensor, along dimensions that are 
+    tensor of higher rank than the source tensor, along dimensions that are
     statically known to be of size 1.
     This rank-altering behavior is not required by the op semantics: this
     flexibility allows to progressively drop unit dimensions while lowering
     between different flavors of ops on that operate on tensors.
-    The rank-altering behavior of tensor.parallel_insert_slice matches the 
+    The rank-altering behavior of tensor.parallel_insert_slice matches the
     rank-reducing behavior of tensor.insert_slice and tensor.extract_slice.
 
     Verification in the rank-reduced case:
     ======================================
     The same verification discussion and mechanisms apply as for ExtractSliceOp.
     Unlike ExtractSliceOp however, there is no need for a specific inference.
   }];
 
   let arguments = (ins
     AnyRankedTensor:$source,
     AnyRankedTensor:$dest,
     Variadic<Index>:$offsets,
     Variadic<Index>:$sizes,
     Variadic<Index>:$strides,
     I64ArrayAttr:$static_offsets,
     I64ArrayAttr:$static_sizes,
     I64ArrayAttr:$static_strides
   );
   let assemblyFormat = [{
     $source `into` $dest ``
-    custom<OperandsOrIntegersOffsetsOrStridesList>($offsets, $static_offsets)
-    custom<OperandsOrIntegersSizesList>($sizes, $static_sizes)
-    custom<OperandsOrIntegersOffsetsOrStridesList>($strides, $static_strides)
+    custom<OperandsOrIntegers>($offsets, $static_offsets,
+                               "ShapedType::kDynamicStrideOrOffset")
+    custom<OperandsOrIntegers>($sizes, $static_sizes,
+                               "ShapedType::kDynamicSize")
+    custom<OperandsOrIntegers>($strides, $static_strides,
+                               "ShapedType::kDynamicStrideOrOffset")
     attr-dict `:` type($source) `into` type($dest)
   }];
 
   let extraClassDeclaration = [{
     Type yieldedType() { return getDest().getType(); }
 
     RankedTensorType getSourceType() {
       return getSource().getType().cast<RankedTensorType>();
OpBuilder<(ins "Value":$source, "Value":$dest,
       "ArrayRef<OpFoldResult>":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
 
     // Build a ParallelInsertSliceOp with dynamic entries.
     OpBuilder<(ins "Value":$source, "Value":$dest,
       "ValueRange":$offsets, "ValueRange":$sizes, "ValueRange":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
   ];
-  
   let hasCanonicalizer = 1;
   let hasFolder = 1;
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // SplatOp
 //===----------------------------------------------------------------------===//

mlir/include/mlir/Interfaces/ViewLikeInterface.h

 
 /// Include the generated interface declarations.
 #include "mlir/Interfaces/ViewLikeInterface.h.inc"
 
 namespace mlir {
 
 /// Printer hook for custom directive in assemblyFormat.
 ///
-///   custom<OperandsOrIntegersOffsetsOrStridesList>($values, $integers)
+///   custom<OperandsOrIntegers>($values, $integers)
 ///
 /// where `values` is of ODS type `Variadic<Index>` and `integers` is of ODS
-/// type `I64ArrayAttr`.  for use in in assemblyFormat. Prints a list with
-/// either (1) the static integer value in `integers` if the value is
-/// ShapedType::kDynamicStrideOrOffset or (2) the next value otherwise.  This
-/// allows idiomatic printing of mixed value and integer attributes in a
-/// list. E.g. `[%arg0, 7, 42, %arg42]`.
-void printOperandsOrIntegersOffsetsOrStridesList(OpAsmPrinter &printer,
-                                                 Operation *op,
-                                                 OperandRange values,
-                                                 ArrayAttr integers);
-
-/// Printer hook for custom directive in assemblyFormat.
-///
-///   custom<OperandsOrIntegersSizesList>($values, $integers)
-///
-/// where `values` is of ODS type `Variadic<Index>` and `integers` is of ODS
-/// type `I64ArrayAttr`.  for use in in assemblyFormat. Prints a list with
-/// either (1) the static integer value in `integers` if the value is
-/// ShapedType::kDynamicSize or (2) the next value otherwise.  This
-/// allows idiomatic printing of mixed value and integer attributes in a
-/// list. E.g. `[%arg0, 7, 42, %arg42]`.
-void printOperandsOrIntegersSizesList(OpAsmPrinter &printer, Operation *op,
-                                      OperandRange values, ArrayAttr integers);
-
-/// Pasrer hook for custom directive in assemblyFormat.
-///
-///   custom<OperandsOrIntegersOffsetsOrStridesList>($values, $integers)
-///
-/// where `values` is of ODS type `Variadic<Index>` and `integers` is of ODS
-/// type `I64ArrayAttr`.  for use in in assemblyFormat. Parse a mixed list with
-/// either (1) static integer values or (2) SSA values.  Fill `integers` with
-/// the integer ArrayAttr, where ShapedType::kDynamicStrideOrOffset encodes the
-/// position of SSA values. Add the parsed SSA values to `values` in-order.
-//
-/// E.g. after parsing "[%arg0, 7, 42, %arg42]":
-///   1. `result` is filled with the i64 ArrayAttr "[`dynVal`, 7, 42, `dynVal`]"
-///   2. `ssa` is filled with "[%arg0, %arg1]".
-ParseResult parseOperandsOrIntegersOffsetsOrStridesList(
-    OpAsmParser &parser,
-    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &values,
-    ArrayAttr &integers);
+/// type `I64ArrayAttr`. Prints a list with either (1) the static integer value
+/// in `integers` is `dynVal` or (2) the next value otherwise. This allows
+/// idiomatic printing of mixed value and integer attributes in a list. E.g.
+/// `[%arg0, 7, 42, %arg42]`.
+void printOperandsOrIntegers(OpAsmPrinter &printer, Operation *op,
+                             OperandRange values, ArrayAttr integers,
+                             int64_t dynVal);
 
 /// Pasrer hook for custom directive in assemblyFormat.
 ///
-///   custom<OperandsOrIntegersSizesList>($values, $integers)
+///   custom<OperandsOrIntegers>($values, $integers)
 ///
 /// where `values` is of ODS type `Variadic<Index>` and `integers` is of ODS
-/// type `I64ArrayAttr`.  for use in in assemblyFormat. Parse a mixed list with
-/// either (1) static integer values or (2) SSA values.  Fill `integers` with
-/// the integer ArrayAttr, where ShapedType::kDynamicSize encodes the
-/// position of SSA values. Add the parsed SSA values to `values` in-order.
+/// type `I64ArrayAttr`. Parse a mixed list with either (1) static integer
+/// values or (2) SSA values. Fill `integers` with the integer ArrayAttr, where
+/// `dynVal` encodes the position of SSA values. Add the parsed SSA values
+/// to `values` in-order.
 //
 /// E.g. after parsing "[%arg0, 7, 42, %arg42]":
 ///   1. `result` is filled with the i64 ArrayAttr "[`dynVal`, 7, 42, `dynVal`]"
 ///   2. `ssa` is filled with "[%arg0, %arg1]".
-ParseResult parseOperandsOrIntegersSizesList(
-    OpAsmParser &parser,
+ParseResult
+parseOperandsOrIntegers(OpAsmParser &parser,
                         SmallVectorImpl<OpAsmParser::UnresolvedOperand> &values,
-    ArrayAttr &integers);
+                        ArrayAttr &integers, int64_t dynVal);
 
 /// Verify that a the `values` has as many elements as the number of entries in
 /// `attr` for which `isDynamic` evaluates to true.
 LogicalResult verifyListOfOperandsOrIntegers(
     Operation *op, StringRef name, unsigned expectedNumElements, ArrayAttr attr,
-    ValueRange values, llvm::function_ref<bool(int64_t)> isDynamic);
+    ValueRange values, function_ref<bool(int64_t)> isDynamic);
 
 } // namespace mlir
 
 #endif // MLIR_INTERFACES_VIEWLIKEINTERFACE_H_

mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp

 ParseResult transform::TileOp::parse(OpAsmParser &parser,
                                      OperationState &result) {
   OpAsmParser::UnresolvedOperand target;
   SmallVector<OpAsmParser::UnresolvedOperand> dynamicSizes;
   ArrayAttr staticSizes;
   auto pdlOperationType = pdl::OperationType::get(parser.getContext());
   if (parser.parseOperand(target) ||
       parser.resolveOperand(target, pdlOperationType, result.operands) ||
-      parseOperandsOrIntegersSizesList(parser, dynamicSizes, staticSizes) ||
+      parseOperandsOrIntegers(parser, dynamicSizes, staticSizes,
+                              ShapedType::kDynamicSize) ||
       parser.resolveOperands(dynamicSizes, pdlOperationType, result.operands) ||
       parser.parseOptionalAttrDict(result.attributes))
     return ParseResult::failure();
 
   result.addAttribute(getStaticSizesAttrName(result.name), staticSizes);
   size_t numExpectedLoops =
       staticSizes.size() - llvm::count(extractFromI64ArrayAttr(staticSizes), 0);
   result.addTypes(SmallVector<Type>(numExpectedLoops + 1, pdlOperationType));
   return success();
 }
 
 void TileOp::print(OpAsmPrinter &p) {
   p << ' ' << getTarget();
-  printOperandsOrIntegersSizesList(p, getOperation(), getDynamicSizes(),
-                                   getStaticSizes());
+  printOperandsOrIntegers(p, getOperation(), getDynamicSizes(),
+                          getStaticSizes(), ShapedType::kDynamicSize);
   p.printOptionalAttrDict((*this)->getAttrs(), {getStaticSizesAttrName()});
 }
 
 void transform::TileOp::getEffects(
     SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
   consumesHandle(getTarget(), effects);
   onlyReadsHandle(getDynamicSizes(), effects);
   producesHandle(getTiledLinalgOp(), effects);

mlir/lib/Interfaces/ViewLikeInterface.cpp

if (failed(verifyListOfOperandsOrIntegers(op, "size", maxRanks[1],
     return failure();
   if (failed(verifyListOfOperandsOrIntegers(
           op, "stride", maxRanks[2], op.static_strides(), op.strides(),
           ShapedType::isDynamicStrideOrOffset)))
     return failure();
   return success();
 }
 
-template <int64_t dynVal>
-static void printOperandsOrIntegersListImpl(OpAsmPrinter &p, ValueRange values,
-                                            ArrayAttr arrayAttr) {
-  p << '[';
-  if (arrayAttr.empty()) {
-    p << "]";
+void mlir::printOperandsOrIntegers(OpAsmPrinter &printer, Operation *op,
+                                   OperandRange values, ArrayAttr integers,
+                                   int64_t dynVal) {
+  printer << '[';
+  if (integers.empty()) {
+    printer << "]";
     return;
   }
   unsigned idx = 0;
-  llvm::interleaveComma(arrayAttr, p, [&](Attribute a) {
+  llvm::interleaveComma(integers, printer, [&](Attribute a) {
     int64_t val = a.cast<IntegerAttr>().getInt();
     if (val == dynVal)
-      p << values[idx++];
+      printer << values[idx++];
     else
-      p << val;
+      printer << val;
   });
-  p << ']';
+  printer << ']';
 }
 
-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);
-}
-
-template <int64_t dynVal>
-static ParseResult parseOperandsOrIntegersImpl(
+ParseResult mlir::parseOperandsOrIntegers(
     OpAsmParser &parser,
     SmallVectorImpl<OpAsmParser::UnresolvedOperand> &values,
-    ArrayAttr &integers) {
+    ArrayAttr &integers, int64_t dynVal) {
   if (failed(parser.parseLSquare()))
     return failure();
   // 0-D.
   if (succeeded(parser.parseOptionalRSquare())) {
     integers = parser.getBuilder().getArrayAttr({});
     return success();
   }
 
while (true) {
     if (failed(parser.parseRSquare()))
       return failure();
     break;
   }
   integers = parser.getBuilder().getI64ArrayAttr(attrVals);
   return success();
 }
 
-ParseResult mlir::parseOperandsOrIntegersOffsetsOrStridesList(
-    OpAsmParser &parser,
-    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &values,
-    ArrayAttr &integers) {
-  return parseOperandsOrIntegersImpl<ShapedType::kDynamicStrideOrOffset>(
-      parser, values, integers);
-}
-
-ParseResult mlir::parseOperandsOrIntegersSizesList(
-    OpAsmParser &parser,
-    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &values,
-    ArrayAttr &integers) {
-  return parseOperandsOrIntegersImpl<ShapedType::kDynamicSize>(parser, values,
-                                                               integers);
-}
-
 bool mlir::detail::sameOffsetsSizesAndStrides(
     OffsetSizeAndStrideOpInterface a, OffsetSizeAndStrideOpInterface b,
     llvm::function_ref<bool(OpFoldResult, OpFoldResult)> cmp) {
   if (a.static_offsets().size() != b.static_offsets().size())
     return false;
   if (a.static_sizes().size() != b.static_sizes().size())
     return false;
   if (a.static_strides().size() != b.static_strides().size())
     return false;
   for (auto it : llvm::zip(a.getMixedOffsets(), b.getMixedOffsets()))
     if (!cmp(std::get<0>(it), std::get<1>(it)))
       return false;
   for (auto it : llvm::zip(a.getMixedSizes(), b.getMixedSizes()))
     if (!cmp(std::get<0>(it), std::get<1>(it)))
       return false;

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");