[mlir] Support for defining Types in tblgen

[jdd]

Summary

Adds a TypeDef class to OpBase and backing generation code

[jdd]

Moved hash_value(float) to hashing.h, fixed clang-tidy warnings

[jdd]

Restoring old revision

[silvas]

llvm/lib/Support/Hashing.cpp

30 ↗

(On Diff #289321)

Drive-by comment: this actually is not a correct hashing implementation. it can result in x == y yet have hash(x) != hash(y) and other violation of invariants. (consider negative 0 and NaN's)

[silvas]

llvm/lib/Support/Hashing.cpp

30 ↗

(On Diff #289321)

more details here: https://research.swtch.com/randhash

[rriddle]

Thanks! This all looks really really good. I'm extremely busy over the next few days, but I'll try to give it a run over this weekend. Happy to see this coming to fruition.

[jdd]

llvm/lib/Support/Hashing.cpp

30 ↗

(On Diff #289321)

yeah, I'm not accounting for -0. NaN is "just" a performance problem for degenerate cases AFAICT.

I'll probably remove these. I only need them for a test which probably doesn't make sense so I'll modify the test to not use them.

[rriddle]

Thanks for driving this!

Started making my way through it.

mlir/include/mlir/IR/OpBase.td

2355 ↗

(On Diff #292115)

nit: Please add proper punctuation to the end of comments.

2357 ↗

(On Diff #292115)

nit: I would swap the names here:

Dialect dialect = owningDialect;

2394 ↗

(On Diff #292115)

Please use the same name for this field as the other ODS classes; extraClassDeclaration.

2400 ↗

(On Diff #292115)

Can you add comments to these?

2427 ↗

(On Diff #292115)

nit: There are a few format issues in this code block.

mlir/include/mlir/TableGen/CodeGenHelpers.h

26 ↗

(On Diff #292115)

nit: Only specify inline on methods if you have a good reason to.

41 ↗

(On Diff #292115)

nit: Same comments on inline here and throughout.

41 ↗

(On Diff #292115)

Seems like this could take the fully qualified cpp namespace string instead of a dialect.

mlir/include/mlir/TableGen/TypeDef.h

1 ↗

(On Diff #292115)

This comment block looks incorrect, can you look at other files for examples?

22 ↗

(On Diff #292115)

Are these necessary given that you include Record.h?

61 ↗

(On Diff #292115)

nit: Can you add a better comment here?

101 ↗

(On Diff #292115)

This comment and a few others look like they need to be updated.

111 ↗

(On Diff #292115)

This class needs some documentation.

129 ↗

(On Diff #292115)

nit: Use llvm::function_ref instead of std::function if you don't need to store the functor.

mlir/include/mlir/TableGen/TypeDefGenHelpers.h

2 ↗

(On Diff #292115)

Do we need this file for this commit? This looks like it is only used for the testing and I'd rather leave parsing/printer utilities separately.

mlir/lib/TableGen/TypeDef.cpp

23

dyn_cast may return null, use cast if you know that it is of the type you expect.

33

nit: Can you spell out auto here, the type isn't obvious.

65

nit: Add braces around the if here, the body isn't trivial.

66

nit: Cache the end iterator of for loops unless you rely on the value changing during the loop.

71

return membersDag ? membersDag->getNumArgs() : 0;?

85

The error message here seems off.

129

nit: Don't use else after return.

141

PrintFatalError? Same below.

[jdd]

It looks like the test build didn't happen... Am I right? Did I do something wrong?

[jdd]

mlir/include/mlir/TableGen/CodeGenHelpers.h

41 ↗

(On Diff #292115)

It could, but everything which uses it gets the namespace from the dialect so this enables maximum code sharing.

mlir/include/mlir/TableGen/TypeDefGenHelpers.h

2 ↗

(On Diff #292115)

It's not just for testing. The auto-generated parsers/printers use the templates in this file so whenever one is using auto-generated printers/parsers this file has to be #included. The alternative is to emit this file in the generated code, but I prefer this approach so as to not bloat the emit'ed code.

I get that this template-based design decision is likely to be controversial. This is one piece where I'm looking for high-level feedback.

[jdd]

Changed 'memebers' to 'parameters' and addressed existing review comments

[jdd]

Addressed

[jdd]

Adding ::get method to classes so we can keep storage types in the cpp file.

Also, modifying the custom allocator for ArrayRef parameters so as to not require types with default constructors.

[jdd]

Doesn't cleanly apply to current master. Fixing.

[rriddle]

mlir/include/mlir/TableGen/TypeDefGenHelpers.h

2 ↗

(On Diff #292115)

Yeah, I'd prefer removing all of the parsing stuff from this revision. It is just going to hold back all of the other stuff, and is something that can be discussed separately.

[rriddle]

Apologies for the delay, I've been OOO for the past few weeks. Will take another look in the next day or two.

[jdd]

mlir/include/mlir/TableGen/TypeDefGenHelpers.h

2 ↗

(On Diff #292115)

If the parsing stuff what's blocking this, then I agree. I'd like to keep the custom parser code in tblgen and the parsing dispatch. I think this is value and and is not controversial, right?

[jdd]

Syncing w/ master & removing auto-parsing stuff

[jdd]

I will never understand arc

[jdd]

Let's try this again

[jdd]

Fixing whitespace and clang-tidy issues

[jdd]

Fixing the previous arc diff

[jdd]

One more clang-tidy fix

[jdd]

Changes based on Chris' comments

(https://github.com/circt/llvm/pull/3)

[rriddle]

Sorry for the delay. Took another run through. Thanks.

mlir/include/mlir/IR/OpBase.td

2364 ↗

(On Diff #295632)

nit: Please add proper punctuation to the end of comments.

There are many cases within the revision still.

2374 ↗

(On Diff #295632)

nit: Phrase the comments as statements instead of questions.

2440 ↗

(On Diff #295632)

nit: Drop trivial braces, and use pre-increment.

2444 ↗

(On Diff #295632)

The formatting is still a bit off.

mlir/lib/TableGen/TypeDef.cpp

69

nit: Drop trivial braces here and throughout the revision.

130

Drop the newline here.

163

Don't use else after return.

164

Should this be a fatal error instead?

mlir/test/lib/Dialect/Test/TestTypes.cpp

20 ↗

(On Diff #295632)

Namespaces in source files should only really be used for class declarations. Everything else should be in the top-level scope.

36 ↗

(On Diff #295632)

nit: Return the error directly.

63 ↗

(On Diff #295632)

nit: Merge all of these together using ||

93 ↗

(On Diff #295632)

nit: Use llvm::interleaveComma here instead.

mlir/test/lib/Dialect/Test/TestTypes.h

27 ↗

(On Diff #295632)

Please add comments for this class and it's usages.

28 ↗

(On Diff #295632)

This public seems unnecessary.

[rriddle]

mlir/include/mlir/TableGen/TypeDef.h

132 ↗

(On Diff #295632)

Seems like TypeDef could just provide a range of it's parameters and callers of this could just you llvm::map_range instead.

mlir/test/lib/Dialect/Test/TestTypes.cpp

28 ↗

(On Diff #295632)

nit: Drop all of the mlir:: in this file, and throughout the revision.

101 ↗

(On Diff #295632)

The definitions of methods in header files should be fully qualified :: and not placed in a namespace in the .cpp.

mlir/tools/mlir-tblgen/OpDocGen.cpp

202

nit: Prefer early return instead.

205

nit: Unless the end loop iterator changes, cache it.

mlir/tools/mlir-tblgen/TypeDefGen.cpp

83

The name of this parameter doesn't seem to match what you are doing here.

85

Could you just format the parameters into a llvm::raw_string_ostream instead of constructing separate strings?

98

Same comment as above.

134

This looks like the indent is off.

186

Do we need to generate this method? Seems like the uses of it by the generator could just inline the string instead.

197

nit: Spell out auto here, also use a reference instead of by-value.

222

Seems like this would be something only generated in the source file and marked as static.

274

This looks over indented, should be 2 spaces not 4.

293

This looks misaligned.

311

nit: Spell out auto here and don't use a by-value iterator variable.

348

Should these be auto &instead?

373

Please remove all of the personal comments from the revision.

381

nit: Comments should be complete sentences. This applies throughout the revision.

420

nit: Same comment about auto here as above.

481

Stray comment?

505

Can we use a LogicalResult return instead?

513

Can we avoid generating print/parse on the types themselves? We should try to keep as much internal details hidden away as possible.

[jdd]

As for declaring parse(...), print(...), and getMnemonic() in the header file: these are intended for cases where (for some reason) the dialect doesn't use the global parse/print dispatch method. The dialect could call each parse/print method in its Dialect::parseType/Dialect::printType methods, in concert with the getMnemonic(). I figure even if it's not often used, its just an extra 3 lines in each type declaration.

Do you agree or should I remove it?

mlir/include/mlir/IR/OpBase.td

2364 ↗

(On Diff #295632)

Ah. I thought proper punctuation was only necessary after full sentences.

[jdd]

mlir/test/lib/Dialect/Test/TestTypes.cpp

63 ↗

(On Diff #295632)

Nice!

93 ↗

(On Diff #295632)

That's handy

101 ↗

(On Diff #295632)

I've removed two from the header

mlir/tools/mlir-tblgen/TypeDefGen.cpp

222

The dialect calls these from its parseType and printType functions so we must declare them here.

[jdd]

Revisions base on River's comments

[jdd]

Missed a comment

[jdd]

clang-format

[rriddle]

Really great stuff, I'm glad you've been pushing this! Mostly nits left for the code, it's enough that we can just iterate further in tree. Can you document all of this cool new stuff? Either in docs/OpDefinitions or a new docs/TypeDefinitions?

mlir/include/mlir/TableGen/TypeDef.h

71 ↗

(On Diff #296316)

nit: Can we remove the llvm:: on these as well?

93 ↗

(On Diff #296316)

Is the llvm:: here necessary?

mlir/lib/TableGen/TypeDef.cpp

152

Please drop else after a return.

154

nit: Drop the != nullptr.

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

118 ↗

(On Diff #296316)

Please cache the end iterator of loops if the size doesn't change.

119 ↗

(On Diff #296316)

The formatting here seems off.

mlir/test/lib/Dialect/Test/TestTypes.cpp

36 ↗

(On Diff #296316)

nit: Drop trivial braces here. Also if you use braces on one if/else, please use it for all of them.

87 ↗

(On Diff #296316)

Please only use namespaces in source files for classes.

105 ↗

(On Diff #296316)

nit: Drop the newline here.

mlir/tools/mlir-tblgen/OpDocGen.cpp

272

nit: Drop trivial braces here.

mlir/tools/mlir-tblgen/TypeDefGen.cpp

57

Please use braces on every else if they are used on one.

63

nit: auto -> const TypeDef &

82

llvm::interleaveComma?

99

Same here?

309

Can you stream the tgfmt directly into os?

433

Can you stream it into os directly?

[jdd]

I'll update the documentation as you requested. Do you mind if I do it in a subsequent commit? I have a feeling there's going to be some back-and-forth on the documentation and I don't want that editorial process to gate this commit.

Meanwhile, I've addressed all your comments. No matter how carefully I examine my code, I just keep missing your nits. I gotta learn to write code in the LLVM style. It's pretty much the complete opposite of how I'm used to writing code!

mlir/include/mlir/TableGen/TypeDef.h

71 ↗

(On Diff #296316)

Actually, no. It doesn't find Optional if I remove it. I'd have to add a 'using namespace' in the header, which is a no-no.

Why StringRef and ArrayRef work and nothing else in the llvm namespace is a mystery to me, though my understanding of C++ namespace scoping rules is doubtlessly lacking.

mlir/test/lib/Dialect/Test/TestTypes.cpp

87 ↗

(On Diff #296316)

Doesn't work in this case. Since FieldInfo is in the mlir namespace (with the rest of the Test dialect), these two functions have to be also. They do not have to be exposed outside of this file, so they're not declared in the header.

mlir/tools/mlir-tblgen/TypeDefGen.cpp

82

Ohhh. I'll do ya one better. Lemme know if the is too far deep into C++ trickery territory.

[jdd]

• Changes based on review
• Remove llvm:: from the cpp file

[jdd]

• Clang-tidy fix

[rriddle]

In D86904#2323208, @jdd wrote:

I'll update the documentation as you requested. Do you mind if I do it in a subsequent commit? I have a feeling there's going to be some back-and-forth on the documentation and I don't want that editorial process to gate this commit.

That's fine with me.

LGTM after fixing the remaining comments.

mlir/include/mlir/TableGen/TypeDef.h

71 ↗

(On Diff #296316)

Optional, like ArrayRef/StringRef/and many other things, is already re-exported into the MLIR namespace.

https://github.com/llvm/llvm-project/blob/3f2386de6325157324a0dc2ae00ef3db3a144563/mlir/include/mlir/Support/LLVM.h#L110

mlir/test/lib/Dialect/Test/TestTypes.cpp

87 ↗

(On Diff #296316)

You need to fully qualify the methods: https://llvm.org/docs/CodingStandards.html#use-namespace-qualifiers-to-implement-previously-declared-functions

You should very very rarely (most cases are bugs in the compiler, e.g. some templates in GCC 5) need to actually use a namespace in the .cpp to define a previously declared method.

mlir/tools/mlir-tblgen/TypeDefGen.cpp

27

nit: Can you please avoid using namespace llvm here?

50

nit: Add & unless it is trivially copyable, using the type instead of auto would it make it a bit clearer what is being iterated here.

73

I would prefer that these just be function_ref and boolean fields of the class instead.

74

This class needs to be wrapped in an anonymous namespace.

75

nit: Prefer having the members at the end of the class definition, not first.

97

Please do not use typedef, prefer using Foo = blah; directives instead.

[jdd]

mlir/tools/mlir-tblgen/TypeDefGen.cpp

73

That kinda defeats the syntactic niceness. Will convert this to normal class w/ enum to determine the format. This will make the calling syntax longer but preserve the efficiency.

[jdd]

• Another round of changes based on feedback.

[jdd]

• Rebasing w/ conflicts
• New branch, applying everything at once
• Clang-(format|tidy) fixes
• One more clang-tidy fix
• Changes based on Chris' comments
• Ending a sentence comment w/ a period
• Revisions base on River's comments
• Clang-tidy and some missed comments
• Missed a comment
• clang-format
• Changes based on review
• Remove llvm:: from the cpp file
• Clang-tidy fix
• Another round of changes based on feedback.

[mehdi_amini]

In D86904#2323208, @jdd wrote:

I'll update the documentation as you requested. Do you mind if I do it in a subsequent commit? I have a feeling there's going to be some back-and-forth on the documentation and I don't want that editorial process to gate this commit.

When you get to landing the doc, please update the newsletter on Discourse :)
This is a really cool feature.

mlir/lib/TableGen/TypeDef.cpp

 #include "llvm/ADT/StringExtras.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 
 using namespace mlir;
 using namespace mlir::tblgen;
 
 Dialect TypeDef::getDialect() const {
-  auto dialectDef =
+  auto *dialectDef =
       dyn_cast<llvm::DefInit>(def->getValue("dialect")->getValue());
   if (dialectDef == nullptr)
     return Dialect(nullptr);
   return Dialect(dialectDef->getDef());
 }
 
 StringRef TypeDef::getName() const { return def->getName(); }
 StringRef TypeDef::getCppClassName() const {
   return def->getValueAsString("cppClassName");
 }
 
 bool TypeDef::hasDescription() const {
   const llvm::RecordVal *s = def->getValue("description");
   return s != nullptr && isa<llvm::StringInit>(s->getValue());
 }
 
 StringRef TypeDef::getDescription() const {
   return def->getValueAsString("description");
 }

 }
 
 bool TypeDef::genStorageClass() const {
   return def->getValueAsBit("genStorageClass");
 }
 bool TypeDef::hasStorageCustomConstructor() const {
   return def->getValueAsBit("hasStorageCustomConstructor");
 }
 void TypeDef::getParameters(SmallVectorImpl<TypeParameter> &parameters) const {
   auto *parametersDag = def->getValueAsDag("parameters");
   if (parametersDag != nullptr) {
     size_t numParams = parametersDag->getNumArgs();
     for (unsigned i = 0; i < numParams; i++) {
       parameters.push_back(TypeParameter(parametersDag, i));
     }
   }
 }
 unsigned TypeDef::getNumParameters() const {
   auto *parametersDag = def->getValueAsDag("parameters");
   return parametersDag ? parametersDag->getNumArgs() : 0;
 }
 llvm::Optional<StringRef> TypeDef::getMnemonic() const {
   return def->getValueAsOptionalString("mnemonic");
 }
 llvm::Optional<StringRef> TypeDef::getPrinterCode() const {
   return def->getValueAsOptionalCode("printer");
 }
 llvm::Optional<StringRef> TypeDef::getParserCode() const {
   return def->getValueAsOptionalCode("parser");
 }
 bool TypeDef::genAccessors() const {
   return def->getValueAsBit("genAccessors");
 }
 bool TypeDef::genVerifyInvariantsDecl() const {
   return def->getValueAsBit("genVerifyInvariantsDecl");
 }
 llvm::Optional<StringRef> TypeDef::getExtraDecls() const {
if (auto *typeParameter = dyn_cast<llvm::DefInit>(parameterType)) {
 
     llvm::PrintFatalError(
         typeParameter->getDef()->getLoc(),
         "Record `" + def->getArgName(num)->getValue() +
             "', field `printer' does not have a code initializer!");
   }
 
   llvm::PrintFatalError(
       "Parameters DAG arguments must be either strings or defs "
       "which inherit from TypeParameter\n");
 }
 StringRef TypeParameter::getCppType() const {
   auto *parameterType = def->getArg(num);
   if (auto *stringType = dyn_cast<llvm::StringInit>(parameterType)) {
     return stringType->getValue();
   }
   if (auto *typeParameter = dyn_cast<llvm::DefInit>(parameterType)) {
     return typeParameter->getDef()->getValueAsString("cppType");
   }
   llvm::PrintFatalError(
       "Parameters DAG arguments must be either strings or defs "
       "which inherit from TypeParameter\n");
 }
 llvm::Optional<StringRef> TypeParameter::getDescription() const {
 
   auto *parameterType = def->getArg(num);
   if (auto *typeParameter = dyn_cast<llvm::DefInit>(parameterType)) {
     const auto *desc = typeParameter->getDef()->getValue("description");
     if (llvm::StringInit *ci = dyn_cast<llvm::StringInit>(desc->getValue()))
       return ci->getValue();
   }
   return llvm::Optional<StringRef>();
 }
 StringRef TypeParameter::getSyntax() const {
   auto *parameterType = def->getArg(num);
   if (auto *stringType = dyn_cast<llvm::StringInit>(parameterType)) {
     return stringType->getValue();
   } else if (auto *typeParameter = dyn_cast<llvm::DefInit>(parameterType)) {
     const auto *syntax = typeParameter->getDef()->getValue("syntax");
     if (syntax != nullptr && isa<llvm::StringInit>(syntax->getValue()))
       return dyn_cast<llvm::StringInit>(syntax->getValue())->getValue();
     return getCppType();
   } else {
     llvm::errs() << "Parameters DAG arguments must be either strings or defs "
                     "which inherit from TypeParameter\n";
     return StringRef();
   }
 }

mlir/tools/mlir-tblgen/OpDocGen.cpp

 
 /// Emit the assembly format of a type.
 static void emitTypeAssemblyFormat(TypeDef td, raw_ostream &os) {
   SmallVector<TypeParameter, 4> parameters;
   td.getParameters(parameters);
   if (parameters.size() == 0) {
     os << "\nSyntax: `!" << td.getDialect().getName() << "." << td.getMnemonic()
        << "`\n";
   } else {
     os << "\nSyntax:\n\n```\n!" << td.getDialect().getName() << "."
        << td.getMnemonic() << "<\n";
-    for (auto it = parameters.begin(); it < parameters.end(); it++) {
+    for (auto *it = parameters.begin(); it < parameters.end(); it++) {
       os << "  " << it->getSyntax();
       if (it < parameters.end() - 1)
         os << ",";
       os << "   # " << it->getName() << "\n";
     }
     os << ">\n```\n";
   }
 }
static void emitDialectDoc(const Dialect &dialect, ArrayRef<Operator> ops,
   if (!ops.empty()) {
     os << "## Operation definition\n\n";
     for (const Operator &op : ops)
       emitOpDoc(op, os);
   }
 
   if (!typeDefs.empty()) {
     os << "## Type definition\n\n";
     for (const TypeDef &td : typeDefs) {
       emitTypeDefDoc(td, os);
     }
   }
 }
 
 static void emitDialectDoc(const RecordKeeper &recordKeeper, raw_ostream &os) {
   const auto &opDefs = recordKeeper.getAllDerivedDefinitions("Op");
   const auto &typeDefs = recordKeeper.getAllDerivedDefinitions("DialectType");

mlir/tools/mlir-tblgen/TypeDefGen.cpp

 #include "mlir/TableGen/OpTrait.h"
 #include "mlir/TableGen/Operator.h"
 #include "mlir/TableGen/TypeDef.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/TableGenBackend.h"
 
 #define DEBUG_TYPE "mlir-tblgen-typedefgen"
 
 using namespace mlir;
 using namespace mlir::tblgen;
 
 static llvm::cl::OptionCategory typedefGenCat("Options for -gen-typedef-*");
 static llvm::cl::opt<std::string>
     selectedDialect("typedefs-dialect",
                     llvm::cl::desc("Gen types for this dialect"),
                     llvm::cl::cat(typedefGenCat), llvm::cl::CommaSeparated);
 
 /// Find all the TypeDefs for the specified dialect. If no dialect specified and
 /// can only find one dialect's types, use that.
 static mlir::LogicalResult
 findAllTypeDefs(const llvm::RecordKeeper &recordKeeper,
                 SmallVectorImpl<TypeDef> &typeDefs) {
   auto recDefs = recordKeeper.getAllDerivedDefinitions("TypeDef");
   auto defs = llvm::map_range(
       recDefs, [&](const llvm::Record *rec) { return TypeDef(rec); });
   if (defs.empty())
     return mlir::success();
 
   StringRef dialectName;
   if (selectedDialect.getNumOccurrences() == 0) {
     if (defs.empty())
       return mlir::success();
 
     llvm::SmallSet<mlir::tblgen::Dialect, 4> dialects;
     for (auto typeDef : defs) {
       dialects.insert(typeDef.getDialect());
     }
     if (dialects.size() != 1) {
       llvm::errs() << "TypeDefs belonging to more than one dialect. Must "
                       "select one via '--typedefs-dialect'\n";
       return mlir::failure();
     }
 
     dialectName = (*dialects.begin()).getName();
   } else if (selectedDialect.getNumOccurrences() == 1) {
     dialectName = selectedDialect.getValue();
   } else {
     llvm::errs()
         << "cannot select multiple dialects for which to generate types"
            "via '--typedefs-dialect'\n";
     return mlir::failure();
   }
 
   for (auto typeDef : defs) {
     if (typeDef.getDialect().getName().equals(dialectName))
       typeDefs.push_back(typeDef);
   }
   return mlir::success();
 }
 
 /// Create a string list of parameters and types for function decls
 /// String construction helper function: parameter1Type parameter1Name,
 /// parameter2Type parameter2Name
 static std::string constructParameterParameters(TypeDef &typeDef,
                                                 bool prependComma) {
   SmallVector<std::string, 4> parameters;
   if (prependComma)
     parameters.push_back("");
   typeDef.getParametersAs<std::string>(parameters, [](auto parameter) {
     return (parameter.getCppType() + " " + parameter.getName()).str();
   });
   if (parameters.size() > 0)
     return llvm::join(parameters, ", ");
   return "";
 }
 
 /// Create an initializer for the storage class
 /// String construction helper function: parameter1(parameter1),
 /// parameter2(parameter2),
 /// [...]
 static std::string constructParametersInitializers(TypeDef &typeDef) {
   SmallVector<std::string, 4> parameters;
   typeDef.getParametersAs<std::string>(parameters, [](auto parameter) {

 
 )";
 
 /// The code block for the start of a typeDef class declaration -- parametric
 /// case
 ///
 /// {0}: The name of the typeDef class.
 /// {1}: The typeDef storage class namespace.
 /// {2}: The storage class name
 /// {3}: The list of parameters with types
 static const char *const typeDefDeclParametricBeginStr = R"(
   namespace {1} {
     struct {2};
   }
   class {0}: public ::mlir::Type::TypeBase<{0}, ::mlir::Type,
                                         {1}::{2}> {{
 public:
static void emitTypeDefDecl(TypeDef &typeDef, raw_ostream &os) {
   if (llvm::Optional<StringRef> extraDecl = typeDef.getExtraDecls())
     os << *extraDecl;
 
   // Get the CppType1 param1, CppType2 param2 argument list
   std::string parameterParameters = constructParameterParameters(typeDef, true);
 
   os << llvm::formatv("  static {0} get(::mlir::MLIRContext* ctxt{1});\n",
                       typeDef.getCppClassName(), parameterParameters);
 
-
-
   // verify invariants
   if (typeDef.genVerifyInvariantsDecl())
     os << llvm::formatv(typeDefDeclVerifyStr, parameterParameters,
                         typeDef.getCppClassName());
 
   // mnenomic, if specified
   if (auto mnenomic = typeDef.getMnemonic()) {
     os << "    static ::llvm::StringRef getMnemonic() { return \"" << mnenomic
        << "\"; }\n";
 
     // if mnemonic specified, emit print/parse declarations
     os << typeDefParsePrint;
   }
 
   if (typeDef.genAccessors()) {
     SmallVector<TypeParameter, 4> parameters;
     typeDef.getParameters(parameters);
 
     for (auto parameter : parameters) {
       SmallString<16> name = parameter.getName();
       name[0] = llvm::toUpper(name[0]);
       os << llvm::formatv("    {0} get{1}() const;\n", parameter.getCppType(),
                           name);
     }
   }
 
   // End the typeDef decl.
   os << "  };\n";
 }
 
 /// Main entry point for decls
 static bool emitTypeDefDecls(const llvm::RecordKeeper &recordKeeper,
                              raw_ostream &os) {
   emitSourceFileHeader("TypeDef Declarations", os);
 
   SmallVector<TypeDef, 16> typeDefs;
   if (mlir::failed(findAllTypeDefs(recordKeeper, typeDefs)))
     return true;
 
   IfDefScope scope("GET_TYPEDEF_CLASSES", os);
   if (typeDefs.size() > 0) {
     NamespaceEmitter nsEmitter(os, typeDefs.begin()->getDialect());
     // well known print/parse dispatch function declarations
     os << "  ::mlir::Type generatedTypeParser(::mlir::MLIRContext* ctxt, "

 }
 
 //===----------------------------------------------------------------------===//
 // GEN: TypeDef definitions
 //===----------------------------------------------------------------------===//
 
 /// Beginning of storage class
 /// {0}: Storage class namespace
 /// {1}: Storage class c++ name
 /// {2}: Parameters parameters
 /// {3}: Parameter initialzer string
 /// {4}: Parameter name list;
 /// {5}: Parameter types
 static const char *const typeDefStorageClassBegin = R"(
 namespace {0} {{
   struct {1} : public ::mlir::TypeStorage {{
       {1} ({2})
           : {3} {{ }
 
       /// The hash key for this storage is a pair of the integer and type params.
       using KeyTy = std::tuple<{5}>;
 
       /// Define the comparison function for the key type.
       bool operator==(const KeyTy &key) const {{
           return key == KeyTy({4});
       }
 
       static ::llvm::hash_code hashKey(const KeyTy &key) {{
 )";
 
 /// The storage class' constructor template
 /// {0}: storage class name
 static const char *const typeDefStorageClassConstructorBegin = R"(
       /// Define a construction method for creating a new instance of this storage.
       static {0} *construct(::mlir::TypeStorageAllocator &allocator,
                                           const KeyTy &key) {{
 )";
 
 /// The storage class' constructor return template
 /// {0}: storage class name
 /// {1}: list of parameters
 static const char *const typeDefStorageClassConstructorReturn = R"(
           return new (allocator.allocate<{0}>())
               {0}({1});
       }
 )";
 
 /// use tgfmt to emit custom allocation code for each parameter, if necessary
 static mlir::LogicalResult emitCustomAllocationCode(TypeDef &typeDef,
                                                     raw_ostream &os) {
   SmallVector<TypeParameter, 4> parameters;
   typeDef.getParameters(parameters);
   auto fmtCtxt = FmtContext().addSubst("_allocator", "allocator");
   for (auto parameter : parameters) {
static mlir::LogicalResult emitStorageClass(TypeDef typeDef, raw_ostream &os) {
   auto parameterTypes =
       llvm::map_range(parameters, [](TypeParameter parameter) {
         return parameter.getCppType();
       });
   auto parameterList = llvm::join(parameterNames, ", ");
   auto parameterTypeList = llvm::join(parameterTypes, ", ");
   auto parameterParameters = constructParameterParameters(typeDef, false);
   auto parameterInits = constructParametersInitializers(typeDef);
 
   // emit most of the storage class up until the hashKey body
   os << llvm::formatv(typeDefStorageClassBegin, typeDef.getStorageNamespace(),
                       typeDef.getStorageClassName(), parameterParameters,
                       parameterInits, parameterList, parameterTypeList);
 
   // extract each parameter from the key (auto unboxing is a c++17 feature)
   for (size_t i = 0; i < parameters.size(); i++) {
     os << llvm::formatv("      auto {0} = std::get<{1}>(key);\n",
                         parameters[i].getName(), i);
   }
   // then combine them all. this requires all the parameters types to have a
   // hash_value defined
   os << "        return ::llvm::hash_combine(\n";
   for (auto *parameterIter = parameters.begin();
        parameterIter < parameters.end(); parameterIter++) {
     os << "          " << parameterIter->getName();
     if (parameterIter < parameters.end() - 1) {
       os << ",\n";
     }
   }
   os << ");\n";
   os << "      }\n";
 
   // if user wants to build the storage constructor themselves, declare it here
   // and then they can write the definition elsewhere
   if (typeDef.hasStorageCustomConstructor())
     os << "  static " << typeDef.getStorageClassName()
        << " *construct(::mlir::TypeStorageAllocator &allocator, const KeyTy "
           "&key);\n";
   else {
     os << llvm::formatv(typeDefStorageClassConstructorBegin,
                         typeDef.getStorageClassName());
     // I want C++17's unboxing!!!
     for (size_t i = 0; i < parameters.size(); i++) {
       os << llvm::formatv("      auto {0} = std::get<{1}>(key);\n",
                           parameters[i].getName(), i);
     }
     // Reassign the parameter variables with allocation code, if it's specified
     if (mlir::failed(emitCustomAllocationCode(typeDef, os)))
       return mlir::failure();
     // return an allocated copy
static mlir::LogicalResult emitTypeDefDef(TypeDef typeDef, raw_ostream &os) {
   if (typeDef.genStorageClass() && typeDef.getNumParameters() > 0)
     if (mlir::failed(emitStorageClass(typeDef, os)))
       return mlir::failure();
 
   std::string paramFuncParams = constructParameterParameters(typeDef, true);
   SmallVector<StringRef, 5> paramNames;
   paramNames.push_back("");
   typeDef.getParametersAs<StringRef>(
       paramNames, [](TypeParameter param) { return param.getName(); });
   os << llvm::formatv("{0} {0}::get(::mlir::MLIRContext* ctxt{1}) {{\n"
                       "  return Base::get(ctxt{2});\n"
                       "}\n",
                       typeDef.getCppClassName(), paramFuncParams,
                       llvm::join(paramNames, ","));
   // emit the accessors
   if (typeDef.genAccessors()) {
     for (auto parameter : parameters) {
       SmallString<16> name = parameter.getName();
       name[0] = llvm::toUpper(name[0]);
       os << llvm::formatv(
           "{0} {3}::get{1}() const { return getImpl()->{2}; }\n",
           parameter.getCppType(), name, parameter.getName(),
           typeDef.getCppClassName());
     }
   }
 
   // If mnemonic is specified, maybe print a def
   if (typeDef.getMnemonic()) {
     // emit the printer code, if appropriate
     auto printerCode = typeDef.getPrinterCode();
     if (printerCode) {
       // Both the mnenomic and printerCode must be defined (for parity with
       // parserCode)
       os << "void " << typeDef.getCppClassName()
          << "::print(mlir::DialectAsmPrinter& printer) const {\n";
       if (*printerCode == "") {
         // if no code specified, emit error
         llvm::PrintError(
             typeDef.getLoc(),
             typeDef.getName() +
                 ": printer (if specified) must have non-empty code");
         return mlir::failure();
       } else {
         auto fmtCtxt = FmtContext().addSubst("_printer", "printer");
         auto fmtObj = tgfmt(*printerCode, &fmtCtxt);
         fmtObj.format(os);
         os << "\n";
       }
       os << "}\n";
     }
 
     // emit a parser, if appropriate
     auto parserCode = typeDef.getParserCode();
     if (parserCode) {
       // The mnenomic must be defined so the dispatcher knows how to dispatch
       os << "::mlir::Type " << typeDef.getCppClassName()
          << "::parse(::mlir::MLIRContext* ctxt, ::mlir::DialectAsmParser& "
             "parser) "
             "{\n";
       if (*parserCode == "") {
         // if no code specified, emit error
         llvm::PrintError(
             typeDef.getLoc(),
             typeDef.getName() +
                 ": parser (if specified) must have non-empty code");
         return mlir::failure();
       } else {
-        auto fmtCtxt = FmtContext().addSubst("_parser", "parser").addSubst("_ctxt", "ctxt");
+        auto fmtCtxt = FmtContext()
+                           .addSubst("_parser", "parser")
+                           .addSubst("_ctxt", "ctxt");
         auto fmtObj = tgfmt(*parserCode, &fmtCtxt);
         fmtObj.format(os);
         os << "\n";
       }
       os << "}\n";
     }
 
   } // typeDef.getMnemonic()
   return mlir::success();
 }
 
 /// Emit the dialect printer/parser dispatch. Client code should call these
 /// functions from their dialect's print/parse methods.
 static mlir::LogicalResult
 emitParsePrintDispatch(SmallVectorImpl<TypeDef> &typeDefs, raw_ostream &os) {
   if (typeDefs.size() == 0)
     return mlir::success();
   const Dialect &dialect = typeDefs.begin()->getDialect();
   NamespaceEmitter ns(os, dialect);
   os << "::mlir::Type generatedTypeParser(::mlir::MLIRContext* ctxt, "
         "::mlir::DialectAsmParser& parser, ::llvm::StringRef mnemonic) {\n";
   for (auto typeDef : typeDefs) {
     if (typeDef.getMnemonic())
       os << llvm::formatv("  if (mnemonic == {0}::{1}::getMnemonic()) return "
                           "{0}::{1}::parse(ctxt, parser);\n",
                           typeDef.getDialect().getCppNamespace(),
                           typeDef.getCppClassName());
   }
   os << "  return ::mlir::Type();\n";
   os << "}\n\n";
 
   os << "bool generatedTypePrinter(::mlir::Type type, "
         "::mlir::DialectAsmPrinter& "
         "printer) {\n"
      << "  bool notfound = false;\n"
      << "  ::llvm::TypeSwitch<::mlir::Type>(type)\n";
   for (auto typeDef : typeDefs) {
     if (typeDef.getMnemonic())
       os << llvm::formatv("    .Case<{0}::{1}>([&](::mlir::Type t) {{ "
                           "t.dyn_cast<{0}::{1}>().print(printer); })\n",