[mlir] Generate Dialect constructors in .cpp instead of .h

[rriddle]

Summary

By generating in the .h file, we were forcing dialects to include
a lot of additional header files because:

• Fields of the dialect, e.g. std::unique_ptr<>, were unable to use forward declarations.
• Dependent dialects are loaded in the constructor, requiring the full definition of each dependent dialect (which, depending on the file structure of the dialect, may include the operations).

By generating in the .cpp we get much faster builds, and also
better align with the rest of the code base.

Fixes #55044

[lattner]

Fantastic, thank you!

mlir/tools/mlir-tblgen/DialectGen.cpp

 //===----------------------------------------------------------------------===//
 // GEN: Dialect declarations
 //===----------------------------------------------------------------------===//
 
 /// The code block for the start of a dialect class declaration.
 ///
 /// {0}: The name of the dialect class.
 /// {1}: The dialect namespace.
-/// {2}: initialization code that is emitted in the ctor body before calling
-/// initialize()
 static const char *const dialectDeclBeginStr = R"(
 class {0} : public ::mlir::Dialect {
-  explicit {0}(::mlir::MLIRContext *context)
-    : ::mlir::Dialect(getDialectNamespace(), context,
-      ::mlir::TypeID::get<{0}>()) {{
-    {2}
-    initialize();
-  }
+  explicit {0}(::mlir::MLIRContext *context);
 
   void initialize();
   friend class ::mlir::MLIRContext;
 public:
   ~{0}() override;
   static constexpr ::llvm::StringLiteral getDialectNamespace() {
     return ::llvm::StringLiteral("{1}");
   }

 )";
 
 /// Generate the declaration for the given dialect class.
 static void
 emitDialectDecl(Dialect &dialect,
                 const iterator_range<DialectFilterIterator> &dialectAttrs,
                 const iterator_range<DialectFilterIterator> &dialectTypes,
                 raw_ostream &os) {
-  /// Build the list of dependent dialects
-  std::string dependentDialectRegistrations;
-  {
-    llvm::raw_string_ostream dialectsOs(dependentDialectRegistrations);
-    for (StringRef dependentDialect : dialect.getDependentDialects())
-      dialectsOs << llvm::formatv(dialectRegistrationTemplate,
-                                  dependentDialect);
-  }
-
   // Emit all nested namespaces.
   {
     NamespaceEmitter nsEmitter(os, dialect);
 
     // Emit the start of the decl.
     std::string cppName = dialect.getCppClassName();
-    os << llvm::formatv(dialectDeclBeginStr, cppName, dialect.getName(),
-                        dependentDialectRegistrations);
+    os << llvm::formatv(dialectDeclBeginStr, cppName, dialect.getName());
 
     // Check for any attributes/types registered to this dialect.  If there are,
     // add the hooks for parsing/printing.
     if (!dialectAttrs.empty() && dialect.useDefaultAttributePrinterParser())
       os << attrParserDecl;
     if (!dialectTypes.empty() && dialect.useDefaultTypePrinterParser())
       os << typeParserDecl;
 
emitDialectDecl(*dialect, filterForDialect<Attribute>(attrDefs, *dialect),
                   filterForDialect<Type>(typeDefs, *dialect), os);
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // GEN: Dialect definitions
 //===----------------------------------------------------------------------===//
 
+/// The code block to generate a dialect constructor definition.
+///
+/// {0}: The name of the dialect class.
+/// {1}: initialization code that is emitted in the ctor body before calling
+///      initialize().
+static const char *const dialectConstructorStr = R"(
+{0}::{0}(::mlir::MLIRContext *context) 
+    : ::mlir::Dialect(getDialectNamespace(), context, ::mlir::TypeID::get<{0}>()) {{
+  {1}
+  initialize();
+}
+)";
+
 /// The code block to generate a default desturctor definition.
 ///
 /// {0}: The name of the dialect class.
 static const char *const dialectDestructorStr = R"(
 {0}::~{0}() = default;
 
 )";
 
 static void emitDialectDef(Dialect &dialect, raw_ostream &os) {
+  std::string cppClassName = dialect.getCppClassName();
+
   // Emit the TypeID explicit specializations to have a single symbol def.
   if (!dialect.getCppNamespace().empty())
     os << "MLIR_DEFINE_EXPLICIT_TYPE_ID(" << dialect.getCppNamespace()
-       << "::" << dialect.getCppClassName() << ")\n";
+       << "::" << cppClassName << ")\n";
 
   // Emit all nested namespaces.
   NamespaceEmitter nsEmitter(os, dialect);
 
+  /// Build the list of dependent dialects.
+  std::string dependentDialectRegistrations;
+  {
+    llvm::raw_string_ostream dialectsOs(dependentDialectRegistrations);
+    for (StringRef dependentDialect : dialect.getDependentDialects())
+      dialectsOs << llvm::formatv(dialectRegistrationTemplate,
+                                  dependentDialect);
+  }
+
+  // Emit the constructor and destructor.
+  os << llvm::formatv(dialectConstructorStr, cppClassName,
+                      dependentDialectRegistrations);
   if (!dialect.hasNonDefaultDestructor())
-    os << llvm::formatv(dialectDestructorStr, dialect.getCppClassName());
+    os << llvm::formatv(dialectDestructorStr, cppClassName);
 }
 
 static bool emitDialectDefs(const llvm::RecordKeeper &recordKeeper,
                             raw_ostream &os) {
   emitSourceFileHeader("Dialect Definitions", os);
 
   auto dialectDefs = recordKeeper.getAllDerivedDefinitions("Dialect");
   if (dialectDefs.empty())