[MLIR] Switch the default for usePropertiesForAttributes (NFC)

[mehdi_amini]

Summary

This is adopting properties as storage for attribute by default.

[csigg]

Would it be possible to land https://reviews.llvm.org/D158608 first?
It seems that even some of mlir's own tests require this (python tests, iirc).

[mehdi_amini]

Seems like we didn't get push back on this, @jpienaar can we land it?

mlir/docs/ReleaseNotes.md

 # MLIR Release Notes
 
 This document tries to provide some context about MLIR important changes in the
 context of LLVM releases. It is updated on a best effort basis.
 
 At the moment the MLIR community does not qualify the LLVM release branch
 specifically, it is a snapshot of the MLIR development at the time of the release.
 
 [TOC]
 
+## LLVM 18
+
+### Properties: beyond attributes
+
+See LLVM 17 notes below. The Dialect option `let usePropertiesForAttributes = 1;` is
+now the default. You can set it to 0 to revert to the previous behavior. This will be
+removed in LLVM 19.
+
 ## LLVM 17
 
 See also the [deprecations and refactoring](https://mlir.llvm.org/deprecation/) doc.
 
 ### Bytecode
 
 MLIR now support a [bytecode serialization](https://mlir.llvm.org/docs/BytecodeFormat/)
 with versionning compatibility allowing 2 ways compatibility scheme, and lazy-loading

mlir/examples/toy/Ch2/include/toy/Dialect.h

 //===- Dialect.h - Dialect definition for the Toy IR ----------------------===//
 //
 // 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 implements the IR Dialect for the Toy language.
 // See docs/Tutorials/Toy/Ch-2.md for more information.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TUTORIAL_TOY_DIALECT_H_
 #define MLIR_TUTORIAL_TOY_DIALECT_H_
 
+#include "mlir/Bytecode/BytecodeOpInterface.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/FunctionInterfaces.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/Interfaces/CallInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
 /// Include the auto-generated header file containing the declaration of the toy
 /// dialect.
 #include "toy/Dialect.h.inc"
 
 /// Include the auto-generated header file containing the declarations of the
 /// toy operations.
 #define GET_OP_CLASSES
 #include "toy/Ops.h.inc"
 
 #endif // MLIR_TUTORIAL_TOY_DIALECT_H_

mlir/examples/toy/Ch3/include/toy/Dialect.h

 //===- Dialect.h - Dialect definition for the Toy IR ----------------------===//
 //
 // 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 implements the IR Dialect for the Toy language.
 // See docs/Tutorials/Toy/Ch-2.md for more information.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TUTORIAL_TOY_DIALECT_H_
 #define MLIR_TUTORIAL_TOY_DIALECT_H_
 
+#include "mlir/Bytecode/BytecodeOpInterface.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/FunctionInterfaces.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/Interfaces/CallInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
 /// Include the auto-generated header file containing the declaration of the toy
 /// dialect.
 #include "toy/Dialect.h.inc"
 
 /// Include the auto-generated header file containing the declarations of the
 /// toy operations.
 #define GET_OP_CLASSES
 #include "toy/Ops.h.inc"
 
 #endif // MLIR_TUTORIAL_TOY_DIALECT_H_

mlir/examples/toy/Ch4/include/toy/Dialect.h

 //===- Dialect.h - Dialect definition for the Toy IR ----------------------===//
 //
 // 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 implements the IR Dialect for the Toy language.
 // See docs/Tutorials/Toy/Ch-2.md for more information.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TUTORIAL_TOY_DIALECT_H_
 #define MLIR_TUTORIAL_TOY_DIALECT_H_
 
+#include "mlir/Bytecode/BytecodeOpInterface.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/FunctionInterfaces.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/Interfaces/CallInterfaces.h"
 #include "mlir/Interfaces/CastInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "toy/ShapeInferenceInterface.h"

mlir/examples/toy/Ch5/include/toy/Dialect.h

 //===- Dialect.h - Dialect definition for the Toy IR ----------------------===//
 //
 // 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 implements the IR Dialect for the Toy language.
 // See docs/Tutorials/Toy/Ch-2.md for more information.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TUTORIAL_TOY_DIALECT_H_
 #define MLIR_TUTORIAL_TOY_DIALECT_H_
 
+#include "mlir/Bytecode/BytecodeOpInterface.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/FunctionInterfaces.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/Interfaces/CallInterfaces.h"
 #include "mlir/Interfaces/CastInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "toy/ShapeInferenceInterface.h"

mlir/examples/toy/Ch6/include/toy/Dialect.h

 //===- Dialect.h - Dialect definition for the Toy IR ----------------------===//
 //
 // 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 implements the IR Dialect for the Toy language.
 // See docs/Tutorials/Toy/Ch-2.md for more information.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TUTORIAL_TOY_DIALECT_H_
 #define MLIR_TUTORIAL_TOY_DIALECT_H_
 
+#include "mlir/Bytecode/BytecodeOpInterface.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/FunctionInterfaces.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/Interfaces/CallInterfaces.h"
 #include "mlir/Interfaces/CastInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "toy/ShapeInferenceInterface.h"

mlir/examples/toy/Ch7/include/toy/Dialect.h

 //===- Dialect.h - Dialect definition for the Toy IR ----------------------===//
 //
 // 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 implements the IR Dialect for the Toy language.
 // See docs/Tutorials/Toy/Ch-2.md for more information.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TUTORIAL_TOY_DIALECT_H_
 #define MLIR_TUTORIAL_TOY_DIALECT_H_
 
+#include "mlir/Bytecode/BytecodeOpInterface.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/FunctionInterfaces.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/Interfaces/CallInterfaces.h"
 #include "mlir/Interfaces/CastInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "toy/ShapeInferenceInterface.h"

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

def AMDGPU_Dialect : Dialect {
   }];
 
 
   let dependentDialects = [
     "arith::ArithDialect",
     "gpu::GPUDialect"
   ];
   let useDefaultAttributePrinterParser = 1;
-  let usePropertiesForAttributes = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // AMDGPU Op definitions
 //===----------------------------------------------------------------------===//
 
 class AMDGPU_Op<string mnemonic, list<Trait> traits = []> :
   Op<AMDGPU_Dialect, mnemonic, traits> {}

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

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

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

 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/Interfaces/LoopLikeInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 def Affine_Dialect : Dialect {
   let name = "affine";
   let cppNamespace = "::mlir::affine";
   let hasConstantMaterializer = 1;
-  let usePropertiesForAttributes = 1;
   let dependentDialects = ["arith::ArithDialect"];
 }
 
 // Base class for Affine dialect ops.
 class Affine_Op<string mnemonic, list<Trait> traits = []> :
     Op<Affine_Dialect, mnemonic, traits>;
 
 // Require regions to have affine.yield.

mlir/include/mlir/Dialect/Arith/IR/ArithBase.td

let description = [{
     The arith dialect is intended to hold basic integer and floating point
     mathematical operations. This includes unary, binary, and ternary arithmetic
     ops, bitwise and shift ops, cast ops, and compare ops. Operations in this
     dialect also accept vectors and tensors of integers or floats.
   }];
 
   let hasConstantMaterializer = 1;
   let useDefaultAttributePrinterParser = 1;
-  let usePropertiesForAttributes = 1;
 }
 
 // The predicate indicates the type of the comparison to perform:
 // (un)orderedness, (in)equality and less/greater than (or equal to) as
 // well as predicates that are always true or false.
 def Arith_CmpFPredicateAttr : I64EnumAttr<
     "CmpFPredicate", "",
     [

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

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

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

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

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

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

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

let extraClassDeclaration = [{
     /// BufferDeallocation pass.
     ///
     /// Note: Only ops with at least one OpResult that bufferizes to a buffer
     /// allocation (as per BufferizableOpInterface) may have this attribute.
     constexpr const static ::llvm::StringLiteral
         kEscapeAttrName = "bufferization.escape";
   }];
   let hasOperationAttrVerify = 1;
-  let usePropertiesForAttributes = 1;
 }
 
 #endif // BUFFERIZATION_BASE

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

