[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

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

2357

nit: I would swap the names here:

Dialect dialect = owningDialect;

2394

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

2400

Can you add comments to these?

2427

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

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

22

Are these necessary given that you include Record.h?

61

nit: Can you add a better comment here?

101

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

111

This class needs some documentation.

129

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

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

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

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

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

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

There are many cases within the revision still.

2374

nit: Phrase the comments as statements instead of questions.

2440

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

2444

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

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

36

nit: Return the error directly.

63

nit: Merge all of these together using ||

93

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

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

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

101

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 ↗

(On Diff #295632)

nit: Prefer early return instead.

205 ↗

(On Diff #295632)

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

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

[jdd]

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

63

Nice!

93

That's handy

101

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

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

93

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

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

119

The formatting here seems off.

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

36

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

87

Please only use namespaces in source files for classes.

105

nit: Drop the newline here.

mlir/tools/mlir-tblgen/OpDocGen.cpp

273 ↗

(On Diff #296316)

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

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

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

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

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.

llvm/lib/TableGen/Record.cpp

Record::getValueAsOptionalCode(StringRef FieldName) const {
 
   if (CodeInit *CI = dyn_cast<CodeInit>(R->getValue()))
     return CI->getValue();
 
   PrintFatalError(getLoc(),
                   "Record `" + getName() + "', field `" + FieldName +
                       "' exists but does not have a code initializer!");
 }
-llvm::Optional<StringRef>
-Record::getValueAsOptionalString(StringRef FieldName) const {
-  const RecordVal *R = getValue(FieldName);
-  if (!R || !R->getValue())
-    return llvm::Optional<StringRef>();
-  if (isa<UnsetInit>(R->getValue()))
-    return llvm::Optional<StringRef>();
-
-  if (StringInit *SI = dyn_cast<StringInit>(R->getValue()))
-    return SI->getValue();
-  if (CodeInit *CI = dyn_cast<CodeInit>(R->getValue()))
-    return CI->getValue();
-
-  PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + FieldName +
-                                "' does not have a string initializer!");
-}
-llvm::Optional<StringRef>
-Record::getValueAsOptionalCode(StringRef FieldName) const {
-  const RecordVal *R = getValue(FieldName);
-  if (!R || !R->getValue())
-    return llvm::Optional<StringRef>();
-
-  if (CodeInit *CI = dyn_cast<CodeInit>(R->getValue()))
-    return CI->getValue();
-
-  PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + FieldName +
-                                "' does not have a code initializer!");
-}
 
 BitsInit *Record::getValueAsBitsInit(StringRef FieldName) const {
   const RecordVal *R = getValue(FieldName);
   if (!R || !R->getValue())
     PrintFatalError(getLoc(), "Record `" + getName() +
       "' does not have a field named `" + FieldName + "'!\n");
 
   if (BitsInit *BI = dyn_cast<BitsInit>(R->getValue()))

mlir/include/mlir/IR/OpBase.td

 // DAG construct. The arguments to location must be previously captured symbol.
 def location;
 
 // Directive used in result pattern to indicate that no new op are generated,
 // so to replace the matched DAG with an existing SSA value.
 def replaceWithValue;
 
 
 //===----------------------------------------------------------------------===//
 // Data type generation
 //===----------------------------------------------------------------------===//
 
 // Define a new type belonging to a dialect and called 'name'.
 class TypeDef<Dialect owningdialect, string name> {
   Dialect dialect = owningdialect;
   string cppClassName = name # "Type";
 
   // Short summary of the type
   string summary = ?;
   // The longer description of this type
   string description = ?;
 
   // Name of storage class to generate or use
   string storageClass = name # "TypeStorage";
   // Namespace (withing dialect c++ namespace) in which the storage class resides
   string storageNamespace = "detail";
   // Should we generate the storage class? (Or use an existing one?)
   bit genStorageClass = 1;
   // Should we generate the storage class constructor?
   bit hasStorageCustomConstructor = 0;
 
   // This is the list of fields in the storage class (and list of parameters
   // in the creation functions). If empty, don't use or generate a storage class.
   dag parameters = (ins);
 
   // Use the lowercased name as the keyword for parsing/printing. Specify only
-  // if you want tblgen to automatically generate the printer/parser for this
+  // if you want tblgen to generate decls and/or defs of printer/parser for this
   // type.
   string mnemonic = ?;
 
-  // If null, generate just the declarations.
-  // If an empty code block, generate print/parser methods only if 'mnemonic' is specified.
-  // If a non-empty code block, just use that code as the definition code.
-  code printer = [{}];
-  code parser = [{}];
+  // If 'mnemonic' specified,
+  //   If null, generate just the declarations.
+  //   Error if an empty code block.
+  //   If a non-empty code block, just use that code as the definition code.
+  code printer = ?;
+  code parser = ?;
 
   // If set, generate accessors for each Type parameter.
   bit genAccessors = 1;
   // Generate the verifyConstructionInvariants declaration and getChecked method.
   bit genVerifyInvariantsDecl = 0;
   // Extra code to include in the class declaration
   code extraClassDeclaration = [{}];
 }
 
 // 'Parameters' should be subclasses of this or simple strings (which is a
 // shorthand for TypeParameter<"C++Type">).
 class TypeParameter<string type, string desc> {
   // Custom memory allocation code for storage constructor
   code allocator = ?;
   // The C++ type of this parameter
   string cppType = type;
   // A description of this parameter
   string description = desc;
   // The format string for the asm syntax (documentation only)
   string syntax = ?;
 }
 
 // For StringRefs, which require allocation
 class StringRefParameter<string desc> : TypeParameter<"::llvm::StringRef", desc> {
   let allocator = [{$_dst = $_allocator.copyInto($_self);}];
-  let syntax = "\"foo bar\"";
 }
 
 // For standard ArrayRefs, which require allocation
 class ArrayRefParameter<string arrayOf, string desc> : TypeParameter<"::llvm::ArrayRef<" # arrayOf # ">", desc> {
   let allocator = [{$_dst = $_allocator.copyInto($_self);}];
-  let syntax = "[ " # arrayOf # ", " # arrayOf # ", ... ]";
 }
 
 // For classes which require allocation and have their own allocateInto method
 class SelfAllocationParameter<string type, string desc> : TypeParameter<type, desc> {
   let allocator = [{$_dst = $_self.allocateInto($_allocator);}];
 }
 
 // For ArrayRefs which contain things which allocate themselves
 class ArrayRefOfSelfAllocationParameter<string arrayOf, string desc> : TypeParameter<"::llvm::ArrayRef<" # arrayOf # ">", desc> {
   let allocator = [{
-    llvm::SmallVector<}] # arrayOf # [{, 4> tmpFields($_self.size());
+    llvm::SmallVector<}] # arrayOf # [{, 4> tmpFields;
     for (size_t i = 0; i < $_self.size(); i++) {
-      tmpFields[i] = $_self[i].allocateInto($_allocator);
+      tmpFields.push_back($_self[i].allocateInto($_allocator));
     }
     $_dst = $_allocator.copyInto(ArrayRef<}] # arrayOf # [{>(tmpFields));
     }];
