[mlir] Make use of C++17 language features

[zero9178]

Summary

Now that C++17 is enabled in LLVM, a lot of the TODOs and patterns to emulate C++17 features can be eliminated.
The steps I have taken were essentially:

git grep C++17
git grep c++17
git grep "initializer_list<int>"

and address given comments and patterns.
Most of the changes boiled down to just using fold expressions rather than initializer_list.

While doing this I also discovered that Clang by default restricts the depth of fold expressions to 256 elements. I specifically hit this with TestDialect in addOperations. I opted to not replace it with fold expressions because of that but instead adding a comment documenting the issue.
If any other functions may be called with more than 256 elements in the future we might have to revert other parts as well.
I don't think this is a common occurence besides the TestDialect however. If need be, this could potentially be fixed via mlir-tblgen in the future.

[zero9178]

mlir/include/mlir/IR/BuiltinAttributes.h

87

I removed this comment because I felt it was not really applicable/an improvement. One place one could use std::disjunction below would be to replace llvm::is_one_of, which felt uneccessary to me, or as a replacement for the || of the two terms, which I felt like is not really an improvement either.

[Mogball]

There are plenty of places that can use structured bindings too (llvm::zip, etc.)

mlir/include/mlir/IR/Dialect.h

215

You can change this with -fbracket-depth I think, but that's not great and I worry about dialects with too many ops

[zero9178]

In D131323#3704247, @Mogball wrote:

There are plenty of places that can use structured bindings too (llvm::zip, etc.)

That's true and I have thought about it, but I think this might require a discussion before doing so as structured bindings essentially require the use of auto in places we have previously discouraged them.

mlir/include/mlir/IR/Dialect.h

215

That might be a good solution if we consider just TestDialect on clang having this issue. But since this is used by EVERYONE downstream in a header I'd rather not have to tell everyone "please just add this compiler flag to your build system when using clang".
At least not in this patch.

[zero9178]

Fix examples/standalone build

[Mogball]

In many cases, I'd expect

for (auto [operand, type] : llvm::zip(operands, types)) {
}

to be preferred to

for (auto it = llvm::zip(operands, types)) {
  Value operand = std::get<0>(it);
  Type type = std::get<1>(it);
}

[jpienaar]

mlir/include/mlir/IR/Dialect.h

215

Yes as I can think of two larger dialects than Test.

[mehdi_amini]

mlir/include/mlir/IR/Dialect.h

215

I think we should move away from our current macro based expansion and variadic templates, and generate code with TableGen directly instead.

mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp

181

Is inline useful here? I thought this was the default in C++17?

[zero9178]

mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp

181

You're right. constexpr implies inline for static member variables.
Fixing in a follow up commit

[rriddle]

Really awesome! Thanks for doing this.

mlir/examples/standalone/CMakeLists.txt

 cmake_minimum_required(VERSION 3.13.4)
 project(standalone-dialect LANGUAGES CXX C)
 
 set(CMAKE_BUILD_WITH_INSTALL_NAME_DIR ON)
 
-set(CMAKE_CXX_STANDARD 14 CACHE STRING "C++ standard to conform to")
+set(CMAKE_CXX_STANDARD 17 CACHE STRING "C++ standard to conform to")
 
 find_package(MLIR REQUIRED CONFIG)
 
 message(STATUS "Using MLIRConfig.cmake in: ${MLIR_DIR}")
 message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
 
 set(LLVM_RUNTIME_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/bin)
 set(LLVM_LIBRARY_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/lib)

mlir/include/mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h