def Complex_Dialect : Dialect {
   let description = [{
     The complex dialect is intended to hold complex numbers creation and
     arithmetic ops.
   }];
 
   let dependentDialects = ["arith::ArithDialect"];
   let hasConstantMaterializer = 1;
   let useDefaultAttributePrinterParser = 1;
-  let usePropertiesForAttributes = 1;
 }
 
 #endif // COMPLEX_BASE

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

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

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

let extraClassDeclaration = [{
     constexpr const static ::llvm::StringLiteral
     kDataLayoutAllocaMemorySpaceKey = "dlti.alloca_memory_space";
 
     constexpr const static ::llvm::StringLiteral
     kDataLayoutStackAlignmentKey = "dlti.stack_alignment";
   }];
 
   let useDefaultAttributePrinterParser = 1;
-  let usePropertiesForAttributes = 1;
 }
 
 def DLTI_DataLayoutEntryAttr : DialectAttr<
     DLTI_Dialect,
     CPred<"::llvm::isa<::mlir::DataLayoutEntryAttr>($_self)">,
     "Target data layout entry"> {
   let storageType = "::mlir::DataLayoutEntryAttr";
   let returnType = "::mlir::DataLayoutEntryAttr";

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

def EmitC_Dialect : Dialect {
   let summary = "Dialect to generate C/C++ from MLIR.";
   let description = [{
     [include "Dialects/emitc.md"]
   }];
 
   let hasConstantMaterializer = 1;
   let useDefaultTypePrinterParser = 1;
   let useDefaultAttributePrinterParser = 1;
-  let usePropertiesForAttributes = 1;
 }
 
 #endif // MLIR_DIALECT_EMITC_IR_EMITCBASE

mlir/include/mlir/Dialect/Func/IR/FuncOps.td

 include "mlir/IR/FunctionInterfaces.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 def Func_Dialect : Dialect {
   let name = "func";
   let cppNamespace = "::mlir::func";
   let hasConstantMaterializer = 1;
-  let usePropertiesForAttributes = 1;
 }
 
 // Base class for Func dialect ops.
 class Func_Op<string mnemonic, list<Trait> traits = []> :
     Op<Func_Dialect, mnemonic, traits>;
 
 //===----------------------------------------------------------------------===//
 // CallOp