-  let syntax = "[ " # arrayOf # ", " # arrayOf # ", ... ]";
 }
 
 
 #endif // OP_BASE

mlir/include/mlir/TableGen/TypeDef.h

 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // TypeDef wrapper to simplify using TableGen Record defining a MLIR type.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TABLEGEN_TYPEDEF_H
 #define MLIR_TABLEGEN_TYPEDEF_H
 
 #include "mlir/Support/LLVM.h"
 #include "mlir/TableGen/Dialect.h"
 #include "llvm/TableGen/Record.h"
 #include <functional>
 #include <string>
 
 namespace mlir {
 namespace tblgen {
 
 class TypeParameter;
 
 // Wrapper class that contains a TableGen TypeDef's record and provides helper
 // methods for accessing them.
 class TypeDef {
 public:
   explicit TypeDef(const llvm::Record *def) : def(def) {}
public:
   // Returns true if we should generate the storage class
   bool genStorageClass() const;
 
   // Should we generate the storage class constructor?
   bool hasStorageCustomConstructor() const;
 
   // Return the list of fields for the storage class and constructors
   void getParameters(SmallVectorImpl<TypeParameter> &) const;
   unsigned getNumParameters() const;
 
   // Iterate though parameters, applying a map function before adding to list
   template <typename T>
   void getParametersAs(SmallVectorImpl<T> &parameters,
                        llvm::function_ref<T(TypeParameter)> map) const;
 
   // Return the keyword/mnemonic to use in the printer/parser methods if we are
   // supposed to auto-generate them
   llvm::Optional<StringRef> getMnemonic() const;
 
-  // Returns the code to use as the types printer method. If empty, generate
-  // just the declaration. If null and mnemonic is non-null, generate the
-  // declaration and definition.
+  // Returns the code to use as the types printer method. If not specified,
+  // return a non-value. Otherwise, return the contents of that code block.
   llvm::Optional<StringRef> getPrinterCode() const;
 
-  // Returns the code to use as the types parser method. If empty, generate
-  // just the declaration. If null and mnemonic is non-null, generate the
-  // declaration and definition.
+  // Returns the code to use as the types parser method. If not specified,
+  // return a non-value. Otherwise, return the contents of that code block.
   llvm::Optional<StringRef> getParserCode() const;
 
   // Should we generate accessors based on the types parameters?
   bool genAccessors() const;
 
   // Return true if we need to generate the verifyConstructionInvariants
   // declaration and getChecked method
   bool genVerifyInvariantsDecl() const;
 
   // Returns the dialects extra class declaration code.
   llvm::Optional<StringRef> getExtraDecls() const;
 
+  // Get the code location (for error printing)
+  llvm::ArrayRef<llvm::SMLoc> getLoc() const;
+
   // Returns whether two TypeDefs are equal by checking the equality of the
   // underlying record.
   bool operator==(const TypeDef &other) const;
 
   // Compares two TypeDefs by comparing the names of the dialects.
   bool operator<(const TypeDef &other) const;
 
   // Returns whether the TypeDef is defined.
   operator bool() const { return def != nullptr; }
 
 private:
   const llvm::Record *def;
 };
 
 // A wrapper class for tblgen TypeParameter, arrays of which belong to TypeDefs
 // to parameterize them.
 class TypeParameter {
 public:
   explicit TypeParameter(const llvm::DagInit *def, unsigned num)
       : def(def), num(num) {}
 
   // Get the parameter name
   StringRef getName() const;
   // If specified, get the custom allocator code for this parameter
   llvm::Optional<StringRef> getAllocator() const;
   // Get the C++ type of this parameter
   StringRef getCppType() const;
   // Get a description of this parameter for documentation purposes
   llvm::Optional<StringRef> getDescription() const;
   // Get the assembly syntax documentation
   StringRef getSyntax() const;
 
 private:
   const llvm::DagInit *def;
   const unsigned num;
 };
 
 template <typename T>
 void TypeDef::getParametersAs(SmallVectorImpl<T> &parameters,
                               llvm::function_ref<T(TypeParameter)> map) const {
   auto parametersDag = def->getValueAsDag("parameters");
   if (parametersDag != nullptr)
     for (unsigned i = 0; i < parametersDag->getNumArgs(); i++)
       parameters.push_back(map(TypeParameter(parametersDag, i)));
 }
 
 } // end namespace tblgen
 } // end namespace mlir
 
 #endif // MLIR_TABLEGEN_TYPEDEF_H

