Remove OpTrait, AttrTrait and TypeTrait

[sanjoy]

Summary

• Remove the {Op,Attr,Type}Trait TableGen classes and replace with Trait
• Rename OpTraitList to TraitList and use it in a few places

The bulk of this change is a mechanical s/OpTrait/Trait/ throughout the codebase.

[rriddle]

Nice! Looks like you are missing updates for flang.

mlir/include/mlir/IR/OpBase.td

2025–2026

Why not just name this TraitList and move it next to Trait?

2078–2079

Could we update this to use TraitList?

mlir/include/mlir/IR/RegionKindInterface.td

56–57

Same here about using TraitList.

[sanjoy]

Address comments.

[bondhugula]

Can you please add a commit summary?

[sanjoy]

In D118543#3282422, @bondhugula wrote:

Can you please add a commit summary?

Done, PTAL.

flang/include/flang/Optimizer/CodeGen/CGOps.td

 
 def fircg_Dialect : Dialect {
   let name = "fircg";
   let cppNamespace = "::fir::cg";
 }
 
 // Base class for FIR CG operations.
 // All operations automatically get a prefix of "fircg.".
-class fircg_Op<string mnemonic, list<OpTrait> traits>
+class fircg_Op<string mnemonic, list<Trait> traits>
   : Op<fircg_Dialect, mnemonic, traits>;
 
 // Extended embox operation.
 def fircg_XEmboxOp : fircg_Op<"ext_embox", [AttrSizedOperandSegments]> {
   let summary = "for internal conversion only";
 
   let description = [{
     Prior to lowering to LLVM IR dialect, a non-scalar non-trivial embox op will

flang/include/flang/Optimizer/Dialect/FIROps.td

 #ifndef FORTRAN_DIALECT_FIR_OPS
 #define FORTRAN_DIALECT_FIR_OPS
 
 include "flang/Optimizer/Dialect/FIRDialect.td"
 include "flang/Optimizer/Dialect/FIRTypes.td"
 
 // Base class for FIR operations.
 // All operations automatically get a prefix of "fir.".
-class fir_Op<string mnemonic, list<OpTrait> traits>
+class fir_Op<string mnemonic, list<Trait> traits>
   : Op<fir_Dialect, mnemonic, traits>;
 
 // Base class for FIR operations that take a single argument
-class fir_SimpleOp<string mnemonic, list<OpTrait> traits>
+class fir_SimpleOp<string mnemonic, list<Trait> traits>
   : fir_Op<mnemonic, traits> {
 
   let assemblyFormat = [{
     operands attr-dict `:` functional-type(operands, results)
   }];
 }
 
 def fir_OneResultOpBuilder : OpBuilder<(ins
     "mlir::Type":$resultType,
     "mlir::ValueRange":$operands,
     CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes),
   [{
     if (resultType)
       $_state.addTypes(resultType);
     $_state.addOperands(operands);
     $_state.addAttributes(attributes);
   }]>;
 
 // Base class of FIR operations that return 1 result
-class fir_OneResultOp<string mnemonic, list<OpTrait> traits = []> :
+class fir_OneResultOp<string mnemonic, list<Trait> traits = []> :
     fir_Op<mnemonic, traits>, Results<(outs fir_Type:$res)> {
   let builders = [fir_OneResultOpBuilder];
 }
 
 // Base class of FIR operations that have 1 argument and return 1 result
-class fir_SimpleOneResultOp<string mnemonic, list<OpTrait> traits = []> :
+class fir_SimpleOneResultOp<string mnemonic, list<Trait> traits = []> :
     fir_SimpleOp<mnemonic, traits> {
   let builders = [fir_OneResultOpBuilder];
 }
 
 //===----------------------------------------------------------------------===//
 // Memory SSA operations
 //===----------------------------------------------------------------------===//
 
def fir_ZeroOp : fir_OneResultOp<"zero_bits", [NoSideEffect]> {
 
   let assemblyFormat = "type($intype) attr-dict";
 }
 
 //===----------------------------------------------------------------------===//
 // Terminator operations
 //===----------------------------------------------------------------------===//
 
-class fir_SwitchTerminatorOp<string mnemonic, list<OpTrait> traits = []> :
+class fir_SwitchTerminatorOp<string mnemonic, list<Trait> traits = []> :
     fir_Op<mnemonic, !listconcat(traits, [AttrSizedOperandSegments,
     DeclareOpInterfaceMethods<BranchOpInterface>, Terminator])> {
 
   let arguments = (ins
     AnyType:$selector,
     Variadic<AnyType>:$compareArgs,
     Variadic<AnyType>:$targetArgs
   );
mlir::ArrayAttr getCases() {
       return (*this)->getAttrOfType<mlir::ArrayAttr>(getCasesAttr());
     }
 
     unsigned targetOffsetSize();
   }];
 }
 
 class fir_IntegralSwitchTerminatorOp<string mnemonic,
-    list<OpTrait> traits = []> : fir_SwitchTerminatorOp<mnemonic, traits> {
+    list<Trait> traits = []> : fir_SwitchTerminatorOp<mnemonic, traits> {
 
   let skipDefaultBuilders = 1;
   let builders = [OpBuilder<(ins "mlir::Value":$selector,
     "llvm::ArrayRef<int64_t>":$compareOperands,
     "llvm::ArrayRef<mlir::Block *>":$destinations,
     CArg<"llvm::ArrayRef<mlir::ValueRange>", "{}">:$destOperands,
     CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes),
     [{
def fir_ResultOp : fir_Op<"result",
 
   let assemblyFormat = "($results^ `:` type($results))? attr-dict";
 
   let verifier = "return ::verify(*this);";
 }
 
 def FirRegionTerminator : SingleBlockImplicitTerminator<"ResultOp">;
 
-class region_Op<string mnemonic, list<OpTrait> traits = []> :
+class region_Op<string mnemonic, list<Trait> traits = []> :
     fir_Op<mnemonic,
     !listconcat(traits, [FirRegionTerminator, RecursiveSideEffects])> {
   let printer = "return ::print(p, *this);";
   let verifier = "return ::verify(*this);";
   let parser = "return ::parse$cppClass(parser, result);";
 }
 
 def fir_DoLoopOp : region_Op<"do_loop",
let extraClassDeclaration = [{
 
     /// Is this a wide character literal (1 character > 8 bits)
     bool isWideValue();
   }];
 }
 
 // Complex operations
 
-class fir_ArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
+class fir_ArithmeticOp<string mnemonic, list<Trait> traits = []> :
     fir_Op<mnemonic,
            !listconcat(traits, [NoSideEffect, SameOperandsAndResultType])>,
     Results<(outs AnyType)> {
   let parser = "return impl::parseOneResultSameOperandTypeOp(parser, result);";
 
   let printer = "return printBinaryOp(this->getOperation(), p);";
 }
 
-class fir_UnaryArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
+class fir_UnaryArithmeticOp<string mnemonic, list<Trait> traits = []> :
       fir_Op<mnemonic,
              !listconcat(traits, [NoSideEffect, SameOperandsAndResultType])>,
       Results<(outs AnyType)> {
   let parser = "return impl::parseOneResultSameOperandTypeOp(parser, result);";
 
   let printer = "return printUnaryOp(this->getOperation(), p);";
 }
 
let extraClassDeclaration = [{
     static constexpr llvm::StringRef realAttrName() { return "real"; }
     static constexpr llvm::StringRef imagAttrName() { return "imaginary"; }
 
     mlir::Attribute getReal() { return (*this)->getAttr(realAttrName()); }
     mlir::Attribute getImaginary() { return (*this)->getAttr(imagAttrName()); }
   }];
 }
 
-class ComplexUnaryArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
+class ComplexUnaryArithmeticOp<string mnemonic, list<Trait> traits = []> :
       fir_UnaryArithmeticOp<mnemonic, traits>,
       Arguments<(ins fir_ComplexType:$operand)>;
 
 def fir_NegcOp : ComplexUnaryArithmeticOp<"negc">;
 
-class ComplexArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
+class ComplexArithmeticOp<string mnemonic, list<Trait> traits = []> :
       fir_ArithmeticOp<mnemonic, traits>,
       Arguments<(ins fir_ComplexType:$lhs, fir_ComplexType:$rhs)>;
 
 def fir_AddcOp : ComplexArithmeticOp<"addc", [Commutative]>;
 def fir_SubcOp : ComplexArithmeticOp<"subc">;
 def fir_MulcOp : ComplexArithmeticOp<"mulc", [Commutative]>;
 def fir_DivcOp : ComplexArithmeticOp<"divc">;
 // Pow is a builtin call and not a primitive

mlir/docs/Tutorials/Toy/Ch-2.md

 dialect.
 
 ```tablegen
 // Base class for toy dialect operations. This operation inherits from the base
 // `Op` class in OpBase.td, and provides:
 //   * The parent dialect of the operation.
 //   * The mnemonic for the operation, or the name without the dialect prefix.
 //   * A list of traits for the operation.
-class Toy_Op<string mnemonic, list<OpTrait> traits = []> :
+class Toy_Op<string mnemonic, list<Trait> traits = []> :
     Op<Toy_Dialect, mnemonic, traits>;
 ```
 
 With all of the preliminary pieces defined, we can begin to define the constant
 operation.
 
 We define a toy operation by inheriting from our base 'Toy_Op' class above. Here
 we provide the mnemonic and a list of traits for the operation. The

mlir/examples/standalone/include/Standalone/StandaloneDialect.td

def Standalone_Dialect : Dialect {
     }];
     let cppNamespace = "::mlir::standalone";
 }
 
 //===----------------------------------------------------------------------===//
 // Base standalone operation definition.
 //===----------------------------------------------------------------------===//
 
-class Standalone_Op<string mnemonic, list<OpTrait> traits = []> :
+class Standalone_Op<string mnemonic, list<Trait> traits = []> :
         Op<Standalone_Dialect, mnemonic, traits>;
 
 #endif // STANDALONE_DIALECT

mlir/examples/toy/Ch2/include/toy/Ops.td

def Toy_Dialect : Dialect {
   let cppNamespace = "::mlir::toy";
 }
 
 // Base class for toy dialect operations. This operation inherits from the base
 // `Op` class in OpBase.td, and provides:
 //   * The parent dialect of the operation.
 //   * The mnemonic for the operation, or the name without the dialect prefix.
 //   * A list of traits for the operation.
-class Toy_Op<string mnemonic, list<OpTrait> traits = []> :
+class Toy_Op<string mnemonic, list<Trait> traits = []> :
     Op<Toy_Dialect, mnemonic, traits>;
 
 //===----------------------------------------------------------------------===//
 // Toy Operations
 //===----------------------------------------------------------------------===//
 
 // We define a toy operation by inheriting from our base 'Toy_Op' class above.
 // Here we provide the mnemonic and a list of traits for the operation. The

mlir/examples/toy/Ch3/include/toy/Ops.td

def Toy_Dialect : Dialect {
   let cppNamespace = "::mlir::toy";
 }
 
 // Base class for toy dialect operations. This operation inherits from the base
 // `Op` class in OpBase.td, and provides:
 //   * The parent dialect of the operation.
 //   * The mnemonic for the operation, or the name without the dialect prefix.
 //   * A list of traits for the operation.
-class Toy_Op<string mnemonic, list<OpTrait> traits = []> :
+class Toy_Op<string mnemonic, list<Trait> traits = []> :
     Op<Toy_Dialect, mnemonic, traits>;
 
 //===----------------------------------------------------------------------===//
 // Toy Operations
 //===----------------------------------------------------------------------===//
 
 // We define a toy operation by inheriting from our base 'Toy_Op' class above.
 // Here we provide the mnemonic and a list of traits for the operation. The

mlir/examples/toy/Ch4/include/toy/Ops.td

def Toy_Dialect : Dialect {
   let cppNamespace = "::mlir::toy";
 }
 
 // Base class for toy dialect operations. This operation inherits from the base
 // `Op` class in OpBase.td, and provides:
 //   * The parent dialect of the operation.
 //   * The mnemonic for the operation, or the name without the dialect prefix.
 //   * A list of traits for the operation.
-class Toy_Op<string mnemonic, list<OpTrait> traits = []> :
+class Toy_Op<string mnemonic, list<Trait> traits = []> :
     Op<Toy_Dialect, mnemonic, traits>;
 
 //===----------------------------------------------------------------------===//
 // Toy Operations
 //===----------------------------------------------------------------------===//
 
 // We define a toy operation by inheriting from our base 'Toy_Op' class above.
 // Here we provide the mnemonic and a list of traits for the operation. The

mlir/examples/toy/Ch5/include/toy/Ops.td

def Toy_Dialect : Dialect {
   let cppNamespace = "::mlir::toy";
 }
 
 // Base class for toy dialect operations. This operation inherits from the base
 // `Op` class in OpBase.td, and provides:
 //   * The parent dialect of the operation.
 //   * The mnemonic for the operation, or the name without the dialect prefix.
 //   * A list of traits for the operation.
-class Toy_Op<string mnemonic, list<OpTrait> traits = []> :
+class Toy_Op<string mnemonic, list<Trait> traits = []> :
     Op<Toy_Dialect, mnemonic, traits>;
 
 //===----------------------------------------------------------------------===//
 // Toy Operations
 //===----------------------------------------------------------------------===//
 
 // We define a toy operation by inheriting from our base 'Toy_Op' class above.
 // Here we provide the mnemonic and a list of traits for the operation. The

mlir/examples/toy/Ch6/include/toy/Ops.td

def Toy_Dialect : Dialect {
   let cppNamespace = "::mlir::toy";
 }
 
 // Base class for toy dialect operations. This operation inherits from the base
 // `Op` class in OpBase.td, and provides:
 //   * The parent dialect of the operation.
 //   * The mnemonic for the operation, or the name without the dialect prefix.
 //   * A list of traits for the operation.
-class Toy_Op<string mnemonic, list<OpTrait> traits = []> :
+class Toy_Op<string mnemonic, list<Trait> traits = []> :
     Op<Toy_Dialect, mnemonic, traits>;
 
 //===----------------------------------------------------------------------===//
 // Toy Operations
 //===----------------------------------------------------------------------===//
 
 // We define a toy operation by inheriting from our base 'Toy_Op' class above.
 // Here we provide the mnemonic and a list of traits for the operation. The

mlir/examples/toy/Ch7/include/toy/Ops.td

def Toy_Dialect : Dialect {
   let hasConstantMaterializer = 1;
 }
 
 // Base class for toy dialect operations. This operation inherits from the base
 // `Op` class in OpBase.td, and provides:
 //   * The parent dialect of the operation.
 //   * The mnemonic for the operation, or the name without the dialect prefix.
 //   * A list of traits for the operation.
-class Toy_Op<string mnemonic, list<OpTrait> traits = []> :
+class Toy_Op<string mnemonic, list<Trait> traits = []> :
     Op<Toy_Dialect, mnemonic, traits>;
 
 // Provide a definition for the Toy StructType for use in ODS. This allows for
 // using StructType in a similar way to Tensor or MemRef. We use `DialectType`
 // to demarcate the StructType as belonging to the Toy dialect.
 def Toy_StructType :
     DialectType<Toy_Dialect, CPred<"$_self.isa<StructType>()">,
                 "Toy struct type">;

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

let description = [{
     https://software.intel.com/content/www/us/en/develop/articles/intel-sdm.html
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // AMX Op and IntrOp definitions.
 //===----------------------------------------------------------------------===//
 
-class AMX_Op<string mnemonic, list<OpTrait> traits = []> :
+class AMX_Op<string mnemonic, list<Trait> traits = []> :
   Op<AMX_Dialect, mnemonic, traits> {}
 
 // The "internal" intrinsics are meant for compiler usage.
-class AMX_IntrOp<string mnemonic, int numResults, list<OpTrait> traits = []> :
+class AMX_IntrOp<string mnemonic, int numResults, list<Trait> traits = []> :
   LLVM_IntrOpBase<AMX_Dialect, mnemonic,
                   "x86_" # !subst(".", "_", mnemonic) # "_internal",
                   [], [], traits, numResults>;
 
 //===----------------------------------------------------------------------===//
 // AMX Op definitions (user facing).
 //===----------------------------------------------------------------------===//
 

mlir/include/mlir/Dialect/Affine/IR/AffineOps.td

 def Affine_Dialect : Dialect {
   let name = "affine";
   let cppNamespace = "mlir";
   let hasConstantMaterializer = 1;
   let dependentDialects = ["arith::ArithmeticDialect"];
 }
 
 // Base class for Affine dialect ops.
-class Affine_Op<string mnemonic, list<OpTrait> traits = []> :
+class Affine_Op<string mnemonic, list<Trait> traits = []> :
     Op<Affine_Dialect, mnemonic, traits> {
   // For every affine op, there needs to be a:
   //   * void print(OpAsmPrinter &p, ${C++ class of Op} op)
   //   * LogicalResult verify(${C++ class of Op} op)
   //   * ParseResult parse${C++ class of Op}(OpAsmParser &parser,
   //                                         OperationState &result)
   // functions.
   let printer = [{ return ::print(p, *this); }];
OpBuilder getElseBodyBuilder() {
       return OpBuilder(&body, std::prev(body.end()));
     }
   }];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
 }
 
-class AffineLoadOpBase<string mnemonic, list<OpTrait> traits = []> :
+class AffineLoadOpBase<string mnemonic, list<Trait> traits = []> :
     Affine_Op<mnemonic, !listconcat(traits,
         [DeclareOpInterfaceMethods<AffineReadOpInterface>,
         DeclareOpInterfaceMethods<AffineMapAccessInterface>,
         MemRefsNormalizable])> {
   let arguments = (ins Arg<AnyMemRef, "the reference to load from",
       [MemRead]>:$memref,
       Variadic<Index>:$indices);
 
def AffineLoadOp : AffineLoadOpBase<"load"> {
   ];
 
   let extraClassDeclaration = extraClassDeclarationBase;
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
 }
 
-class AffineMinMaxOpBase<string mnemonic, list<OpTrait> traits = []> :
+class AffineMinMaxOpBase<string mnemonic, list<Trait> traits = []> :
     Op<Affine_Dialect, mnemonic, traits> {
   let arguments = (ins AffineMapAttr:$map, Variadic<Index>:$operands);
   let results = (outs Index);
 
   let builders = [
     OpBuilder<(ins "AffineMap":$affineMap, "ValueRange":$mapOperands),
     [{
       build($_builder, $_state, $_builder.getIndexType(), affineMap, mapOperands);
let extraClassDeclaration = [{
     static StringRef getIsWriteAttrName() { return "isWrite"; }
     static StringRef getIsDataCacheAttrName() { return "isDataCache"; }
   }];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
 }
 
-class AffineStoreOpBase<string mnemonic, list<OpTrait> traits = []> :
+class AffineStoreOpBase<string mnemonic, list<Trait> traits = []> :
     Affine_Op<mnemonic, !listconcat(traits,
     [DeclareOpInterfaceMethods<AffineWriteOpInterface>,
     DeclareOpInterfaceMethods<AffineMapAccessInterface>,
     MemRefsNormalizable])> {
   code extraClassDeclarationBase = [{
     /// Returns the operand index of the value to be stored.
     unsigned getStoredValOperandIndex() { return 0; }
 

mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.td

 include "mlir/Interfaces/CastInterfaces.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/Interfaces/VectorInterfaces.td"
 include "mlir/IR/OpAsmInterface.td"
 
 // Base class for Arithmetic dialect ops. Ops in this dialect have no side
 // effects and can be applied element-wise to vectors and tensors.
-class Arith_Op<string mnemonic, list<OpTrait> traits = []> :
+class Arith_Op<string mnemonic, list<Trait> traits = []> :
     Op<Arithmetic_Dialect, mnemonic, traits # [NoSideEffect,
     DeclareOpInterfaceMethods<VectorUnrollOpInterface>] #
     ElementwiseMappable.traits>;
 
 // Base class for integer and floating point arithmetic ops. All ops have one
 // result, require operands and results to be of the same type, and can accept
 // tensors or vectors of integers or floats.
-class Arith_ArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
+class Arith_ArithmeticOp<string mnemonic, list<Trait> traits = []> :
     Arith_Op<mnemonic, traits # [SameOperandsAndResultType]>;
 
 // Base class for unary arithmetic operations.
-class Arith_UnaryOp<string mnemonic, list<OpTrait> traits = []> :
+class Arith_UnaryOp<string mnemonic, list<Trait> traits = []> :
     Arith_ArithmeticOp<mnemonic, traits> {
   let assemblyFormat = "$operand attr-dict `:` type($result)";
 }
 
 // Base class for binary arithmetic operations.
-class Arith_BinaryOp<string mnemonic, list<OpTrait> traits = []> :
+class Arith_BinaryOp<string mnemonic, list<Trait> traits = []> :
     Arith_ArithmeticOp<mnemonic, traits> {
   let assemblyFormat = "$lhs `,` $rhs attr-dict `:` type($result)";
 }
 
 // Base class for ternary arithmetic operations.
-class Arith_TernaryOp<string mnemonic, list<OpTrait> traits = []> :
+class Arith_TernaryOp<string mnemonic, list<Trait> traits = []> :
     Arith_ArithmeticOp<mnemonic, traits> {
   let assemblyFormat = "$a `,` $b `,` $c attr-dict `:` type($result)";
 }
 
 // Base class for integer binary operations.
-class Arith_IntBinaryOp<string mnemonic, list<OpTrait> traits = []> :
+class Arith_IntBinaryOp<string mnemonic, list<Trait> traits = []> :
     Arith_BinaryOp<mnemonic, traits>,
     Arguments<(ins SignlessIntegerLike:$lhs, SignlessIntegerLike:$rhs)>,
     Results<(outs SignlessIntegerLike:$result)>;
 
 // Base class for floating point unary operations.
-class Arith_FloatUnaryOp<string mnemonic, list<OpTrait> traits = []> :
+class Arith_FloatUnaryOp<string mnemonic, list<Trait> traits = []> :
     Arith_UnaryOp<mnemonic, traits>,
     Arguments<(ins FloatLike:$operand)>,
     Results<(outs FloatLike:$result)>;
 
 // Base class for floating point binary operations.
-class Arith_FloatBinaryOp<string mnemonic, list<OpTrait> traits = []> :
+class Arith_FloatBinaryOp<string mnemonic, list<Trait> traits = []> :
     Arith_BinaryOp<mnemonic, traits>,
     Arguments<(ins FloatLike:$lhs, FloatLike:$rhs)>,
     Results<(outs FloatLike:$result)>;
 
 // Base class for arithmetic cast operations. Requires a single operand and
 // result. If either is a shaped type, then the other must be of the same shape.
 class Arith_CastOp<string mnemonic, TypeConstraint From, TypeConstraint To,
-                   list<OpTrait> traits = []> :
+                   list<Trait> traits = []> :
     Arith_Op<mnemonic, traits # [SameOperandsAndResultShape,
     DeclareOpInterfaceMethods<CastOpInterface>]>,
     Arguments<(ins From:$in)>,
     Results<(outs To:$out)> {
   let builders = [
     OpBuilder<(ins "Value":$source, "Type":$destType), [{
       impl::buildCastOp($_builder, $_state, source, destType);
     }]>
   ];
 
   let assemblyFormat = "$in attr-dict `:` type($in) `to` type($out)";
 }
 
 // Casts do not accept indices. Type constraint for signless-integer-like types
 // excluding indices: signless integers, vectors or tensors thereof.
 def SignlessFixedWidthIntegerLike : TypeConstraint<Or<[
         AnySignlessInteger.predicate,
         VectorOf<[AnySignlessInteger]>.predicate,
         TensorOf<[AnySignlessInteger]>.predicate]>,
     "signless-fixed-width-integer-like">;
 
 // Cast from an integer type to another integer type.
-class Arith_IToICastOp<string mnemonic, list<OpTrait> traits = []> :
+class Arith_IToICastOp<string mnemonic, list<Trait> traits = []> :
     Arith_CastOp<mnemonic, SignlessFixedWidthIntegerLike,
                            SignlessFixedWidthIntegerLike, traits>;
 // Cast from an integer type to a floating point type.
-class Arith_IToFCastOp<string mnemonic, list<OpTrait> traits = []> :
+class Arith_IToFCastOp<string mnemonic, list<Trait> traits = []> :
     Arith_CastOp<mnemonic, SignlessFixedWidthIntegerLike, FloatLike, traits>;
 // Cast from a floating point type to an integer type.
-class Arith_FToICastOp<string mnemonic, list<OpTrait> traits = []> :
+class Arith_FToICastOp<string mnemonic, list<Trait> traits = []> :
     Arith_CastOp<mnemonic, FloatLike, SignlessFixedWidthIntegerLike, traits>;
 // Cast from a floating point type to another floating point type.
-class Arith_FToFCastOp<string mnemonic, list<OpTrait> traits = []> :
+class Arith_FToFCastOp<string mnemonic, list<Trait> traits = []> :
     Arith_CastOp<mnemonic, FloatLike, FloatLike, traits>;
 
 // Base class for compare operations. Requires two operands of the same type
 // and returns a single `BoolLike` result. If the operand type is a vector or
 // tensor, then the result will be one of `i1` of the same shape.
-class Arith_CompareOp<string mnemonic, list<OpTrait> traits = []> :
+class Arith_CompareOp<string mnemonic, list<Trait> traits = []> :
     Arith_Op<mnemonic, traits # [SameTypeOperands, TypesMatchWith<
     "result type has i1 element type and same shape as operands",
     "lhs", "result", "::getI1SameShape($_self)">]> {
   let results = (outs BoolLike:$result);
 
   let assemblyFormat = "$predicate `,` $lhs `,` $rhs attr-dict `:` type($lhs)";
 }
 
 // Just like `Arith_CompareOp` but also admits 0-D vectors. Introduced
 // temporarily to allow gradual transition to 0-D vectors.
-class Arith_CompareOpOfAnyRank<string mnemonic, list<OpTrait> traits = []> :
+class Arith_CompareOpOfAnyRank<string mnemonic, list<Trait> traits = []> :
     Arith_CompareOp<mnemonic, traits> {
   let results = (outs BoolLikeOfAnyRank:$result);
 }
 
 //===----------------------------------------------------------------------===//
 // ConstantOp
 //===----------------------------------------------------------------------===//
 

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

 //===----------------------------------------------------------------------===//
 // ArmNeon op definitions
 //===----------------------------------------------------------------------===//
 
 // ArmNeon dialect op that corresponds (and is convertible to) an LLVM IR
 // intrinsic.
 class ArmNeon_IntrOp<string mnemonic, list<int> overloadedResults,
                      list<int> overloadedOperands, int numResults,
-                     list<OpTrait> traits = [], bit requiresAccessGroup = 0,
+                     list<Trait> traits = [], bit requiresAccessGroup = 0,
                      bit requiresAliasScope = 0>
     : LLVM_IntrOpBase</*dialect=*/ArmNeon_Dialect,
                       /*opName=*/"intr." # mnemonic,
                       /*enumName=*/"aarch64_neon_" # !subst(".", "_", mnemonic),
                       /*overloadedResults=*/overloadedResults,
                       /*overloadedOperands=*/overloadedOperands,
                       /*traits=*/traits,
                       /*numResults=*/numResults,
                       /*requiresAccessGroup=*/requiresAccessGroup,
                       /*requiresAliasScope=*/requiresAliasScope>;
 
 // ArmNeon dialect op that corresponds to an LLVM IR intrinsic with one
 // overloaded result.
 class ArmNeon_OverloadedOneResultIntrOp<string mnemonic,
-                                        list<OpTrait> traits = []>
+                                        list<Trait> traits = []>
   : ArmNeon_IntrOp<mnemonic, [0], [], 1, traits>;
 
 // ArmNeon dialect op that corresponds to an LLVM IR intrinsic with one
 // overloaded result and overloaded operands list.
 class ArmNeon_OverloadedOperandsWithOneResultIntrOp<string mnemonic,
                                                     list<int> overloadedOperands,
-                                                    list<OpTrait> traits = []>
+                                                    list<Trait> traits = []>
   : ArmNeon_IntrOp<mnemonic, [0], overloadedOperands, 1, traits>;
 
 def SMullOp : ArmNeon_OverloadedOneResultIntrOp<"smull", [
        NoSideEffect,
        AllTypesMatch<["a", "b"]>,
        TypesMatchWith<
          "res has same vector shape and element bitwidth scaled by 2 as a",
          "a", "res", "$_self.cast<VectorType>().scaleElementBitwidth(2)">
def SdotOp : ArmNeon_OverloadedOperandsWithOneResultIntrOp<"sdot",[1], [
   let arguments = (ins VectorOfLengthAndType<[4, 2], [I32]>:$a,
                        VectorOfLengthAndType<[16, 8], [I8]>:$b,
                        VectorOfLengthAndType<[16, 8], [I8]>:$c);
   let results = (outs VectorOfLengthAndType<[4, 2], [I32]>:$res);
   let assemblyFormat =
     "$a `,` $b `,` $c attr-dict `:` type($b) `,` type($c) `to` type($res)";
   }
 
-class ArmNeon_2dOp<string mnemonic, list<OpTrait> traits = []>
+class ArmNeon_2dOp<string mnemonic, list<Trait> traits = []>
     : Op</*dialect=*/ArmNeon_Dialect,
          /*opName=*/"2d." # mnemonic,
          /*traits=*/traits>;
 
 def Sdot2dOp : ArmNeon_2dOp<"sdot", [
       NoSideEffect,
       AllTypesMatch<["b", "c"]>,
       AllTypesMatch<["a", "res"]>,

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

let description = [{
     scalable vector operations.
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // ArmSVE op definitions
 //===----------------------------------------------------------------------===//
 
-class ArmSVE_Op<string mnemonic, list<OpTrait> traits = []> :
+class ArmSVE_Op<string mnemonic, list<Trait> traits = []> :
   Op<ArmSVE_Dialect, mnemonic, traits> {}
 
 class ArmSVE_IntrBinaryOverloadedOp<string mnemonic,
-                                    list<OpTrait> traits = []> :
+                                    list<Trait> traits = []> :
   LLVM_IntrOpBase</*Dialect dialect=*/ArmSVE_Dialect,
                   /*string opName=*/"intr." # mnemonic,
                   /*string enumName=*/"aarch64_sve_" # !subst(".", "_", mnemonic),
                   /*list<int> overloadedResults=*/[0],
                   /*list<int> overloadedOperands=*/[], // defined by result overload
-                  /*list<OpTrait> traits=*/traits,
+                  /*list<Trait> traits=*/traits,
                   /*int numResults=*/1>;
 
 class ScalableMaskedFOp<string mnemonic, string op_description,
-                        list<OpTrait> traits = []> :
+                        list<Trait> traits = []> :
   ArmSVE_Op<mnemonic, !listconcat(traits,
                        [AllTypesMatch<["src1", "src2", "res"]>,
                         TypesMatchWith<
                           "mask has i1 element type and same shape as operands",
                           "src1", "mask", "getI1SameShape($_self)">])> {
   let summary = "masked " # op_description # " for scalable vectors of floats";
   let description = [{
     The `arm_sve.}] # mnemonic # [{` operation takes one scalable vector mask
     and two scalable vector operands, and perform floating point }] #
     op_description # [{ on active lanes. Inactive lanes will keep the value of
     the first operand.}];
   let arguments = (ins
           ScalableVectorOf<[I1]>:$mask,
           ScalableVectorOf<[AnyFloat]>:$src1,
           ScalableVectorOf<[AnyFloat]>:$src2
   );
   let results = (outs ScalableVectorOf<[AnyFloat]>:$res);
   let assemblyFormat =
     "$mask `,` $src1 `,` $src2 attr-dict `:` type($mask) `,` type($res)";
 }
 
 class ScalableMaskedIOp<string mnemonic, string op_description,
-                        list<OpTrait> traits = []> :
+                        list<Trait> traits = []> :
   ArmSVE_Op<mnemonic, !listconcat(traits,
                        [AllTypesMatch<["src1", "src2", "res"]>,
                         TypesMatchWith<
                           "mask has i1 element type and same shape as operands",
                           "src1", "mask", "getI1SameShape($_self)">])> {
   let summary = "masked " # op_description # " for scalable vectors of integers";
   let description = [{
     The `arm_sve.}] # mnemonic # [{` operation takes one scalable vector mask

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

 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 //===----------------------------------------------------------------------===//
 // Async op definitions
 //===----------------------------------------------------------------------===//
 
 // Base class for the operation in this dialect
-class Async_Op<string mnemonic, list<OpTrait> traits = []> :
+class Async_Op<string mnemonic, list<Trait> traits = []> :
     Op<AsyncDialect, mnemonic, traits>;
 
 def Async_ExecuteOp :
   Async_Op<"execute", [SingleBlockImplicitTerminator<"YieldOp">,
                        DeclareOpInterfaceMethods<RegionBranchOpInterface,
                                                  ["getSuccessorEntryOperands"]>,
                        AttrSizedOperandSegments]> {
   let summary = "Asynchronous execute operation";

mlir/include/mlir/Dialect/Bufferization/IR/BufferizationOps.td

 #define BUFFERIZATION_OPS
 
 include "mlir/Dialect/Bufferization/IR/AllocationOpInterface.td"
 include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.td"
 include "mlir/Dialect/Bufferization/IR/BufferizationBase.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/Interfaces/CopyOpInterface.td"
 
-class Bufferization_Op<string mnemonic, list<OpTrait> traits = []>
+class Bufferization_Op<string mnemonic, list<Trait> traits = []>
     : Op<Bufferization_Dialect, mnemonic, traits>;
 
 //===----------------------------------------------------------------------===//
 // CloneOp
 //===----------------------------------------------------------------------===//
 
 def Bufferization_CloneOp : Bufferization_Op<"clone", [
     CopyOpInterface,

mlir/include/mlir/Dialect/Complex/IR/ComplexOps.td

 //===- ComplexOps.td - Complex op definitions ----------------*- tablegen -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef COMPLEX_OPS
 #define COMPLEX_OPS
 
 include "mlir/Dialect/Complex/IR/ComplexBase.td"
 include "mlir/IR/OpAsmInterface.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
-class Complex_Op<string mnemonic, list<OpTrait> traits = []>
+class Complex_Op<string mnemonic, list<Trait> traits = []>
     : Op<Complex_Dialect, mnemonic, traits>;
 
 // Base class for standard arithmetic operations on complex numbers with a
 // floating-point element type. These operations take two operands and return
 // one result, all of which must be complex numbers of the same type.
-class ComplexArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
+class ComplexArithmeticOp<string mnemonic, list<Trait> traits = []> :
     Complex_Op<mnemonic, traits # [NoSideEffect, SameOperandsAndResultType,
     Elementwise]> {
   let arguments = (ins Complex<AnyFloat>:$lhs, Complex<AnyFloat>:$rhs);
   let results = (outs Complex<AnyFloat>:$result);
   let assemblyFormat = "$lhs `,` $rhs  attr-dict `:` type($result)";
   let verifier = ?;
 }
 
 // Base class for standard unary operations on complex numbers with a
 // floating-point element type. These operations take one operand and return
 // one result; the operand must be a complex number.
-class ComplexUnaryOp<string mnemonic, list<OpTrait> traits = []> :
+class ComplexUnaryOp<string mnemonic, list<Trait> traits = []> :
     Complex_Op<mnemonic, traits # [NoSideEffect, Elementwise]> {
   let arguments = (ins Complex<AnyFloat>:$complex);
   let assemblyFormat = "$complex attr-dict `:` type($complex)";
   let verifier = ?;
 }
 
 //===----------------------------------------------------------------------===//
 // AbsOp

mlir/include/mlir/Dialect/EmitC/IR/EmitC.td

 
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 //===----------------------------------------------------------------------===//
 // EmitC op definitions
 //===----------------------------------------------------------------------===//
 
 // Base class for EmitC dialect ops.
-class EmitC_Op<string mnemonic, list<OpTrait> traits = []>
+class EmitC_Op<string mnemonic, list<Trait> traits = []>
     : Op<EmitC_Dialect, mnemonic, traits> {
   let verifier = "return ::verify(*this);";
 }
 
 def EmitC_ApplyOp : EmitC_Op<"apply", []> {
   let summary = "Apply operation";
   let description = [{
     With the `apply` operation the operators & (address of) and * (contents of)

mlir/include/mlir/Dialect/GPU/GPUOps.td

 include "mlir/Interfaces/DataLayoutInterfaces.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 //===----------------------------------------------------------------------===//
 // GPU Dialect operations.
 //===----------------------------------------------------------------------===//
 
-class GPU_Op<string mnemonic, list<OpTrait> traits = []> :
+class GPU_Op<string mnemonic, list<Trait> traits = []> :
     Op<GPU_Dialect, mnemonic, traits>;
 
 def GPU_Dimension : I32EnumAttr<"Dimension",
     "a dimension, either 'x', 'y', or 'z'",
     [
       I32EnumAttrCase<"x", 0>,
       I32EnumAttrCase<"y", 1>,
       I32EnumAttrCase<"z", 2>
     ]>{
   let genSpecializedAttr = 0;
   let cppNamespace = "::mlir::gpu";
 }
 def GPU_DimensionAttr : EnumAttr<GPU_Dialect, GPU_Dimension, "dim">;
 
-class GPU_IndexOp<string mnemonic, list<OpTrait> traits = []> :
+class GPU_IndexOp<string mnemonic, list<Trait> traits = []> :
     GPU_Op<mnemonic, !listconcat(traits, [NoSideEffect])>,
     Arguments<(ins GPU_DimensionAttr:$dimension)>, Results<(outs Index)> {
   let assemblyFormat = "$dimension attr-dict";
 }
 
 def GPU_BlockDimOp : GPU_IndexOp<"block_dim"> {
   let description = [{
     Returns the number of threads in the thread block (aka the block size) along

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

class LLVM_VectorOf<Type element> : Type<
   "LLVM dialect-compatible vector of " # element.summary>;
 
 // Type constraint accepting a constrained type, or a vector of such types.
 class LLVM_ScalarOrVectorOf<Type element> :
     AnyTypeOf<[element, LLVM_VectorOf<element>]>;
 
 // Base class for LLVM operations. Defines the interface to the llvm::IRBuilder
 // used to translate to LLVM IR proper.
-class LLVM_OpBase<Dialect dialect, string mnemonic, list<OpTrait> traits = []> :
+class LLVM_OpBase<Dialect dialect, string mnemonic, list<Trait> traits = []> :
     Op<dialect, mnemonic, traits> {
   // A pattern for constructing the LLVM IR Instruction (or other Value) that
   // corresponds to this op.  This pattern can use `builder` to refer to an
   // `llvm::IRBuilder<>` instance, $-names of arguments and results and the
   // following special variable names:
   //   - $_resultType - substituted with the LLVM IR type of the result;
   //   - $_numOperands - substituted with the number of operands (including
   //                     the variadic ones);
   //   - $_hasResult - substituted with a check that a variadic-result op does
   //                   have a result (LLVM ops can have 0 or 1 result);
   //   - $_location - mlir::Location object of the instruction.
   // Additionally, `$$` can be used to produce the dollar character.
   string llvmBuilder = "";
 }
 
 //===----------------------------------------------------------------------===//
 // Base classes for LLVM dialect operations.
 //===----------------------------------------------------------------------===//
 
 // Base class for LLVM operations. All operations get an "llvm." prefix in
 // their name automatically. LLVM operations have either zero or one result,
 // this class is specialized below for both cases and should not be used
 // directly.
-class LLVM_Op<string mnemonic, list<OpTrait> traits = []> :
+class LLVM_Op<string mnemonic, list<Trait> traits = []> :
     LLVM_OpBase<LLVM_Dialect, mnemonic, traits>;
 
 // Case of the LLVM enum attribute backed by I64Attr with customized string
 // representation that corresponds to what is visible in the textual IR form.
 // The parameters are as follows:
 //   - `cppSym`: name of the C++ enumerant for this case in MLIR API;
 //   - `irSym`: keyword used in the custom form of MLIR operation;
 //   - `llvmSym`: name of the C++ enumerant for this case in LLVM API.

 // If the intrinsic has multiple results, this will eventually be packed into a
 // single struct result. In this case, the types of any overloaded results need
 // to be accessed via the LLVMStructType, instead of directly via the result.
 // "opName" contains the name of the operation to be associated with the
 // intrinsic and "enumName" contains the name of the intrinsic as appears in
 // `llvm::Intrinsic` enum; one usually wants these to be related.
 class LLVM_IntrOpBase<Dialect dialect, string opName, string enumName,
                       list<int> overloadedResults, list<int> overloadedOperands,
-                      list<OpTrait> traits, int numResults,
+                      list<Trait> traits, int numResults,
                       bit requiresAccessGroup = 0, bit requiresAliasScope = 0>
     : LLVM_OpBase<dialect, opName, traits>,
       Results<!if(!gt(numResults, 0), (outs LLVM_Type:$res), (outs))> {
   string resultPattern = !if(!gt(numResults, 1),
                              LLVM_IntrPatterns.structResult,
                              LLVM_IntrPatterns.result);
   let llvmBuilder = [{
     llvm::Module *module = builder.GetInsertBlock()->getModule();
# !if(!gt(requiresAliasScope, 0),
       "moduleTranslation.setAliasScopeMetadata(op, inst);",
       "(void) inst;")
     # !if(!gt(numResults, 0), "$res = inst;", "");
 }
 
 // Base class for LLVM intrinsic operations, should not be used directly. Places
 // the intrinsic into the LLVM dialect and prefixes its name with "intr.".
 class LLVM_IntrOp<string mnem, list<int> overloadedResults,
-                  list<int> overloadedOperands, list<OpTrait> traits,
+                  list<int> overloadedOperands, list<Trait> traits,
                   int numResults, bit requiresAccessGroup = 0,
                   bit requiresAliasScope = 0>
     : LLVM_IntrOpBase<LLVM_Dialect, "intr." # mnem, !subst(".", "_", mnem),
                       overloadedResults, overloadedOperands, traits,
                       numResults, requiresAccessGroup, requiresAliasScope>;
 
 // Base class for LLVM intrinsic operations returning no results. Places the
 // intrinsic into the LLVM dialect and prefixes its name with "intr.".
 //
 // Sample use: derive an entry from this class and populate the fields.
 //
 //    def LLVM_Name : LLVM_ZeroResultIntrOp<"name", [0], [NoSideEffect]>,
 //                    Arguments<(ins LLVM_Type, LLVM_Type)>;
 //
 // The mnemonic will be prefixed with "llvm.intr.", where the "llvm." part comes
 // from the LLVM dialect. The overloadedOperands list contains the indices of
 // the operands the type of which will be passed in the LLVM IR intrinsic
 // builder. In the example above, the Op has two arguments, but only the first
 // one (as indicated by `[0]`) is necessary to resolve the overloaded intrinsic.
 // The Op has no results.
 class LLVM_ZeroResultIntrOp<string mnem, list<int> overloadedOperands = [],
-                            list<OpTrait> traits = []>
+                            list<Trait> traits = []>
     : LLVM_IntrOp<mnem, [], overloadedOperands, traits, 0>;
 
 // Base class for LLVM intrinsic operations returning one result. Places the
 // intrinsic into the LLVM dialect and prefixes its name with "intr.". This is
 // similar to LLVM_ZeroResultIntrOp but allows one to define Ops returning one
 // result, called "res". Additionally, the overloadedResults list should contain
 // "0" if the result must be used to resolve overloaded intrinsics, or remain
 // empty otherwise.
 class LLVM_OneResultIntrOp<string mnem, list<int> overloadedResults = [],
                            list<int> overloadedOperands = [],
-                           list<OpTrait> traits = []>
+                           list<Trait> traits = []>
     : LLVM_IntrOp<mnem, overloadedResults, overloadedOperands, traits, 1>;
 
 // LLVM vector reduction over a single vector.
 class LLVM_VectorReduction<string mnem>
     : LLVM_OneResultIntrOp<"vector.reduce." # mnem,
                            [], [0], [NoSideEffect]>,
       Arguments<(ins LLVM_Type)>;
 

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

def LLVM_TerminatorPassthroughOpBuilder :
   [{
     $_state.addOperands(operands);
     $_state.addSuccessors(destinations);
     $_state.addAttributes(attributes);
   }]>;
 
 // Base class for LLVM terminator operations.  All terminator operations have
 // zero results and an optional list of successors.
-class LLVM_TerminatorOp<string mnemonic, list<OpTrait> traits = []> :
+class LLVM_TerminatorOp<string mnemonic, list<Trait> traits = []> :
     LLVM_Op<mnemonic, !listconcat(traits, [Terminator])>;
 
 // Class for arithmetic binary operations.
 class LLVM_ArithmeticOpBase<Type type, string mnemonic,
-                            string builderFunc, list<OpTrait> traits = []> :
+                            string builderFunc, list<Trait> traits = []> :
     LLVM_Op<mnemonic,
            !listconcat([NoSideEffect, SameOperandsAndResultType], traits)>,
     LLVM_Builder<"$res = builder." # builderFunc # "($lhs, $rhs);"> {
   dag commonArgs = (ins LLVM_ScalarOrVectorOf<type>:$lhs,
                     LLVM_ScalarOrVectorOf<type>:$rhs);
   let results = (outs LLVM_ScalarOrVectorOf<type>:$res);
   let builders = [LLVM_OneResultOpBuilder];
   let assemblyFormat = "$lhs `,` $rhs custom<LLVMOpAttrs>(attr-dict) `:` type($res)";
 }
 class LLVM_IntArithmeticOp<string mnemonic, string builderFunc,
-                           list<OpTrait> traits = []> :
+                           list<Trait> traits = []> :
     LLVM_ArithmeticOpBase<AnyInteger, mnemonic, builderFunc, traits> {
   let arguments = commonArgs;
 }
 class LLVM_FloatArithmeticOp<string mnemonic, string builderFunc,
-                             list<OpTrait> traits = []> :
+                             list<Trait> traits = []> :
     LLVM_ArithmeticOpBase<LLVM_AnyFloat, mnemonic, builderFunc,
     !listconcat([DeclareOpInterfaceMethods<FastmathFlagsInterface>], traits)> {
   dag fmfArg = (ins DefaultValuedAttr<LLVM_FMFAttr, "{}">:$fastmathFlags);
   let arguments = !con(commonArgs, fmfArg);
 }
 
 // Class for arithmetic unary operations.
 class LLVM_UnaryFloatArithmeticOp<Type type, string mnemonic,
-                             string builderFunc, list<OpTrait> traits = []> :
+                             string builderFunc, list<Trait> traits = []> :
     LLVM_Op<mnemonic,
            !listconcat([NoSideEffect, SameOperandsAndResultType, DeclareOpInterfaceMethods<FastmathFlagsInterface>], traits)>,
     LLVM_Builder<"$res = builder." # builderFunc # "($operand);"> {
   let arguments = (ins type:$operand, DefaultValuedAttr<LLVM_FMFAttr, "{}">:$fastmathFlags);
   let results = (outs type:$res);
   let builders = [LLVM_OneResultOpBuilder];
   let assemblyFormat = "$operand custom<LLVMOpAttrs>(attr-dict) `:` type($res)";
 }
let builders = [
     ];
   let parser = [{ return parseStoreOp(parser, result); }];
   let printer = [{ printStoreOp(p, *this); }];
   let verifier = [{ return ::verify(*this);  }];
 }
 
 // Casts.
 class LLVM_CastOp<string mnemonic, string builderFunc, Type type,
-                  Type resultType, list<OpTrait> traits = []> :
+                  Type resultType, list<Trait> traits = []> :
     LLVM_Op<mnemonic, !listconcat([NoSideEffect], traits)>,
     LLVM_Builder<"$res = builder." # builderFunc # "($arg, $_resultType);"> {
   let arguments = (ins type:$arg);
   let results = (outs resultType:$res);
   let builders = [LLVM_OneResultOpBuilder];
   let parser = [{ return mlir::impl::parseCastOp(parser, result); }];
   let printer = [{ mlir::impl::printCastOp(this->getOperation(), p); }];
 }
def LLVM_ConstantOp
   let hasFolder = 1;
 }
 
 // Operations that correspond to LLVM intrinsics. With MLIR operation set being
 // extendable, there is no reason to introduce a hard boundary between "core"
 // operations and intrinsics. However, we systematically prefix them with
 // "intr." to avoid potential name clashes.
 
-class LLVM_UnaryIntrinsicOp<string func, list<OpTrait> traits = []> :
+class LLVM_UnaryIntrinsicOp<string func, list<Trait> traits = []> :
     LLVM_OneResultIntrOp<func, [], [0],
            !listconcat([NoSideEffect, SameOperandsAndResultType], traits)> {
   let arguments = (ins LLVM_Type:$in);
 }
 
-class LLVM_BinarySameArgsIntrinsicOp<string func, list<OpTrait> traits = []> :
+class LLVM_BinarySameArgsIntrinsicOp<string func, list<Trait> traits = []> :
     LLVM_OneResultIntrOp<func, [], [0],
            !listconcat([NoSideEffect, SameOperandsAndResultType], traits)> {
   let arguments = (ins LLVM_Type:$a, LLVM_Type:$b);
 }
 
-class LLVM_BinaryIntrinsicOp<string func, list<OpTrait> traits = []> :
+class LLVM_BinaryIntrinsicOp<string func, list<Trait> traits = []> :
     LLVM_OneResultIntrOp<func, [], [0,1],
            !listconcat([NoSideEffect], traits)> {
   let arguments = (ins LLVM_Type:$a, LLVM_Type:$b);
 }
 
-class LLVM_TernarySameArgsIntrinsicOp<string func, list<OpTrait> traits = []> :
+class LLVM_TernarySameArgsIntrinsicOp<string func, list<Trait> traits = []> :
     LLVM_OneResultIntrOp<func, [], [0],
            !listconcat([NoSideEffect, SameOperandsAndResultType], traits)> {
   let arguments = (ins LLVM_Type:$a, LLVM_Type:$b, LLVM_Type:$c);
 }
 
-class LLVM_CountZerosIntrinsicOp<string func, list<OpTrait> traits = []> :
+class LLVM_CountZerosIntrinsicOp<string func, list<Trait> traits = []> :
     LLVM_OneResultIntrOp<func, [], [0],
            !listconcat([NoSideEffect], traits)> {
   let arguments = (ins LLVM_Type:$in, I<1>:$zero_undefined);
 }
 
 def LLVM_CopySignOp : LLVM_BinarySameArgsIntrinsicOp<"copysign">;
 def LLVM_CosOp : LLVM_UnaryIntrinsicOp<"cos">;
 def LLVM_ExpOp : LLVM_UnaryIntrinsicOp<"exp">;

mlir/include/mlir/Dialect/LLVMIR/NVVMOps.td

def NVVM_Dialect : Dialect {
 
   let useDefaultAttributePrinterParser = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // NVVM op definitions
 //===----------------------------------------------------------------------===//
 
-class NVVM_Op<string mnemonic, list<OpTrait> traits = []> :
+class NVVM_Op<string mnemonic, list<Trait> traits = []> :
   LLVM_OpBase<NVVM_Dialect, mnemonic, traits> {
 }
 
 //===----------------------------------------------------------------------===//
 // NVVM intrinsic operations
 //===----------------------------------------------------------------------===//
 
 class NVVM_IntrOp<string mnem, list<int> overloadedResults,
-                  list<int> overloadedOperands, list<OpTrait> traits,
+                  list<int> overloadedOperands, list<Trait> traits,
                   int numResults>
   : LLVM_IntrOpBase<NVVM_Dialect, mnem, "nvvm_" # !subst(".", "_", mnem),
                     overloadedResults, overloadedOperands, traits, numResults>;
 
 
 //===----------------------------------------------------------------------===//
 // NVVM special register op definitions
 //===----------------------------------------------------------------------===//
 
 class NVVM_SpecialRegisterOp<string mnemonic,
-    list<OpTrait> traits = []> :
+    list<Trait> traits = []> :
   NVVM_IntrOp<mnemonic, [], [], !listconcat(traits, [NoSideEffect]), 1>,
   Arguments<(ins)> {
   let assemblyFormat = "attr-dict `:` type($res)";
 }
 
 //===----------------------------------------------------------------------===//
 // Lane index and range
 def NVVM_LaneIdOp : NVVM_SpecialRegisterOp<"read.ptx.sreg.laneid">;

mlir/include/mlir/Dialect/LLVMIR/ROCDLOps.td

let extraClassDeclaration = [{
     static StringRef getKernelFuncAttrName() { return "rocdl.kernel"; }
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // ROCDL op definitions
 //===----------------------------------------------------------------------===//
 
-class ROCDL_Op<string mnemonic, list<OpTrait> traits = []> :
+class ROCDL_Op<string mnemonic, list<Trait> traits = []> :
   LLVM_OpBase<ROCDL_Dialect, mnemonic, traits> {
 }
 
 //===----------------------------------------------------------------------===//
 // ROCDL special register op definitions
 //===----------------------------------------------------------------------===//
 
 class ROCDL_SpecialRegisterOp<string mnemonic,
-    list<OpTrait> traits = []> :
+    list<Trait> traits = []> :
   ROCDL_Op<mnemonic, !listconcat(traits, [NoSideEffect])>,
   Results<(outs LLVM_Type:$res)>, Arguments<(ins)> {
   string llvmBuilder = "$res = createIntrinsicCall(builder,"
     # "llvm::Intrinsic::amdgcn_" # !subst(".","_", mnemonic) # ");";
   let assemblyFormat = "attr-dict `:` type($res)";
 }
 
 class ROCDL_DeviceFunctionOp<string mnemonic, string device_function,
-                             int parameter, list<OpTrait> traits = []> :
+                             int parameter, list<Trait> traits = []> :
   ROCDL_Op<mnemonic, !listconcat(traits, [NoSideEffect])>,
   Results<(outs LLVM_Type:$res)>, Arguments<(ins)> {
   string llvmBuilder = "$res = createDeviceFunctionCall(builder, \""
   # device_function # "\", " # parameter # ");";
   let assemblyFormat = "attr-dict `:` type($res)";
 }
 
 //===----------------------------------------------------------------------===//
builder.CreateFence(llvm::AtomicOrdering::Acquire,
                         llvmContext.getOrInsertSyncScopeID("workgroup"));
   }];
   let assemblyFormat = "attr-dict";
 }
 
 //===---------------------------------------------------------------------===//
 // Xdlops intrinsics
 
-class ROCDL_Mfma_IntrOp<string mnemonic, list<OpTrait> traits = []> :
+class ROCDL_Mfma_IntrOp<string mnemonic, list<Trait> traits = []> :
   LLVM_IntrOpBase<ROCDL_Dialect, mnemonic,
                   "amdgcn_" # !subst(".","_", mnemonic),
                   [], [], traits, 1>,
   Arguments<(ins Variadic<LLVM_Type>:$args)> {
   let assemblyFormat =
     "$args attr-dict `:` functional-type($args, $res)";
 }
 

mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.td

 include "mlir/Dialect/Linalg/IR/LinalgBase.td"
 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/LoopLikeInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/Interfaces/ViewLikeInterface.td"
 
 // Base class for Linalg dialect ops that do not correspond to library calls.
-class Linalg_Op<string mnemonic, list<OpTrait> traits = []> :
+class Linalg_Op<string mnemonic, list<Trait> traits = []> :
     Op<Linalg_Dialect, mnemonic, traits> {
   // For every linalg op, there needs to be a:
   //   * void print(OpAsmPrinter &p, ${C++ class of Op} op)
   //   * LogicalResult verify(${C++ class of Op} op)
   //   * ParseResult parse${C++ class of Op}(OpAsmParser &parser,
   //                                         OperationState &result)
   // functions.
   let printer = [{ return ::print(p, *this); }];

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td

 include "mlir/Interfaces/CopyOpInterface.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 // Base Tablegen class for Linalg ops.
 // Linalg ops that correspond to library calls operate on ShapedType as their
 // first operands. These may be optionally followed by non-view operands
 // depending on the specific Linalg op.
-class LinalgStructuredBase_Op<string mnemonic, list<OpTrait> props>
+class LinalgStructuredBase_Op<string mnemonic, list<Trait> props>
   : Op<Linalg_Dialect, mnemonic, !listconcat([
        SingleBlockImplicitTerminator<"YieldOp">,
        DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
        LinalgStructuredInterface,
        ReifyRankedShapedTypeOpInterface], props)> {
   code structuredOpsBaseDecls = [{
     // Return whether the op accesses the iteration indices.
     bool hasIndexSemantics() {
       return !this->getBody()->getOps<IndexOp>().empty();
     }
 
     LogicalResult reifyResultShapes(OpBuilder &b,
         ReifiedRankedShapedTypeDims &reifiedReturnShapes) {
       return cast<LinalgOp>(getOperation()).reifyResultShapes(b,
           reifiedReturnShapes);
     }
   }];
 }
 
-class LinalgStructured_Op<string mnemonic, list<OpTrait> props>
+class LinalgStructured_Op<string mnemonic, list<Trait> props>
   : LinalgStructuredBase_Op<mnemonic, !listconcat(props, [])> {
   code structuredOpsDecls = structuredOpsBaseDecls # [{
     std::string getLibraryCallName() {
       return generateLibraryCallName(getOperation());
     }
   }];
   let assemblyFormat = "`(` operands `)` attr-dict `:` type(operands)";
 }

mlir/include/mlir/Dialect/Math/IR/MathOps.td

 
 include "mlir/Dialect/Math/IR/MathBase.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/VectorInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 // Base class for math dialect ops. Ops in this dialect have no side effects and
 // can be applied element-wise to vectors and tensors.
-class Math_Op<string mnemonic, list<OpTrait> traits = []> :
+class Math_Op<string mnemonic, list<Trait> traits = []> :
     Op<Math_Dialect, mnemonic, traits # [NoSideEffect,
     DeclareOpInterfaceMethods<VectorUnrollOpInterface>] #
     ElementwiseMappable.traits>;
 
 // Base class for unary math operations on integer types. Require a operand and
 // result of the same type. This type can be an integer type, or vector or tensor
 // thereof.
-class Math_IntegerUnaryOp<string mnemonic, list<OpTrait> traits = []> :
+class Math_IntegerUnaryOp<string mnemonic, list<Trait> traits = []> :
     Math_Op<mnemonic, traits # [SameOperandsAndResultType]> {
   let arguments = (ins SignlessIntegerLike:$operand);
   let results = (outs SignlessIntegerLike:$result);
 
   let assemblyFormat = "$operand attr-dict `:` type($result)";
 }
 
 // Base class for unary math operations on floating point types. Require a
 // operand and result of the same type. This type can be a floating point type,
 // or vector or tensor thereof.
-class Math_FloatUnaryOp<string mnemonic, list<OpTrait> traits = []> :
+class Math_FloatUnaryOp<string mnemonic, list<Trait> traits = []> :
     Math_Op<mnemonic, traits # [SameOperandsAndResultType]> {
   let arguments = (ins FloatLike:$operand);
   let results = (outs FloatLike:$result);
 
   let assemblyFormat = "$operand attr-dict `:` type($result)";
 }
 
 // Base class for binary math operations on floating point types. Require two
 // operands and one result of the same type. This type can be a floating point
 // type, or a vector or tensor thereof.
-class Math_FloatBinaryOp<string mnemonic, list<OpTrait> traits = []> :
+class Math_FloatBinaryOp<string mnemonic, list<Trait> traits = []> :
     Math_Op<mnemonic, traits # [SameOperandsAndResultType]> {
   let arguments = (ins FloatLike:$lhs, FloatLike:$rhs);
   let results = (outs FloatLike:$result);
 
   let assemblyFormat = "$lhs `,` $rhs attr-dict `:` type($result)";
 }
 
 // Base class for floating point ternary operations. Require three operands and
 // one result of the same type. This type can be a floating point type, or a
 // vector or tensor thereof.
-class Math_FloatTernaryOp<string mnemonic, list<OpTrait> traits = []> :
+class Math_FloatTernaryOp<string mnemonic, list<Trait> traits = []> :
     Math_Op<mnemonic, traits # [SameOperandsAndResultType]> {
   let arguments = (ins FloatLike:$a, FloatLike:$b, FloatLike:$c);
   let results = (outs FloatLike:$result);
 
   let assemblyFormat = "$a `,` $b `,` $c attr-dict `:` type($result)";
 }
 
 //===----------------------------------------------------------------------===//

mlir/include/mlir/Dialect/MemRef/IR/MemRefOps.td

 include "mlir/IR/SymbolInterfaces.td"
 
 /// A TypeAttr for memref types.
 def MemRefTypeAttr
     : TypeAttrBase<"::mlir::MemRefType", "memref type attribute"> {
   let constBuilderCall = "::mlir::TypeAttr::get($0)";
 }
 
-class MemRef_Op<string mnemonic, list<OpTrait> traits = []>
+class MemRef_Op<string mnemonic, list<Trait> traits = []>
     : Op<MemRef_Dialect, mnemonic, traits> {
   let printer = [{ return ::print(p, *this); }];
   let verifier = [{ return ::verify(*this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
 }
 
 //===----------------------------------------------------------------------===//
 // AllocLikeOp
 //===----------------------------------------------------------------------===//
 
 // Base class for memref allocating ops: alloca and alloc.
 //
 //   %0 = alloclike(%m)[%s] : memref<8x?xf32, affine_map<(d0, d1)[s0] -> (d0 + s0, d1)>>
 //
 class AllocLikeOp<string mnemonic,
                   Resource resource,
-                  list<OpTrait> traits = []> :
+                  list<Trait> traits = []> :
     MemRef_Op<mnemonic,
     !listconcat([
       AttrSizedOperandSegments
     ], traits)> {
 
   let arguments = (ins Variadic<Index>:$dynamicSizes,
                        // The symbolic operands (the ones in square brackets)
                        // bind to the symbols of the memref's layout map.
let assemblyFormat = [{
     $source `(` $shape `)` attr-dict `:` functional-type(operands, results)
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // ExpandShapeOp / CollapseShapeOp
 //===----------------------------------------------------------------------===//
 
-class MemRef_ReassociativeReshapeOp<string mnemonic, list<OpTrait> traits = []> :
+class MemRef_ReassociativeReshapeOp<string mnemonic, list<Trait> traits = []> :
     MemRef_Op<mnemonic, !listconcat(traits,
       [NoSideEffect, ViewLikeOpInterface])>,
     Arguments<(ins AnyStridedMemRef:$src, IndexListArrayAttr:$reassociation)>,
     Results<(outs AnyStridedMemRef:$result)>{
   let builders = [
     // Builders for a contracting reshape whose result type is computed from
     // `src` and `reassociation`.
     OpBuilder<(ins "Value":$src,

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

def OpenACC_Dialect : Dialect {
   let useDefaultAttributePrinterParser = 1;
   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<OpTrait> traits = []> :
+class OpenACC_Op<string mnemonic, list<Trait> traits = []> :
   Op<OpenACC_Dialect, mnemonic, traits> {
 
   let printer = [{ return ::print(p, *this); }];
   let verifier = [{ return ::verify(*this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
 }
 
 // Reduction operation enumeration.

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

def OpenMP_Dialect : Dialect {
   let cppNamespace = "::mlir::omp";
   let dependentDialects = ["::mlir::LLVM::LLVMDialect"];
   let useDefaultAttributePrinterParser = 1;
 }
 
 // OmpCommon requires definition of OpenACC_Dialect.
 include "mlir/Dialect/OpenMP/OmpCommon.td"
 
-class OpenMP_Op<string mnemonic, list<OpTrait> traits = []> :
+class OpenMP_Op<string mnemonic, list<Trait> traits = []> :
       Op<OpenMP_Dialect, mnemonic, traits>;
 
 // Type which can be constraint accepting standard integers and indices.
 def IntLikeType : AnyTypeOf<[AnyInteger, Index]>;
 
 def OpenMP_PointerLikeTypeInterface : TypeInterface<"PointerLikeType"> {
   let cppNamespace = "::mlir::omp";
 

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

 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/IR/OpAsmInterface.td"
 include "mlir/IR/SymbolInterfaces.td"
 
 //===----------------------------------------------------------------------===//
 // PDL Ops
 //===----------------------------------------------------------------------===//
 
-class PDL_Op<string mnemonic, list<OpTrait> traits = []>
+class PDL_Op<string mnemonic, list<Trait> traits = []>
     : Op<PDL_Dialect, mnemonic, traits> {
   let printer = [{ ::print(p, *this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
   let verifier = [{ return ::verify(*this); }];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::ApplyNativeConstraintOp

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

def PDLInterp_Dialect : Dialect {
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // PDLInterp Operations
 //===----------------------------------------------------------------------===//
 
 // Generic interpreter operation.
-class PDLInterp_Op<string mnemonic, list<OpTrait> traits = []> :
+class PDLInterp_Op<string mnemonic, list<Trait> traits = []> :
     Op<PDLInterp_Dialect, mnemonic, traits>;
 
 //===----------------------------------------------------------------------===//
 // PDLInterp_PredicateOp
 
 // Check operations evaluate a predicate on a positional value and then
 // conditionally branch on the result.
-class PDLInterp_PredicateOp<string mnemonic, list<OpTrait> traits = []> :
+class PDLInterp_PredicateOp<string mnemonic, list<Trait> traits = []> :
     PDLInterp_Op<mnemonic, !listconcat([Terminator], traits)> {
   let successors = (successor AnySuccessor:$trueDest, AnySuccessor:$falseDest);
 }
 
 //===----------------------------------------------------------------------===//
 // PDLInterp_SwitchOp
 
 // Switch operations evaluate a predicate on a positional value and then
 // conditionally branch on the result.
-class PDLInterp_SwitchOp<string mnemonic, list<OpTrait> traits = []> :
+class PDLInterp_SwitchOp<string mnemonic, list<Trait> traits = []> :
     PDLInterp_Op<mnemonic, !listconcat([Terminator], traits)> {
   let successors = (successor AnySuccessor:$defaultDest,
                               VariadicSuccessor<AnySuccessor>:$cases);
 
   let verifier = [{
     // Verify that the number of case destinations matches the number of case
     // values.
     size_t numDests = cases().size();

mlir/include/mlir/Dialect/Quant/QuantOps.td

 include "mlir/Dialect/Quant/QuantOpsBase.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 //===----------------------------------------------------------------------===//
 // Base classes
 //===----------------------------------------------------------------------===//
 
-class quant_Op<string mnemonic, list<OpTrait> traits> :
+class quant_Op<string mnemonic, list<Trait> traits> :
     Op<Quantization_Dialect, mnemonic, traits>;
 
 //===----------------------------------------------------------------------===//
 // Quantization casts
 //===----------------------------------------------------------------------===//
 // A QuantizeCast (qcast) represents a potential type shift from a quantizable
 // type to a quantized type.
 //

mlir/include/mlir/Dialect/SCF/SCFOps.td

 def SCF_Dialect : Dialect {
   let name = "scf";
   let cppNamespace = "::mlir::scf";
   let dependentDialects = ["arith::ArithmeticDialect"];
   let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;
 }
 
 // Base class for SCF dialect ops.
-class SCF_Op<string mnemonic, list<OpTrait> traits = []> :
+class SCF_Op<string mnemonic, list<Trait> traits = []> :
     Op<SCF_Dialect, mnemonic, traits> {
   // For every standard op, there needs to be a:
   //   * void print(OpAsmPrinter &p, ${C++ class of Op} op)
   //   * LogicalResult verify(${C++ class of Op} op)
   //   * ParseResult parse${C++ class of Op}(OpAsmParser &parser,
   //                                         OperationState &result)
   // functions.
   let printer = [{ return ::print(p, *this); }];

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVArithmeticOps.td

 #ifndef MLIR_DIALECT_SPIRV_IR_ARITHMETIC_OPS
 #define MLIR_DIALECT_SPIRV_IR_ARITHMETIC_OPS
 
 include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 class SPV_ArithmeticBinaryOp<string mnemonic, Type type,
-                       list<OpTrait> traits = []> :
+                       list<Trait> traits = []> :
       // Operands type same as result type.
       SPV_BinaryOp<mnemonic, type, type,
                    !listconcat(traits,
                                [NoSideEffect, SameOperandsAndResultType])> {
   // In addition to normal types arithmetic instructions can support cooperative
   // matrix.
   let arguments = (ins
     SPV_ScalarOrVectorOrCoopMatrixOf<type>:$operand1,
     SPV_ScalarOrVectorOrCoopMatrixOf<type>:$operand2
   );
 
   let results = (outs
     SPV_ScalarOrVectorOrCoopMatrixOf<type>:$result
   );
 }
 
 class SPV_ArithmeticUnaryOp<string mnemonic, Type type,
-                            list<OpTrait> traits = []> :
+                            list<Trait> traits = []> :
       // Operand type same as result type.
       SPV_UnaryOp<mnemonic, type, type,
                    !listconcat(traits,
                                [NoSideEffect, SameOperandsAndResultType])>;
 
 // -----
 
 def SPV_FAddOp : SPV_ArithmeticBinaryOp<"FAdd", SPV_Float, [Commutative]> {

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVAtomicOps.td

 //===-- SPIRVAtomicOps.td - MLIR SPIR-V Atomic Ops ---------*- tablegen -*-===//
 //
 // 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 atomic ops for the SPIR-V dialect. It corresponds to
 // "3.32.18. Atomic Instructions" of the SPIR-V specification.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_SPIRV_IR_ATOMIC_OPS
 #define MLIR_DIALECT_SPIRV_IR_ATOMIC_OPS
 
-class SPV_AtomicUpdateOp<string mnemonic, list<OpTrait> traits = []> :
+class SPV_AtomicUpdateOp<string mnemonic, list<Trait> traits = []> :
   SPV_Op<mnemonic, traits> {
   let parser = [{ return ::parseAtomicUpdateOp(parser, result, false); }];
   let printer = [{ return ::printAtomicUpdateOp(getOperation(), p); }];
   let verifier = [{ return ::verifyAtomicUpdateOp<IntegerType>(getOperation()); }];
 
   let arguments = (ins
     SPV_AnyPtr:$pointer,
     SPV_ScopeAttr:$memory_scope,
     SPV_MemorySemanticsAttr:$semantics
   );
 
   let results = (outs
     SPV_Integer:$result
   );
 }
 
-class SPV_AtomicUpdateWithValueOp<string mnemonic, list<OpTrait> traits = []> :
+class SPV_AtomicUpdateWithValueOp<string mnemonic, list<Trait> traits = []> :
   SPV_Op<mnemonic, traits> {
   let parser = [{ return ::parseAtomicUpdateOp(parser, result, true); }];
   let printer = [{ return ::printAtomicUpdateOp(getOperation(), p); }];
   let verifier = [{ return ::verifyAtomicUpdateOp<IntegerType>(getOperation()); }];
 
   let arguments = (ins
     SPV_AnyPtr:$pointer,
     SPV_ScopeAttr:$memory_scope,

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVBase.td

 
 // End opcode section. Generated from SPIR-V spec; DO NOT MODIFY!
 
 //===----------------------------------------------------------------------===//
 // SPIR-V op definitions
 //===----------------------------------------------------------------------===//
 
 // Base class for all SPIR-V ops.
-class SPV_Op<string mnemonic, list<OpTrait> traits = []> :
+class SPV_Op<string mnemonic, list<Trait> traits = []> :
     Op<SPIRV_Dialect, mnemonic, !listconcat(traits, [
          // TODO: We don't need all of the following traits for every op; only
          // the suitable ones should be added automatically after ODS supports
          // dialect-specific contents.
          DeclareOpInterfaceMethods<QueryMinVersionInterface>,
          DeclareOpInterfaceMethods<QueryMaxVersionInterface>,
          DeclareOpInterfaceMethods<QueryExtensionInterface>,
          DeclareOpInterfaceMethods<QueryCapabilityInterface>
class SPV_Op<string mnemonic, list<Trait> traits = []> :
   //    above methods for (de)serialization are generated, but there is no
   //    entry added in the dispatch tables to invoke these methods. The
   //    dispatch needs to be handled manually. SPV_ExtInstOps are an
   //    example of this.
   bit autogenSerialization = 1;
 }
 
 class SPV_UnaryOp<string mnemonic, Type resultType, Type operandType,
-                  list<OpTrait> traits = []> :
+                  list<Trait> traits = []> :
       SPV_Op<mnemonic, traits> {
   let arguments = (ins
     SPV_ScalarOrVectorOf<operandType>:$operand
   );
 
   let results = (outs
     SPV_ScalarOrVectorOf<resultType>:$result
   );
 
   let parser = [{ return ::parseUnaryOp(parser, result); }];
   let printer = [{ return ::printUnaryOp(getOperation(), p); }];
   // No additional verification needed in addition to the ODS-generated ones.
   let verifier = [{ return success(); }];
 }
 
 class SPV_BinaryOp<string mnemonic, Type resultType, Type operandsType,
-                   list<OpTrait> traits = []> :
+                   list<Trait> traits = []> :
       SPV_Op<mnemonic, traits> {
   let arguments = (ins
     SPV_ScalarOrVectorOf<operandsType>:$operand1,
     SPV_ScalarOrVectorOf<operandsType>:$operand2
   );
 
   let results = (outs
     SPV_ScalarOrVectorOf<resultType>:$result
   );
 
   let parser = [{ return impl::parseOneResultSameOperandTypeOp(parser, result); }];
   let printer = [{ return impl::printOneResultOp(getOperation(), p); }];
   // No additional verification needed in addition to the ODS-generated ones.
   let verifier = [{ return success(); }];
 }
 
 class SPV_ExtInstOp<string mnemonic, string setPrefix, string setName,
-                    int opcode, list<OpTrait> traits = []> :
+                    int opcode, list<Trait> traits = []> :
   SPV_Op<setPrefix # "." # mnemonic, traits> {
 
   // Extended instruction sets have no direct opcode (they share the
   // same `OpExtInst` instruction). So the hasOpcode field is set to
   // false. So no entry corresponding to these ops are added in the
   // dispatch functions for (de)serialization. The methods for
   // (de)serialization are still automatically generated (since
   // autogenSerialization remains 1). A separate method is generated

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVBitOps.td

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_SPIRV_IR_BIT_OPS
 #define MLIR_DIALECT_SPIRV_IR_BIT_OPS
 
 include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
-class SPV_BitBinaryOp<string mnemonic, list<OpTrait> traits = []> :
+class SPV_BitBinaryOp<string mnemonic, list<Trait> traits = []> :
       // All the operands type used in bit instructions are SPV_Integer.
       SPV_BinaryOp<mnemonic, SPV_Integer, SPV_Integer,
                    !listconcat(traits,
                                [NoSideEffect, SameOperandsAndResultType])>;
 
-class SPV_BitFieldExtractOp<string mnemonic, list<OpTrait> traits = []> :
+class SPV_BitFieldExtractOp<string mnemonic, list<Trait> traits = []> :
       SPV_Op<mnemonic, !listconcat(traits,
              [NoSideEffect, AllTypesMatch<["base", "result"]>])> {
   let arguments = (ins
     SPV_ScalarOrVectorOf<SPV_Integer>:$base,
     SPV_Integer:$offset,
     SPV_Integer:$count
   );
 
   let results = (outs
     SPV_ScalarOrVectorOf<SPV_Integer>:$result
   );
 
   let verifier = [{ return success(); }];
 
   let assemblyFormat = [{
     operands attr-dict `:` type($base) `,` type($offset) `,` type($count)
   }];
 }
 
-class SPV_BitUnaryOp<string mnemonic, list<OpTrait> traits = []> :
+class SPV_BitUnaryOp<string mnemonic, list<Trait> traits = []> :
       SPV_UnaryOp<mnemonic, SPV_Integer, SPV_Integer,
                    !listconcat(traits,
                                [NoSideEffect, SameOperandsAndResultType])>;
 
-class SPV_ShiftOp<string mnemonic, list<OpTrait> traits = []> :
+class SPV_ShiftOp<string mnemonic, list<Trait> traits = []> :
       SPV_BinaryOp<mnemonic, SPV_Integer, SPV_Integer,
                    !listconcat(traits,
                                [NoSideEffect, SameOperandsAndResultShape])> {
   let parser = [{ return ::parseShiftOp(parser, result); }];
   let printer = [{ ::printShiftOp(this->getOperation(), p); }];
   let verifier = [{ return ::verifyShiftOp(this->getOperation()); }];
 }
 

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVCastOps.td

 
 #ifndef MLIR_DIALECT_SPIRV_IR_CAST_OPS
 #define MLIR_DIALECT_SPIRV_IR_CAST_OPS
 
 include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 class SPV_CastOp<string mnemonic, Type resultType, Type operandType,
-                 list<OpTrait> traits = []> :
+                 list<Trait> traits = []> :
       SPV_Op<mnemonic,
              !listconcat(traits,
                          [NoSideEffect, SameOperandsAndResultShape])> {
   let arguments = (ins
     SPV_ScalarOrVectorOrCoopMatrixOf<operandType>:$operand
   );
 
   let results = (outs

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVGLSLOps.td

 include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 //===----------------------------------------------------------------------===//
 // SPIR-V GLSL 4.50 opcode specification.
 //===----------------------------------------------------------------------===//
 
 // Base class for all GLSL ops.
-class SPV_GLSLOp<string mnemonic, int opcode, list<OpTrait> traits = []> :
+class SPV_GLSLOp<string mnemonic, int opcode, list<Trait> traits = []> :
   SPV_ExtInstOp<mnemonic, "GLSL", "GLSL.std.450", opcode, traits> {
 
   let availability = [
     MinVersion<SPV_V_1_0>,
     MaxVersion<SPV_V_1_5>,
     Extension<[]>,
     Capability<[SPV_C_Shader]>
   ];
 }
 
 // Base class for GLSL unary ops.
 class SPV_GLSLUnaryOp<string mnemonic, int opcode, Type resultType,
-                      Type operandType, list<OpTrait> traits = []> :
+                      Type operandType, list<Trait> traits = []> :
   SPV_GLSLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
 
   let arguments = (ins
     SPV_ScalarOrVectorOf<operandType>:$operand
   );
 
   let results = (outs
     SPV_ScalarOrVectorOf<resultType>:$result
   );
 
   let parser = [{ return parseUnaryOp(parser, result); }];
 
   let printer = [{ return printUnaryOp(getOperation(), p); }];
 
   let verifier = [{ return success(); }];
 }
 
 // Base class for GLSL Unary arithmetic ops where return type matches
 // the operand type.
 class SPV_GLSLUnaryArithmeticOp<string mnemonic, int opcode, Type type,
-                                list<OpTrait> traits = []> :
+                                list<Trait> traits = []> :
   SPV_GLSLUnaryOp<mnemonic, opcode, type, type, traits>;
 
 // Base class for GLSL binary ops.
 class SPV_GLSLBinaryOp<string mnemonic, int opcode, Type resultType,
-                        Type operandType, list<OpTrait> traits = []> :
+                        Type operandType, list<Trait> traits = []> :
   SPV_GLSLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
 
   let arguments = (ins
     SPV_ScalarOrVectorOf<operandType>:$lhs,
     SPV_ScalarOrVectorOf<operandType>:$rhs
   );
 
   let results = (outs
     SPV_ScalarOrVectorOf<resultType>:$result
   );
 
   let parser = [{ return impl::parseOneResultSameOperandTypeOp(parser, result); }];
 
   let printer = [{ return impl::printOneResultOp(getOperation(), p); }];
 
   let verifier = [{ return success(); }];
 }
 
 // Base class for GLSL Binary arithmetic ops where operand types and
 // return type matches.
 class SPV_GLSLBinaryArithmeticOp<string mnemonic, int opcode, Type type,
-                                 list<OpTrait> traits = []> :
+                                 list<Trait> traits = []> :
   SPV_GLSLBinaryOp<mnemonic, opcode, type, type, traits>;
 
 // Base class for GLSL ternary ops.
 class SPV_GLSLTernaryArithmeticOp<string mnemonic, int opcode, Type type,
-                        list<OpTrait> traits = []> :
+                        list<Trait> traits = []> :
   SPV_GLSLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
 
   let arguments = (ins
     SPV_ScalarOrVectorOf<type>:$x,
     SPV_ScalarOrVectorOf<type>:$y,
     SPV_ScalarOrVectorOf<type>:$z
   );
 

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVLogicalOps.td

 
 #ifndef MLIR_DIALECT_SPIRV_IR_LOGICAL_OPS
 #define MLIR_DIALECT_SPIRV_IR_LOGICAL_OPS
 
 include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 class SPV_LogicalBinaryOp<string mnemonic, Type operandsType,
-                    list<OpTrait> traits = []> :
+                    list<Trait> traits = []> :
       // Result type is SPV_Bool.
       SPV_BinaryOp<mnemonic, SPV_Bool, operandsType,
                    !listconcat(traits,
                                [NoSideEffect, SameTypeOperands,
                                 SameOperandsAndResultShape])> {
   let parser = [{ return ::parseLogicalBinaryOp(parser, result); }];
   let printer = [{ return ::printLogicalOp(getOperation(), p); }];
 
   let builders = [
     OpBuilder<(ins "Value":$lhs, "Value":$rhs),
     [{::buildLogicalBinaryOp($_builder, $_state, lhs, rhs);}]>
   ];
 }
 
 class SPV_LogicalUnaryOp<string mnemonic, Type operandType,
-                         list<OpTrait> traits = []> :
+                         list<Trait> traits = []> :
       // Result type is SPV_Bool.
       SPV_UnaryOp<mnemonic, SPV_Bool, operandType,
                   !listconcat(traits, [NoSideEffect, SameTypeOperands,
                                        SameOperandsAndResultShape])> {
   let parser = [{ return ::parseLogicalUnaryOp(parser, result); }];
   let printer = [{ return ::printLogicalOp(getOperation(), p); }];
 
   let builders = [

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVNonUniformOps.td

 // "3.32.24. Non-Uniform Instructions" of the SPIR-V specification.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_SPIRV_IR_NON_UNIFORM_OPS
 #define MLIR_DIALECT_SPIRV_IR_NON_UNIFORM_OPS
 
 class SPV_GroupNonUniformArithmeticOp<string mnemonic, Type type,
-      list<OpTrait> traits = []> : SPV_Op<mnemonic, traits> {
+      list<Trait> traits = []> : SPV_Op<mnemonic, traits> {
 
   let arguments = (ins
     SPV_ScopeAttr:$execution_scope,
     SPV_GroupOperationAttr:$group_operation,
     SPV_ScalarOrVectorOf<type>:$value,
     Optional<SPV_Integer>:$cluster_size
   );
 

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVOCLOps.td

 
 include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
 
 //===----------------------------------------------------------------------===//
 // SPIR-V OpenCL opcode specification.
 //===----------------------------------------------------------------------===//
 
 // Base class for all OpenCL ops.
-class SPV_OCLOp<string mnemonic, int opcode, list<OpTrait> traits = []> :
+class SPV_OCLOp<string mnemonic, int opcode, list<Trait> traits = []> :
   SPV_ExtInstOp<mnemonic, "OCL", "OpenCL.std", opcode, traits> {
 
   let availability = [
     MinVersion<SPV_V_1_0>,
     MaxVersion<SPV_V_1_5>,
     Extension<[]>,
     Capability<[SPV_C_Kernel]>
   ];
 }
 
 // Base class for OpenCL unary ops.
 class SPV_OCLUnaryOp<string mnemonic, int opcode, Type resultType,
-                     Type operandType, list<OpTrait> traits = []> :
+                     Type operandType, list<Trait> traits = []> :
   SPV_OCLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
 
   let arguments = (ins
     SPV_ScalarOrVectorOf<operandType>:$operand
   );
 
   let results = (outs
     SPV_ScalarOrVectorOf<resultType>:$result
   );
 
   let parser = [{ return parseUnaryOp(parser, result); }];
 
   let printer = [{ return printUnaryOp(getOperation(), p); }];
 
   let verifier = [{ return success(); }];
 }
 
 // Base class for OpenCL Unary arithmetic ops where return type matches
 // the operand type.
 class SPV_OCLUnaryArithmeticOp<string mnemonic, int opcode, Type type,
-                               list<OpTrait> traits = []> :
+                               list<Trait> traits = []> :
   SPV_OCLUnaryOp<mnemonic, opcode, type, type, traits>;
 
 // Base class for OpenCL binary ops.
 class SPV_OCLBinaryOp<string mnemonic, int opcode, Type resultType,
-                      Type operandType, list<OpTrait> traits = []> :
+                      Type operandType, list<Trait> traits = []> :
   SPV_OCLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
 
   let arguments = (ins
     SPV_ScalarOrVectorOf<operandType>:$lhs,
     SPV_ScalarOrVectorOf<operandType>:$rhs
   );
 
   let results = (outs
     SPV_ScalarOrVectorOf<resultType>:$result
   );
 
   let parser = [{ return impl::parseOneResultSameOperandTypeOp(parser, result); }];
 
   let printer = [{ return impl::printOneResultOp(getOperation(), p); }];
 
   let verifier = [{ return success(); }];
 }
 
 // Base class for OpenCL Binary arithmetic ops where operand types and
 // return type matches.
 class SPV_OCLBinaryArithmeticOp<string mnemonic, int opcode, Type type,
-                                list<OpTrait> traits = []> :
+                                list<Trait> traits = []> :
   SPV_OCLBinaryOp<mnemonic, opcode, type, type, traits>;
 
 // -----
 
 def SPV_OCLErfOp : SPV_OCLUnaryArithmeticOp<"erf", 18, SPV_Float> {
   let summary = [{
     Error function of x encountered in integrating the normal distribution.
   }];

mlir/include/mlir/Dialect/Shape/IR/ShapeOps.td

 include "mlir/IR/OpAsmInterface.td"
 include "mlir/IR/SymbolInterfaces.td"
 
 //===----------------------------------------------------------------------===//
 // Shape op definitions
 //===----------------------------------------------------------------------===//
 
 // Base class for the operation in this dialect
-class Shape_Op<string mnemonic, list<OpTrait> traits = []> :
+class Shape_Op<string mnemonic, list<Trait> traits = []> :
     Op<ShapeDialect, mnemonic, traits>;
 
 def Shape_AddOp : Shape_Op<"add",
     [Commutative, NoSideEffect,
      DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
   let summary = "Addition of sizes and indices";
   let description = [{
     Adds two sizes or indices. If either operand is an error it will be

mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorOps.td

 include "mlir/Dialect/SparseTensor/IR/SparseTensorBase.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 //===----------------------------------------------------------------------===//
 // Base class.
 //===----------------------------------------------------------------------===//
 
-class SparseTensor_Op<string mnemonic, list<OpTrait> traits = []>
+class SparseTensor_Op<string mnemonic, list<Trait> traits = []>
   : Op<SparseTensor_Dialect, mnemonic, traits> {
   let printer = [{ return ::print(p, *this); }];
   let verifier = [{ return ::verify(*this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
 }
 
 //===----------------------------------------------------------------------===//
 // Sparse Tensor Operations.

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

def StandardOps_Dialect : Dialect {
   let name = "std";
   let cppNamespace = "::mlir";
   let dependentDialects = ["arith::ArithmeticDialect"];
   let hasConstantMaterializer = 1;
   let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;
 }
 
 // Base class for Standard dialect ops.
-class Std_Op<string mnemonic, list<OpTrait> traits = []> :
+class Std_Op<string mnemonic, list<Trait> traits = []> :
     Op<StandardOps_Dialect, mnemonic, traits> {
   // For every standard op, there needs to be a:
   //   * void print(OpAsmPrinter &p, ${C++ class of Op} op)
   //   * LogicalResult verify(${C++ class of Op} op)
   //   * ParseResult parse${C++ class of Op}(OpAsmParser &parser,
   //                                         OperationState &result)
   // functions.
   let printer = [{ return ::print(p, *this); }];
   let verifier = [{ return ::verify(*this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
 }
 
 // Base class for unary ops. Requires single operand and result. Individual
 // classes will have `operand` accessor.
-class UnaryOp<string mnemonic, list<OpTrait> traits = []> :
+class UnaryOp<string mnemonic, list<Trait> traits = []> :
     Op<StandardOps_Dialect, mnemonic, !listconcat(traits, [NoSideEffect])> {
   let results = (outs AnyType);
   let printer = [{
     return printStandardUnaryOp(this->getOperation(), p);
   }];
 }
 
 class UnaryOpSameOperandAndResultType<string mnemonic,
-                                      list<OpTrait> traits = []> :
+                                      list<Trait> traits = []> :
     UnaryOp<mnemonic, !listconcat(traits, [SameOperandsAndResultType])> {
   let parser = [{
     return impl::parseOneResultSameOperandTypeOp(parser, result);
   }];
 }
 
-class FloatUnaryOp<string mnemonic, list<OpTrait> traits = []> :
+class FloatUnaryOp<string mnemonic, list<Trait> traits = []> :
     UnaryOpSameOperandAndResultType<mnemonic, traits # [
     DeclareOpInterfaceMethods<VectorUnrollOpInterface>] #
     ElementwiseMappable.traits>, Arguments<(ins FloatLike:$operand)>;
 
 // Base class for standard arithmetic operations.  Requires operands and
 // results to be of the same type, but does not constrain them to specific
 // types.
-class ArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
+class ArithmeticOp<string mnemonic, list<Trait> traits = []> :
     Op<StandardOps_Dialect, mnemonic, traits # [NoSideEffect,
     SameOperandsAndResultType,
     DeclareOpInterfaceMethods<VectorUnrollOpInterface>] #
     ElementwiseMappable.traits> {
 
   let results = (outs AnyType:$result);
 
   let parser = [{
     return impl::parseOneResultSameOperandTypeOp(parser, result);
   }];
 }
 
 // Base class for standard binary arithmetic operations.
-class ArithmeticBinaryOp<string mnemonic, list<OpTrait> traits = []> :
+class ArithmeticBinaryOp<string mnemonic, list<Trait> traits = []> :
     ArithmeticOp<mnemonic, traits> {
 
   let parser = [{
     return impl::parseOneResultSameOperandTypeOp(parser, result);
   }];
 }
 
 // Base class for standard ternary arithmetic operations.
-class ArithmeticTernaryOp<string mnemonic, list<OpTrait> traits = []> :
+class ArithmeticTernaryOp<string mnemonic, list<Trait> traits = []> :
     ArithmeticOp<mnemonic, traits> {
 
   let parser = [{
     return impl::parseOneResultSameOperandTypeOp(parser, result);
   }];
 
   let printer = [{
     return printStandardTernaryOp(this->getOperation(), p);
   }];
 }
 
 // Base class for standard arithmetic operations on integers, vectors and
 // tensors thereof.  This operation takes two operands and returns one result,
 // each of these is required to be of the same type.  This type may be an
 // integer scalar type, a vector whose element type is an integer type, or an
 // integer tensor.  The custom assembly form of the operation is as follows
 //
 //     <op>i %0, %1 : i32
 //
-class IntBinaryOp<string mnemonic, list<OpTrait> traits = []> :
+class IntBinaryOp<string mnemonic, list<Trait> traits = []> :
     ArithmeticBinaryOp<mnemonic,
       !listconcat(traits,
                   [DeclareOpInterfaceMethods<VectorUnrollOpInterface>])>,
     Arguments<(ins SignlessIntegerLike:$lhs, SignlessIntegerLike:$rhs)>;
 
 // Base class for standard arithmetic binary operations on floats, vectors and
 // tensors thereof.  This operation has two operands and returns one result,
 // each of these is required to be of the same type.  This type may be a
 // floating point scalar type, a vector whose element type is a floating point
 // type, or a floating point tensor.  The custom assembly form of the operation
 // is as follows
 //
 //     <op>f %0, %1 : f32
 //
-class FloatBinaryOp<string mnemonic, list<OpTrait> traits = []> :
+class FloatBinaryOp<string mnemonic, list<Trait> traits = []> :
     ArithmeticBinaryOp<mnemonic,
       !listconcat(traits,
                   [DeclareOpInterfaceMethods<VectorUnrollOpInterface>])>,
     Arguments<(ins FloatLike:$lhs, FloatLike:$rhs)>;
 
 // Base class for standard arithmetic ternary operations on floats, vectors and
 // tensors thereof.  This operation has three operands and returns one result,
 // each of these is required to be of the same type.  This type may be a
 // floating point scalar type, a vector whose element type is a floating point
 // type, or a floating point tensor.  The custom assembly form of the operation
 // is as follows
 //
 //     <op> %0, %1, %2 : f32
 //
-class FloatTernaryOp<string mnemonic, list<OpTrait> traits = []> :
+class FloatTernaryOp<string mnemonic, list<Trait> traits = []> :
     ArithmeticTernaryOp<mnemonic,
       !listconcat(traits,
                   [DeclareOpInterfaceMethods<VectorUnrollOpInterface>])>,
     Arguments<(ins FloatLike:$a, FloatLike:$b, FloatLike:$c)>;
 
 //===----------------------------------------------------------------------===//
 // AssertOp
 //===----------------------------------------------------------------------===//

mlir/include/mlir/Dialect/Tensor/IR/TensorOps.td

 include "mlir/Dialect/Tensor/IR/TensorBase.td"
 include "mlir/Interfaces/CastInterfaces.td"
 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/Interfaces/TilingInterface.td"
 include "mlir/Interfaces/ViewLikeInterface.td"
 
-class Tensor_Op<string mnemonic, list<OpTrait> traits = []>
+class Tensor_Op<string mnemonic, list<Trait> traits = []>
     : Op<Tensor_Dialect, mnemonic, traits> {
   let printer = [{ return ::print(p, *this); }];
   let verifier = [{ return ::verify(*this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
 }
 
 //===----------------------------------------------------------------------===//
 // CastOp
let assemblyFormat = [{
     $source `(` $shape `)` attr-dict `:` functional-type(operands, results)
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // ExpandShapeOp / CollapseShapeOp
 //===----------------------------------------------------------------------===//
 
-class Tensor_ReassociativeReshapeOp<string mnemonic, list<OpTrait> traits = []> :
+class Tensor_ReassociativeReshapeOp<string mnemonic, list<Trait> traits = []> :
     Tensor_Op<mnemonic, !listconcat(traits, [NoSideEffect])>,
     Arguments<(ins AnyTensor:$src, IndexListArrayAttr:$reassociation)>,
     Results<(outs AnyTensor:$result)> {
   let builders = [
     // Builders for a contracting reshape whose result type is computed from
     // `src` and `reassociation`.
     OpBuilder<(ins "Value":$src,
       "ArrayRef<ReassociationIndices>":$reassociation,

mlir/include/mlir/Dialect/Tosa/IR/TosaOpBase.td

[{
     buildExplicitValuePadOpWithQuantInfo($_builder, $_state, outputType,
                                          input, paddings, pad_value);
   }]>;
 
 //===----------------------------------------------------------------------===//
 // TOSA Operator.
 //===----------------------------------------------------------------------===//
 
-class Tosa_Op<string mnemonic, list<OpTrait> traits = []> :
+class Tosa_Op<string mnemonic, list<Trait> traits = []> :
     Op<Tosa_Dialect, mnemonic, !listconcat(traits, [TosaOpInterface])> {
 }
 
 #endif // TOSA_OP_BASE

mlir/include/mlir/Dialect/Vector/VectorOps.td

 def Vector_Dialect : Dialect {
   let name = "vector";
   let cppNamespace = "::mlir::vector";
   let hasConstantMaterializer = 1;
   let dependentDialects = ["arith::ArithmeticDialect"];
 }
 
 // Base class for Vector dialect ops.
-class Vector_Op<string mnemonic, list<OpTrait> traits = []> :
+class Vector_Op<string mnemonic, list<Trait> traits = []> :
     Op<Vector_Dialect, mnemonic, traits> {
   // For every vector op, there needs to be a:
   //   * void print(OpAsmPrinter &p, ${C++ class of Op} op)
   //   * LogicalResult verify(${C++ class of Op} op)
   //   * ParseResult parse${C++ class of Op}(OpAsmParser &parser,
   //                                         OperationState &result)
   // functions.
   let printer = [{ return ::print(p, *this); }];

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

def X86Vector_Dialect : Dialect {
   let cppNamespace = "::mlir::x86vector";
 }
 
 //===----------------------------------------------------------------------===//
 // AVX512 op definitions
 //===----------------------------------------------------------------------===//
 
 // Operation that is part of the input dialect.
-class AVX512_Op<string mnemonic, list<OpTrait> traits = []> :
+class AVX512_Op<string mnemonic, list<Trait> traits = []> :
   Op<X86Vector_Dialect, "avx512." # mnemonic, traits> {}
 
 // Intrinsic operation used during lowering to LLVM IR.
-class AVX512_IntrOp<string mnemonic, int numResults, list<OpTrait> traits = []> :
+class AVX512_IntrOp<string mnemonic, int numResults, list<Trait> traits = []> :
   LLVM_IntrOpBase<X86Vector_Dialect, "avx512.intr." # mnemonic,
                   "x86_avx512_" # !subst(".", "_", mnemonic),
                   [], [], traits, numResults>;
 
 // Defined by first result overload. May have to be extended for other
 // instructions in the future.
 class AVX512_IntrOverloadedOp<string mnemonic,
-                              list<OpTrait> traits = []> :
+                              list<Trait> traits = []> :
   LLVM_IntrOpBase<X86Vector_Dialect, "avx512.intr." # mnemonic,
                   "x86_avx512_" # !subst(".", "_", mnemonic),
                   /*list<int> overloadedResults=*/[0],
                   /*list<int> overloadedOperands=*/[],
                   traits, /*numResults=*/1>;
 
 //----------------------------------------------------------------------------//
 // MaskCompressOp
let arguments = (ins VectorOfLengthAndType<[8], [I64]>:$a,
                    VectorOfLengthAndType<[8], [I64]>:$b);
 }
 
 //===----------------------------------------------------------------------===//
 // AVX op definitions
 //===----------------------------------------------------------------------===//
 
 // Operation that is part of the input dialect.
-class AVX_Op<string mnemonic, list<OpTrait> traits = []> :
+class AVX_Op<string mnemonic, list<Trait> traits = []> :
   Op<X86Vector_Dialect, "avx." # mnemonic, traits> {}
 
 // Operation that may be part of the input dialect, but whose
 // form is somewhere between the user view of the operation
 // and the actual lower level intrinsic in LLVM IR.
-class AVX_LowOp<string mnemonic, list<OpTrait> traits = []> :
+class AVX_LowOp<string mnemonic, list<Trait> traits = []> :
   Op<X86Vector_Dialect, "avx.intr." # mnemonic, traits> {}
 
 // Intrinsic operation used during lowering to LLVM IR.
-class AVX_IntrOp<string mnemonic, int numResults, list<OpTrait> traits = []> :
+class AVX_IntrOp<string mnemonic, int numResults, list<Trait> traits = []> :
   LLVM_IntrOpBase<X86Vector_Dialect, "avx.intr." # mnemonic,
                   "x86_avx_" # !subst(".", "_", mnemonic),
                   [], [], traits, numResults>;
 
 //----------------------------------------------------------------------------//
 // AVX Rsqrt
 //----------------------------------------------------------------------------//
 

mlir/include/mlir/IR/BuiltinOps.td

 include "mlir/IR/RegionKindInterface.td"
 include "mlir/IR/SymbolInterfaces.td"
 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/CastInterfaces.td"
 include "mlir/Interfaces/DataLayoutInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 // Base class for Builtin dialect ops.
-class Builtin_Op<string mnemonic, list<OpTrait> traits = []> :
+class Builtin_Op<string mnemonic, list<Trait> traits = []> :
     Op<Builtin_Dialect, mnemonic, traits>;
 
 //===----------------------------------------------------------------------===//
 // FuncOp
 //===----------------------------------------------------------------------===//
 
 def FuncOp : Builtin_Op<"func", [
   AffineScope, AutomaticAllocationScope, CallableOpInterface,

mlir/include/mlir/IR/OpBase.td

 
 //===----------------------------------------------------------------------===//
 // Trait definitions
 //===----------------------------------------------------------------------===//
 
 // Trait represents a trait regarding an attribute, operation, or type.
 class Trait;
 
+// Define a Trait corresponding to a list of Traits, this allows for specifying
+// a list of traits as trait. Avoids needing to do `[Traits, ...] # ListOfTraits
+// # [Others, ...]` while still allowing providing convenient groupings.
+class TraitList<list<Trait> props> : Trait {
+  list<Trait> traits = props;
+}
+
 // NativeTrait corresponds to the MLIR C++ trait mechanism. The purpose to wrap
 // around C++ symbol string with this class is to make traits specified for
 // entities in TableGen less alien and more integrated.
 class NativeTrait<string name, string entityType> : Trait {
   string trait = name;
   string cppNamespace = "::mlir::" # entityType # "Trait";
 }
 
class PredTrait<string descr, Pred pred> : Trait {
   string summary = descr;
   Pred predicate = pred;
 }
 
 //===----------------------------------------------------------------------===//
 // TypeTrait definitions
 //===----------------------------------------------------------------------===//
 
-// TypeTrait represents a trait regarding a type.
-// TODO: Remove this class in favor of using Trait.
-class TypeTrait;
-
 // These classes are used to define type specific traits.
-class NativeTypeTrait<string name> : NativeTrait<name, "Type">, TypeTrait;
+class NativeTypeTrait<string name> : NativeTrait<name, "Type">;
 class ParamNativeTypeTrait<string prop, string params>
-    : ParamNativeTrait<prop, params, "Type">, TypeTrait;
-class GenInternalTypeTrait<string prop>
-    : GenInternalTrait<prop, "Type">, TypeTrait;
-class PredTypeTrait<string descr, Pred pred>
-    : PredTrait<descr, pred>, TypeTrait;
+    : ParamNativeTrait<prop, params, "Type">;
+class GenInternalTypeTrait<string prop> : GenInternalTrait<prop, "Type">;
+class PredTypeTrait<string descr, Pred pred> : PredTrait<descr, pred>;
 
 //===----------------------------------------------------------------------===//
 // AttrTrait definitions
 //===----------------------------------------------------------------------===//
 
-// AttrTrait represents a trait regarding an attribute.
-// TODO: Remove this class in favor of using Trait.
-class AttrTrait;
-
 // These classes are used to define attribute specific traits.
-class NativeAttrTrait<string name> : NativeTrait<name, "Attribute">, AttrTrait;
+class NativeAttrTrait<string name> : NativeTrait<name, "Attribute">;
 class ParamNativeAttrTrait<string prop, string params>
-    : ParamNativeTrait<prop, params, "Attribute">, AttrTrait;
-class GenInternalAttrTrait<string prop>
-    : GenInternalTrait<prop, "Attribute">, AttrTrait;
-class PredAttrTrait<string descr, Pred pred>
-    : PredTrait<descr, pred>, AttrTrait;
+    : ParamNativeTrait<prop, params, "Attribute">;
+class GenInternalAttrTrait<string prop> : GenInternalTrait<prop, "Attribute">;
+class PredAttrTrait<string descr, Pred pred> : PredTrait<descr, pred>;
 
 //===----------------------------------------------------------------------===//
 // OpTrait definitions
 //===----------------------------------------------------------------------===//
 
-// OpTrait represents a trait regarding an operation.
-// TODO: Remove this class in favor of using Trait.
-class OpTrait;
-
-// Define a OpTrait corresponding to a list of OpTraits, this allows for
-// specifying a list of traits as trait. Avoids needing to do
-// `[Traits, ...] # ListOfTraits # [Others, ...]` while still allowing providing
-// convenient groupings.
-class OpTraitList<list<OpTrait> props> : OpTrait {
-  list<OpTrait> traits = props;
-}
-
 // These classes are used to define operation specific traits.
-class NativeOpTrait<string name> : NativeTrait<name, "Op">, OpTrait;
+class NativeOpTrait<string name> : NativeTrait<name, "Op">;
 class ParamNativeOpTrait<string prop, string params>
-    : ParamNativeTrait<prop, params, "Op">, OpTrait;
-class GenInternalOpTrait<string prop> : GenInternalTrait<prop, "Op">, OpTrait;
-class PredOpTrait<string descr, Pred pred> : PredTrait<descr, pred>, OpTrait;
+    : ParamNativeTrait<prop, params, "Op">;
+class GenInternalOpTrait<string prop> : GenInternalTrait<prop, "Op">;
+class PredOpTrait<string descr, Pred pred> : PredTrait<descr, pred>;
 
 // Op defines an affine scope.
 def AffineScope : NativeOpTrait<"AffineScope">;
 // Op defines an automatic allocation scope.
 def AutomaticAllocationScope : NativeOpTrait<"AutomaticAllocationScope">;
 // Op supports operand broadcast behavior.
 def ResultsBroadcastableShape :
   NativeOpTrait<"ResultsBroadcastableShape">;

 // Elementwise op can be applied to scalars instead tensor/vector operands.
 def Scalarizable : NativeOpTrait<"Scalarizable">;
 // Elementwise op can be applied to all-vector operands.
 def Vectorizable : NativeOpTrait<"Vectorizable">;
 // Elementwise op can be applied to all-tensor operands.
 def Tensorizable : NativeOpTrait<"Tensorizable">;
 
 // Group together `Elementwise`, `Scalarizable`, `Vectorizable`, and
 // `Tensorizable` for convenience.
-def ElementwiseMappable {
-  list<OpTrait> traits = [
+def ElementwiseMappable : TraitList<[
     Elementwise,
     Scalarizable,
     Vectorizable,
     Tensorizable,
-  ];
-}
+]>;
 
 // Op's regions have a single block.
 def SingleBlock : NativeOpTrait<"SingleBlock">;
 
 // Op's regions have a single block with the specified terminator.
 class SingleBlockImplicitTerminator<string op>
     : ParamNativeOpTrait<"SingleBlockImplicitTerminator", op>;
 
class InterfaceTrait<string name> : NativeTrait<"", ""> {
   // interface trait declaration.
   code extraTraitClassDeclaration = "";
 }
 
 // OpInterfaceTrait corresponds to a specific 'OpInterface' class defined in
 // C++. The purpose to wrap around C++ symbol string with this class is to make
 // interfaces specified for ops in TableGen less alien and more integrated.
 class OpInterfaceTrait<string name, code verifyBody = [{}]>
-    : InterfaceTrait<name>, OpTrait {
+    : InterfaceTrait<name> {
   // Specify the body of the verification function. `$_op` will be replaced with
   // the operation being verified.
   code verify = verifyBody;
 }
 
 // This class represents a single, optionally static, interface method.
 // Note: non-static interface methods have an implicit parameter, either
 // $_op/$_attr/$_type corresponding to an instance of the derived value.

 class Arg<Constraint constraint, string desc = "",
           list<OpVariableDecorator> decorators = []>
   : OpVariable<constraint, desc, decorators>;
 class Res<Constraint constraint, string desc = "",
           list<OpVariableDecorator> decorators = []>
   : OpVariable<constraint, desc, decorators>;
 
 // Base class for all ops.
-class Op<Dialect dialect, string mnemonic, list<OpTrait> props = []> {
+class Op<Dialect dialect, string mnemonic, list<Trait> props = []> {
   // The dialect of the op.
   Dialect opDialect = dialect;
 
   // The mnemonic of the op.
   string opName = mnemonic;
 
   // The C++ namespace to use for this op.
   string cppNamespace = dialect.cppNamespace;
class Op<Dialect dialect, string mnemonic, list<Trait> props = []> {
   // rewrite patterns".
   bit hasCanonicalizeMethod = 0;
 
   // Whether this op has a folder.
   bit hasFolder = 0;
 
   // Op traits.
   // Note: The list of traits will be uniqued by ODS.
-  list<OpTrait> traits = props;
+  list<Trait> traits = props;
 
   // Additional code that will be added to the public part of the generated
   // C++ code of the op declaration.
   code extraClassDeclaration = ?;
 
   // Additional code that will be added to the generated source file. The
   // generated code is placed inside the op's C++ namespace. `$cppClass` is
   // replaced by the op's C++ class name.
   code extraClassDefinition = ?;
 }
 
 // Base class for ops with static/dynamic offset, sizes and strides
 // attributes/arguments.
 class BaseOpWithOffsetSizesAndStrides<Dialect dialect, string mnemonic,
-                                      list<OpTrait> traits = []> :
+                                      list<Trait> traits = []> :
   Op<dialect, mnemonic, traits> {
 
   // For every such op, there needs to be a:
   //   * void print(OpAsmPrinter &p, ${C++ class of Op} op)
   //   * LogicalResult verify(${C++ class of Op} op)
   //   * ParseResult parse${C++ class of Op}(OpAsmParser &parser,
   //                                         OperationState &result)
   // functions.

mlir/include/mlir/IR/RegionKindInterface.td

StaticInterfaceMethod<
       }]
     >,
   ];
 }
 
 def HasOnlyGraphRegion : NativeOpTrait<"HasOnlyGraphRegion">;
 
 // Op's regions that don't need a terminator: requires some other traits
 // so it defines a list that must be concatenated.
-def GraphRegionNoTerminator {
-  list<OpTrait> traits = [
+def GraphRegionNoTerminator : TraitList<[
     NoTerminator,
     SingleBlock,
     RegionKindInterface,
     HasOnlyGraphRegion
-  ];
-}
+  ]>;
 
 #endif // MLIR_IR_REGIONKINDINTERFACE

mlir/include/mlir/Interfaces/InferTypeOpInterface.td

InterfaceMethod<
       /*methodBody=*/[{}],
       /*defaultImplementation=*/[{ return ::mlir::failure(); }]
     >
   ];
 }
 
 // Convenience class grouping together type and shaped type op interfaces for
 // ops that have tensor return types.
-class InferTensorType<list<string> overridenMethods = []> : OpTraitList<
+class InferTensorType<list<string> overridenMethods = []> : TraitList<
   [
     // Op implements infer type op interface.
     InferTypeOpInterface,
     // The op will have methods implementing the ShapedType type inference
     // interface.
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface, overridenMethods>,
     // The op produces tensors and will use the ShapedType type infer interface
     // along with knowledge that it is producing Tensors to infer the type.
     NativeOpTrait<"InferTensorType">
   ]>;
-def InferTensorTypeWithReify: OpTraitList<InferTensorType<[
+def InferTensorTypeWithReify: TraitList<InferTensorType<[
     "inferReturnTypeComponents", "reifyReturnTypeShapes"]>.traits>;
 
 
 def ReifyRankedShapedTypeOpInterface :
     OpInterface<"ReifyRankedShapedTypeOpInterface"> {
   let description = [{
     Interface to compute the shape of the result of an operation when
     the result is a ranked shape type, i.e. `RankedTensorType` or

mlir/lib/TableGen/Operator.cpp

if (auto *traitList = def.getValueAsListInit("traits")) {
     // This is uniquing based on pointers of the trait.
     SmallPtrSet<const llvm::Init *, 32> traitSet;
     traits.reserve(traitSet.size());
 
     std::function<void(llvm::ListInit *)> insert;
     insert = [&](llvm::ListInit *traitList) {
       for (auto *traitInit : *traitList) {
         auto *def = cast<DefInit>(traitInit)->getDef();
-        if (def->isSubClassOf("OpTraitList")) {
+        if (def->isSubClassOf("TraitList")) {
           insert(def->getValueAsListInit("traits"));
           continue;
         }
         // Keep traits in the same order while skipping over duplicates.
         if (traitSet.insert(traitInit).second)
           traits.push_back(Trait::create(traitInit));
       }
     };

mlir/test/lib/Dialect/Test/TestOps.td

 
 
 // Include the attribute definitions.
 include "TestAttrDefs.td"
 // Include the type definitions.
 include "TestTypeDefs.td"
 
 
-class TEST_Op<string mnemonic, list<OpTrait> traits = []> :
+class TEST_Op<string mnemonic, list<Trait> traits = []> :
     Op<Test_Dialect, mnemonic, traits>;
 
 //===----------------------------------------------------------------------===//
 // Test Types
 //===----------------------------------------------------------------------===//
 
 def IntTypesOp : TEST_Op<"int_types"> {
   let results = (outs

 // Check that formatget supports DeclareOpInterfaceMethods.
 def FormatInferType2Op : TEST_Op<"format_infer_type2", [DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
   let results = (outs AnyType);
   let assemblyFormat = "attr-dict";
 }
 
 // Base class for testing mixing allOperandTypes, allOperands, and
 // inferResultTypes.
-class FormatInferAllTypesBaseOp<string mnemonic, list<OpTrait> traits = []>
+class FormatInferAllTypesBaseOp<string mnemonic, list<Trait> traits = []>
     : TEST_Op<mnemonic, [InferTypeOpInterface] # traits> {
   let arguments = (ins Variadic<AnyType>:$args);
   let results = (outs Variadic<AnyType>:$outs);
   let extraClassDeclaration = [{
     static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context,
           ::llvm::Optional<::mlir::Location> location, ::mlir::ValueRange operands,
           ::mlir::DictionaryAttr attributes, ::mlir::RegionRange regions,
           ::llvm::SmallVectorImpl<::mlir::Type> &inferredReturnTypes) {
def RegionYieldOp : TEST_Op<"region_yield",
   let assemblyFormat = [{
     $result `:` type($result) attr-dict
   }];
   let builders = [OpBuilder<(ins),
     [{ build($_builder, $_state, {}); }]>
   ];
 }
 
-class BufferBasedOpBase<string mnemonic, list<OpTrait> traits>
+class BufferBasedOpBase<string mnemonic, list<Trait> traits>
     : TEST_Op<mnemonic, traits> {
   let description = [{
     A buffer based operation, that uses memRefs as input and output.
   }];
   let arguments = (ins AnyRankedOrUnrankedMemRef:$input,
                        AnyRankedOrUnrankedMemRef:$output);
 }
 

 def TableGenBuildOp4 : TEST_Op<"tblgen_build_4", [SameOperandsAndResultType]> {
   let arguments = (ins Variadic<AnyType>:$inputs);
   let results = (outs AnyType:$result);
 }
 
 // Base class for testing `build` methods for ops with
 // InferReturnTypeOpInterface.
 class TableGenBuildInferReturnTypeBaseOp<string mnemonic,
-                                         list<OpTrait> traits = []>
+                                         list<Trait> traits = []>
     : TEST_Op<mnemonic, [InferTypeOpInterface] # traits> {
   let arguments = (ins Variadic<AnyType>:$inputs);
   let results = (outs AnyType:$result);
 
   let extraClassDeclaration = [{
     static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *,
           ::llvm::Optional<::mlir::Location> location, ::mlir::ValueRange operands,
           ::mlir::DictionaryAttr attributes, ::mlir::RegionRange regions,

mlir/test/mlir-tblgen/constraint-unique.td

 // RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s
 
 include "mlir/IR/OpBase.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
 }
 
-class NS_Op<string mnemonic, list<OpTrait> traits = []> :
+class NS_Op<string mnemonic, list<Trait> traits = []> :
     Op<Test_Dialect, mnemonic, traits>;
 
 /// Test unique'ing of type, attribute, successor, and region constraints.
 
 def ATypePred : CPred<"typePred($_self, $_op)">;
 def AType : Type<ATypePred, "a type">;
 def OtherType : Type<ATypePred, "another type">;
 

mlir/test/mlir-tblgen/op-attribute.td

 // RUN: mlir-tblgen -gen-op-decls -I %S/../../include %s | FileCheck %s --check-prefix=DECL
 // RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s --check-prefix=DEF
 // RUN: mlir-tblgen -print-records -I %S/../../include %s | FileCheck %s --check-prefix=RECORD
 
 include "mlir/IR/OpBase.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
   let cppNamespace = "foobar";
 }
-class NS_Op<string mnemonic, list<OpTrait> traits> :
+class NS_Op<string mnemonic, list<Trait> traits> :
     Op<Test_Dialect, mnemonic, traits>;
 
 def SomeAttr : Attr<CPred<"some-condition">, "some attribute kind"> {
   let storageType = "some-attr-kind";
   let returnType = "some-return-type";
   let convertFromStorage = "$_self.some-convert-from-storage()";
   let constBuilderCall = "some-const-builder-call($_builder, $0)";
 }

mlir/test/mlir-tblgen/op-decl-and-defs.td

 // RUN: mlir-tblgen -gen-op-decls -I %S/../../include %s | FileCheck %s
 // RUN: mlir-tblgen -gen-op-decls -op-include-regex="test.a_op" -I %S/../../include %s | FileCheck  %s --check-prefix=REDUCE_INC
 // RUN: mlir-tblgen -gen-op-decls -op-exclude-regex="test.a_op" -I %S/../../include %s | FileCheck  %s --check-prefix=REDUCE_EXC
 
 // RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s --check-prefix=DEFS
 
 include "mlir/IR/OpBase.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
   let cppNamespace = "NS";
   let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;
 }
-class NS_Op<string mnemonic, list<OpTrait> traits> :
+class NS_Op<string mnemonic, list<Trait> traits> :
     Op<Test_Dialect, mnemonic, traits>;
 
 // IsolatedFromAbove trait is included twice to ensure it gets uniqued during
 // emission.
 def NS_AOp : NS_Op<"a_op", [IsolatedFromAbove, IsolatedFromAbove]> {
   let arguments = (ins
     I32:$a,
     Variadic<F32>:$b,

 }
 // CHECK_LABEL: class NS_JOp :
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type r, ::mlir::Value a, ::mlir::Value b);
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value a, ::mlir::Value b);
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a, ::mlir::Value b);
 // CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
 
-// Test usage of OpTraitList getting flattened during emission.
+// Test usage of TraitList getting flattened during emission.
 def NS_KOp : NS_Op<"k_op", [IsolatedFromAbove,
-    OpTraitList<[DeclareOpInterfaceMethods<InferTypeOpInterface>]>]> {
+    TraitList<[DeclareOpInterfaceMethods<InferTypeOpInterface>]>]> {
   let arguments = (ins AnyType:$a, AnyType:$b);
 }
 
 // CHECK: class KOp : public ::mlir::Op<KOp,
 // CHECK-SAME: ::mlir::OpTrait::IsIsolatedFromAbove, ::mlir::InferTypeOpInterface::Trait
 
 // Check native OpTrait usage
 // ---

mlir/test/mlir-tblgen/op-format-spec.td

 // RUN: mlir-tblgen -gen-op-decls -asmformat-error-is-fatal=false -I %S/../../include %s -o=%t 2>&1 | FileCheck %s
 
 // This file contains tests for the specification of the declarative op format.
 
 include "mlir/IR/OpBase.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 
 def TestDialect : Dialect {
   let name = "test";
 }
-class TestFormat_Op<string fmt, list<OpTrait> traits = []>
+class TestFormat_Op<string fmt, list<Trait> traits = []>
     : Op<TestDialect, "format_op", traits> {
   let assemblyFormat = fmt;
 }
 
 //===----------------------------------------------------------------------===//
 // Directives
 //===----------------------------------------------------------------------===//
 

mlir/test/mlir-tblgen/op-operand.td

 // RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s
 
 include "mlir/IR/OpBase.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
 }
-class NS_Op<string mnemonic, list<OpTrait> traits> :
+class NS_Op<string mnemonic, list<Trait> traits> :
     Op<Test_Dialect, mnemonic, traits>;
 
 def OpA : NS_Op<"one_normal_operand_op", []> {
   let arguments = (ins I32:$input);
 }
 
 // CHECK-LABEL: OpA definitions
 

mlir/test/mlir-tblgen/op-python-bindings.td

 // RUN: mlir-tblgen -gen-python-op-bindings -bind-dialect=test -I %S/../../include %s | FileCheck %s
 
 include "mlir/IR/OpBase.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Bindings/Python/Attributes.td"
 
 // CHECK: @_ods_cext.register_dialect
 // CHECK: class _Dialect(_ods_ir.Dialect):
   // CHECK: DIALECT_NAMESPACE = "test"
   // CHECK: pass
 def Test_Dialect : Dialect {
   let name = "test";
   let cppNamespace = "Test";
 }
-class TestOp<string mnemonic, list<OpTrait> traits = []> :
+class TestOp<string mnemonic, list<Trait> traits = []> :
     Op<Test_Dialect, mnemonic, traits>;
 
 // CHECK: @_ods_cext.register_operation(_Dialect)
 // CHECK: class AttrSizedOperandsOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.attr_sized_operands"
 // CHECK: _ODS_OPERAND_SEGMENTS = [-1,1,0,]
 def AttrSizedOperandsOp : TestOp<"attr_sized_operands",
                                  [AttrSizedOperandSegments]> {

mlir/test/mlir-tblgen/op-result.td

 // RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s
 
 include "mlir/IR/OpBase.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
 }
-class NS_Op<string mnemonic, list<OpTrait> traits> :
+class NS_Op<string mnemonic, list<Trait> traits> :
     Op<Test_Dialect, mnemonic, traits>;
 
 def OpA : NS_Op<"one_normal_result_op", []> {
   let results = (outs I32:$result);
 }
 
 // CHECK-LABEL: void OpA::build
 // CHECK:         ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands

mlir/test/mlir-tblgen/op-side-effects.td

 // RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s
 
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 def TEST_Dialect : Dialect {
   let name = "test";
 }
-class TEST_Op<string mnemonic, list<OpTrait> traits = []> :
+class TEST_Op<string mnemonic, list<Trait> traits = []> :
     Op<TEST_Dialect, mnemonic, traits>;
 
 def CustomResource : Resource<"CustomResource">;
 
 def SideEffectOpA : TEST_Op<"side_effect_op_a"> {
   let arguments = (ins
     Arg<Variadic<AnyMemRef>, "", [MemRead]>,
     Arg<SymbolRefAttr, "", [MemRead]>:$symbol,

mlir/test/mlir-tblgen/predicate.td

 // RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s
 
 include "mlir/IR/OpBase.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
 }
-class NS_Op<string mnemonic, list<OpTrait> traits> :
+class NS_Op<string mnemonic, list<Trait> traits> :
     Op<Test_Dialect, mnemonic, traits>;
 
 def I32OrF32 : Type<CPred<"$_self.isInteger(32) || $_self.isF32()">,
                     "32-bit integer or floating-point type">;
 
 def OpA : NS_Op<"op_for_CPred_containing_multiple_same_placeholder", []> {
   let arguments = (ins I32OrF32:$x);
   let results = (outs Variadic<I32OrF32>:$y);

mlir/test/mlir-tblgen/rewriter-errors.td

 // RUN: not mlir-tblgen -gen-rewriters -I %S/../../include -DERROR1 %s 2>&1 | FileCheck --check-prefix=ERROR1 %s
 // RUN: not mlir-tblgen -gen-rewriters -I %S/../../include -DERROR2 %s 2>&1 | FileCheck --check-prefix=ERROR2 %s
 // RUN: not mlir-tblgen -gen-rewriters -I %S/../../include -DERROR3 %s 2>&1 | FileCheck --check-prefix=ERROR3 %s
 // RUN: not mlir-tblgen -gen-rewriters -I %S/../../include -DERROR4 %s 2>&1 | FileCheck --check-prefix=ERROR4 %s
 // RUN: not mlir-tblgen -gen-rewriters -I %S/../../include -DERROR5 %s 2>&1 | FileCheck --check-prefix=ERROR5 %s
 
 include "mlir/IR/OpBase.td"
 
 // Check using the dialect name as the namespace
 def A_Dialect : Dialect {
   let name = "a";
 }
 
-class A_Op<string mnemonic, list<OpTrait> traits = []> :
+class A_Op<string mnemonic, list<Trait> traits = []> :
     Op<A_Dialect, mnemonic, traits>;
 
 def OpA : A_Op<"op_a">, Arguments<(ins AnyInteger, AnyInteger)>, Results<(outs AnyInteger)>;
 def OpB : A_Op<"op_b">, Arguments<(ins AnyInteger, AnyAttr:$value)>, Results<(outs AnyInteger)>;
 
 #ifdef ERROR1
 def NativeMatcher : NativeCodeCall<"success(nativeCall($0, $1))">;
 // ERROR1: [[@LINE+1]]:1: error: NativeCodeCall must have $_self as argument for passing the defining Operation

mlir/test/mlir-tblgen/rewriter-indexing.td

 // RUN: mlir-tblgen -gen-rewriters -I %S/../../include %s | FileCheck %s
 
 include "mlir/IR/OpBase.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
 }
-class NS_Op<string mnemonic, list<OpTrait> traits> :
+class NS_Op<string mnemonic, list<Trait> traits> :
     Op<Test_Dialect, mnemonic, traits>;
 
 def AOp : NS_Op<"a_op", []> {
   let arguments = (ins
     AnyInteger:$any_integer
   );
 
   let results = (outs AnyInteger);

mlir/test/mlir-tblgen/rewriter-static-matcher.td

 // RUN: mlir-tblgen -gen-rewriters -I %S/../../include %s | FileCheck %s
 
 include "mlir/IR/OpBase.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
 }
-class NS_Op<string mnemonic, list<OpTrait> traits> :
+class NS_Op<string mnemonic, list<Trait> traits> :
     Op<Test_Dialect, mnemonic, traits>;
 
 def AOp : NS_Op<"a_op", []> {
   let arguments = (ins
     AnyInteger:$any_integer
   );
 
   let results = (outs AnyInteger);

mlir/test/python/python_test_ops.td

class TestType<string name, string typeMnemonic>
   let mnemonic = typeMnemonic;
 }
 
 class TestAttr<string name, string attrMnemonic>
     : AttrDef<Python_Test_Dialect, name> {
   let mnemonic = attrMnemonic;
 }
 
-class TestOp<string mnemonic, list<OpTrait> traits = []>
+class TestOp<string mnemonic, list<Trait> traits = []>
     : Op<Python_Test_Dialect, mnemonic, traits>;
 
 //===----------------------------------------------------------------------===//
 // Type definitions.
 //===----------------------------------------------------------------------===//
 
 def TestType : TestType<"TestType", "test_type">;