public:
   bool isOpAllowed(Operation *op) const;
 
   /// Allow the given dialects.
   ///
   /// This function adds one or multiple ALLOW entries.
   template <typename... DialectTs>
   void allowDialect() {
     // The following expands a call to allowDialectImpl for each dialect
-    // in 'DialectTs'. This magic is necessary due to a limitation in the places
-    // that a parameter pack can be expanded in c++11.
-    // FIXME: In c++17 this can be simplified by using 'fold expressions'.
-    (void)std::initializer_list<int>{0, (allowDialectImpl<DialectTs>(), 0)...};
+    // in 'DialectTs'.
+    (allowDialectImpl<DialectTs>(), ...);
   }
 
   /// Deny the given dialects.
   ///
   /// This function adds one or multiple DENY entries.
   template <typename... DialectTs>
   void denyDialect() {
-    // FIXME: In c++17 this can be simplified by using 'fold expressions'.
-    (void)std::initializer_list<int>{0, (denyDialectImpl<DialectTs>(), 0)...};
+    (denyDialectImpl<DialectTs>(), ...);
   }
 
   /// Allow the given dialect.
   ///
   /// This function adds an ALLOW entry.
   void allowDialect(StringRef dialectNamespace) {
     Entry::FilterFn filterFn = [=](Operation *op) {
       return op->getDialect()->getNamespace() == dialectNamespace;
     };
     entries.push_back(Entry{filterFn, Entry::FilterType::ALLOW});
   }
 
   /// Allow the given ops.
   ///
   /// This function adds one or multiple ALLOW entries.
   template <typename... OpTys>
   void allowOperation() {
-    // FIXME: In c++17 this can be simplified by using 'fold expressions'.
-    (void)std::initializer_list<int>{0, (allowOperationImpl<OpTys>(), 0)...};
+    (allowOperationImpl<OpTys>(), ...);
   }
 
   /// Deny the given ops.
   ///
   /// This function adds one or multiple DENY entries.
   template <typename... OpTys>
   void denyOperation() {
-    // FIXME: In c++17 this can be simplified by using 'fold expressions'.
-    (void)std::initializer_list<int>{0, (denyOperationImpl<OpTys>(), 0)...};
+    (denyOperationImpl<OpTys>(), ...);
   }
 
   /// Allow the given op.
   ///
   /// This function adds an ALLOW entry.
   void allowOperation(StringRef opName) {
     Entry::FilterFn filterFn = [=](Operation *op) {
       return op->getName().getStringRef() == opName;

mlir/include/mlir/Dialect/Transform/IR/TransformDialect.td

private:
                      << "' is already registered with a mismatching TypeID";
         abort();
       }
 
       /// Registers operations specified as template parameters with this
       /// dialect. Checks that they implement the required interfaces.
       template <typename... OpTys>
       void addOperationsChecked() {
-        (void)std::initializer_list<int>{(addOperationIfNotRegistered<OpTys>(),
-                                          0)...};
+        (addOperationIfNotRegistered<OpTys>(),...);
 
         #ifndef NDEBUG
-        (void)std::initializer_list<int>{
-          (detail::checkImplementsTransformInterface<OpTys>(getContext()),
-           0)...};
+        (detail::checkImplementsTransformInterface<OpTys>(getContext()),...);
         #endif // NDEBUG
       }
 
       template <typename, typename...>
       friend class TransformDialectExtension;
 
       /// Takes ownership of the named PDL constraint function from the given
       /// map and makes them available for use by the operations in the dialect.

mlir/include/mlir/ExecutionEngine/ExecutionEngine.h

public:
   ///                                     result(result));
   template <typename... Args>
   llvm::Error invoke(StringRef funcName, Args... args) {
     const std::string adapterName =
         std::string("_mlir_ciface_") + funcName.str();
     llvm::SmallVector<void *> argsArray;
     // Pack every arguments in an array of pointers. Delegate the packing to a
     // trait so that it can be overridden per argument type.
-    // TODO: replace with a fold expression when migrating to C++17.
-    int dummy[] = {0, ((void)Argument<Args>::pack(argsArray, args), 0)...};
-    (void)dummy;
+    (Argument<Args>::pack(argsArray, args), ...);
     return invokePacked(adapterName, argsArray);
   }
 
   /// Set the target triple on the module. This is implicitly done when creating
   /// the engine.
   static bool setupTargetTriple(llvm::Module *llvmModule);
 
   /// Dump object code to output file `filename`.

mlir/include/mlir/IR/BuiltinAttributes.h

public:
   /// Allow implicit conversion to ElementsAttr.
   operator ElementsAttr() const {
     return *this ? cast<ElementsAttr>() : nullptr;
   }
 
   /// Type trait used to check if the given type T is a potentially valid C++
   /// floating point type that can be used to access the underlying element
   /// types of a DenseElementsAttr.
-  // TODO: Use std::disjunction when C++17 is supported.
   template <typename T>
   struct is_valid_cpp_fp_type {
     /// The type is a valid floating point type if it is a builtin floating
     /// point type, or is a potentially user defined floating point type. The
     /// latter allows for supporting users that have custom types defined for
     /// bfloat16/half/etc.
     static constexpr bool value = llvm::is_one_of<T, float, double>::value ||
                                   (std::numeric_limits<T>::is_specialized &&

mlir/include/mlir/IR/BuiltinTypes.td

let extraClassDeclaration = [{
 
     /// Get or create a new IntegerType with the same signedness as `this` and a
     /// bitwidth scaled by `scale`.
     /// Return null if the scaled element type cannot be represented.
     IntegerType scaleElementBitwidth(unsigned scale);
 
     /// Integer representation maximal bitwidth.
     /// Note: This is aligned with the maximum width of llvm::IntegerType.
-    static constexpr unsigned kMaxWidth = (1 << 24) - 1;
+    static constexpr inline unsigned kMaxWidth = (1 << 24) - 1;
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // MemRefType
 //===----------------------------------------------------------------------===//
 
 def Builtin_MemRef : Builtin_Type<"MemRef", [

mlir/include/mlir/IR/Dialect.h

public:
   }
 
   /// 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... Args>
   void addInterfaces() {
-    (void)std::initializer_list<int>{
-        0, (addInterface(std::make_unique<Args>(this)), 0)...};
+    (addInterface(std::make_unique<Args>(this)), ...);
   }
   template <typename InterfaceT, typename... Args>
   InterfaceT &addInterface(Args &&...args) {
     InterfaceT *interface = new InterfaceT(this, std::forward<Args>(args)...);
     addInterface(std::unique_ptr<DialectInterface>(interface));
     return *interface;
   }
 
 protected:
   /// The constructor takes a unique namespace for this dialect as well as the
   /// context to bind to.
   /// Note: The namespace must not contain '.' characters.
   /// Note: All operations belonging to this dialect must have names starting
   ///       with the namespace followed by '.'.
   /// Example:
   ///       - "tf" for the TensorFlow ops like "tf.add".
   Dialect(StringRef name, MLIRContext *context, TypeID id);
 
   /// This method is used by derived classes to add their operations to the set.
   ///
   template <typename... Args>
   void addOperations() {
+    // This initializer_list argument pack expansion is essentially equal to
+    // using a fold expression with a comma operator. Clang however, refuses
+    // to compile a fold expression with a depth of more than 256 by default.
+    // There seem to be no such limitations for initializer_list.
     (void)std::initializer_list<int>{
         0, (RegisteredOperationName::insert<Args>(*this), 0)...};
   }
 
   /// Register a set of type classes with this dialect.
   template <typename... Args>
   void addTypes() {
-    (void)std::initializer_list<int>{0, (addType<Args>(), 0)...};
+    (addType<Args>(), ...);
   }
 
   /// Register a type instance with this dialect.
   /// The use of this method is in general discouraged in favor of
   /// 'addTypes<CustomType>()'.
   void addType(TypeID typeID, AbstractType &&typeInfo);
 
   /// Register a set of attribute classes with this dialect.
   template <typename... Args>
   void addAttributes() {
-    (void)std::initializer_list<int>{0, (addAttribute<Args>(), 0)...};
+    (addAttribute<Args>(), ...);
   }
 
   /// Register an attribute instance with this dialect.
   /// The use of this method is in general discouraged in favor of
   /// 'addAttributes<CustomAttr>()'.
   void addAttribute(TypeID typeID, AbstractAttribute &&attrInfo);
 
   /// Enable support for unregistered operations.

mlir/include/mlir/IR/DialectRegistry.h

public:
   /// Add the given extension to the registry.
   void addExtension(std::unique_ptr<DialectExtensionBase> extension) {
     extensions.push_back(std::move(extension));
   }
 
   /// Add the given extensions to the registry.
   template <typename... ExtensionsT>
   void addExtensions() {
-    (void)std::initializer_list<int>{
-        (addExtension(std::make_unique<ExtensionsT>()), 0)...};
+    (addExtension(std::make_unique<ExtensionsT>()), ...);
   }
 
   /// Add an extension function that requires the given dialects.
   /// Note: This bare functor overload is provided in addition to the
   /// std::function variant to enable dialect type deduction, e.g.:
   ///  registry.addExtension(+[](MLIRContext *ctx, MyDialect *dialect) { ... })
   ///
   /// is equivalent to:

mlir/include/mlir/IR/Matchers.h

struct PatternMatcherValue {
   PatternMatcherValue(Value val) : value(val) {}
   bool match(Value val) const { return val == value; }
   Value value;
 };
 
 template <typename TupleT, class CallbackT, std::size_t... Is>
 constexpr void enumerateImpl(TupleT &&tuple, CallbackT &&callback,
                              std::index_sequence<Is...>) {
-  (void)std::initializer_list<int>{
-      0,
-      (callback(std::integral_constant<std::size_t, Is>{}, std::get<Is>(tuple)),
-       0)...};
+
+   ...);
 }
 
 template <typename... Tys, typename CallbackT>
 constexpr void enumerate(std::tuple<Tys...> &tuple, CallbackT &&callback) {
   detail::enumerateImpl(tuple, std::forward<CallbackT>(callback),
                         std::make_index_sequence<sizeof...(Tys)>{});
 }
 

mlir/include/mlir/IR/OpDefinition.h

 template <typename T, typename... Args>
 using has_fold_trait =
     decltype(T::foldTrait(std::declval<Operation *>(),
                           std::declval<ArrayRef<Attribute>>(),
                           std::declval<SmallVectorImpl<OpFoldResult> &>()));
 template <typename T>
 using detect_has_fold_trait = llvm::is_detected<has_fold_trait, T>;
 /// Trait to check if T provides any `foldTrait` method.
-/// NOTE: This should use std::disjunction when C++17 is available.
 template <typename T>
 using detect_has_any_fold_trait =
-    std::conditional_t<bool(detect_has_fold_trait<T>::value),
-                       detect_has_fold_trait<T>,
-                       detect_has_single_result_fold_trait<T>>;
+    std::disjunction<detect_has_fold_trait<T>,
 
 /// Returns the result of folding a trait that implements a `foldTrait` function
 /// that is specialized for operations that have a single result.
 template <typename Trait>
 static std::enable_if_t<detect_has_single_result_fold_trait<Trait>::value,
                         LogicalResult>
 foldTrait(Operation *op, ArrayRef<Attribute> operands,
           SmallVectorImpl<OpFoldResult> &results) {
foldTrait(Operation *, ArrayRef<Attribute>, SmallVectorImpl<OpFoldResult> &) {
   return failure();
 }
 
 /// Given a tuple type containing a set of traits, return the result of folding
 /// the given operation.
 template <typename... Ts>
 static LogicalResult foldTraits(Operation *op, ArrayRef<Attribute> operands,
                                 SmallVectorImpl<OpFoldResult> &results) {
-  bool anyFolded = false;
-  (void)std::initializer_list<int>{
-      (anyFolded |= succeeded(foldTrait<Ts>(op, operands, results)), 0)...};
-  return success(anyFolded);
+  return success((succeeded(foldTrait<Ts>(op, operands, results)) | ...));
 }
 
 //===----------------------------------------------------------------------===//
 // Trait Verification
 
 /// Trait to check if T provides a `verifyTrait` method.
 template <typename T, typename... Args>
 using has_verify_trait = decltype(T::verifyTrait(std::declval<Operation *>()));

 inline std::enable_if_t<!detect_has_verify_trait<T>::value, LogicalResult>
 verifyTrait(Operation *) {
   return success();
 }
 
 /// Given a set of traits, return the result of verifying the given operation.
 template <typename... Ts>
 LogicalResult verifyTraits(Operation *op) {
-  LogicalResult result = success();
-  (void)std::initializer_list<int>{
-      (result = succeeded(result) ? verifyTrait<Ts>(op) : failure(), 0)...};
-  return result;
+  return success((succeeded(verifyTrait<Ts>(op)) && ...));
 }
 
 /// Verify the given trait if it provides a region verifier.
 template <typename T>
 std::enable_if_t<detect_has_verify_region_trait<T>::value, LogicalResult>
 verifyRegionTrait(Operation *op) {
   return T::verifyRegionTrait(op);
 }
 template <typename T>
 inline std::enable_if_t<!detect_has_verify_region_trait<T>::value,
                         LogicalResult>
 verifyRegionTrait(Operation *) {
   return success();
 }
 
 /// Given a set of traits, return the result of verifying the regions of the
 /// given operation.
 template <typename... Ts>
 LogicalResult verifyRegionTraits(Operation *op) {
-  (void)op;
-  LogicalResult result = success();
-  (void)std::initializer_list<int>{
-      (result = succeeded(result) ? verifyRegionTrait<Ts>(op) : failure(),
-       0)...};
-  return result;
+  return success((succeeded(verifyRegionTrait<Ts>(op)) && ...));
 }
 } // namespace op_definition_impl
 
 //===----------------------------------------------------------------------===//
 // Operation Definition classes
 //===----------------------------------------------------------------------===//
 
 /// This provides public APIs that all operations should have.  The template
#endif
   template <typename... Models>
   static void attachInterface(MLIRContext &context) {
     Optional<RegisteredOperationName> info = RegisteredOperationName::lookup(
         ConcreteType::getOperationName(), &context);
     if (!info)
       llvm::report_fatal_error(
           "Attempting to attach an interface to an unregistered operation " +
           ConcreteType::getOperationName() + ".");
-    (void)std::initializer_list<int>{(checkInterfaceTarget<Models>(), 0)...};
+    (checkInterfaceTarget<Models>(), ...);
     info->attachInterface<Models...>();
   }
 
 private:
   /// Trait to check if T provides a 'fold' method for a single result op.
   template <typename T, typename... Args>
   using has_single_result_fold =
       decltype(std::declval<T>().fold(std::declval<ArrayRef<Attribute>>()));

mlir/include/mlir/IR/PatternMatch.h

 template <typename PDLFnT, std::size_t... I>
 LogicalResult verifyAsArgs(PatternRewriter &rewriter, ArrayRef<PDLValue> values,
                            std::index_sequence<I...>) {
   using FnTraitsT = llvm::function_traits<PDLFnT>;
 
   auto errorFn = [&](const Twine &msg) {
     return rewriter.notifyMatchFailure(rewriter.getUnknownLoc(), msg);
   };
-  LogicalResult result = success();
-  (void)std::initializer_list<int>{
-      (result =
-           succeeded(result)
-               ? ProcessPDLValue<typename FnTraitsT::template arg_t<I + 1>>::
-                     verifyAsArg(errorFn, values[I], I)
-               : failure(),
-       0)...};
-  return result;
+  return success(
+      (succeeded(ProcessPDLValue<typename FnTraitsT::template arg_t<I + 1>>::
+                     verifyAsArg(errorFn, values[I], I)) &&
+       ...));
 }
 
 /// Assert that the given PDLValues match the constraints defined by the
 /// arguments of the given function. In the case of failure, a fatal error
 /// is emitted.
 template <typename PDLFnT, std::size_t... I>
 void assertArgs(PatternRewriter &rewriter, ArrayRef<PDLValue> values,
                 std::index_sequence<I...>) {
   // We only want to do verification in debug builds, same as with `assert`.
 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
   using FnTraitsT = llvm::function_traits<PDLFnT>;
   auto errorFn = [&](const Twine &msg) -> LogicalResult {
     llvm::report_fatal_error(msg);
   };
-  (void)std::initializer_list<int>{
-      (assert(succeeded(ProcessPDLValue<typename FnTraitsT::template arg_t<
-                            I + 1>>::verifyAsArg(errorFn, values[I], I))),
-       0)...};
+  (assert(succeeded(
+       ProcessPDLValue<typename FnTraitsT::template arg_t<I + 1>>::verifyAsArg(
+           errorFn, values[I], I))),
+   ...);
 #endif
 }
 
 //===----------------------------------------------------------------------===//
 // PDL Function Builder: Results Handling
 //===----------------------------------------------------------------------===//
 
 /// Store a single result within the result list.
static void processResults(PatternRewriter &rewriter, PDLResultList &results,
   processResults(rewriter, results, std::move(pair.second));
 }
 
 /// Store a std::tuple<> as individual results within the result list.
 template <typename... Ts>
 static void processResults(PatternRewriter &rewriter, PDLResultList &results,
                            std::tuple<Ts...> &&tuple) {
   auto applyFn = [&](auto &&...args) {
-    // TODO: Use proper fold expressions when we have C++17. For now we use a
-    // bogus std::initializer_list to work around C++14 limitations.
-    (void)std::initializer_list<int>{
-        (processResults(rewriter, results, std::move(args)), 0)...};
+    (processResults(rewriter, results, std::move(args)), ...);
   };
   llvm::apply_tuple(applyFn, std::move(tuple));
 }
 
 //===----------------------------------------------------------------------===//
 // PDL Constraint Builder
 //===----------------------------------------------------------------------===//
 
public:
   /// Add an instance of each of the pattern types 'Ts' to the pattern list with
   /// the given arguments. Return a reference to `this` for chaining insertions.
   /// Note: ConstructorArg is necessary here to separate the two variadic lists.
   template <typename... Ts, typename ConstructorArg,
             typename... ConstructorArgs,
             typename = std::enable_if_t<sizeof...(Ts) != 0>>
   RewritePatternSet &add(ConstructorArg &&arg, ConstructorArgs &&...args) {
     // The following expands a call to emplace_back for each of the pattern
-    // types 'Ts'. This magic is necessary due to a limitation in the places
-    // that a parameter pack can be expanded in c++11.
-    // FIXME: In c++17 this can be simplified by using 'fold expressions'.
-    (void)std::initializer_list<int>{
-        0, (addImpl<Ts>(/*debugLabels=*/llvm::None,
-                        std::forward<ConstructorArg>(arg),
-                        std::forward<ConstructorArgs>(args)...),
-            0)...};
+    // types 'Ts'.
+    (addImpl<Ts>(/*debugLabels=*/llvm::None, std::forward<ConstructorArg>(arg),
+     ...);
     return *this;
   }
   /// An overload of the above `add` method that allows for attaching a set
   /// of debug labels to the attached patterns. This is useful for labeling
   /// groups of patterns that may be shared between multiple different
   /// passes/users.
   template <typename... Ts, typename ConstructorArg,
             typename... ConstructorArgs,
             typename = std::enable_if_t<sizeof...(Ts) != 0>>
   RewritePatternSet &addWithLabel(ArrayRef<StringRef> debugLabels,
                                   ConstructorArg &&arg,
                                   ConstructorArgs &&...args) {
     // The following expands a call to emplace_back for each of the pattern
-    // types 'Ts'. This magic is necessary due to a limitation in the places
-    // that a parameter pack can be expanded in c++11.
-    // FIXME: In c++17 this can be simplified by using 'fold expressions'.
-    (void)std::initializer_list<int>{
-        0, (addImpl<Ts>(debugLabels, arg, args...), 0)...};
+    // types 'Ts'.
+    (addImpl<Ts>(debugLabels, arg, args...), ...);
     return *this;
   }
 
   /// Add an instance of each of the pattern types 'Ts'. Return a reference to
   /// `this` for chaining insertions.
   template <typename... Ts>
   RewritePatternSet &add() {
-    (void)std::initializer_list<int>{0, (addImpl<Ts>(), 0)...};
+    (addImpl<Ts>(), ...);
     return *this;
   }
 
   /// Add the given native pattern to the pattern list. Return a reference to
   /// `this` for chaining insertions.
   RewritePatternSet &add(std::unique_ptr<RewritePattern> pattern) {
     nativePatterns.emplace_back(std::move(pattern));
     return *this;
public:
   /// Add an instance of each of the pattern types 'Ts' to the pattern list with
   /// the given arguments. Return a reference to `this` for chaining insertions.
   /// Note: ConstructorArg is necessary here to separate the two variadic lists.
   template <typename... Ts, typename ConstructorArg,
             typename... ConstructorArgs,
             typename = std::enable_if_t<sizeof...(Ts) != 0>>
   RewritePatternSet &insert(ConstructorArg &&arg, ConstructorArgs &&...args) {
     // The following expands a call to emplace_back for each of the pattern
-    // types 'Ts'. This magic is necessary due to a limitation in the places
-    // that a parameter pack can be expanded in c++11.
-    // FIXME: In c++17 this can be simplified by using 'fold expressions'.
-    (void)std::initializer_list<int>{
-        0, (addImpl<Ts>(/*debugLabels=*/llvm::None, arg, args...), 0)...};
+    // types 'Ts'.
+    (addImpl<Ts>(/*debugLabels=*/llvm::None, arg, args...), ...);
     return *this;
   }
 
   /// Add an instance of each of the pattern types 'Ts'. Return a reference to
   /// `this` for chaining insertions.
   template <typename... Ts>
   RewritePatternSet &insert() {
-    (void)std::initializer_list<int>{0, (addImpl<Ts>(), 0)...};
+    (addImpl<Ts>(), ...);
     return *this;
   }
 
   /// Add the given native pattern to the pattern list. Return a reference to
   /// `this` for chaining insertions.
   RewritePatternSet &insert(std::unique_ptr<RewritePattern> pattern) {
     nativePatterns.emplace_back(std::move(pattern));
     return *this;

mlir/include/mlir/IR/StorageUniquerSupport.h

public:
   template <typename... IfaceModels>
   static void attachInterface(MLIRContext &context) {
     typename ConcreteT::AbstractTy *abstract =
         ConcreteT::AbstractTy::lookupMutable(TypeID::get<ConcreteT>(),
                                              &context);
     if (!abstract)
       llvm::report_fatal_error("Registering an interface for an attribute/type "
                                "that is not itself registered.");
-    (void)std::initializer_list<int>{
-        (checkInterfaceTarget<IfaceModels>(), 0)...};
+
+    (checkInterfaceTarget<IfaceModels>(), ...);
     abstract->interfaceMap.template insert<IfaceModels...>();
   }
 
   /// Get or create a new ConcreteT instance within the ctx. This
   /// function is guaranteed to return a non null object and will assert if
   /// the arguments provided are invalid.
   template <typename... Args>
   static ConcreteT get(MLIRContext *ctx, Args... args) {

mlir/include/mlir/Support/InterfaceSupport.h

public:
   }
 
   /// Construct an InterfaceMap with the given set of template types. For
   /// convenience given that object trait lists may contain other non-interface
   /// types, not all of the types need to be interfaces. The provided types that
   /// do not represent interfaces are not added to the interface map.
   template <typename... Types>
   static InterfaceMap get() {
-    // TODO: Use constexpr if here in C++17.
     constexpr size_t numInterfaces = num_interface_types_t<Types...>::value;
-    if (numInterfaces == 0)
+    if constexpr (numInterfaces == 0)
       return InterfaceMap();
 
     std::array<std::pair<TypeID, void *>, numInterfaces> elements;
     std::pair<TypeID, void *> *elementIt = elements.data();
     (void)elementIt;
-    (void)std::initializer_list<int>{
-        0, (addModelAndUpdateIterator<Types>(elementIt), 0)...};
+    (addModelAndUpdateIterator<Types>(elementIt), ...);
     return InterfaceMap(elements);
   }
 
   /// Returns an instance of the concept object for the given interface if it
   /// was registered to this map, null otherwise.
   template <typename T>
   typename T::Concept *lookup() const {
     return reinterpret_cast<typename T::Concept *>(lookup(T::getInterfaceID()));

mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp

auto results =
                        getVoidPtrType());
     Value allocatedPtr =
         rewriter.create<LLVM::BitcastOp>(loc, elementPtrType, results[0]);
 
     return std::make_tuple(allocatedPtr, allocatedPtr);
   }
 
   /// The minimum alignment to use with aligned_alloc (has to be a power of 2).
-  static constexpr uint64_t kMinAlignedAllocAlignment = 16UL;
+  static inline constexpr uint64_t kMinAlignedAllocAlignment = 16UL;
 
   /// Default layout to use in absence of the corresponding analysis.
   DataLayout defaultLayout;
 };
 
-// Out of line definition, required till C++17.
-constexpr uint64_t AlignedAllocOpLowering::kMinAlignedAllocAlignment;
-
 struct AllocaOpLowering : public AllocLikeOpLLVMLowering {
   AllocaOpLowering(LLVMTypeConverter &converter)
       : AllocLikeOpLLVMLowering(memref::AllocaOp::getOperationName(),
                                 converter) {}
 
   /// Allocates the underlying buffer using the right call. `allocatedBytePtr`
   /// is set to null for stack allocations. `accessAlignment` is set if
   /// alignment is needed post allocation (for eg. in conjunction with malloc).

mlir/lib/Dialect/Linalg/IR/LinalgDialect.cpp

void addNamedOpBuilderImpl(
   map.insert(std::make_pair(
       OpType::getOperationName(),
       static_cast<LinalgDialect::RegionBuilderFunType>(OpType::regionBuilder)));
 }
 
 template <typename... OpTypes>
 void addNamedOpBuilders(
     llvm::StringMap<LinalgDialect::RegionBuilderFunType> &map) {
-  (void)std::initializer_list<int>{0,
-                                   (addNamedOpBuilderImpl<OpTypes>(map), 0)...};
+  (addNamedOpBuilderImpl<OpTypes>(map), ...);
 }
 
 void mlir::linalg::LinalgDialect::initialize() {
   addAttributes<
 #define GET_ATTRDEF_LIST
 #include "mlir/Dialect/Linalg/IR/LinalgOpsAttrDefs.cpp.inc"
       >();
   addOperations<

mlir/lib/Dialect/Linalg/Transforms/BufferizableOpInterfaceImpl.cpp

struct LinalgOpInterface
   }
 };
 
 /// Helper structure that iterates over all LinalgOps in `OpTys` and registers
 /// the `BufferizableOpInterface` with each of them.
 template <typename... Ops>
 struct LinalgOpInterfaceHelper {
   static void registerOpInterface(MLIRContext *ctx) {
-    (void)std::initializer_list<int>{
-        0, (Ops::template attachInterface<LinalgOpInterface<Ops>>(*ctx), 0)...};
+    (Ops::template attachInterface<LinalgOpInterface<Ops>>(*ctx), ...);
   }
 };
 } // namespace
 
 void mlir::linalg::registerBufferizableOpInterfaceExternalModels(
     DialectRegistry &registry) {
   registry.addExtension(+[](MLIRContext *ctx, linalg::LinalgDialect *dialect) {
     // Register all Linalg structured ops. `LinalgOp` is an interface and it is
     // not possible to attach an external interface to an existing interface.
     // Therefore, attach the `BufferizableOpInterface` to all ops one-by-one.
     LinalgOpInterfaceHelper<
 #define GET_OP_LIST
 #include "mlir/Dialect/Linalg/IR/LinalgStructuredOps.cpp.inc"
         >::registerOpInterface(ctx);
   });
 }

mlir/lib/Dialect/Linalg/Transforms/TilingInterfaceImpl.cpp

 template <typename OpType>
 static void registerOne(MLIRContext *ctx) {
   OpType::template attachInterface<LinalgOpTilingInterface<OpType>>(*ctx);
 }
 
 /// Variadic helper function.
 template <typename... OpTypes>
 static void registerAll(MLIRContext *ctx) {
-  // FIXME: In c++17 this can be simplified by using 'fold expressions'.
-  (void)std::initializer_list<int>{0, (registerOne<OpTypes>(ctx), 0)...};
+  (registerOne<OpTypes>(ctx), ...);
 }
 
 #define GET_OP_LIST
 
 void mlir::linalg::registerTilingInterfaceExternalModels(
     DialectRegistry &registry) {
   registry.addExtension(+[](MLIRContext *ctx, linalg::LinalgDialect *dialect) {
     registerOne<linalg::GenericOp>(ctx);
     registerAll<
 #include "mlir/Dialect/Linalg/IR/LinalgStructuredOps.cpp.inc"
         >(ctx);
   });
 }

mlir/lib/Dialect/Tosa/Transforms/TosaLayerwiseConstantFoldPass.cpp

 
 using namespace mlir;
 using namespace mlir::tosa;
 
 namespace {
 
 template <typename... Args>
 void addOpsCanonicalizations(MLIRContext *ctx, RewritePatternSet &patterns) {
-  (void)std::initializer_list<int>{
-      0, (Args::getCanonicalizationPatterns(patterns, ctx), 0)...};
+  (Args::getCanonicalizationPatterns(patterns, ctx), ...);
 }
 
 void populateTosaOpsCanonicalizationPatterns(MLIRContext *ctx,
                                              RewritePatternSet &patterns) {
   addOpsCanonicalizations<
 #define GET_OP_LIST
 #include "mlir/Dialect/Tosa/IR/TosaOps.cpp.inc"
       >(ctx, patterns);

mlir/lib/IR/BuiltinTypes.cpp

if (!elementType.isIntOrFloat())
     return emitError() << "invalid element type for complex";
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Integer Type
 //===----------------------------------------------------------------------===//
 
-// static constexpr must have a definition (until in C++17 and inline variable).
-constexpr unsigned IntegerType::kMaxWidth;
-
 /// Verify the construction of an integer type.
 LogicalResult IntegerType::verify(function_ref<InFlightDiagnostic()> emitError,
                                   unsigned width,
                                   SignednessSemantics signedness) {
   if (width > IntegerType::kMaxWidth) {
     return emitError() << "integer bitwidth is limited to "
                        << IntegerType::kMaxWidth << " bits";
   }