[mlir][ods] Attribute and type formats: support whitespaces

[Mogball]

Summary

Supports whitespace elements: and \\n as well as the "empty" whitespace `` that removes an otherwise printed space.

Depends on D118208

[rriddle]

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

767–773

768

This should require $_printer.printNewline() just like operation formats, though I think that requires me to finish my patch for removing the nested printing awkwardness. Would be good to add a FIXME here that this should be driven by the printer.

[Mogball]

review comments

[Mogball]

rebase

[Mogball]

rebase again

mlir/test/lib/Dialect/Test/TestTypeDefs.td

 
 def TestTypeOptionalGroupStruct : Test_Type<"TestTypeOptionalGroupStruct"> {
   let parameters = (ins OptionalParameter<"mlir::Optional<int>">:$a,
                         OptionalParameter<"mlir::Optional<int>">:$b);
   let mnemonic = "optional_group_struct";
   let assemblyFormat = "`<` (`(` struct(params)^ `)`) : (`x`)? `>`";
 }
 
+def TestTypeSpaces : Test_Type<"TestTypeSpaceS"> {
+  let parameters = (ins "int":$a, "int":$b);
+  let mnemonic = "spaces";
+  let assemblyFormat = "`<` ` ` $a `\\n` `(` `)` `` `(` `)` $b `>`";
+}
+
 #endif // TEST_TYPEDEFS

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

 // CHECK: !test.optional_group<(5) 6>
 // CHECK: !test.optional_group<x 6>
 // CHECK: !test.optional_group_params<x>
 // CHECK: !test.optional_group_params<(5)>
 // CHECK: !test.optional_group_params<(5, 6)>
 // CHECK: !test.optional_group_struct<x>
 // CHECK: !test.optional_group_struct<(b = 5)>
 // CHECK: !test.optional_group_struct<(a = 10, b = 5)>
+// CHECK: !test.spaces< 5
+// CHECK-NEXT: ()() 6>
 func private @test_roundtrip_default_parsers_struct(
   !test.no_parser<255, [1, 2, 3, 4, 5], "foobar", 4>
 ) -> (
   !test.struct_capture_all<v3 = 3, v1 = 1, v2 = 2, v0 = 0>,
   !test.optional_param<, 6>,
   !test.optional_param<5, 6>,
   !test.optional_params<"a">,
   !test.optional_params<5, "a">,
) -> (
   !test.all_optional_struct<b = 10, a = 5>,
   !test.optional_group<(5) 6>,
   !test.optional_group<x 6>,
   !test.optional_group_params<x>,
   !test.optional_group_params<(5)>,
   !test.optional_group_params<(5, 6)>,
   !test.optional_group_struct<x>,
   !test.optional_group_struct<(b = 5)>,
-  !test.optional_group_struct<(b = 5, a = 10)>
+  !test.optional_group_struct<(b = 5, a = 10)>,
+  !test.spaces<5 ()() 6>
 )

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

void genCommaSeparatedPrinter(ArrayRef<ParameterElement *> params,
                                 function_ref<void(ParameterElement *)> extra);
   /// Generate the printer code for a `params` directive.
   void genParamsPrinter(ParamsDirective *el, FmtContext &ctx, MethodBody &os);
   /// Generate the printer code for a `struct` directive.
   void genStructPrinter(StructDirective *el, FmtContext &ctx, MethodBody &os);
   /// Generate the printer code for an optional group.
   void genOptionalGroupPrinter(OptionalElement *el, FmtContext &ctx,
                                MethodBody &os);
+  /// Generate a printer (or space eraser) for a whitespace element.
+  void genWhitespacePrinter(WhitespaceElement *el, FmtContext &ctx,
+                            MethodBody &os);
 
   /// The ODS definition of the attribute or type whose format is being used to
   /// generate a parser and printer.
   const AttrOrTypeDef &def;
   /// The list of top-level format elements returned by the assembly format
   /// parser.
   std::vector<FormatElement *> elements;
 
void DefFormat::genElementParser(FormatElement *el, FmtContext &ctx,
   if (auto *var = dyn_cast<ParameterElement>(el))
     return genVariableParser(var, ctx, os);
   if (auto *params = dyn_cast<ParamsDirective>(el))
     return genParamsParser(params, ctx, os);
   if (auto *strct = dyn_cast<StructDirective>(el))
     return genStructParser(strct, ctx, os);
   if (auto *optional = dyn_cast<OptionalElement>(el))
     return genOptionalGroupParser(optional, ctx, os);
+  if (isa<WhitespaceElement>(el))
+    return;
 
   llvm_unreachable("unknown format element");
 }
 
 void DefFormat::genLiteralParser(StringRef value, FmtContext &ctx,
                                  MethodBody &os, bool isOptional) {
   os << "// Parse literal '" << value << "'\n";
   os << tgfmt("if ($_parser.parse", &ctx);
void DefFormat::genElementPrinter(FormatElement *el, FmtContext &ctx,
   if (auto *params = dyn_cast<ParamsDirective>(el))
     return genParamsPrinter(params, ctx, os);
   if (auto *strct = dyn_cast<StructDirective>(el))
     return genStructPrinter(strct, ctx, os);
   if (auto *var = dyn_cast<ParameterElement>(el))
     return genVariablePrinter(var, ctx, os);
   if (auto *optional = dyn_cast<OptionalElement>(el))
     return genOptionalGroupPrinter(optional, ctx, os);
+  if (auto *whitespace = dyn_cast<WhitespaceElement>(el))
+    return genWhitespacePrinter(whitespace, ctx, os);
 
   llvm::PrintFatalError("unsupported format element");
 }
 
 void DefFormat::genLiteralPrinter(StringRef value, FmtContext &ctx,
                                   MethodBody &os) {
   // Don't insert a space before certain punctuation.
   bool needSpace =
void DefFormat::genOptionalGroupPrinter(OptionalElement *el, FmtContext &ctx,
   }
   os.unindent() << "} else {\n";
   os.indent();
   for (FormatElement *element : el->getElseElements())
     genElementPrinter(element, ctx, os);
   os.unindent() << "}\n";
 }
 
+void DefFormat::genWhitespacePrinter(WhitespaceElement *el, FmtContext &ctx,
+                                     MethodBody &os) {
+  if (el->getValue() == "\\n") {
+    // FIXME: The newline should be `printer.printNewLine()`, i.e., handled by
+    // the printer.
+    os << tgfmt("$_printer << '\\n';\n", &ctx);
+  } else if (!el->getValue().empty()) {
+    os << tgfmt("$_printer << \"$0\";\n", &ctx, el->getValue());
+  } else {
+    lastWasPunctuation = true;
+  }
+  shouldEmitSpace = false;
+}
+
 //===----------------------------------------------------------------------===//
 // DefFormatParser
 //===----------------------------------------------------------------------===//
 
 namespace {
 class DefFormatParser : public FormatParser {
 public:
   DefFormatParser(llvm::SourceMgr &mgr, const AttrOrTypeDef &def)