mlir/include/mlir/TableGen/TypeDefGenHelpers.h

-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// Accessory functions / templates to assist autogenerated code. The print/parse
-// struct templates define standard serializations which can be overridden with
-// custom printers/parsers. These structs can be used for temporary stack
-// storage also.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef MLIR_TABLEGEN_PARSER_HELPERS_H
-#define MLIR_TABLEGEN_PARSER_HELPERS_H
-
-#include "mlir/IR/Attributes.h"
-#include "mlir/IR/DialectImplementation.h"
-#include <type_traits>
-
-namespace mlir {
-namespace tblgen {
-namespace parser_helpers {
-
-//===----------------------------------------------------------------------===//
-//
-// Template enables identify various types for which we have specializations
-//
-//===----------------------------------------------------------------------===//
-
-template <typename...>
-using void_t = void;
-
-template <typename T>
-using remove_constref =
-    typename std::remove_const<typename std::remove_reference<T>::type>::type;
-
-template <typename T, typename TestType>
-using enable_if_type = typename std::enable_if<
-    std::is_same<remove_constref<T>, TestType>::value>::type;
-
-template <typename T, typename TestType>
-using is_not_type =
-    std::is_same<typename std::is_same<remove_constref<T>, TestType>::type,
-                 typename std::false_type::type>;
-
-template <typename T>
-using get_indexable_type = remove_constref<decltype(std::declval<T>()[0])>;
-
-template <typename T>
-using enable_if_arrayref =
-    enable_if_type<T, typename mlir::ArrayRef<get_indexable_type<T>>>;
-
-//===----------------------------------------------------------------------===//
-//
-// These structs handle Type parameters' parsing for common types
-//
-//===----------------------------------------------------------------------===//
-
-template <typename T, typename Enable = void>
-struct Parse {
-  ParseResult go(MLIRContext *ctxt,        // The context, should it be needed
-                 DialectAsmParser &parser, // The parser
-                 StringRef parameterName,  // Type parameter name, for error
-                                           // printing (if necessary)
-                 T &result);               // Put the parsed value here
-};
-
-// Int specialization
-template <typename T>
-using enable_if_integral_type =
-    typename std::enable_if<std::is_integral<T>::value &&
-                            is_not_type<T, bool>::value>::type;
-template <typename T>
-struct Parse<T, enable_if_integral_type<T>> {
-  ParseResult go(MLIRContext *ctxt, DialectAsmParser &parser,
-                 StringRef parameterName, T &result) {
-    return parser.parseInteger(result);
-  }
-};
-
-// Bool specialization -- 'true' / 'false' instead of 0/1
-template <typename T>
-struct Parse<T, enable_if_type<T, bool>> {
-  ParseResult go(MLIRContext *ctxt, DialectAsmParser &parser,
-                 StringRef parameterName, bool &result) {
-    StringRef boolStr;
-    if (parser.parseKeyword(&boolStr))
-      return mlir::failure();
-    if (!boolStr.compare_lower("false")) {
-      result = false;
-      return mlir::success();
-    }
-    if (!boolStr.compare_lower("true")) {
-      result = true;
-      return mlir::success();
-    }
-    llvm::errs() << "Parser expected true/false, not '" << boolStr << "'\n";
-    return mlir::failure();
-  }
-};
-
-// Float specialization
-template <typename T>
-using enable_if_float_type =
-    typename std::enable_if<std::is_floating_point<T>::value>::type;
-template <typename T>
-struct Parse<T, enable_if_float_type<T>> {
-  ParseResult go(MLIRContext *ctxt, DialectAsmParser &parser,
-                 StringRef parameterName, T &result) {
-    double d;
-    if (parser.parseFloat(d))
-      return mlir::failure();
-    result = d;
-    return mlir::success();
-  }
-};
-
-// mlir::Type specialization
-template <typename T>
-using enable_if_mlir_type =
-    typename std::enable_if<std::is_convertible<T, mlir::Type>::value>::type;
-template <typename T>
-struct Parse<T, enable_if_mlir_type<T>> {
-  ParseResult go(MLIRContext *ctxt, DialectAsmParser &parser,
-                 StringRef parameterName, T &result) {
-    Type type;
-    auto loc = parser.getCurrentLocation();
-    if (parser.parseType(type))
-      return mlir::failure();
-    if ((result = type.dyn_cast_or_null<T>()) == nullptr) {
-      parser.emitError(loc, "expected type '" + parameterName + "'");
-      return mlir::failure();
-    }
-    return mlir::success();
-  }
-};
-
-// StringRef specialization
-template <typename T>
-struct Parse<T, enable_if_type<T, StringRef>> {
-  ParseResult go(MLIRContext *ctxt, DialectAsmParser &parser,
-                 StringRef parameterName, StringRef &result) {
-    StringAttr a;
-    if (parser.parseAttribute<StringAttr>(a))
-      return mlir::failure();
-    result = a.getValue();
-    return mlir::success();
-  }
-};
-
-// ArrayRef specialization
-template <typename T>
-struct Parse<T, enable_if_arrayref<T>> {
-  using inner_t = get_indexable_type<T>;
-  Parse<inner_t> innerParser;
-  llvm::SmallVector<inner_t, 4> parameters;
-
-  ParseResult go(MLIRContext *ctxt, DialectAsmParser &parser,
-                 StringRef parameterName, ArrayRef<inner_t> &result) {
-    if (parser.parseLSquare())
-      return mlir::failure();
-    if (failed(parser.parseOptionalRSquare())) {
-      do {
-        inner_t parameter; // = std::declval<inner_t>();
-        innerParser.go(ctxt, parser, parameterName, parameter);
-        parameters.push_back(parameter);
-      } while (succeeded(parser.parseOptionalComma()));
-      if (parser.parseRSquare())
-        return mlir::failure();
-    }
-    result = ArrayRef<inner_t>(parameters);
-    return mlir::success();
-  }
-};
-
-//===----------------------------------------------------------------------===//
-//
-// These structs handle Type parameters' printing for common types
-//
-//===----------------------------------------------------------------------===//
-
-template <typename T, typename Enable = void>
-struct Print {
-  static void go(DialectAsmPrinter &printer, const T &obj);
-};
-
-// Several C++ types can just be piped into the printer
-template <typename T>
-using enable_if_trivial_print =
-    typename std::enable_if<std::is_convertible<T, mlir::Type>::value ||
-                            (std::is_integral<T>::value &&
-                             is_not_type<T, bool>::value) ||
-                            std::is_floating_point<T>::value>::type;
-template <typename T>
-struct Print<T, enable_if_trivial_print<remove_constref<T>>> {
-  static void go(DialectAsmPrinter &printer, const T &obj) { printer << obj; }
-};
-
-// StringRef has to be quoted to match the parse specialization above
-template <typename T>
-struct Print<T, enable_if_type<T, StringRef>> {
-  static void go(DialectAsmPrinter &printer, const T &obj) {
-    printer << "\"" << obj << "\"";
-  }
-};
-
-// bool specialization
-template <typename T>
-struct Print<T, enable_if_type<T, bool>> {
-  static void go(DialectAsmPrinter &printer, const bool &obj) {
-    if (obj)
-      printer << "true";
-    else
-      printer << "false";
-  }
-};
-
-// ArrayRef specialization
-template <typename T>
-struct Print<T, enable_if_arrayref<T>> {
-  static void go(DialectAsmPrinter &printer,
-                 const ArrayRef<get_indexable_type<T>> &obj) {
-    printer << "[";
-    for (size_t i = 0; i < obj.size(); i++) {
-      Print<remove_constref<decltype(obj[i])>>::go(printer, obj[i]);
-      if (i < obj.size() - 1)
-        printer << ", ";
-    }
-    printer << "]";
-  }
-};
-
-} // end namespace parser_helpers
-} // end namespace tblgen
-} // end namespace mlir
-
-#endif // MLIR_TABLEGEN_PARSER_HELPERS_H

