[mlir][NFC] Switch dialects with no fold methods to the new fold API

[zero9178]

Summary

These are the trivial cases which do not require any other code changes.
Changing the default might not have any semantic changes but at least guarantees that no new fold methods may be added to these dialects while migrating.

This commit is also revertible at the end of the migration.

mlir/include/mlir/Dialect/AMDGPU/AMDGPU.td

let description = [{
     that will eventually be executed on AMD hardware.
   }];
 
 
   let dependentDialects = [
     "arith::ArithDialect"
   ];
   let useDefaultAttributePrinterParser = 1;
+  let useFoldAPI = kEmitFoldAdaptorFolder;
 }
 
 //===----------------------------------------------------------------------===//
 // AMDGPU Op definitions
 //===----------------------------------------------------------------------===//
 
 class AMDGPU_Op<string mnemonic, list<Trait> traits = []> :
   Op<AMDGPU_Dialect, mnemonic, traits> {}

mlir/include/mlir/Dialect/AMX/AMX.td

let description = [{
 
     Note that since configuration changes (implicit at dialect level) are
     costly, it is highly recommended to use the AMX dialect on same-shaped
     vectors, at least within a single method.
 
     For details, see the Intel documentation:
     https://software.intel.com/content/www/us/en/develop/articles/intel-sdm.html
   }];
+
+  let useFoldAPI = kEmitFoldAdaptorFolder;
 }
 
 //===----------------------------------------------------------------------===//
 // AMX Op and IntrOp definitions.
 //===----------------------------------------------------------------------===//
 
 class AMX_Op<string mnemonic, list<Trait> traits = []> :
   Op<AMX_Dialect, mnemonic, traits> {}

mlir/include/mlir/Dialect/ArmNeon/ArmNeon.td

 //===----------------------------------------------------------------------===//
 // ArmNeon dialect definition
 //===----------------------------------------------------------------------===//
 
 def ArmNeon_Dialect : Dialect {
   let name = "arm_neon";
   let cppNamespace = "::mlir::arm_neon";
 
+  let useFoldAPI = kEmitFoldAdaptorFolder;
+
   // Note: this does not need to depend on LLVMDialect as long as functions in
   // this dialect (such as canonicalization) do not produce entities belonging
   // to the LLVMDialect (ops or types).
 }
 
 //===----------------------------------------------------------------------===//
 // ArmNeon op definitions
 //===----------------------------------------------------------------------===//

mlir/include/mlir/Dialect/ArmSVE/ArmSVE.td

 def ArmSVE_Dialect : Dialect {
   let name = "arm_sve";
   let cppNamespace = "::mlir::arm_sve";
   let summary = "Basic dialect to target Arm SVE architectures";
   let description = [{
     This dialect contains the definitions necessary to target specific Arm SVE
     scalable vector operations.
   }];
+
+  let useFoldAPI = kEmitFoldAdaptorFolder;
 }
 
 //===----------------------------------------------------------------------===//
 // ArmSVE op definitions
 //===----------------------------------------------------------------------===//
 
 class ArmSVE_Op<string mnemonic, list<Trait> traits = []> :
   Op<ArmSVE_Dialect, mnemonic, traits> {}

mlir/include/mlir/Dialect/Async/IR/AsyncDialect.td

def AsyncDialect : Dialect {
   let cppNamespace = "::mlir::async";
 
   let summary = "Types and operations for async dialect";
   let description = [{
     This dialect contains operations for modeling asynchronous execution.
   }];
 
   let useDefaultTypePrinterParser = 1;
+  let useFoldAPI = kEmitFoldAdaptorFolder;
 
   let extraClassDeclaration = [{
     /// The name of a unit attribute on funcs that are allowed to have a
     /// blocking async.runtime.await ops. In absence of this attribute the
     /// asyncification pass might convert a func to a coroutine.
     static constexpr StringRef kAllowedToBlockAttrName =
         "async.allowed_to_block";
   }];
 }
 
 #endif // ASYNC_DIALECT_TD

mlir/include/mlir/Dialect/ControlFlow/IR/ControlFlowOps.td

def ControlFlow_Dialect : Dialect {
   let name = "cf";
   let cppNamespace = "::mlir::cf";
   let dependentDialects = ["arith::ArithDialect"];
   let description = [{
     This dialect contains low-level, i.e. non-region based, control flow
     constructs. These constructs generally represent control flow directly
     on SSA blocks of a control flow graph.
   }];
+
+  let useFoldAPI = kEmitFoldAdaptorFolder;
 }
 
 class CF_Op<string mnemonic, list<Trait> traits = []> :
     Op<ControlFlow_Dialect, mnemonic, traits>;
 
 //===----------------------------------------------------------------------===//
 // AssertOp
 //===----------------------------------------------------------------------===//

mlir/include/mlir/Dialect/DLTI/DLTIBase.td

let extraClassDeclaration = [{
     constexpr const static ::llvm::StringLiteral
     kDataLayoutEndiannessBig = "big";
 
     constexpr const static ::llvm::StringLiteral
     kDataLayoutEndiannessLittle = "little";
   }];
 
   let useDefaultAttributePrinterParser = 1;