mlir/include/mlir/Dialect/GPU/IR/GPUBase.td

let extraClassDeclaration = [{
     /// Returns the numeric value used to identify the private memory address
     /// space.
     static AddressSpace getPrivateAddressSpace() { return AddressSpace::Private; }
   }];
 
   let dependentDialects = ["arith::ArithDialect"];
   let useDefaultAttributePrinterParser = 1;
   let useDefaultTypePrinterParser = 1;
-  let usePropertiesForAttributes = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // GPU Enums.
 //===----------------------------------------------------------------------===//
 
 class GPU_I32Enum<string name, string description, list<I32EnumAttrCase> cases>
     : I32EnumAttr<name, description, cases> {

mlir/include/mlir/Dialect/IRDL/IR/IRDL.td

let description = [{
 
     IRDL variables are handle over `mlir::Attribute`. In order to support
     manipulating `mlir::Type`, IRDL wraps all types in an `mlir::TypeAttr`
     attribute. The rationale of this is to simplify the dialect.
   }];
 
   let useDefaultAttributePrinterParser = 1;
   let useDefaultTypePrinterParser = 1;
-  let usePropertiesForAttributes = 1;
 
   let name = "irdl";
   let cppNamespace = "::mlir::irdl";
 }
 
 #endif // MLIR_DIALECT_IRDL_IR_IRDL

mlir/include/mlir/Dialect/Index/IR/IndexDialect.td