mlir/lib/TableGen/TypeDef.cpp

 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 
 using namespace mlir;
 using namespace mlir::tblgen;
 
 Dialect TypeDef::getDialect() const {
   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 {
   auto value = def->getValueAsString("extraClassDeclaration");
   return value.empty() ? llvm::Optional<StringRef>() : value;
 }
-
+llvm::ArrayRef<llvm::SMLoc> TypeDef::getLoc() const { return def->getLoc(); }
 bool TypeDef::operator==(const TypeDef &other) const {
   return def == other.def;
 }
 
 bool TypeDef::operator<(const TypeDef &other) const {
   return getName() < other.getName();
 }
 
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/test/lib/Dialect/Test/TestTypeDefs.td

 
 // To get the test dialect def
 include "TestOps.td"
 
 class Test_Type<string name> : TypeDef<Test_Dialect, name> { }
 
 def SimpleTypeA : Test_Type<"SimpleA"> {
     let mnemonic = "smpla";
+
+    let printer = [{ $_printer << "smpla"; }];
+    let parser = [{ return get($_ctxt); }];
 }
 
 // A more complex parameterized type
 def CompoundTypeA : Test_Type<"CompoundA"> {
     // Override the default mnemonic
     let mnemonic = "cmpnd_a";
 
     // What types do we contain?
     let parameters = (
         ins
         "int":$widthOfSomething,
-        "::mlir::SimpleAType": $exampleTdType,
-        ArrayRefParameter<"int", "">: $arrayOfInts,
-        ArrayRefParameter<"Type", "An example of an array of types as a type parameter">: $arrayOfTypes,
-        "::llvm::StringRef": $simpleString,
-        ArrayRefParameter<"::llvm::StringRef", "">: $arrayOfStrings
+        "::mlir::Type":$oneType,
+        ArrayRefParameter<"int", "An example of an array of ints">: $arrayOfInts
     );
 
     let extraClassDeclaration = [{
         struct SomeCppStruct {};
     }];
 }
 
 def IntegerType : Test_Type<"TestInteger"> {
-    let mnemonic = "int";
-    let genVerifyInvariantsDecl = 1;
-    let parameters = (
-        ins
-        "::mlir::TestIntegerType::SignednessSemantics":$signedness,
-        "unsigned":$width
-    );
 
-    let extraClassDeclaration = [{
+  let printer = [{
+    $_printer << "int<";
+    Print($_printer, getImpl()->signedness);
+    $_printer << ", " << getImpl()->width << ">";
+  }];
+
+  let parser = [{
+    if (parser.parseLess()) return Type();
+    SignednessSemantics signedness;
+    if (Parse($_parser, signedness)) return mlir::Type();
+    if ($_parser.parseComma()) return Type();
+    int width;
+    if ($_parser.parseInteger(width)) return Type();
+    if ($_parser.parseGreater()) return Type();
+    return get(ctxt, signedness, width);
+  }];
+
   /// Signedness semantics.
   enum SignednessSemantics {
     Signless, /// No signedness semantics
     Signed,   /// Signed integer
     Unsigned, /// Unsigned integer
   };
 
   /// This extra function is necessary since it doesn't include signedness
   static IntegerType getChecked(unsigned width, Location location);
 
   /// Return true if this is a signless integer type.
   bool isSignless() const { return getSignedness() == Signless; }
   /// Return true if this is a signed integer type.
   bool isSigned() const { return getSignedness() == Signed; }
   /// Return true if this is an unsigned integer type.
   bool isUnsigned() const { return getSignedness() == Unsigned; }
     }];
 }
 
 class FieldInfo_Type<string name> : Test_Type<name> {
   let parameters = (
       ins
       ArrayRefOfSelfAllocationParameter<"::mlir::FieldInfo", "Models struct fields">: $fields
   );
 
   let printer = [{
-    printer << "struct" << "<";
+      $_printer << "struct" << "<";
       for (size_t i=0; i<getImpl()->fields.size(); i++) {
       const auto& field = getImpl()->fields[i];
-    printer << "{" << field.name << "," << field.type << "}";
+      $_printer << "{" << field.name << "," << field.type << "}";
       if (i < getImpl()->fields.size() - 1)
-        printer << ",";
+          $_printer << ",";
       }
-    printer << ">";
+      $_printer << ">";
   }];
 
   let parser = [{
       llvm::SmallVector<FieldInfo, 4> parameters;
-    if (parser.parseLess()) return Type();
-    while (mlir::succeeded(parser.parseOptionalLBrace())) {
+      if ($_parser.parseLess()) return Type();
+      while (mlir::succeeded($_parser.parseOptionalLBrace())) {
           StringRef name;
-        if (parser.parseKeyword(&name)) return Type();
-        if (parser.parseComma()) return Type();
+          if ($_parser.parseKeyword(&name)) return Type();
+          if ($_parser.parseComma()) return Type();
           Type type;
-        if (parser.parseType(type)) return Type();
-        if (parser.parseRBrace()) return Type();
+          if ($_parser.parseType(type)) return Type();
+          if ($_parser.parseRBrace()) return Type();
           parameters.push_back(FieldInfo {name, type});
-        if (parser.parseOptionalComma()) break;
+          if ($_parser.parseOptionalComma()) break;
       }
-    if (parser.parseGreater()) return Type();
-    return get(ctxt, parameters);
+      if ($_parser.parseGreater()) return Type();
+      return get($_ctxt, parameters);
   }];
 }
 
 def StructType : FieldInfo_Type<"Struct"> {
     let mnemonic = "struct";
 }
 
 
 #endif // TEST_TYPEDEFS

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

 //===- TestTypes.cpp - MLIR Test Dialect Types ----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains types defined by the TestDialect for testing various
 // features of MLIR.
 //
 //===----------------------------------------------------------------------===//
 
 #include "TestTypes.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/Types.h"
-#include "mlir/TableGen/TypeDefGenHelpers.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/TypeSwitch.h"
 
 namespace mlir {
-namespace tblgen {
-namespace parser_helpers {
 
 // Custom parser for SignednessSemantics
-template <>
-struct Parse<TestIntegerType::SignednessSemantics> {
-  static ParseResult go(MLIRContext *ctxt, DialectAsmParser &parser,
-                        StringRef parameterName,
+static ParseResult Parse(DialectAsmParser &parser,
                          TestIntegerType::SignednessSemantics &result) {
-    StringRef signStr;
-    auto loc = parser.getCurrentLocation();
-    if (parser.parseKeyword(&signStr))
-      return mlir::failure();
-    if (signStr.compare_lower("u") || signStr.compare_lower("unsigned"))
-      result = TestIntegerType::SignednessSemantics::Unsigned;
-    else if (signStr.compare_lower("s") || signStr.compare_lower("signed"))
-      result = TestIntegerType::SignednessSemantics::Signed;
-    else if (signStr.compare_lower("n") || signStr.compare_lower("none"))
-      result = TestIntegerType::SignednessSemantics::Signless;
-    else {
-      parser.emitError(loc, "expected signed, unsigned, or none");
-      return mlir::failure();
-    }
-    return mlir::success();
-  }
-};
 
 // Custom printer for SignednessSemantics
-template <>
-struct Print<TestIntegerType::SignednessSemantics> {
-  static void go(DialectAsmPrinter &printer,
+static void Print(DialectAsmPrinter &printer,
                   const TestIntegerType::SignednessSemantics &ss) {
-    switch (ss) {
-    case TestIntegerType::SignednessSemantics::Unsigned:
-      printer << "unsigned";
-      break;
-    case TestIntegerType::SignednessSemantics::Signed:
-      printer << "signed";
-      break;
-    case TestIntegerType::SignednessSemantics::Signless:
-      printer << "none";
-      break;
-    }
-  }
-};
 
-} // namespace parser_helpers
-} // namespace tblgen
+Type CompoundAType::parse(::mlir::MLIRContext *ctxt,
+                          ::mlir::DialectAsmParser &parser) {
+  int widthOfSomething;
+  Type oneType;
+  SmallVector<int, 4> arrayOfInts;
+  if (parser.parseLess())
+    return Type();
+  if (parser.parseInteger(widthOfSomething))
+    return Type();
+  if (parser.parseComma())
+    return Type();
+  if (parser.parseType(oneType))
+    return Type();
+  if (parser.parseComma())
+    return Type();
+
+  if (parser.parseLSquare())
+    return Type();
+  int i;
+  while (!*parser.parseOptionalInteger(i)) {
+    arrayOfInts.push_back(i);
+    if (parser.parseOptionalComma())
+      break;
+  }
+  if (parser.parseRSquare())
+    return Type();
+  if (parser.parseGreater())
+    return Type();
+
+  return get(ctxt, widthOfSomething, oneType, arrayOfInts);
+}
+void CompoundAType::print(::mlir::DialectAsmPrinter &printer) const {
+  printer << "cmpnd_a<" << getWidthOfSomething() << ", " << getOneType()
+          << ", [";
+  auto intArray = getArrayOfInts();
+  for (size_t idx = 0; idx < intArray.size(); idx++) {
+    printer << intArray[idx];
+    if (idx < intArray.size() - 1)
+      printer << ", ";
+  }
+  printer << "]>";
+}
 
 bool operator==(const FieldInfo &a, const FieldInfo &b) {
   return a.name == b.name && a.type == b.type;
 }
 
 llvm::hash_code hash_value(const FieldInfo &fi) {
   return llvm::hash_combine(fi.name, fi.type);
 }
 
 // Example type validity checker
 LogicalResult TestIntegerType::verifyConstructionInvariants(
     mlir::Location loc, mlir::TestIntegerType::SignednessSemantics ss,
     unsigned int width) {
 
   if (width > 8)
     return mlir::failure();
   return mlir::success();
 }
 
-struct TestType;
 } // end namespace mlir
 
 #define GET_TYPEDEF_CLASSES
 #include "TestTypeDefs.cpp.inc"

mlir/test/mlir-tblgen/testdialect-typedefs.mlir

 // RUN: mlir-opt %s | mlir-opt -verify-diagnostics | FileCheck %s
 
 //////////////
 // Tests the types in the 'Test' dialect, not the ones in 'typedefs.mlir'
 
 // CHECK: @simpleA(%arg0: !test.smpla)
 func @simpleA(%A : !test.smpla) -> () {
   return
 }
 
-// CHECK: @compoundA(%arg0: !test.cmpnd_a<1, !test.smpla, [5, 6], [i1, i2], "example str", ["array", "of", "strings"]>)
-func @compoundA(%A : !test.cmpnd_a<1, !test.smpla, [5, 6], [i1, i2], "example str", ["array","of","strings"]>) -> () {
+// CHECK: @compoundA(%arg0: !test.cmpnd_a<1, !test.smpla, [5, 6]>)
+func @compoundA(%A : !test.cmpnd_a<1, !test.smpla, [5, 6]>)-> () {
   return
 }
 
 // CHECK: @testInt(%arg0: !test.int<unsigned, 8>, %arg1: !test.int<unsigned, 2>, %arg2: !test.int<unsigned, 1>)
 func @testInt(%A : !test.int<s, 8>, %B : !test.int<unsigned, 2>, %C : !test.int<n, 1>) {
   return
 }
 
 // CHECK: @structTest(%arg0: !test.struct<{field1,!test.smpla},{field2,!test.int<unsigned, 3>}>)
 func @structTest (%A : !test.struct< {field1, !test.smpla}, {field2, !test.int<none, 3>} > ) {
-  return 
+  return
 }

mlir/test/mlir-tblgen/typedefs.td

// DEF-NOT: TestDialect
     let name = "TestDialect";
     let cppNamespace = "::mlir::test";
 }
 
 class TestType<string name> : TypeDef<Test_Dialect, name> { }
 
 def A_SimpleTypeA : TestType<"SimpleA"> {
 // DECL: class SimpleAType: public ::mlir::Type
-// DECL: static ::mlir::Type parse(::mlir::MLIRContext* ctxt, ::mlir::DialectAsmParser& parser);
-// DECL: void print(::mlir::DialectAsmPrinter& printer) const;
 }
 
 // A more complex parameterized type
 def B_CompoundTypeA : TestType<"CompoundA"> {
   let summary = "A more complex parameterized type";
   let description = "This type is to test a reasonably complex type";
   let mnemonic = "cmpnd_a";
   let parameters = (
       ins
       "int":$widthOfSomething,
       "::mlir::test::SimpleTypeA": $exampleTdType,
       "SomeCppStruct": $exampleCppType,
       ArrayRefParameter<"int", "Matrix dimensions">:$dims
   );
 
   let genVerifyInvariantsDecl = 1;
 
 // DECL-LABEL: class CompoundAType: public ::mlir::Type
 // DECL: static ::mlir::LogicalResult verifyConstructionInvariants(Location loc, int widthOfSomething, ::mlir::test::SimpleTypeA exampleTdType, SomeCppStruct exampleCppType, ::llvm::ArrayRef<int> dims);
 // DECL: static CompoundAType getChecked(Location loc, int widthOfSomething, ::mlir::test::SimpleTypeA exampleTdType, SomeCppStruct exampleCppType, ::llvm::ArrayRef<int> dims);
 // DECL: static ::llvm::StringRef getMnemonic() { return "cmpnd_a"; }
+// DECL: static ::mlir::Type parse(::mlir::MLIRContext* ctxt, ::mlir::DialectAsmParser& parser);
+// DECL: void print(::mlir::DialectAsmPrinter& printer) const;
 // DECL: int getWidthOfSomething() const;
 // DECL: ::mlir::test::SimpleTypeA getExampleTdType() const;
 // DECL: SomeCppStruct getExampleCppType() const;
 }
 
 def C_IndexType : TestType<"Index"> {
     let mnemonic = "index";
 
     let parameters = (
       ins
       StringRefParameter<"Label for index">:$label
     );
 
 // DECL-LABEL: class IndexType: public ::mlir::Type
+// DECL: static ::llvm::StringRef getMnemonic() { return "index"; }
 // DECL: static ::mlir::Type parse(::mlir::MLIRContext* ctxt, ::mlir::DialectAsmParser& parser);
 // DECL: void print(::mlir::DialectAsmPrinter& printer) const;
-// DECL: static ::llvm::StringRef getMnemonic() { return "index"; }
 }
 
 def D_SingleParameterType : TestType<"SingleParameter"> {
   let parameters = (
     ins
     "int": $num
   );
 // DECL-LABEL: struct SingleParameterTypeStorage;
 // DECL-LABEL: class SingleParameterType
 // DECL-NEXT:                   detail::SingleParameterTypeStorage
-// DECL: static ::mlir::Type parse(::mlir::MLIRContext* ctxt, ::mlir::DialectAsmParser& parser);
-// DECL: void print(::mlir::DialectAsmPrinter& printer) const;
 }
 
 def E_IntegerType : TestType<"Integer"> {
-    let parser = [{}];
-    let printer = [{}];
     let mnemonic = "int";
     let genVerifyInvariantsDecl = 1;
     let parameters = (
         ins
-        "SignednessSemantics":$signedness, 
+        "SignednessSemantics":$signedness,
         TypeParameter<"unsigned", "Bitwdith of integer">:$width
     );
 
 // DECL-LABEL: IntegerType: public ::mlir::Type
 
     let extraClassDeclaration = [{
   /// Signedness semantics.
   enum SignednessSemantics {

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:
     /// Inherit some necessary constructors from 'TypeBase'.
     using Base::Base;
+
 )";
 
 // snippet for print/parse
 static const char *const typeDefParsePrint = R"(
     static ::mlir::Type parse(::mlir::MLIRContext* ctxt, ::mlir::DialectAsmParser& parser);
     void print(::mlir::DialectAsmPrinter& printer) const;
 )";
 
os << llvm::formatv(
         typeDefDeclParametricBeginStr, typeDef.getCppClassName(),
         typeDef.getStorageNamespace(), typeDef.getStorageClassName());
 
   // Emit the extra declarations first in case there's a type definition in
   // there
   if (llvm::Optional<StringRef> extraDecl = typeDef.getExtraDecls())
     os << *extraDecl;
 
+  // Get the CppType1 param1, CppType2 param2 argument list
   std::string parameterParameters = constructParameterParameters(typeDef, true);
 
-  // parse/print
-  os << typeDefParsePrint;
+  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());
static mlir::LogicalResult emitTypeDefList(SmallVectorImpl<TypeDef> &typeDefs,
   }
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // 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);
static mlir::LogicalResult emitStorageClass(TypeDef typeDef, raw_ostream &os) {
   auto parameterNames = llvm::map_range(
       parameters, [](TypeParameter parameter) { return parameter.getName(); });
   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)))
os << "      " << parameter.getCppType() << " " << parameter.getName()
        << ";\n";
   }
   os << "  };\n";
   os << "} // namespace " << typeDef.getStorageNamespace() << "\n";
 
   return mlir::success();
 }
 
-/// Emit the body of an autogenerated printer
-static mlir::LogicalResult emitPrinterAutogen(TypeDef typeDef,
-                                              raw_ostream &os) {
-  if (auto mnemonic = typeDef.getMnemonic()) {
-    SmallVector<TypeParameter, 4> parameters;
-    typeDef.getParameters(parameters);
-
-    os << "  printer << \"" << *mnemonic << "\";\n";
-
-    // if non-parametric, we're done
-    if (parameters.size() > 0) {
-      os << "  printer << \"<\";\n";
-
-      // emit a printer for each parameter separated by ','.
-      // printer structs for common C++ types are defined in
-      // TypeDefGenHelpers.h, which must be #included by the consuming code.
-      for (auto *parameterIter = parameters.begin();
-           parameterIter < parameters.end(); parameterIter++) {
-        // Each printer struct must be put on the stack then 'go' called
-        os << "  ::mlir::tblgen::parser_helpers::Print<"
-           << parameterIter->getCppType() << ">::go(printer, getImpl()->"
-           << parameterIter->getName() << ");\n";
-
-        // emit the comma unless we're the last parameter
-        if (parameterIter < parameters.end() - 1) {
-          os << "  printer << \", \";\n";
-        }
-      }
-      os << "  printer << \">\";\n";
-    }
-  }
-  return mlir::success();
-}
-
-/// Emit the body of an autogenerated parser
-static mlir::LogicalResult emitParserAutogen(TypeDef typeDef, raw_ostream &os) {
-  SmallVector<TypeParameter, 4> parameters;
-  typeDef.getParameters(parameters);
-
-  // by the time we get to this function, the mnenomic has already been parsed
-  if (parameters.size() > 0) {
-    os << "  if (parser.parseLess()) return ::mlir::Type();\n";
-
-    // emit a parser for each parameter separated by ','.
-    // parse structs for common C++ types are defined in
-    // TypeDefGenHelpers.h, which must be #included by the consuming code.
-    for (auto *parameterIter = parameters.begin();
-         parameterIter < parameters.end(); parameterIter++) {
-      os << "  " << parameterIter->getCppType() << " "
-         << parameterIter->getName() << ";\n";
-      os << llvm::formatv(
-          "  ::mlir::tblgen::parser_helpers::Parse<{0}> {1}Parser;\n",
-          parameterIter->getCppType(), parameterIter->getName());
-      os << llvm::formatv("  if ({0}Parser.go(ctxt, parser, \"{1}\", {0})) "
-                          "return ::mlir::Type();\n",
-                          parameterIter->getName(),
-                          parameterIter->getCppType());
-
-      // parse a comma unless we're the last parameter
-      if (parameterIter < parameters.end() - 1) {
-        os << "  if (parser.parseComma()) return ::mlir::Type();\n";
-      }
-    }
-    os << "  if (parser.parseGreater()) return ::mlir::Type();\n";
-    // done with the parsing
-
-    // all the parameters are now in variables named the same as the parameters
-    auto parameterNames =
-        llvm::map_range(parameters, [](TypeParameter parameter) {
-          return parameter.getName();
-        });
-    os << "  return get(ctxt, " << llvm::join(parameterNames, ", ") << ");\n";
-  } else {
-    os << "  return get(ctxt);\n";
-  }
-  return mlir::success();
-}
-
 /// Print all the typedef-specific definition code
 static mlir::LogicalResult emitTypeDefDef(TypeDef typeDef, raw_ostream &os) {
   NamespaceEmitter ns(os, typeDef.getDialect());
   SmallVector<TypeParameter, 4> parameters;
   typeDef.getParameters(parameters);
 
   // emit the storage class, if requested and necessary
   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 && typeDef.getMnemonic()) {
+    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, autogenerate a parser
-      if (mlir::failed(emitPrinterAutogen(typeDef, os)))
+        // if no code specified, emit error
+        llvm::PrintError(
+            typeDef.getLoc(),
+            typeDef.getName() +
+                ": printer (if specified) must have non-empty code");
         return mlir::failure();
       } else {
-      os << *printerCode << "\n";
+        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 && typeDef.getMnemonic()) {
+    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 (mlir::failed(emitParserAutogen(typeDef, os)))
+        // if no code specified, emit error
+        llvm::PrintError(
+            typeDef.getLoc(),
+            typeDef.getName() +
+                ": parser (if specified) must have non-empty code");
         return mlir::failure();
-    } else
-      os << *parserCode << "\n";
+      } else {
+        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",