OpaqueType: Use format string

Author: josel-amd

mlir/include/mlir/Dialect/EmitC/IR/EmitCTypes.td

@@ -99,9 +99,20 @@ def EmitC_OpaqueType : EmitC_Type<"Opaque", "opaque"> {
     ```
   }];
 
-  let parameters = (ins StringRefParameter<"the opaque value">:$value);
-  let assemblyFormat = "`<` $value `>`";
+  let parameters = (ins StringRefParameter<"the opaque value">:$value,
+                        OptionalArrayRefParameter<"Type">:$fmtArgs);
+  let assemblyFormat = "`<` $value (`,` custom<VariadicFmtArgs>($fmtArgs)^)? `>`";
   let genVerifyDecl = 1;
+
+  let builders = [TypeBuilder<(ins "::llvm::StringRef":$value), [{ return $_get($_ctxt, value, SmallVector<Type>{}); }] >];
+
+  let extraClassDeclaration = [{
+    // Either a literal string, or an placeholder for the fmtArgs.
+    struct Placeholder {};
+    using ReplacementItem = std::variant<StringRef, Placeholder>;
+
+    FailureOr<SmallVector<ReplacementItem>> parseFormatString();
+  }];
 }
 
 def EmitC_PointerType : EmitC_Type<"Pointer", "ptr"> {

mlir/lib/Dialect/EmitC/IR/EmitC.cpp

@@ -20,6 +20,7 @@
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/FormatVariadic.h"
 
 using namespace mlir;
 using namespace mlir::emitc;
@@ -929,22 +930,44 @@ LogicalResult emitc::VerbatimOp::verify() {
   return success();
 }
 
+static ParseResult parseVariadicFmtArgs(AsmParser &p,
+                                        SmallVector<Type> &params) {
+  Type type;
+  if (p.parseType(type))
+    return failure();
+
+  params.push_back(type);
+  while (succeeded(p.parseOptionalComma())) {
+    if (p.parseType(type))
+      return failure();
+    params.push_back(type);
+  }
+
+  return success();
+}
+
+static void printVariadicFmtArgs(AsmPrinter &p, ArrayRef<Type> params) {
+  llvm::interleaveComma(params, p, [&](Type type) { p.printType(type); });
+}
+
 /// Parse a format string and return a list of its parts.
 /// A part is either a StringRef that has to be printed as-is, or
 /// a Placeholder which requires printing the next operand of the VerbatimOp.
 /// In the format string, all `{}` are replaced by Placeholders, except if the
-/// `{` is escaped by `{{` - then it doesn't start a placeholder.
-FailureOr<SmallVector<emitc::VerbatimOp::ReplacementItem>>
-emitc::VerbatimOp::parseFormatString() {
-  SmallVector<ReplacementItem> items;
+/// `{` is escaped by `{{` - then it doesn't start a placeholder
+template <typename Op, class ArgType>
+FailureOr<SmallVector<typename Op::ReplacementItem>>
+parseFormatString(StringRef toParse, ArgType fmtArgs,
+                  std::optional<llvm::function_ref<mlir::InFlightDiagnostic()>>
+                      emitError = {}) {
+  SmallVector<typename Op::ReplacementItem> items;
 
   // If there are not operands, the format string is not interpreted.
-  if (getFmtArgs().empty()) {
-    items.push_back(getValue());
+  if (fmtArgs.empty()) {
+    items.push_back(toParse);
     return items;
   }
 
-  StringRef toParse = getValue();
   while (!toParse.empty()) {
     size_t idx = toParse.find('{');
     if (idx == StringRef::npos) {
@@ -972,15 +995,28 @@ emitc::VerbatimOp::parseFormatString() {
       continue;
     }
     if (nextChar == '}') {
-      items.push_back(Placeholder{});
+      items.push_back(typename Op::Placeholder{});
       toParse = toParse.drop_front(2);
       continue;
     }
-    return emitOpError() << "expected '}' after unescaped '{'";
+
+    if (emitError.has_value()) {
+      return (*emitError)() << "expected '}' after unescaped '{'";
+    }
+    return failure();
   }
   return items;
 }
 
+FailureOr<SmallVector<emitc::VerbatimOp::ReplacementItem>>
+emitc::VerbatimOp::parseFormatString() {
+  auto errorCallback = [&]() -> InFlightDiagnostic {
+    return this->emitError();
+  };
+  return ::parseFormatString<emitc::VerbatimOp>(getValue(), getFmtArgs(),
+                                                errorCallback);
+}
+
 //===----------------------------------------------------------------------===//
 // EmitC Enums
 //===----------------------------------------------------------------------===//
@@ -1072,17 +1108,37 @@ emitc::ArrayType::cloneWith(std::optional<ArrayRef<int64_t>> shape,
 
 LogicalResult mlir::emitc::OpaqueType::verify(
     llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
-    llvm::StringRef value) {
+    llvm::StringRef value, ArrayRef<Type> fmtArgs) {
   if (value.empty()) {
     return emitError() << "expected non empty string in !emitc.opaque type";
   }
   if (value.back() == '*') {
     return emitError() << "pointer not allowed as outer type with "
                           "!emitc.opaque, use !emitc.ptr instead";
   }
+
+  FailureOr<SmallVector<ReplacementItem>> fmt =
+      ::parseFormatString<emitc::OpaqueType>(value, fmtArgs, emitError);
+  if (failed(fmt))
+    return failure();
+
+  size_t numPlaceholders = llvm::count_if(*fmt, [](ReplacementItem &item) {
+    return std::holds_alternative<Placeholder>(item);
+  });
+
+  if (numPlaceholders != fmtArgs.size()) {
+    return emitError()
+           << "requires operands for each placeholder in the format string";
+  }
+
   return success();
 }
 
+FailureOr<SmallVector<emitc::OpaqueType::ReplacementItem>>
+emitc::OpaqueType::parseFormatString() {
+  return ::parseFormatString<emitc::OpaqueType>(getValue(), getFmtArgs());
+}
+
 //===----------------------------------------------------------------------===//
 // GlobalOp
 //===----------------------------------------------------------------------===//

mlir/lib/Target/Cpp/TranslateToCpp.cpp

@@ -1728,6 +1728,24 @@ LogicalResult CppEmitter::emitType(Location loc, Type type) {
   if (auto tType = dyn_cast<TupleType>(type))
     return emitTupleType(loc, tType.getTypes());
   if (auto oType = dyn_cast<emitc::OpaqueType>(type)) {
+    FailureOr<SmallVector<emitc::OpaqueType::ReplacementItem>> items =
+        oType.parseFormatString();
+    if (failed(items))
+      return failure();
+
+    auto fmtArg = oType.getFmtArgs().begin();
+    for (emitc::OpaqueType::ReplacementItem &item : *items) {
+      if (auto *str = std::get_if<StringRef>(&item)) {
+        os << *str;
+      } else {
+        if (failed(emitType(loc, *fmtArg++))) {
+          return failure();
+        }
+      }
+    }
+
+    return success();
+
     os << oType.getValue();
     return success();
   }

mlir/test/Dialect/EmitC/invalid_types.mlir

@@ -14,6 +14,34 @@ func.func @illegal_opaque_type_2() {
 
 // -----
 
+func.func @illegal_opaque_type() {
+    // expected-error @+1 {{expected non-function type}}
+    %1 = "emitc.variable"(){value = "42" : !emitc.opaque<"{}, {}", "string">} : () -> !emitc.opaque<"mytype">
+}
+
+// -----
+
+func.func @illegal_opaque_type() {
+    // expected-error @+1 {{requires operands for each placeholder in the format string}}
+    %1 = "emitc.variable"(){value = "42" : !emitc.opaque<"a", f32>} : () -> !emitc.opaque<"mytype">
+}
+
+// -----
+
+func.func @illegal_opaque_type() {
+    // expected-error @+1 {{requires operands for each placeholder in the format string}}
+    %1 = "emitc.variable"(){value = "42" : !emitc.opaque<"{}, {}", f32>} : () -> !emitc.opaque<"mytype">
+}
+
+// -----
+
+func.func @illegal_opaque_type() {
+    // expected-error @+1 {{expected '}' after unescaped '{'}}
+    %1 = "emitc.variable"(){value = "42" : !emitc.opaque<"{ ", i32>} : () -> !emitc.opaque<"mytype">
+}
+
+// -----
+
 func.func @illegal_array_missing_spec(
     // expected-error @+1 {{expected non-function type}}
     %arg0: !emitc.array<>) {

mlir/test/Dialect/EmitC/types.mlir

@@ -38,6 +38,12 @@ func.func @opaque_types() {
   emitc.call_opaque "f"() {template_args = [!emitc.opaque<"std::vector<std::string>">]} : () -> ()
   // CHECK-NEXT: !emitc.opaque<"SmallVector<int*, 4>">
   emitc.call_opaque "f"() {template_args = [!emitc.opaque<"SmallVector<int*, 4>">]} : () -> ()
+  // CHECK-NEXT: !emitc.opaque<"{}", i32>
+  emitc.call_opaque "f"() {template_args = [!emitc<opaque<"{}", i32>>]} : () -> ()
+  // CHECK-NEXT: !emitc.opaque<"{}, {}", i32, f32>]
+  emitc.call_opaque "f"() {template_args = [!emitc<opaque<"{}, {}", i32, f32>>]} : () -> ()
+  // CHECK-NEXT: !emitc.opaque<"{}"
+  emitc.call_opaque "f"() {template_args = [!emitc<opaque<"{}">>]} : () -> ()
 
   return
 }

mlir/test/Target/Cpp/types.mlir

@@ -12,6 +12,16 @@ func.func @opaque_types() {
   emitc.call_opaque "f"() {template_args = [!emitc<opaque<"status_t">>]} : () -> ()
   // CHECK-NEXT: f<std::vector<std::string>>();
   emitc.call_opaque "f"() {template_args = [!emitc.opaque<"std::vector<std::string>">]} : () -> ()
+  // CHECK:  f<float>()
+  emitc.call_opaque "f"() {template_args = [!emitc<opaque<"{}", f32>>]} : () -> ()
+  // CHECK: f<int16_t {>();
+  emitc.call_opaque "f"() {template_args = [!emitc<opaque<"{} {{", si16>>]} : () -> ()
+  // CHECK: f<int8_t {>();
+  emitc.call_opaque "f"() {template_args = [!emitc<opaque<"{} {", i8>>]} : () -> ()
+  // CHECK: f<status_t>();
+  emitc.call_opaque "f"() {template_args = [!emitc<opaque<"{}", !emitc<opaque<"status_t">> >>]} : () -> ()
+  // CHECK: f<top<nested<float>,int32_t>>();
+  emitc.call_opaque "f"() {template_args = [!emitc<opaque<"top<{},{}>", !emitc<opaque<"nested<{}>", f32>>, i32>>]} : () -> ()
 
   return
 }