let extraClassDeclaration = [{
     /// Register all dialect attributes.
     void registerAttributes();
     /// Register all dialect operations.
     void registerOperations();
   }];
 
   let hasConstantMaterializer = 1;
   let useDefaultAttributePrinterParser = 1;
-  let usePropertiesForAttributes = 1;
 }
 
 #endif // INDEX_DIALECT

mlir/include/mlir/Dialect/LLVMIR/LLVMDialect.td

def LLVM_Dialect : Dialect {
   let name = "llvm";
   let cppNamespace = "::mlir::LLVM";
 
   let hasConstantMaterializer = 1;
   let useDefaultAttributePrinterParser = 1;
   let hasRegionArgAttrVerify = 1;
   let hasRegionResultAttrVerify = 1;
   let hasOperationAttrVerify = 1;
-  let usePropertiesForAttributes = 1;
 
   let extraClassDeclaration = [{
     /// Name of the data layout attributes.
     static StringRef getDataLayoutAttrName() { return "llvm.data_layout"; }
     static StringRef getNoAliasScopesAttrName() { return "noalias_scopes"; }
     static StringRef getAliasScopesAttrName() { return "alias_scopes"; }
     static StringRef getAccessGroupsAttrName() { return "access_groups"; }
 

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

let dependentDialects = [
     "math::MathDialect",
     "memref::MemRefDialect",
     "tensor::TensorDialect",
   ];
   let useDefaultAttributePrinterParser = 1;
   let hasCanonicalizer = 1;
   let hasOperationAttrVerify = 1;
   let hasConstantMaterializer = 1;
-  let usePropertiesForAttributes = 1;
   let extraClassDeclaration = [{
     /// Attribute name used to to memoize indexing maps for named ops.
     constexpr const static ::llvm::StringLiteral
         kMemoizedIndexingMapsAttrName = "linalg.memoized_indexing_maps";
 
     using RegionBuilderFunType = llvm::function_ref<
       void(ImplicitLocOpBuilder &b, Block &, ArrayRef<NamedAttribute>)>;
     RegionBuilderFunType getRegionBuilder(StringRef name) {

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

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

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

let description = [{
     // Vector elementwise absolute value.
     %f = math.absf %g : vector<4xf32>
 
     // Tensor elementwise absolute value.
     %x = math.absf %y : tensor<4x?xf8>
     ```
   }];
   let hasConstantMaterializer = 1;
-  let usePropertiesForAttributes = 1;
   let dependentDialects = [
     "::mlir::arith::ArithDialect"
   ];
 }
 #endif // MATH_BASE

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

def MemRef_Dialect : Dialect {
   let cppNamespace = "::mlir::memref";
   let description = [{
     The `memref` dialect is intended to hold core memref creation and
     manipulation ops, which are not strongly associated with any particular
     other dialect or domain abstraction.
   }];
   let dependentDialects = ["arith::ArithDialect"];
   let hasConstantMaterializer = 1;
-  let usePropertiesForAttributes = 1;
 }
 
 #endif // MEMREF_BASE

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

let description = [{
     The `NVGPU` dialect provides a bridge between higher-level target-agnostic
     dialects (GPU and Vector) and the lower-level target-specific dialect
     (LLVM IR based NVVM dialect) for NVIDIA GPUs. This allow representing PTX
     specific operations while using MLIR high level dialects such as Memref
     and Vector for memory and target-specific register operands, respectively.
   }];
 
   let useDefaultTypePrinterParser = 1;
-  let usePropertiesForAttributes = 1;
   let useDefaultAttributePrinterParser = 1;
   
   let extraClassDeclaration = [{
     /// Return true if the given MemRefType has an integer address
     /// space that matches the NVVM shared memory address space or
     /// is a gpu::AddressSpaceAttr attribute with value 'workgroup`.
     static bool hasSharedMemoryAddressSpace(MemRefType type);
 

mlir/include/mlir/Dialect/OpenACC/OpenACCBase.td

def OpenACC_Dialect : Dialect {
   let summary = "An OpenACC dialect for MLIR.";
 
   let description = [{
     This dialect models the construct from the OpenACC 3.3 directive language.
   }];
 
   let useDefaultAttributePrinterParser = 1;
   let useDefaultTypePrinterParser = 1;
-  let usePropertiesForAttributes = 1;
   let cppNamespace = "::mlir::acc";
   let dependentDialects = ["::mlir::memref::MemRefDialect","::mlir::LLVM::LLVMDialect"];
 }
 
 #endif // OPENACC_BASE

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

 include "mlir/Dialect/OpenMP/OpenMPOpsInterfaces.td"
 include "mlir/Dialect/OpenMP/OpenMPTypeInterfaces.td"
 
 def OpenMP_Dialect : Dialect {
   let name = "omp";
   let cppNamespace = "::mlir::omp";
   let dependentDialects = ["::mlir::LLVM::LLVMDialect, ::mlir::func::FuncDialect"];
   let useDefaultAttributePrinterParser = 1;
-  let usePropertiesForAttributes = 1;
 }
 
 // OmpCommon requires definition of OpenACC_Dialect.
 include "mlir/Dialect/OpenMP/OmpCommon.td"
 
 //===----------------------------------------------------------------------===//
 //  OpenMP Attributes
 //===----------------------------------------------------------------------===//

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

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

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

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

mlir/include/mlir/Dialect/Quant/QuantOpsBase.td

 
 include "mlir/IR/OpBase.td"
 
 def Quantization_Dialect : Dialect {
   let name = "quant";
   let cppNamespace = "::mlir::quant";
 
   let useDefaultTypePrinterParser = 1;
-  let usePropertiesForAttributes = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Quantization type definitions
 //===----------------------------------------------------------------------===//
 
 class quant_TypedPrimitiveOrContainer<Type etype> :
     Type<Or<[etype.predicate,

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

 include "mlir/Interfaces/ParallelCombiningOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/Interfaces/ViewLikeInterface.td"
 
 def SCF_Dialect : Dialect {
   let name = "scf";
   let cppNamespace = "::mlir::scf";
   let dependentDialects = ["arith::ArithDialect"];
-  let usePropertiesForAttributes = 1;
 }
 
 // Base class for SCF dialect ops.
 class SCF_Op<string mnemonic, list<Trait> traits = []> :
     Op<SCF_Dialect, mnemonic, traits>;
 
 //===----------------------------------------------------------------------===//
 // ConditionOp

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

def SPIRV_Dialect : Dialect {
   }];
 
   let cppNamespace = "::mlir::spirv";
   let useDefaultTypePrinterParser = 1;
   let hasConstantMaterializer = 1;
   let hasOperationAttrVerify = 1;
   let hasRegionArgAttrVerify = 1;
   let hasRegionResultAttrVerify = 1;
-  let usePropertiesForAttributes = 1;
 
   let extraClassDeclaration = [{
     void registerAttributes();
     void registerTypes();
 
     //===------------------------------------------------------------------===//
     // Attribute
     //===------------------------------------------------------------------===//

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

def ShapeDialect : Dialect {
   }];
 
   let cppNamespace = "::mlir::shape";
   let dependentDialects = ["arith::ArithDialect", "tensor::TensorDialect"];
 
   let useDefaultTypePrinterParser = 1;
   let hasConstantMaterializer = 1;
   let hasOperationAttrVerify = 1;
-  let usePropertiesForAttributes = 1;
 }
 
 class Shape_Type<string name, string typeMnemonic> : TypeDef<ShapeDialect, name> {
   let mnemonic = typeMnemonic;
 }
 
 def Shape_ShapeType : Shape_Type<"Shape", "shape"> {
   let description = [{

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

let description = [{
     Proceedings of the IEEE/ACM International Symposium on Code Generation
     and Optimization, 2019.
     * [Kjolstad20] Fredrik Berg Kjolstad. Sparse Tensor Algebra Compilation.
     PhD thesis, MIT, February, 2020.
   }];
 
   let useDefaultAttributePrinterParser = 1;
   let useDefaultTypePrinterParser = 1;
-  let usePropertiesForAttributes = 1;
 }
 
 #endif // SPARSETENSOR_BASE

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

let description = [{
 
     The `tensor` type is actually a builtin type (it lives in the builtin
     dialect), and does not live in this dialect.
 
   }];
 
   let hasCanonicalizer = 1;
   let hasConstantMaterializer = 1;
-  let usePropertiesForAttributes = 1;
   let dependentDialects = [
     "affine::AffineDialect",
     "arith::ArithDialect",
     "complex::ComplexDialect",
   ];
 }
 
 #endif // TENSOR_BASE

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

let description = [{
     there will be tools to lower from the ML frameworks into TOSA.
   }];
 
   let dependentDialects = ["tensor::TensorDialect", "quant::QuantizationDialect"];
 
   let cppNamespace = "mlir::tosa";
   let hasConstantMaterializer = 1;
   let useDefaultAttributePrinterParser = 1;
-  let usePropertiesForAttributes = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // TOSA Attributes.
 //===----------------------------------------------------------------------===//
 
 class Tosa_Attr<string attrName, string attrMnemonic, list<Trait> traits = []>
     : AttrDef<Tosa_Dialect, attrName, traits> {

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

 def Transform_Dialect : Dialect {
   let summary = "Fine-grain transformation control dialect";
   // For description, see docs/Dialects/Transform.md.
 
   let name = "transform";
   let cppNamespace = "::mlir::transform";
 
   let hasOperationAttrVerify = 1;
-  let usePropertiesForAttributes = 1;
-
   let extraClassDeclaration = [{
       /// Name of the attribute attachable to the symbol table operation
       /// containing named sequences. This is used to trigger verification.
       constexpr const static ::llvm::StringLiteral
           kWithNamedSequenceAttrName = "transform.with_named_sequence";
 
       /// Name of the attribute attachable to an operation so it can be
       /// identified as root by the default interpreter pass.

mlir/include/mlir/Dialect/UB/IR/UBOps.h

 //===- UBOps.h - UB Dialect Operations ------------------------*--- C++ -*-===//
 //
 // 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 MLIR_DIALECT_UB_IR_OPS_H
 #define MLIR_DIALECT_UB_IR_OPS_H
 
+#include "mlir/Bytecode/BytecodeOpInterface.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
 #include "mlir/Dialect/UB/IR/UBOpsInterfaces.h.inc"
 
 #define GET_ATTRDEF_CLASSES
 #include "mlir/Dialect/UB/IR/UBOpsAttributes.h.inc"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/UB/IR/UBOps.h.inc"
 
 #include "mlir/Dialect/UB/IR/UBOpsDialect.h.inc"
 
 #endif // MLIR_DIALECT_UB_IR_OPS_H

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

 include "mlir/Interfaces/ViewLikeInterface.td"
 
 def Vector_Dialect : Dialect {
   let name = "vector";
   let cppNamespace = "::mlir::vector";
 
   let useDefaultAttributePrinterParser = 1;
   let hasConstantMaterializer = 1;
-  let usePropertiesForAttributes = 1;
   let dependentDialects = ["arith::ArithDialect"];
 }
 
 // Base class for Vector dialect ops.
 class Vector_Op<string mnemonic, list<Trait> traits = []> :
     Op<Vector_Dialect, mnemonic, traits>;
 
 // The "kind" of combining function for contractions and reductions.

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

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

mlir/include/mlir/IR/BuiltinDialect.td

 
 def Builtin_Dialect : Dialect {
   let summary =
     "A dialect containing the builtin Attributes, Operations, and Types";
   let name = "builtin";
   let cppNamespace = "::mlir";
   let useDefaultAttributePrinterParser = 0;
   let useDefaultTypePrinterParser = 0;
-  let usePropertiesForAttributes = 1;
   let extraClassDeclaration = [{
   private:
     // Register the builtin Attributes.
     void registerAttributes();
     // Register the builtin Location Attributes.
     void registerLocationAttributes();
     // Register the builtin Types.
     void registerTypes();
 
   public:
   }];
 
 }
 
 #endif // BUILTIN_BASE

mlir/include/mlir/IR/DialectBase.td

class Dialect {
 
   // If this dialect overrides the hook for canonicalization patterns.
   bit hasCanonicalizer = 0;
 
   // If this dialect can be extended at runtime with new operations or types.
   bit isExtensible = 0;
 
   // Whether inherent Attributes defined in ODS will be stored as Properties.
-  bit usePropertiesForAttributes = 0;
+  bit usePropertiesForAttributes = 1;
 }
 
 #endif // DIALECTBASE_TD

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

def Test_Dialect : Dialect {
   let hasOperationAttrVerify = 1;
   let hasRegionArgAttrVerify = 1;
   let hasRegionResultAttrVerify = 1;
   let hasOperationInterfaceFallback = 1;
   let hasNonDefaultDestructor = 1;
   let useDefaultTypePrinterParser = 0;
   let useDefaultAttributePrinterParser = 1;
   let isExtensible = 1;
-  let usePropertiesForAttributes = 1;
   let dependentDialects = ["::mlir::DLTIDialect"];
 
   let extraClassDeclaration = [{
     void registerAttributes();
     void registerInterfaces();
     void registerTypes();
     void registerOpsSyntax();
 

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";
+  let usePropertiesForAttributes = 0;
 }
 
 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)">;

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/AttrTypeBase.td"
 include "mlir/IR/EnumAttr.td"
 include "mlir/IR/OpBase.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
   let cppNamespace = "foobar";
+  let usePropertiesForAttributes = 0;
 }
 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()";

 // DEF:        ::llvm::ArrayRef<::mlir::NamedAttribute> attributes
 // DEF:      odsState.addAttributes(attributes);
 
 // Test the above but with prefix.
 
 def Test2_Dialect : Dialect {
   let name = "test2";
   let cppNamespace = "foobar2";
+  let usePropertiesForAttributes = 0;
 }
 def AgetOp : Op<Test2_Dialect, "a_get_op", []> {
   let arguments = (ins
       SomeAttr:$aAttr,
       DefaultValuedOptionalAttr<SomeAttr, "4.2">:$bAttr,
       OptionalAttr<SomeAttr>:$cAttr
   );
 }

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/AttrTypeBase.td"
 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 usePropertiesForAttributes = 0;
 }
 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

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

 // RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s
 
 include "mlir/IR/OpBase.td"
 
 def TestDialect : Dialect {
   let name = "test";
+  let usePropertiesForAttributes = 0;
 }
 class TestFormat_Op<string fmt, list<Trait> traits = []>
     : Op<TestDialect, "format_op", traits> {
   let assemblyFormat = fmt;
 }
 
 //===----------------------------------------------------------------------===//
 // Directives

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";
+  let usePropertiesForAttributes = 0;
 }
 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);
 }
 

mlir/test/python/lib/PythonTestDialect.h

 //===- PythonTestDialect.h - PythonTest dialect definition ------*- C++ -*-===//
 //
 // 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 MLIR_TEST_PYTHON_LIB_PYTHONTESTDIALECT_H
 #define MLIR_TEST_PYTHON_LIB_PYTHONTESTDIALECT_H
 
+#include "mlir/Bytecode/BytecodeOpInterface.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Interfaces/InferTypeOpInterface.h"
 
 #include "PythonTestDialect.h.inc"
 
 #define GET_OP_CLASSES
 #include "PythonTestOps.h.inc"
 
 #define GET_ATTRDEF_CLASSES
 #include "PythonTestAttributes.h.inc"
 
 #define GET_TYPEDEF_CLASSES
 #include "PythonTestTypes.h.inc"
 
 #endif // MLIR_TEST_PYTHON_LIB_PYTHONTESTDIALECT_H