[mlir][NFC] Use fold expressions instead of variadic class templates for adding operations/etc. to dialects.

[rriddle]

Summary

This is much simpler, and also greatly reduces the generated template recursion stack.

[matthiaskramm]

Thanks for the fix!

mlir/include/mlir/IR/Dialect.h

protected:
   ///       with the namespace followed by '.'.
   /// Example:
   ///       - "tf" for the TensorFlow ops like "tf.add".
   Dialect(StringRef name, MLIRContext *context);
 
   /// This method is used by derived classes to add their operations to the set.
   ///
   template <typename... Args> void addOperations() {
-    VariadicOperationAdder<Args...>::addToSet(*this);
+    (void)std::initializer_list<int>{
+        0, (addOperation(AbstractOperation::get<Args>(*this)), 0)...};
   }
 
-  // It would be nice to define this as variadic functions instead of a nested
-  // variadic type, but we can't do that: function template partial
-  // specialization is not allowed, and we can't define an overload set because
-  // we don't have any arguments of the types we are pushing around.
-  template <typename First, typename... Rest> class VariadicOperationAdder {
-  public:
-    static void addToSet(Dialect &dialect) {
-      dialect.addOperation(AbstractOperation::get<First>(dialect));
-      VariadicOperationAdder<Rest...>::addToSet(dialect);
-    }
-  };
-
-  template <typename First> class VariadicOperationAdder<First> {
-  public:
-    static void addToSet(Dialect &dialect) {
-      dialect.addOperation(AbstractOperation::get<First>(dialect));
-    }
-  };
-
   void addOperation(AbstractOperation opInfo);
 
   /// This method is used by derived classes to add their types to the set.
   template <typename... Args> void addTypes() {
-    VariadicSymbolAdder<Args...>::addToSet(*this);
+    (void)std::initializer_list<int>{0, (addSymbol(Args::getClassID()), 0)...};
   }
 
   /// This method is used by derived classes to add their attributes to the set.
   template <typename... Args> void addAttributes() {
-    VariadicSymbolAdder<Args...>::addToSet(*this);
+    (void)std::initializer_list<int>{0, (addSymbol(Args::getClassID()), 0)...};
   }
 
-  // It would be nice to define this as variadic functions instead of a nested
-  // variadic type, but we can't do that: function template partial
-  // specialization is not allowed, and we can't define an overload set
-  // because we don't have any arguments of the types we are pushing around.
-  template <typename First, typename... Rest> struct VariadicSymbolAdder {
-    static void addToSet(Dialect &dialect) {
-      VariadicSymbolAdder<First>::addToSet(dialect);
-      VariadicSymbolAdder<Rest...>::addToSet(dialect);
-    }
-  };
-
-  template <typename First> struct VariadicSymbolAdder<First> {
-    static void addToSet(Dialect &dialect) {
-      dialect.addSymbol(First::getClassID());
-    }
-  };
-
   /// Enable support for unregistered operations.
   void allowUnknownOperations(bool allow = true) { unknownOpsAllowed = allow; }
 
   /// Enable support for unregistered types.
   void allowUnknownTypes(bool allow = true) { unknownTypesAllowed = allow; }
 
   /// Register a dialect interface with this dialect instance.
   void addInterface(std::unique_ptr<DialectInterface> interface);
 
   /// Register a set of dialect interfaces with this dialect instance.
-  template <typename T, typename T2, typename... Tys> void addInterfaces() {
-    addInterfaces<T>();
-    addInterfaces<T2, Tys...>();
-  }
-  template <typename T> void addInterfaces() {
-    addInterface(std::make_unique<T>(this));
+  template <typename... Args> void addInterfaces() {
+    (void)std::initializer_list<int>{
+        0, (addInterface(std::make_unique<Args>(this)), 0)...};
   }
 
 private:
   // Register a symbol(e.g. type) with its given unique class identifier.
   void addSymbol(const ClassID *const classID);
 
   Dialect(const Dialect &) = delete;
   void operator=(Dialect &) = delete;