+  let useFoldAPI = kEmitFoldAdaptorFolder;
 }
 
 def DLTI_DataLayoutEntryAttr : DialectAttr<
     DLTI_Dialect,
     CPred<"$_self.isa<::mlir::DataLayoutEntryAttr>()">,
     "Target data layout entry"> {
   let storageType = "::mlir::DataLayoutEntryAttr";
   let returnType = "::mlir::DataLayoutEntryAttr";

mlir/include/mlir/Dialect/MLProgram/IR/MLProgramBase.td

let description = [{
 
     This dialect is under active development, and while stability is an
     eventual goal, it is not guaranteed at this juncture. Given the early state,
     it is recommended to inquire further prior to using this dialect.
   }];
 
   let useDefaultAttributePrinterParser = 1;
   let useDefaultTypePrinterParser = 1;
+  let useFoldAPI = kEmitFoldAdaptorFolder;
 }
 
 #endif // MLPROGRAM_BASE

mlir/include/mlir/Dialect/NVGPU/IR/NVGPU.td

let description = [{
     The `NVGPU` dialect provides a bridge between higher-level target-agnostic
     dialects (GPU and Vector) and the lower-level target-specific dialect
     (LLVM IR based NVVM dialect) for NVIDIA GPUs. This allow representing PTX
     specific operations while using MLIR high level dialects such as Memref
     and Vector for memory and target-specific register operands, respectively.
   }];
 
   let useDefaultTypePrinterParser = 1;
+  let useFoldAPI = kEmitFoldAdaptorFolder;
 }
 
 //===----------------------------------------------------------------------===//
 // NVGPU Type Definitions
 //===----------------------------------------------------------------------===//
 
 class NVGPU_Type<string name, string typeMnemonic,
         list<Trait> traits = []> : TypeDef<NVGPU_Dialect, name, traits> {

mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td

def OpenACC_Dialect : Dialect {
 
   let summary = "An OpenACC dialect for MLIR.";
 
   let description = [{
     This dialect models the construct from the OpenACC 3.1 directive language.
   }];
 
   let useDefaultAttributePrinterParser = 1;
+  let useFoldAPI = kEmitFoldAdaptorFolder;
   let cppNamespace = "::mlir::acc";
 }
 
 // AccCommon requires definition of OpenACC_Dialect.
 include "mlir/Dialect/OpenACC/AccCommon.td"
 
 // Base class for OpenACC dialect ops.
 class OpenACC_Op<string mnemonic, list<Trait> traits = []> :

mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td

 include "mlir/Dialect/OpenMP/OpenMPOpsInterfaces.td"
 include "mlir/Dialect/OpenMP/OpenMPTypeInterfaces.td"
 
 def OpenMP_Dialect : Dialect {
   let name = "omp";
   let cppNamespace = "::mlir::omp";
   let dependentDialects = ["::mlir::LLVM::LLVMDialect"];
   let useDefaultAttributePrinterParser = 1;
+  let useFoldAPI = kEmitFoldAdaptorFolder;
 }
 
 // OmpCommon requires definition of OpenACC_Dialect.
 include "mlir/Dialect/OpenMP/OmpCommon.td"
 
 class OpenMP_Op<string mnemonic, list<Trait> traits = []> :
       Op<OpenMP_Dialect, mnemonic, traits>;
 

mlir/include/mlir/Dialect/PDL/IR/PDLDialect.td

let description = [{
     other features such as applying external constraints or external generator
     methods. These features and more are detailed below.
   }];
 
   let name = "pdl";
   let cppNamespace = "::mlir::pdl";
 
   let useDefaultTypePrinterParser = 1;
+  let useFoldAPI = kEmitFoldAdaptorFolder;
   let extraClassDeclaration = [{
     void registerTypes();
   }];
 }
 
 #endif // MLIR_DIALECT_PDL_IR_PDLDIALECT

mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td

let description = [{
     etc. Many of the operations within this dialect also fuse branching control
     flow with some form of a predicate comparison operation. This type of fusion
     reduces the amount of work that an interpreter must do when executing.
   }];
 
   let name = "pdl_interp";
   let cppNamespace = "::mlir::pdl_interp";
   let dependentDialects = ["pdl::PDLDialect"];
+  let useFoldAPI = kEmitFoldAdaptorFolder;
   let extraClassDeclaration = [{
     /// Returns the name of the function containing the matcher code. This
     /// function is called by the interpreter when matching an operation.
     static StringRef getMatcherFunctionName() { return "matcher"; }
 
     /// Returns the name of the module containing the rewrite functions. These
     /// functions are invoked by distinct patterns within the matcher function
     /// to rewrite the IR after a successful match.

mlir/include/mlir/Dialect/X86Vector/X86Vector.td

 
 //===----------------------------------------------------------------------===//
 // X86Vector dialect definition
 //===----------------------------------------------------------------------===//
 
 def X86Vector_Dialect : Dialect {
   let name = "x86vector";
   let cppNamespace = "::mlir::x86vector";
+  let useFoldAPI = kEmitFoldAdaptorFolder;
 }
 
 //===----------------------------------------------------------------------===//
 // AVX512 op definitions
 //===----------------------------------------------------------------------===//
 
 // Operation that is part of the input dialect.
 class AVX512_Op<string mnemonic, list<Trait> traits = []> :