[mlir] Add availability field in op and enum cases

[antiagainst]

Summary

This commit wires up availability into op and enum
cases by adding fields into the definitions. This
enables better integration with various generators.

Depends On D107846

[jpienaar]

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

127

Could this be done even before the move? (e.g., an NFC before)

mlir/include/mlir/IR/OpBase.td

45

Why does it need to be forward declared?

[antiagainst]

Address comments

[antiagainst]

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

127

Good point. Moved to https://reviews.llvm.org/D108311.

mlir/include/mlir/IR/OpBase.td

45

Because MinVersionBase and MaxVersionBase (which subclass Availability) depends on EnumAttr, and EnumAttr now has a list<Availability> field. I prefer to keep Availability and Min/MaxVersionBase together; but I'm also fine to just move Availability here to avoid forward declarations.

[antiagainst]

Merged into D107846

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

 def SPV_V_1_4 : I32EnumAttrCase<"V_1_4", 4, "v1.4">;
 def SPV_V_1_5 : I32EnumAttrCase<"V_1_5", 5, "v1.5">;
 
 def SPV_VersionAttr : SPV_I32EnumAttr<"Version", "valid SPIR-V version", [
     SPV_V_1_0, SPV_V_1_1, SPV_V_1_2, SPV_V_1_3, SPV_V_1_4, SPV_V_1_5]>;
 
 class MinVersion<I32EnumAttrCase min> : MinVersionBase<
     "QueryMinVersionInterface", SPV_VersionAttr, min> {
   let interfaceNamespace = "::mlir::spirv";
   let interfaceDescription = [{
     Querying interface for minimal required SPIR-V version.
 
     This interface provides a `getMinVersion()` method to query the minimal
     required version for the implementing SPIR-V operation. The returned value
     is a `mlir::spirv::Version` enumerant.
   }];
 }
!interleave(!foreach(cap, capabilities,
                          "::mlir::spirv::Capability::" # cap.symbol), ", ") #
     "}; " #
     // The following manual ArrayRef constructor call is to satisfy GCC 5.
     "ArrayRef<::mlir::spirv::Capability> " #
       "ref(caps, ::llvm::array_lengthof(caps));");
   let instance = "ref";
 }
 
-class SPIRVOpInterface<string name> : OpInterface<name> {
-  let cppNamespace = "::mlir::spirv";
-}
-// TODO: the following interfaces definitions are duplicating with the above.
-// Remove them once we are able to support dialect-specific contents in ODS.
-def QueryMinVersionInterface : SPIRVOpInterface<"QueryMinVersionInterface"> {
-  let methods = [InterfaceMethod<
-    "", "::llvm::Optional<::mlir::spirv::Version>", "getMinVersion">];
-}
-def QueryMaxVersionInterface : SPIRVOpInterface<"QueryMaxVersionInterface"> {
-  let methods = [InterfaceMethod<
-    "", "::llvm::Optional<::mlir::spirv::Version>", "getMaxVersion">];
-}
-def QueryExtensionInterface : SPIRVOpInterface<"QueryExtensionInterface"> {
-  let methods = [InterfaceMethod<
-    "",
-    "::llvm::SmallVector<::llvm::ArrayRef<::mlir::spirv::Extension>, 1>",
-    "getExtensions">];
-}
-def QueryCapabilityInterface : SPIRVOpInterface<"QueryCapabilityInterface"> {
-  let methods = [InterfaceMethod<
-    "",
-    "::llvm::SmallVector<::llvm::ArrayRef<::mlir::spirv::Capability>, 1>",
-    "getCapabilities">];
-}
-
 //===----------------------------------------------------------------------===//
 // SPIR-V target GPU vendor and device definitions
 //===----------------------------------------------------------------------===//
 
 def SPV_DT_CPU           : StrEnumAttrCase<"CPU">;
 def SPV_DT_DiscreteGPU   : StrEnumAttrCase<"DiscreteGPU">;
 def SPV_DT_IntegratedGPU : StrEnumAttrCase<"IntegratedGPU">;
 // An accelerator other than GPU or CPU

 def SPV_C_Matrix                                    : I32EnumAttrCase<"Matrix", 0>;
 def SPV_C_Addresses                                 : I32EnumAttrCase<"Addresses", 4>;
 def SPV_C_Linkage                                   : I32EnumAttrCase<"Linkage", 5>;
 def SPV_C_Kernel                                    : I32EnumAttrCase<"Kernel", 6>;
 def SPV_C_Float16                                   : I32EnumAttrCase<"Float16", 9>;
 def SPV_C_Float64                                   : I32EnumAttrCase<"Float64", 10>;
 def SPV_C_Int64                                     : I32EnumAttrCase<"Int64", 11>;
 def SPV_C_Groups                                    : I32EnumAttrCase<"Groups", 18> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_AMD_shader_ballot]>
   ];
 }
 def SPV_C_Int16                                     : I32EnumAttrCase<"Int16", 22>;
 def SPV_C_Int8                                      : I32EnumAttrCase<"Int8", 39>;
 def SPV_C_Sampled1D                                 : I32EnumAttrCase<"Sampled1D", 43>;
 def SPV_C_SampledBuffer                             : I32EnumAttrCase<"SampledBuffer", 46>;
 def SPV_C_GroupNonUniform                           : I32EnumAttrCase<"GroupNonUniform", 61> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_3>
   ];
 }
 def SPV_C_ShaderLayer                               : I32EnumAttrCase<"ShaderLayer", 69> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_5>
   ];
 }
 def SPV_C_ShaderViewportIndex                       : I32EnumAttrCase<"ShaderViewportIndex", 70> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_5>
   ];
 }
 def SPV_C_SubgroupBallotKHR                         : I32EnumAttrCase<"SubgroupBallotKHR", 4423> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_shader_ballot]>
   ];
 }
 def SPV_C_SubgroupVoteKHR                           : I32EnumAttrCase<"SubgroupVoteKHR", 4431> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_subgroup_vote]>
   ];
 }
 def SPV_C_StorageBuffer16BitAccess                  : I32EnumAttrCase<"StorageBuffer16BitAccess", 4433> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_16bit_storage]>
   ];
 }
 def SPV_C_StoragePushConstant16                     : I32EnumAttrCase<"StoragePushConstant16", 4435> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_16bit_storage]>
   ];
 }
 def SPV_C_StorageInputOutput16                      : I32EnumAttrCase<"StorageInputOutput16", 4436> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_16bit_storage]>
   ];
 }
 def SPV_C_DeviceGroup                               : I32EnumAttrCase<"DeviceGroup", 4437> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_device_group]>
   ];
 }
 def SPV_C_AtomicStorageOps                          : I32EnumAttrCase<"AtomicStorageOps", 4445> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_shader_atomic_counter_ops]>
   ];
 }
 def SPV_C_SampleMaskPostDepthCoverage               : I32EnumAttrCase<"SampleMaskPostDepthCoverage", 4447> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_post_depth_coverage]>
   ];
 }
 def SPV_C_StorageBuffer8BitAccess                   : I32EnumAttrCase<"StorageBuffer8BitAccess", 4448> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_8bit_storage]>
   ];
 }
 def SPV_C_StoragePushConstant8                      : I32EnumAttrCase<"StoragePushConstant8", 4450> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_8bit_storage]>
   ];
 }
 def SPV_C_DenormPreserve                            : I32EnumAttrCase<"DenormPreserve", 4464> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_float_controls]>
   ];
 }
 def SPV_C_DenormFlushToZero                         : I32EnumAttrCase<"DenormFlushToZero", 4465> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_float_controls]>
   ];
 }
 def SPV_C_SignedZeroInfNanPreserve                  : I32EnumAttrCase<"SignedZeroInfNanPreserve", 4466> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_float_controls]>
   ];
 }
 def SPV_C_RoundingModeRTE                           : I32EnumAttrCase<"RoundingModeRTE", 4467> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_float_controls]>
   ];
 }
 def SPV_C_RoundingModeRTZ                           : I32EnumAttrCase<"RoundingModeRTZ", 4468> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_float_controls]>
   ];
 }
 def SPV_C_ImageFootprintNV                          : I32EnumAttrCase<"ImageFootprintNV", 5282> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_shader_image_footprint]>
   ];
 }
 def SPV_C_FragmentBarycentricNV                     : I32EnumAttrCase<"FragmentBarycentricNV", 5284> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_fragment_shader_barycentric]>
   ];
 }
 def SPV_C_ComputeDerivativeGroupQuadsNV             : I32EnumAttrCase<"ComputeDerivativeGroupQuadsNV", 5288> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_compute_shader_derivatives]>
   ];
 }
 def SPV_C_GroupNonUniformPartitionedNV              : I32EnumAttrCase<"GroupNonUniformPartitionedNV", 5297> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_shader_subgroup_partitioned]>
   ];
 }
 def SPV_C_VulkanMemoryModel                         : I32EnumAttrCase<"VulkanMemoryModel", 5345> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_5>
   ];
 }
 def SPV_C_VulkanMemoryModelDeviceScope              : I32EnumAttrCase<"VulkanMemoryModelDeviceScope", 5346> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_5>
   ];
 }
 def SPV_C_ComputeDerivativeGroupLinearNV            : I32EnumAttrCase<"ComputeDerivativeGroupLinearNV", 5350> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_compute_shader_derivatives]>
   ];
 }
 def SPV_C_SubgroupShuffleINTEL                      : I32EnumAttrCase<"SubgroupShuffleINTEL", 5568> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_INTEL_subgroups]>
   ];
 }
 def SPV_C_SubgroupBufferBlockIOINTEL                : I32EnumAttrCase<"SubgroupBufferBlockIOINTEL", 5569> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_INTEL_subgroups]>
   ];
 }
 def SPV_C_SubgroupImageBlockIOINTEL                 : I32EnumAttrCase<"SubgroupImageBlockIOINTEL", 5570> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_INTEL_subgroups]>
   ];
 }
 def SPV_C_SubgroupImageMediaBlockIOINTEL            : I32EnumAttrCase<"SubgroupImageMediaBlockIOINTEL", 5579> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_INTEL_media_block_io]>
   ];
 }
 def SPV_C_SubgroupAvcMotionEstimationINTEL          : I32EnumAttrCase<"SubgroupAvcMotionEstimationINTEL", 5696> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_INTEL_device_side_avc_motion_estimation]>
   ];
 }
 def SPV_C_SubgroupAvcMotionEstimationIntraINTEL     : I32EnumAttrCase<"SubgroupAvcMotionEstimationIntraINTEL", 5697> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_INTEL_device_side_avc_motion_estimation]>
   ];
 }
 def SPV_C_SubgroupAvcMotionEstimationChromaINTEL    : I32EnumAttrCase<"SubgroupAvcMotionEstimationChromaINTEL", 5698> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_INTEL_device_side_avc_motion_estimation]>
   ];
 }
 def SPV_C_Shader                                    : I32EnumAttrCase<"Shader", 1> {
   list<I32EnumAttrCase> implies = [SPV_C_Matrix];
 }
 def SPV_C_Vector16                                  : I32EnumAttrCase<"Vector16", 7> {
   list<I32EnumAttrCase> implies = [SPV_C_Kernel];

 def SPV_C_Image1D                                   : I32EnumAttrCase<"Image1D", 44> {
   list<I32EnumAttrCase> implies = [SPV_C_Sampled1D];
 }
 def SPV_C_ImageBuffer                               : I32EnumAttrCase<"ImageBuffer", 47> {
   list<I32EnumAttrCase> implies = [SPV_C_SampledBuffer];
 }
 def SPV_C_NamedBarrier                              : I32EnumAttrCase<"NamedBarrier", 59> {
   list<I32EnumAttrCase> implies = [SPV_C_Kernel];
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_1>
   ];
 }
 def SPV_C_GroupNonUniformVote                       : I32EnumAttrCase<"GroupNonUniformVote", 62> {
   list<I32EnumAttrCase> implies = [SPV_C_GroupNonUniform];
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_3>
   ];
 }
 def SPV_C_GroupNonUniformArithmetic                 : I32EnumAttrCase<"GroupNonUniformArithmetic", 63> {
   list<I32EnumAttrCase> implies = [SPV_C_GroupNonUniform];
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_3>
   ];
 }
 def SPV_C_GroupNonUniformBallot                     : I32EnumAttrCase<"GroupNonUniformBallot", 64> {
   list<I32EnumAttrCase> implies = [SPV_C_GroupNonUniform];
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_3>
   ];
 }
 def SPV_C_GroupNonUniformShuffle                    : I32EnumAttrCase<"GroupNonUniformShuffle", 65> {
   list<I32EnumAttrCase> implies = [SPV_C_GroupNonUniform];
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_3>
   ];
 }
 def SPV_C_GroupNonUniformShuffleRelative            : I32EnumAttrCase<"GroupNonUniformShuffleRelative", 66> {
   list<I32EnumAttrCase> implies = [SPV_C_GroupNonUniform];
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_3>
   ];
 }
 def SPV_C_GroupNonUniformClustered                  : I32EnumAttrCase<"GroupNonUniformClustered", 67> {
   list<I32EnumAttrCase> implies = [SPV_C_GroupNonUniform];
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_3>
   ];
 }
 def SPV_C_GroupNonUniformQuad                       : I32EnumAttrCase<"GroupNonUniformQuad", 68> {
   list<I32EnumAttrCase> implies = [SPV_C_GroupNonUniform];
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_3>
   ];
 }
 def SPV_C_StorageUniform16                          : I32EnumAttrCase<"StorageUniform16", 4434> {
   list<I32EnumAttrCase> implies = [SPV_C_StorageBuffer16BitAccess];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_16bit_storage]>
   ];
 }
 def SPV_C_UniformAndStorageBuffer8BitAccess         : I32EnumAttrCase<"UniformAndStorageBuffer8BitAccess", 4449> {
   list<I32EnumAttrCase> implies = [SPV_C_StorageBuffer8BitAccess];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_8bit_storage]>
   ];
 }
 def SPV_C_UniformTexelBufferArrayDynamicIndexing    : I32EnumAttrCase<"UniformTexelBufferArrayDynamicIndexing", 5304> {
   list<I32EnumAttrCase> implies = [SPV_C_SampledBuffer];
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_5>
   ];
 }
 def SPV_C_Geometry                                  : I32EnumAttrCase<"Geometry", 2> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
 }
 def SPV_C_Tessellation                              : I32EnumAttrCase<"Tessellation", 3> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];

 def SPV_C_StorageImageReadWithoutFormat             : I32EnumAttrCase<"StorageImageReadWithoutFormat", 55> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
 }
 def SPV_C_StorageImageWriteWithoutFormat            : I32EnumAttrCase<"StorageImageWriteWithoutFormat", 56> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
 }
 def SPV_C_SubgroupDispatch                          : I32EnumAttrCase<"SubgroupDispatch", 58> {
   list<I32EnumAttrCase> implies = [SPV_C_DeviceEnqueue];
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_1>
   ];
 }
 def SPV_C_PipeStorage                               : I32EnumAttrCase<"PipeStorage", 60> {
   list<I32EnumAttrCase> implies = [SPV_C_Pipes];
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_1>
   ];
 }
 def SPV_C_DrawParameters                            : I32EnumAttrCase<"DrawParameters", 4427> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_shader_draw_parameters]>
   ];
 }
 def SPV_C_MultiView                                 : I32EnumAttrCase<"MultiView", 4439> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_multiview]>
   ];
 }
 def SPV_C_VariablePointersStorageBuffer             : I32EnumAttrCase<"VariablePointersStorageBuffer", 4441> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_variable_pointers]>
   ];
 }
 def SPV_C_Float16ImageAMD                           : I32EnumAttrCase<"Float16ImageAMD", 5008> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_AMD_gpu_shader_half_float_fetch]>
   ];
 }
 def SPV_C_ImageGatherBiasLodAMD                     : I32EnumAttrCase<"ImageGatherBiasLodAMD", 5009> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_AMD_texture_gather_bias_lod]>
   ];
 }
 def SPV_C_FragmentMaskAMD                           : I32EnumAttrCase<"FragmentMaskAMD", 5010> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_AMD_shader_fragment_mask]>
   ];
 }
 def SPV_C_StencilExportEXT                          : I32EnumAttrCase<"StencilExportEXT", 5013> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_EXT_shader_stencil_export]>
   ];
 }
 def SPV_C_ImageReadWriteLodAMD                      : I32EnumAttrCase<"ImageReadWriteLodAMD", 5015> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_AMD_shader_image_load_store_lod]>
   ];
 }
 def SPV_C_ShaderClockKHR                            : I32EnumAttrCase<"ShaderClockKHR", 5055> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_shader_clock]>
   ];
 }
 def SPV_C_FragmentFullyCoveredEXT                   : I32EnumAttrCase<"FragmentFullyCoveredEXT", 5265> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_EXT_fragment_fully_covered]>
   ];
 }
 def SPV_C_MeshShadingNV                             : I32EnumAttrCase<"MeshShadingNV", 5266> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_mesh_shader]>
   ];
 }
 def SPV_C_FragmentDensityEXT                        : I32EnumAttrCase<"FragmentDensityEXT", 5291> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_EXT_fragment_invocation_density, SPV_NV_shading_rate]>
   ];
 }
 def SPV_C_ShaderNonUniform                          : I32EnumAttrCase<"ShaderNonUniform", 5301> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_5>
   ];
 }
 def SPV_C_RuntimeDescriptorArray                    : I32EnumAttrCase<"RuntimeDescriptorArray", 5302> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_5>
   ];
 }
 def SPV_C_StorageTexelBufferArrayDynamicIndexing    : I32EnumAttrCase<"StorageTexelBufferArrayDynamicIndexing", 5305> {
   list<I32EnumAttrCase> implies = [SPV_C_ImageBuffer];
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_5>
   ];
 }
 def SPV_C_RayTracingNV                              : I32EnumAttrCase<"RayTracingNV", 5340> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_ray_tracing]>
   ];
 }
 def SPV_C_PhysicalStorageBufferAddresses            : I32EnumAttrCase<"PhysicalStorageBufferAddresses", 5347> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_EXT_physical_storage_buffer, SPV_KHR_physical_storage_buffer]>
   ];
 }
 def SPV_C_CooperativeMatrixNV                       : I32EnumAttrCase<"CooperativeMatrixNV", 5357> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_cooperative_matrix]>
   ];
 }
 def SPV_C_FragmentShaderSampleInterlockEXT          : I32EnumAttrCase<"FragmentShaderSampleInterlockEXT", 5363> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_EXT_fragment_shader_interlock]>
   ];
 }
 def SPV_C_FragmentShaderShadingRateInterlockEXT     : I32EnumAttrCase<"FragmentShaderShadingRateInterlockEXT", 5372> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_EXT_fragment_shader_interlock]>
   ];
 }
 def SPV_C_ShaderSMBuiltinsNV                        : I32EnumAttrCase<"ShaderSMBuiltinsNV", 5373> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_shader_sm_builtins]>
   ];
 }
 def SPV_C_FragmentShaderPixelInterlockEXT           : I32EnumAttrCase<"FragmentShaderPixelInterlockEXT", 5378> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_EXT_fragment_shader_interlock]>
   ];
 }
 def SPV_C_DemoteToHelperInvocationEXT               : I32EnumAttrCase<"DemoteToHelperInvocationEXT", 5379> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_EXT_demote_to_helper_invocation]>
   ];
 }
 def SPV_C_IntegerFunctions2INTEL                    : I32EnumAttrCase<"IntegerFunctions2INTEL", 5584> {
   list<I32EnumAttrCase> implies = [SPV_C_Shader];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_INTEL_shader_integer_functions2]>
   ];
 }
 def SPV_C_TessellationPointSize                     : I32EnumAttrCase<"TessellationPointSize", 23> {
   list<I32EnumAttrCase> implies = [SPV_C_Tessellation];
 }
 def SPV_C_GeometryPointSize                         : I32EnumAttrCase<"GeometryPointSize", 24> {
   list<I32EnumAttrCase> implies = [SPV_C_Geometry];
 }
 def SPV_C_ImageCubeArray                            : I32EnumAttrCase<"ImageCubeArray", 34> {
   list<I32EnumAttrCase> implies = [SPV_C_SampledCubeArray];
 }
 def SPV_C_ImageRect                                 : I32EnumAttrCase<"ImageRect", 36> {
   list<I32EnumAttrCase> implies = [SPV_C_SampledRect];
 }
 def SPV_C_GeometryStreams                           : I32EnumAttrCase<"GeometryStreams", 54> {
   list<I32EnumAttrCase> implies = [SPV_C_Geometry];
 }
 def SPV_C_MultiViewport                             : I32EnumAttrCase<"MultiViewport", 57> {
   list<I32EnumAttrCase> implies = [SPV_C_Geometry];
 }
 def SPV_C_VariablePointers                          : I32EnumAttrCase<"VariablePointers", 4442> {
   list<I32EnumAttrCase> implies = [SPV_C_VariablePointersStorageBuffer];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_variable_pointers]>
   ];
 }
 def SPV_C_SampleMaskOverrideCoverageNV              : I32EnumAttrCase<"SampleMaskOverrideCoverageNV", 5249> {
   list<I32EnumAttrCase> implies = [SPV_C_SampleRateShading];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_sample_mask_override_coverage]>
   ];
 }
 def SPV_C_GeometryShaderPassthroughNV               : I32EnumAttrCase<"GeometryShaderPassthroughNV", 5251> {
   list<I32EnumAttrCase> implies = [SPV_C_Geometry];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_geometry_shader_passthrough]>
   ];
 }
 def SPV_C_PerViewAttributesNV                       : I32EnumAttrCase<"PerViewAttributesNV", 5260> {
   list<I32EnumAttrCase> implies = [SPV_C_MultiView];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NVX_multiview_per_view_attributes]>
   ];
 }
 def SPV_C_InputAttachmentArrayDynamicIndexing       : I32EnumAttrCase<"InputAttachmentArrayDynamicIndexing", 5303> {
   list<I32EnumAttrCase> implies = [SPV_C_InputAttachment];
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_5>
   ];
 }
 def SPV_C_UniformBufferArrayNonUniformIndexing      : I32EnumAttrCase<"UniformBufferArrayNonUniformIndexing", 5306> {
   list<I32EnumAttrCase> implies = [SPV_C_ShaderNonUniform];
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_5>
   ];
 }
 def SPV_C_SampledImageArrayNonUniformIndexing       : I32EnumAttrCase<"SampledImageArrayNonUniformIndexing", 5307> {
   list<I32EnumAttrCase> implies = [SPV_C_ShaderNonUniform];
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_5>
   ];
 }
 def SPV_C_StorageBufferArrayNonUniformIndexing      : I32EnumAttrCase<"StorageBufferArrayNonUniformIndexing", 5308> {
   list<I32EnumAttrCase> implies = [SPV_C_ShaderNonUniform];
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_5>
   ];
 }
 def SPV_C_StorageImageArrayNonUniformIndexing       : I32EnumAttrCase<"StorageImageArrayNonUniformIndexing", 5309> {
   list<I32EnumAttrCase> implies = [SPV_C_ShaderNonUniform];
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_5>
   ];
 }
 def SPV_C_InputAttachmentArrayNonUniformIndexing    : I32EnumAttrCase<"InputAttachmentArrayNonUniformIndexing", 5310> {
   list<I32EnumAttrCase> implies = [SPV_C_InputAttachment, SPV_C_ShaderNonUniform];
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_5>
   ];
 }
 def SPV_C_UniformTexelBufferArrayNonUniformIndexing : I32EnumAttrCase<"UniformTexelBufferArrayNonUniformIndexing", 5311> {
   list<I32EnumAttrCase> implies = [SPV_C_SampledBuffer, SPV_C_ShaderNonUniform];
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_5>
   ];
 }
 def SPV_C_StorageTexelBufferArrayNonUniformIndexing : I32EnumAttrCase<"StorageTexelBufferArrayNonUniformIndexing", 5312> {
   list<I32EnumAttrCase> implies = [SPV_C_ImageBuffer, SPV_C_ShaderNonUniform];
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_5>
   ];
 }
 def SPV_C_ShaderViewportIndexLayerEXT               : I32EnumAttrCase<"ShaderViewportIndexLayerEXT", 5254> {
   list<I32EnumAttrCase> implies = [SPV_C_MultiViewport];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_EXT_shader_viewport_index_layer]>
   ];
 }
 def SPV_C_ShaderViewportMaskNV                      : I32EnumAttrCase<"ShaderViewportMaskNV", 5255> {
   list<I32EnumAttrCase> implies = [SPV_C_ShaderViewportIndexLayerEXT];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_viewport_array2]>
   ];
 }
 def SPV_C_ShaderStereoViewNV                        : I32EnumAttrCase<"ShaderStereoViewNV", 5259> {
   list<I32EnumAttrCase> implies = [SPV_C_ShaderViewportMaskNV];
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_stereo_view_rendering]>
   ];
 }
 
 def SPV_CapabilityAttr :
     SPV_I32EnumAttr<"Capability", "valid SPIR-V Capability", [
       SPV_C_Matrix, SPV_C_Addresses, SPV_C_Linkage, SPV_C_Kernel, SPV_C_Float16,
       SPV_C_Float64, SPV_C_Int64, SPV_C_Groups, SPV_C_Int16, SPV_C_Int8,
SPV_I32EnumAttr<"Capability", "valid SPIR-V Capability", [
       SPV_C_UniformTexelBufferArrayNonUniformIndexing,
       SPV_C_StorageTexelBufferArrayNonUniformIndexing,
       SPV_C_ShaderViewportIndexLayerEXT, SPV_C_ShaderViewportMaskNV,
       SPV_C_ShaderStereoViewNV
     ]>;
 
 def SPV_AM_Logical                 : I32EnumAttrCase<"Logical", 0>;
 def SPV_AM_Physical32              : I32EnumAttrCase<"Physical32", 1> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Addresses]>
   ];
 }
 def SPV_AM_Physical64              : I32EnumAttrCase<"Physical64", 2> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Addresses]>
   ];
 }
 def SPV_AM_PhysicalStorageBuffer64 : I32EnumAttrCase<"PhysicalStorageBuffer64", 5348> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_EXT_physical_storage_buffer, SPV_KHR_physical_storage_buffer]>,
     Capability<[SPV_C_PhysicalStorageBufferAddresses]>
   ];
 }
 
 def SPV_AddressingModelAttr :
     SPV_I32EnumAttr<"AddressingModel", "valid SPIR-V AddressingModel", [
       SPV_AM_Logical, SPV_AM_Physical32, SPV_AM_Physical64,
       SPV_AM_PhysicalStorageBuffer64
     ]>;
 
 def SPV_BI_Position                    : I32EnumAttrCase<"Position", 0> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_BI_PointSize                   : I32EnumAttrCase<"PointSize", 1> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_BI_ClipDistance                : I32EnumAttrCase<"ClipDistance", 3> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_ClipDistance]>
   ];
 }
 def SPV_BI_CullDistance                : I32EnumAttrCase<"CullDistance", 4> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_CullDistance]>
   ];
 }
 def SPV_BI_VertexId                    : I32EnumAttrCase<"VertexId", 5> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_BI_InstanceId                  : I32EnumAttrCase<"InstanceId", 6> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_BI_PrimitiveId                 : I32EnumAttrCase<"PrimitiveId", 7> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Geometry, SPV_C_RayTracingNV, SPV_C_Tessellation]>
   ];
 }
 def SPV_BI_InvocationId                : I32EnumAttrCase<"InvocationId", 8> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Geometry, SPV_C_Tessellation]>
   ];
 }
 def SPV_BI_Layer                       : I32EnumAttrCase<"Layer", 9> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Geometry, SPV_C_ShaderLayer, SPV_C_ShaderViewportIndexLayerEXT]>
   ];
 }
 def SPV_BI_ViewportIndex               : I32EnumAttrCase<"ViewportIndex", 10> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_MultiViewport, SPV_C_ShaderViewportIndex, SPV_C_ShaderViewportIndexLayerEXT]>
   ];
 }
 def SPV_BI_TessLevelOuter              : I32EnumAttrCase<"TessLevelOuter", 11> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Tessellation]>
   ];
 }
 def SPV_BI_TessLevelInner              : I32EnumAttrCase<"TessLevelInner", 12> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Tessellation]>
   ];
 }
 def SPV_BI_TessCoord                   : I32EnumAttrCase<"TessCoord", 13> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Tessellation]>
   ];
 }
 def SPV_BI_PatchVertices               : I32EnumAttrCase<"PatchVertices", 14> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Tessellation]>
   ];
 }
 def SPV_BI_FragCoord                   : I32EnumAttrCase<"FragCoord", 15> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_BI_PointCoord                  : I32EnumAttrCase<"PointCoord", 16> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_BI_FrontFacing                 : I32EnumAttrCase<"FrontFacing", 17> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_BI_SampleId                    : I32EnumAttrCase<"SampleId", 18> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_SampleRateShading]>
   ];
 }
 def SPV_BI_SamplePosition              : I32EnumAttrCase<"SamplePosition", 19> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_SampleRateShading]>
   ];
 }
 def SPV_BI_SampleMask                  : I32EnumAttrCase<"SampleMask", 20> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_BI_FragDepth                   : I32EnumAttrCase<"FragDepth", 22> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_BI_HelperInvocation            : I32EnumAttrCase<"HelperInvocation", 23> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_BI_NumWorkgroups               : I32EnumAttrCase<"NumWorkgroups", 24>;
 def SPV_BI_WorkgroupSize               : I32EnumAttrCase<"WorkgroupSize", 25>;
 def SPV_BI_WorkgroupId                 : I32EnumAttrCase<"WorkgroupId", 26>;
 def SPV_BI_LocalInvocationId           : I32EnumAttrCase<"LocalInvocationId", 27>;
 def SPV_BI_GlobalInvocationId          : I32EnumAttrCase<"GlobalInvocationId", 28>;
 def SPV_BI_LocalInvocationIndex        : I32EnumAttrCase<"LocalInvocationIndex", 29>;
 def SPV_BI_WorkDim                     : I32EnumAttrCase<"WorkDim", 30> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Kernel]>
   ];
 }
 def SPV_BI_GlobalSize                  : I32EnumAttrCase<"GlobalSize", 31> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Kernel]>
   ];
 }
 def SPV_BI_EnqueuedWorkgroupSize       : I32EnumAttrCase<"EnqueuedWorkgroupSize", 32> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Kernel]>
   ];
 }
 def SPV_BI_GlobalOffset                : I32EnumAttrCase<"GlobalOffset", 33> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Kernel]>
   ];
 }
 def SPV_BI_GlobalLinearId              : I32EnumAttrCase<"GlobalLinearId", 34> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Kernel]>
   ];
 }
 def SPV_BI_SubgroupSize                : I32EnumAttrCase<"SubgroupSize", 36> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_GroupNonUniform, SPV_C_Kernel, SPV_C_SubgroupBallotKHR]>
   ];
 }
 def SPV_BI_SubgroupMaxSize             : I32EnumAttrCase<"SubgroupMaxSize", 37> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Kernel]>
   ];
 }
 def SPV_BI_NumSubgroups                : I32EnumAttrCase<"NumSubgroups", 38> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_GroupNonUniform, SPV_C_Kernel]>
   ];
 }
 def SPV_BI_NumEnqueuedSubgroups        : I32EnumAttrCase<"NumEnqueuedSubgroups", 39> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Kernel]>
   ];
 }
 def SPV_BI_SubgroupId                  : I32EnumAttrCase<"SubgroupId", 40> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_GroupNonUniform, SPV_C_Kernel]>
   ];
 }
 def SPV_BI_SubgroupLocalInvocationId   : I32EnumAttrCase<"SubgroupLocalInvocationId", 41> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_GroupNonUniform, SPV_C_Kernel, SPV_C_SubgroupBallotKHR]>
   ];
 }
 def SPV_BI_VertexIndex                 : I32EnumAttrCase<"VertexIndex", 42> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_BI_InstanceIndex               : I32EnumAttrCase<"InstanceIndex", 43> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_BI_SubgroupEqMask              : I32EnumAttrCase<"SubgroupEqMask", 4416> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_3>,
     Capability<[SPV_C_GroupNonUniformBallot, SPV_C_SubgroupBallotKHR]>
   ];
 }
 def SPV_BI_SubgroupGeMask              : I32EnumAttrCase<"SubgroupGeMask", 4417> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_3>,
     Capability<[SPV_C_GroupNonUniformBallot, SPV_C_SubgroupBallotKHR]>
   ];
 }
 def SPV_BI_SubgroupGtMask              : I32EnumAttrCase<"SubgroupGtMask", 4418> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_3>,
     Capability<[SPV_C_GroupNonUniformBallot, SPV_C_SubgroupBallotKHR]>
   ];
 }
 def SPV_BI_SubgroupLeMask              : I32EnumAttrCase<"SubgroupLeMask", 4419> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_3>,
     Capability<[SPV_C_GroupNonUniformBallot, SPV_C_SubgroupBallotKHR]>
   ];
 }
 def SPV_BI_SubgroupLtMask              : I32EnumAttrCase<"SubgroupLtMask", 4420> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_3>,
     Capability<[SPV_C_GroupNonUniformBallot, SPV_C_SubgroupBallotKHR]>
   ];
 }
 def SPV_BI_BaseVertex                  : I32EnumAttrCase<"BaseVertex", 4424> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_shader_draw_parameters]>,
     Capability<[SPV_C_DrawParameters]>
   ];
 }
 def SPV_BI_BaseInstance                : I32EnumAttrCase<"BaseInstance", 4425> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_shader_draw_parameters]>,
     Capability<[SPV_C_DrawParameters]>
   ];
 }
 def SPV_BI_DrawIndex                   : I32EnumAttrCase<"DrawIndex", 4426> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_shader_draw_parameters, SPV_NV_mesh_shader]>,
     Capability<[SPV_C_DrawParameters, SPV_C_MeshShadingNV]>
   ];
 }
 def SPV_BI_DeviceIndex                 : I32EnumAttrCase<"DeviceIndex", 4438> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_device_group]>,
     Capability<[SPV_C_DeviceGroup]>
   ];
 }
 def SPV_BI_ViewIndex                   : I32EnumAttrCase<"ViewIndex", 4440> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_multiview]>,
     Capability<[SPV_C_MultiView]>
   ];
 }
 def SPV_BI_BaryCoordNoPerspAMD         : I32EnumAttrCase<"BaryCoordNoPerspAMD", 4992> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_AMD_shader_explicit_vertex_parameter]>
   ];
 }
 def SPV_BI_BaryCoordNoPerspCentroidAMD : I32EnumAttrCase<"BaryCoordNoPerspCentroidAMD", 4993> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_AMD_shader_explicit_vertex_parameter]>
   ];
 }
 def SPV_BI_BaryCoordNoPerspSampleAMD   : I32EnumAttrCase<"BaryCoordNoPerspSampleAMD", 4994> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_AMD_shader_explicit_vertex_parameter]>
   ];
 }
 def SPV_BI_BaryCoordSmoothAMD          : I32EnumAttrCase<"BaryCoordSmoothAMD", 4995> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_AMD_shader_explicit_vertex_parameter]>
   ];
 }
 def SPV_BI_BaryCoordSmoothCentroidAMD  : I32EnumAttrCase<"BaryCoordSmoothCentroidAMD", 4996> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_AMD_shader_explicit_vertex_parameter]>
   ];
 }
 def SPV_BI_BaryCoordSmoothSampleAMD    : I32EnumAttrCase<"BaryCoordSmoothSampleAMD", 4997> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_AMD_shader_explicit_vertex_parameter]>
   ];
 }
 def SPV_BI_BaryCoordPullModelAMD       : I32EnumAttrCase<"BaryCoordPullModelAMD", 4998> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_AMD_shader_explicit_vertex_parameter]>
   ];
 }
 def SPV_BI_FragStencilRefEXT           : I32EnumAttrCase<"FragStencilRefEXT", 5014> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_EXT_shader_stencil_export]>,
     Capability<[SPV_C_StencilExportEXT]>
   ];
 }
 def SPV_BI_ViewportMaskNV              : I32EnumAttrCase<"ViewportMaskNV", 5253> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_mesh_shader, SPV_NV_viewport_array2]>,
     Capability<[SPV_C_MeshShadingNV, SPV_C_ShaderViewportMaskNV]>
   ];
 }
 def SPV_BI_SecondaryPositionNV         : I32EnumAttrCase<"SecondaryPositionNV", 5257> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_stereo_view_rendering]>,
     Capability<[SPV_C_ShaderStereoViewNV]>
   ];
 }
 def SPV_BI_SecondaryViewportMaskNV     : I32EnumAttrCase<"SecondaryViewportMaskNV", 5258> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_stereo_view_rendering]>,
     Capability<[SPV_C_ShaderStereoViewNV]>
   ];
 }
 def SPV_BI_PositionPerViewNV           : I32EnumAttrCase<"PositionPerViewNV", 5261> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NVX_multiview_per_view_attributes, SPV_NV_mesh_shader]>,
     Capability<[SPV_C_MeshShadingNV, SPV_C_PerViewAttributesNV]>
   ];
 }
 def SPV_BI_ViewportMaskPerViewNV       : I32EnumAttrCase<"ViewportMaskPerViewNV", 5262> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NVX_multiview_per_view_attributes, SPV_NV_mesh_shader]>,
     Capability<[SPV_C_MeshShadingNV, SPV_C_PerViewAttributesNV]>
   ];
 }
 def SPV_BI_FullyCoveredEXT             : I32EnumAttrCase<"FullyCoveredEXT", 5264> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_EXT_fragment_fully_covered]>,
     Capability<[SPV_C_FragmentFullyCoveredEXT]>
   ];
 }
 def SPV_BI_TaskCountNV                 : I32EnumAttrCase<"TaskCountNV", 5274> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_mesh_shader]>,
     Capability<[SPV_C_MeshShadingNV]>
   ];
 }
 def SPV_BI_PrimitiveCountNV            : I32EnumAttrCase<"PrimitiveCountNV", 5275> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_mesh_shader]>,
     Capability<[SPV_C_MeshShadingNV]>
   ];
 }
 def SPV_BI_PrimitiveIndicesNV          : I32EnumAttrCase<"PrimitiveIndicesNV", 5276> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_mesh_shader]>,
     Capability<[SPV_C_MeshShadingNV]>
   ];
 }
 def SPV_BI_ClipDistancePerViewNV       : I32EnumAttrCase<"ClipDistancePerViewNV", 5277> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_mesh_shader]>,
     Capability<[SPV_C_MeshShadingNV]>
   ];
 }
 def SPV_BI_CullDistancePerViewNV       : I32EnumAttrCase<"CullDistancePerViewNV", 5278> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_mesh_shader]>,
     Capability<[SPV_C_MeshShadingNV]>
   ];
 }
 def SPV_BI_LayerPerViewNV              : I32EnumAttrCase<"LayerPerViewNV", 5279> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_mesh_shader]>,
     Capability<[SPV_C_MeshShadingNV]>
   ];
 }
 def SPV_BI_MeshViewCountNV             : I32EnumAttrCase<"MeshViewCountNV", 5280> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_mesh_shader]>,
     Capability<[SPV_C_MeshShadingNV]>
   ];
 }
 def SPV_BI_MeshViewIndicesNV           : I32EnumAttrCase<"MeshViewIndicesNV", 5281> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_mesh_shader]>,
     Capability<[SPV_C_MeshShadingNV]>
   ];
 }
 def SPV_BI_BaryCoordNV                 : I32EnumAttrCase<"BaryCoordNV", 5286> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_fragment_shader_barycentric]>,
     Capability<[SPV_C_FragmentBarycentricNV]>
   ];
 }
 def SPV_BI_BaryCoordNoPerspNV          : I32EnumAttrCase<"BaryCoordNoPerspNV", 5287> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_fragment_shader_barycentric]>,
     Capability<[SPV_C_FragmentBarycentricNV]>
   ];
 }
 def SPV_BI_FragSizeEXT                 : I32EnumAttrCase<"FragSizeEXT", 5292> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_EXT_fragment_invocation_density, SPV_NV_shading_rate]>,
     Capability<[SPV_C_FragmentDensityEXT]>
   ];
 }
 def SPV_BI_FragInvocationCountEXT      : I32EnumAttrCase<"FragInvocationCountEXT", 5293> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_EXT_fragment_invocation_density, SPV_NV_shading_rate]>,
     Capability<[SPV_C_FragmentDensityEXT]>
   ];
 }
 def SPV_BI_LaunchIdNV                  : I32EnumAttrCase<"LaunchIdNV", 5319> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_ray_tracing]>,
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 def SPV_BI_LaunchSizeNV                : I32EnumAttrCase<"LaunchSizeNV", 5320> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_ray_tracing]>,
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 def SPV_BI_WorldRayOriginNV            : I32EnumAttrCase<"WorldRayOriginNV", 5321> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_ray_tracing]>,
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 def SPV_BI_WorldRayDirectionNV         : I32EnumAttrCase<"WorldRayDirectionNV", 5322> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_ray_tracing]>,
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 def SPV_BI_ObjectRayOriginNV           : I32EnumAttrCase<"ObjectRayOriginNV", 5323> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_ray_tracing]>,
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 def SPV_BI_ObjectRayDirectionNV        : I32EnumAttrCase<"ObjectRayDirectionNV", 5324> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_ray_tracing]>,
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 def SPV_BI_RayTminNV                   : I32EnumAttrCase<"RayTminNV", 5325> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_ray_tracing]>,
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 def SPV_BI_RayTmaxNV                   : I32EnumAttrCase<"RayTmaxNV", 5326> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_ray_tracing]>,
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 def SPV_BI_InstanceCustomIndexNV       : I32EnumAttrCase<"InstanceCustomIndexNV", 5327> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_ray_tracing]>,
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 def SPV_BI_ObjectToWorldNV             : I32EnumAttrCase<"ObjectToWorldNV", 5330> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_ray_tracing]>,
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 def SPV_BI_WorldToObjectNV             : I32EnumAttrCase<"WorldToObjectNV", 5331> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_ray_tracing]>,
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 def SPV_BI_HitTNV                      : I32EnumAttrCase<"HitTNV", 5332> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_ray_tracing]>,
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 def SPV_BI_HitKindNV                   : I32EnumAttrCase<"HitKindNV", 5333> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_ray_tracing]>,
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 def SPV_BI_IncomingRayFlagsNV          : I32EnumAttrCase<"IncomingRayFlagsNV", 5351> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_ray_tracing]>,
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 def SPV_BI_WarpsPerSMNV                : I32EnumAttrCase<"WarpsPerSMNV", 5374> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_shader_sm_builtins]>,
     Capability<[SPV_C_ShaderSMBuiltinsNV]>
   ];
 }
 def SPV_BI_SMCountNV                   : I32EnumAttrCase<"SMCountNV", 5375> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_shader_sm_builtins]>,
     Capability<[SPV_C_ShaderSMBuiltinsNV]>
   ];
 }
 def SPV_BI_WarpIDNV                    : I32EnumAttrCase<"WarpIDNV", 5376> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_shader_sm_builtins]>,
     Capability<[SPV_C_ShaderSMBuiltinsNV]>
   ];
 }
 def SPV_BI_SMIDNV                      : I32EnumAttrCase<"SMIDNV", 5377> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_shader_sm_builtins]>,
     Capability<[SPV_C_ShaderSMBuiltinsNV]>
   ];
 }
 
 def SPV_BuiltInAttr :
     SPV_I32EnumAttr<"BuiltIn", "valid SPIR-V BuiltIn", [
       SPV_BI_Position, SPV_BI_PointSize, SPV_BI_ClipDistance, SPV_BI_CullDistance,
SPV_I32EnumAttr<"BuiltIn", "valid SPIR-V BuiltIn", [
       SPV_BI_WorldRayOriginNV, SPV_BI_WorldRayDirectionNV, SPV_BI_ObjectRayOriginNV,
       SPV_BI_ObjectRayDirectionNV, SPV_BI_RayTminNV, SPV_BI_RayTmaxNV,
       SPV_BI_InstanceCustomIndexNV, SPV_BI_ObjectToWorldNV, SPV_BI_WorldToObjectNV,
       SPV_BI_HitTNV, SPV_BI_HitKindNV, SPV_BI_IncomingRayFlagsNV,
       SPV_BI_WarpsPerSMNV, SPV_BI_SMCountNV, SPV_BI_WarpIDNV, SPV_BI_SMIDNV
     ]>;
 
 def SPV_D_RelaxedPrecision            : I32EnumAttrCase<"RelaxedPrecision", 0> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_D_SpecId                      : I32EnumAttrCase<"SpecId", 1> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Kernel, SPV_C_Shader]>
   ];
 }
 def SPV_D_Block                       : I32EnumAttrCase<"Block", 2> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_D_BufferBlock                 : I32EnumAttrCase<"BufferBlock", 3> {
-  list<Availability> availability = [
+  let availability = [
     MaxVersion<SPV_V_1_3>,
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_D_RowMajor                    : I32EnumAttrCase<"RowMajor", 4> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Matrix]>
   ];
 }
 def SPV_D_ColMajor                    : I32EnumAttrCase<"ColMajor", 5> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Matrix]>
   ];
 }
 def SPV_D_ArrayStride                 : I32EnumAttrCase<"ArrayStride", 6> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_D_MatrixStride                : I32EnumAttrCase<"MatrixStride", 7> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Matrix]>
   ];
 }
 def SPV_D_GLSLShared                  : I32EnumAttrCase<"GLSLShared", 8> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_D_GLSLPacked                  : I32EnumAttrCase<"GLSLPacked", 9> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_D_CPacked                     : I32EnumAttrCase<"CPacked", 10> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Kernel]>
   ];
 }
 def SPV_D_BuiltIn                     : I32EnumAttrCase<"BuiltIn", 11>;
 def SPV_D_NoPerspective               : I32EnumAttrCase<"NoPerspective", 13> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_D_Flat                        : I32EnumAttrCase<"Flat", 14> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_D_Patch                       : I32EnumAttrCase<"Patch", 15> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Tessellation]>
   ];
 }
 def SPV_D_Centroid                    : I32EnumAttrCase<"Centroid", 16> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_D_Sample                      : I32EnumAttrCase<"Sample", 17> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_SampleRateShading]>
   ];
 }
 def SPV_D_Invariant                   : I32EnumAttrCase<"Invariant", 18> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_D_Restrict                    : I32EnumAttrCase<"Restrict", 19>;
 def SPV_D_Aliased                     : I32EnumAttrCase<"Aliased", 20>;
 def SPV_D_Volatile                    : I32EnumAttrCase<"Volatile", 21>;
 def SPV_D_Constant                    : I32EnumAttrCase<"Constant", 22> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Kernel]>
   ];
 }
 def SPV_D_Coherent                    : I32EnumAttrCase<"Coherent", 23>;
 def SPV_D_NonWritable                 : I32EnumAttrCase<"NonWritable", 24>;
 def SPV_D_NonReadable                 : I32EnumAttrCase<"NonReadable", 25>;
 def SPV_D_Uniform                     : I32EnumAttrCase<"Uniform", 26> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_D_UniformId                   : I32EnumAttrCase<"UniformId", 27> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_4>,
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_D_SaturatedConversion         : I32EnumAttrCase<"SaturatedConversion", 28> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Kernel]>
   ];
 }
 def SPV_D_Stream                      : I32EnumAttrCase<"Stream", 29> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_GeometryStreams]>
   ];
 }
 def SPV_D_Location                    : I32EnumAttrCase<"Location", 30> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_D_Component                   : I32EnumAttrCase<"Component", 31> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_D_Index                       : I32EnumAttrCase<"Index", 32> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_D_Binding                     : I32EnumAttrCase<"Binding", 33> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_D_DescriptorSet               : I32EnumAttrCase<"DescriptorSet", 34> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_D_Offset                      : I32EnumAttrCase<"Offset", 35> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_D_XfbBuffer                   : I32EnumAttrCase<"XfbBuffer", 36> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_TransformFeedback]>
   ];
 }
 def SPV_D_XfbStride                   : I32EnumAttrCase<"XfbStride", 37> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_TransformFeedback]>
   ];
 }
 def SPV_D_FuncParamAttr               : I32EnumAttrCase<"FuncParamAttr", 38> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Kernel]>
   ];
 }
 def SPV_D_FPRoundingMode              : I32EnumAttrCase<"FPRoundingMode", 39>;
 def SPV_D_FPFastMathMode              : I32EnumAttrCase<"FPFastMathMode", 40> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Kernel]>
   ];
 }
 def SPV_D_LinkageAttributes           : I32EnumAttrCase<"LinkageAttributes", 41> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Linkage]>
   ];
 }
 def SPV_D_NoContraction               : I32EnumAttrCase<"NoContraction", 42> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_D_InputAttachmentIndex        : I32EnumAttrCase<"InputAttachmentIndex", 43> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_InputAttachment]>
   ];
 }
 def SPV_D_Alignment                   : I32EnumAttrCase<"Alignment", 44> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Kernel]>
   ];
 }
 def SPV_D_MaxByteOffset               : I32EnumAttrCase<"MaxByteOffset", 45> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_1>,
     Capability<[SPV_C_Addresses]>
   ];
 }
 def SPV_D_AlignmentId                 : I32EnumAttrCase<"AlignmentId", 46> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_2>,
     Capability<[SPV_C_Kernel]>
   ];
 }
 def SPV_D_MaxByteOffsetId             : I32EnumAttrCase<"MaxByteOffsetId", 47> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_2>,
     Capability<[SPV_C_Addresses]>
   ];
 }
 def SPV_D_NoSignedWrap                : I32EnumAttrCase<"NoSignedWrap", 4469> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_no_integer_wrap_decoration]>
   ];
 }
 def SPV_D_NoUnsignedWrap              : I32EnumAttrCase<"NoUnsignedWrap", 4470> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_no_integer_wrap_decoration]>
   ];
 }
 def SPV_D_ExplicitInterpAMD           : I32EnumAttrCase<"ExplicitInterpAMD", 4999> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_AMD_shader_explicit_vertex_parameter]>
   ];
 }
 def SPV_D_OverrideCoverageNV          : I32EnumAttrCase<"OverrideCoverageNV", 5248> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_sample_mask_override_coverage]>,
     Capability<[SPV_C_SampleMaskOverrideCoverageNV]>
   ];
 }
 def SPV_D_PassthroughNV               : I32EnumAttrCase<"PassthroughNV", 5250> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_geometry_shader_passthrough]>,
     Capability<[SPV_C_GeometryShaderPassthroughNV]>
   ];
 }
 def SPV_D_ViewportRelativeNV          : I32EnumAttrCase<"ViewportRelativeNV", 5252> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_ShaderViewportMaskNV]>
   ];
 }
 def SPV_D_SecondaryViewportRelativeNV : I32EnumAttrCase<"SecondaryViewportRelativeNV", 5256> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_stereo_view_rendering]>,
     Capability<[SPV_C_ShaderStereoViewNV]>
   ];
 }
 def SPV_D_PerPrimitiveNV              : I32EnumAttrCase<"PerPrimitiveNV", 5271> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_mesh_shader]>,
     Capability<[SPV_C_MeshShadingNV]>
   ];
 }
 def SPV_D_PerViewNV                   : I32EnumAttrCase<"PerViewNV", 5272> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_mesh_shader]>,
     Capability<[SPV_C_MeshShadingNV]>
   ];
 }
 def SPV_D_PerTaskNV                   : I32EnumAttrCase<"PerTaskNV", 5273> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_mesh_shader]>,
     Capability<[SPV_C_MeshShadingNV]>
   ];
 }
 def SPV_D_PerVertexNV                 : I32EnumAttrCase<"PerVertexNV", 5285> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_fragment_shader_barycentric]>,
     Capability<[SPV_C_FragmentBarycentricNV]>
   ];
 }
 def SPV_D_NonUniform                  : I32EnumAttrCase<"NonUniform", 5300> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_5>,
     Capability<[SPV_C_ShaderNonUniform]>
   ];
 }
 def SPV_D_RestrictPointer             : I32EnumAttrCase<"RestrictPointer", 5355> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_EXT_physical_storage_buffer, SPV_KHR_physical_storage_buffer]>,
     Capability<[SPV_C_PhysicalStorageBufferAddresses]>
   ];
 }
 def SPV_D_AliasedPointer              : I32EnumAttrCase<"AliasedPointer", 5356> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_EXT_physical_storage_buffer, SPV_KHR_physical_storage_buffer]>,
     Capability<[SPV_C_PhysicalStorageBufferAddresses]>
   ];
 }
 def SPV_D_CounterBuffer               : I32EnumAttrCase<"CounterBuffer", 5634> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_4>
   ];
 }
 def SPV_D_UserSemantic                : I32EnumAttrCase<"UserSemantic", 5635> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_4>
   ];
 }
 def SPV_D_UserTypeGOOGLE              : I32EnumAttrCase<"UserTypeGOOGLE", 5636> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_GOOGLE_user_type]>
   ];
 }
 
 def SPV_DecorationAttr :
     SPV_I32EnumAttr<"Decoration", "valid SPIR-V Decoration", [
       SPV_D_RelaxedPrecision, SPV_D_SpecId, SPV_D_Block, SPV_D_BufferBlock,
       SPV_D_RowMajor, SPV_D_ColMajor, SPV_D_ArrayStride, SPV_D_MatrixStride,
SPV_I32EnumAttr<"Decoration", "valid SPIR-V Decoration", [
       SPV_D_PassthroughNV, SPV_D_ViewportRelativeNV,
       SPV_D_SecondaryViewportRelativeNV, SPV_D_PerPrimitiveNV, SPV_D_PerViewNV,
       SPV_D_PerTaskNV, SPV_D_PerVertexNV, SPV_D_NonUniform, SPV_D_RestrictPointer,
       SPV_D_AliasedPointer, SPV_D_CounterBuffer, SPV_D_UserSemantic,
       SPV_D_UserTypeGOOGLE
     ]>;
 
 def SPV_D_1D          : I32EnumAttrCase<"Dim1D", 0> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Image1D, SPV_C_Sampled1D]>
   ];
 }
 def SPV_D_2D          : I32EnumAttrCase<"Dim2D", 1> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_ImageMSArray, SPV_C_Kernel, SPV_C_Shader]>
   ];
 }
 def SPV_D_3D          : I32EnumAttrCase<"Dim3D", 2>;
 def SPV_D_Cube        : I32EnumAttrCase<"Cube", 3> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_ImageCubeArray, SPV_C_Shader]>
   ];
 }
 def SPV_D_Rect        : I32EnumAttrCase<"Rect", 4> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_ImageRect, SPV_C_SampledRect]>
   ];
 }
 def SPV_D_Buffer      : I32EnumAttrCase<"Buffer", 5> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_ImageBuffer, SPV_C_SampledBuffer]>
   ];
 }
 def SPV_D_SubpassData : I32EnumAttrCase<"SubpassData", 6> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_InputAttachment]>
   ];
 }
 
 def SPV_DimAttr :
     SPV_I32EnumAttr<"Dim", "valid SPIR-V Dim", [
       SPV_D_1D, SPV_D_2D, SPV_D_3D, SPV_D_Cube, SPV_D_Rect, SPV_D_Buffer,
       SPV_D_SubpassData
     ]>;
 
 def SPV_EM_Invocations                      : I32EnumAttrCase<"Invocations", 0> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Geometry]>
   ];
 }
 def SPV_EM_SpacingEqual                     : I32EnumAttrCase<"SpacingEqual", 1> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Tessellation]>
   ];
 }
 def SPV_EM_SpacingFractionalEven            : I32EnumAttrCase<"SpacingFractionalEven", 2> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Tessellation]>
   ];
 }
 def SPV_EM_SpacingFractionalOdd             : I32EnumAttrCase<"SpacingFractionalOdd", 3> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Tessellation]>
   ];
 }
 def SPV_EM_VertexOrderCw                    : I32EnumAttrCase<"VertexOrderCw", 4> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Tessellation]>
   ];
 }
 def SPV_EM_VertexOrderCcw                   : I32EnumAttrCase<"VertexOrderCcw", 5> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Tessellation]>
   ];
 }
 def SPV_EM_PixelCenterInteger               : I32EnumAttrCase<"PixelCenterInteger", 6> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_EM_OriginUpperLeft                  : I32EnumAttrCase<"OriginUpperLeft", 7> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_EM_OriginLowerLeft                  : I32EnumAttrCase<"OriginLowerLeft", 8> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_EM_EarlyFragmentTests               : I32EnumAttrCase<"EarlyFragmentTests", 9> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_EM_PointMode                        : I32EnumAttrCase<"PointMode", 10> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Tessellation]>
   ];
 }
 def SPV_EM_Xfb                              : I32EnumAttrCase<"Xfb", 11> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_TransformFeedback]>
   ];
 }
 def SPV_EM_DepthReplacing                   : I32EnumAttrCase<"DepthReplacing", 12> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_EM_DepthGreater                     : I32EnumAttrCase<"DepthGreater", 14> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_EM_DepthLess                        : I32EnumAttrCase<"DepthLess", 15> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_EM_DepthUnchanged                   : I32EnumAttrCase<"DepthUnchanged", 16> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_EM_LocalSize                        : I32EnumAttrCase<"LocalSize", 17>;
 def SPV_EM_LocalSizeHint                    : I32EnumAttrCase<"LocalSizeHint", 18> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Kernel]>
   ];
 }
 def SPV_EM_InputPoints                      : I32EnumAttrCase<"InputPoints", 19> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Geometry]>
   ];
 }
 def SPV_EM_InputLines                       : I32EnumAttrCase<"InputLines", 20> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Geometry]>
   ];
 }
 def SPV_EM_InputLinesAdjacency              : I32EnumAttrCase<"InputLinesAdjacency", 21> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Geometry]>
   ];
 }
 def SPV_EM_Triangles                        : I32EnumAttrCase<"Triangles", 22> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Geometry, SPV_C_Tessellation]>
   ];
 }
 def SPV_EM_InputTrianglesAdjacency          : I32EnumAttrCase<"InputTrianglesAdjacency", 23> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Geometry]>
   ];
 }
 def SPV_EM_Quads                            : I32EnumAttrCase<"Quads", 24> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Tessellation]>
   ];
 }
 def SPV_EM_Isolines                         : I32EnumAttrCase<"Isolines", 25> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Tessellation]>
   ];
 }
 def SPV_EM_OutputVertices                   : I32EnumAttrCase<"OutputVertices", 26> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Geometry, SPV_C_MeshShadingNV, SPV_C_Tessellation]>
   ];
 }
 def SPV_EM_OutputPoints                     : I32EnumAttrCase<"OutputPoints", 27> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Geometry, SPV_C_MeshShadingNV]>
   ];
 }
 def SPV_EM_OutputLineStrip                  : I32EnumAttrCase<"OutputLineStrip", 28> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Geometry]>
   ];
 }
 def SPV_EM_OutputTriangleStrip              : I32EnumAttrCase<"OutputTriangleStrip", 29> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Geometry]>
   ];
 }
 def SPV_EM_VecTypeHint                      : I32EnumAttrCase<"VecTypeHint", 30> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Kernel]>
   ];
 }
 def SPV_EM_ContractionOff                   : I32EnumAttrCase<"ContractionOff", 31> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Kernel]>
   ];
 }
 def SPV_EM_Initializer                      : I32EnumAttrCase<"Initializer", 33> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_1>,
     Capability<[SPV_C_Kernel]>
   ];
 }
 def SPV_EM_Finalizer                        : I32EnumAttrCase<"Finalizer", 34> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_1>,
     Capability<[SPV_C_Kernel]>
   ];
 }
 def SPV_EM_SubgroupSize                     : I32EnumAttrCase<"SubgroupSize", 35> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_1>,
     Capability<[SPV_C_SubgroupDispatch]>
   ];
 }
 def SPV_EM_SubgroupsPerWorkgroup            : I32EnumAttrCase<"SubgroupsPerWorkgroup", 36> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_1>,
     Capability<[SPV_C_SubgroupDispatch]>
   ];
 }
 def SPV_EM_SubgroupsPerWorkgroupId          : I32EnumAttrCase<"SubgroupsPerWorkgroupId", 37> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_2>,
     Capability<[SPV_C_SubgroupDispatch]>
   ];
 }
 def SPV_EM_LocalSizeId                      : I32EnumAttrCase<"LocalSizeId", 38> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_2>
   ];
 }
 def SPV_EM_LocalSizeHintId                  : I32EnumAttrCase<"LocalSizeHintId", 39> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_2>,
     Capability<[SPV_C_Kernel]>
   ];
 }
 def SPV_EM_PostDepthCoverage                : I32EnumAttrCase<"PostDepthCoverage", 4446> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_post_depth_coverage]>,
     Capability<[SPV_C_SampleMaskPostDepthCoverage]>
   ];
 }
 def SPV_EM_DenormPreserve                   : I32EnumAttrCase<"DenormPreserve", 4459> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_float_controls]>,
     Capability<[SPV_C_DenormPreserve]>
   ];
 }
 def SPV_EM_DenormFlushToZero                : I32EnumAttrCase<"DenormFlushToZero", 4460> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_float_controls]>,
     Capability<[SPV_C_DenormFlushToZero]>
   ];
 }
 def SPV_EM_SignedZeroInfNanPreserve         : I32EnumAttrCase<"SignedZeroInfNanPreserve", 4461> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_float_controls]>,
     Capability<[SPV_C_SignedZeroInfNanPreserve]>
   ];
 }
 def SPV_EM_RoundingModeRTE                  : I32EnumAttrCase<"RoundingModeRTE", 4462> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_float_controls]>,
     Capability<[SPV_C_RoundingModeRTE]>
   ];
 }
 def SPV_EM_RoundingModeRTZ                  : I32EnumAttrCase<"RoundingModeRTZ", 4463> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_float_controls]>,
     Capability<[SPV_C_RoundingModeRTZ]>
   ];
 }
 def SPV_EM_StencilRefReplacingEXT           : I32EnumAttrCase<"StencilRefReplacingEXT", 5027> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_EXT_shader_stencil_export]>,
     Capability<[SPV_C_StencilExportEXT]>
   ];
 }
 def SPV_EM_OutputLinesNV                    : I32EnumAttrCase<"OutputLinesNV", 5269> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_mesh_shader]>,
     Capability<[SPV_C_MeshShadingNV]>
   ];
 }
 def SPV_EM_OutputPrimitivesNV               : I32EnumAttrCase<"OutputPrimitivesNV", 5270> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_mesh_shader]>,
     Capability<[SPV_C_MeshShadingNV]>
   ];
 }
 def SPV_EM_DerivativeGroupQuadsNV           : I32EnumAttrCase<"DerivativeGroupQuadsNV", 5289> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_compute_shader_derivatives]>,
     Capability<[SPV_C_ComputeDerivativeGroupQuadsNV]>
   ];
 }
 def SPV_EM_DerivativeGroupLinearNV          : I32EnumAttrCase<"DerivativeGroupLinearNV", 5290> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_compute_shader_derivatives]>,
     Capability<[SPV_C_ComputeDerivativeGroupLinearNV]>
   ];
 }
 def SPV_EM_OutputTrianglesNV                : I32EnumAttrCase<"OutputTrianglesNV", 5298> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_mesh_shader]>,
     Capability<[SPV_C_MeshShadingNV]>
   ];
 }
 def SPV_EM_PixelInterlockOrderedEXT         : I32EnumAttrCase<"PixelInterlockOrderedEXT", 5366> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_EXT_fragment_shader_interlock]>,
     Capability<[SPV_C_FragmentShaderPixelInterlockEXT]>
   ];
 }
 def SPV_EM_PixelInterlockUnorderedEXT       : I32EnumAttrCase<"PixelInterlockUnorderedEXT", 5367> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_EXT_fragment_shader_interlock]>,
     Capability<[SPV_C_FragmentShaderPixelInterlockEXT]>
   ];
 }
 def SPV_EM_SampleInterlockOrderedEXT        : I32EnumAttrCase<"SampleInterlockOrderedEXT", 5368> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_EXT_fragment_shader_interlock]>,
     Capability<[SPV_C_FragmentShaderSampleInterlockEXT]>
   ];
 }
 def SPV_EM_SampleInterlockUnorderedEXT      : I32EnumAttrCase<"SampleInterlockUnorderedEXT", 5369> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_EXT_fragment_shader_interlock]>,
     Capability<[SPV_C_FragmentShaderSampleInterlockEXT]>
   ];
 }
 def SPV_EM_ShadingRateInterlockOrderedEXT   : I32EnumAttrCase<"ShadingRateInterlockOrderedEXT", 5370> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_EXT_fragment_shader_interlock]>,
     Capability<[SPV_C_FragmentShaderShadingRateInterlockEXT]>
   ];
 }
 def SPV_EM_ShadingRateInterlockUnorderedEXT : I32EnumAttrCase<"ShadingRateInterlockUnorderedEXT", 5371> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_EXT_fragment_shader_interlock]>,
     Capability<[SPV_C_FragmentShaderShadingRateInterlockEXT]>
   ];
 }
 
 def SPV_ExecutionModeAttr :
     SPV_I32EnumAttr<"ExecutionMode", "valid SPIR-V ExecutionMode", [
       SPV_EM_Invocations, SPV_EM_SpacingEqual, SPV_EM_SpacingFractionalEven,
SPV_I32EnumAttr<"ExecutionMode", "valid SPIR-V ExecutionMode", [
       SPV_EM_OutputPrimitivesNV, SPV_EM_DerivativeGroupQuadsNV,
       SPV_EM_DerivativeGroupLinearNV, SPV_EM_OutputTrianglesNV,
       SPV_EM_PixelInterlockOrderedEXT, SPV_EM_PixelInterlockUnorderedEXT,
       SPV_EM_SampleInterlockOrderedEXT, SPV_EM_SampleInterlockUnorderedEXT,
       SPV_EM_ShadingRateInterlockOrderedEXT, SPV_EM_ShadingRateInterlockUnorderedEXT
     ]>;
 
 def SPV_EM_Vertex                 : I32EnumAttrCase<"Vertex", 0> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_EM_TessellationControl    : I32EnumAttrCase<"TessellationControl", 1> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Tessellation]>
   ];
 }
 def SPV_EM_TessellationEvaluation : I32EnumAttrCase<"TessellationEvaluation", 2> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Tessellation]>
   ];
 }
 def SPV_EM_Geometry               : I32EnumAttrCase<"Geometry", 3> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Geometry]>
   ];
 }
 def SPV_EM_Fragment               : I32EnumAttrCase<"Fragment", 4> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_EM_GLCompute              : I32EnumAttrCase<"GLCompute", 5> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_EM_Kernel                 : I32EnumAttrCase<"Kernel", 6> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Kernel]>
   ];
 }
 def SPV_EM_TaskNV                 : I32EnumAttrCase<"TaskNV", 5267> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_MeshShadingNV]>
   ];
 }
 def SPV_EM_MeshNV                 : I32EnumAttrCase<"MeshNV", 5268> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_MeshShadingNV]>
   ];
 }
 def SPV_EM_RayGenerationNV        : I32EnumAttrCase<"RayGenerationNV", 5313> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 def SPV_EM_IntersectionNV         : I32EnumAttrCase<"IntersectionNV", 5314> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 def SPV_EM_AnyHitNV               : I32EnumAttrCase<"AnyHitNV", 5315> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 def SPV_EM_ClosestHitNV           : I32EnumAttrCase<"ClosestHitNV", 5316> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 def SPV_EM_MissNV                 : I32EnumAttrCase<"MissNV", 5317> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 def SPV_EM_CallableNV             : I32EnumAttrCase<"CallableNV", 5318> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 
 def SPV_ExecutionModelAttr :
     SPV_I32EnumAttr<"ExecutionModel", "valid SPIR-V ExecutionModel", [
       SPV_EM_Vertex, SPV_EM_TessellationControl, SPV_EM_TessellationEvaluation,
       SPV_EM_Geometry, SPV_EM_Fragment, SPV_EM_GLCompute, SPV_EM_Kernel,
       SPV_EM_TaskNV, SPV_EM_MeshNV, SPV_EM_RayGenerationNV, SPV_EM_IntersectionNV,
       SPV_EM_AnyHitNV, SPV_EM_ClosestHitNV, SPV_EM_MissNV, SPV_EM_CallableNV
     ]>;
 
 def SPV_FC_None       : BitEnumAttrCase<"None", 0x0000>;
 def SPV_FC_Inline     : BitEnumAttrCase<"Inline", 0x0001>;
 def SPV_FC_DontInline : BitEnumAttrCase<"DontInline", 0x0002>;
 def SPV_FC_Pure       : BitEnumAttrCase<"Pure", 0x0004>;
 def SPV_FC_Const      : BitEnumAttrCase<"Const", 0x0008>;
 
 def SPV_FunctionControlAttr :
     SPV_BitEnumAttr<"FunctionControl", "valid SPIR-V FunctionControl", [
       SPV_FC_None, SPV_FC_Inline, SPV_FC_DontInline, SPV_FC_Pure, SPV_FC_Const
     ]>;
 
 def SPV_GO_Reduce                     : I32EnumAttrCase<"Reduce", 0> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_GroupNonUniformArithmetic, SPV_C_GroupNonUniformBallot, SPV_C_Kernel]>
   ];
 }
 def SPV_GO_InclusiveScan              : I32EnumAttrCase<"InclusiveScan", 1> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_GroupNonUniformArithmetic, SPV_C_GroupNonUniformBallot, SPV_C_Kernel]>
   ];
 }
 def SPV_GO_ExclusiveScan              : I32EnumAttrCase<"ExclusiveScan", 2> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_GroupNonUniformArithmetic, SPV_C_GroupNonUniformBallot, SPV_C_Kernel]>
   ];
 }
 def SPV_GO_ClusteredReduce            : I32EnumAttrCase<"ClusteredReduce", 3> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_3>,
     Capability<[SPV_C_GroupNonUniformClustered]>
   ];
 }
 def SPV_GO_PartitionedReduceNV        : I32EnumAttrCase<"PartitionedReduceNV", 6> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_shader_subgroup_partitioned]>,
     Capability<[SPV_C_GroupNonUniformPartitionedNV]>
   ];
 }
 def SPV_GO_PartitionedInclusiveScanNV : I32EnumAttrCase<"PartitionedInclusiveScanNV", 7> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_shader_subgroup_partitioned]>,
     Capability<[SPV_C_GroupNonUniformPartitionedNV]>
   ];
 }
 def SPV_GO_PartitionedExclusiveScanNV : I32EnumAttrCase<"PartitionedExclusiveScanNV", 8> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_shader_subgroup_partitioned]>,
     Capability<[SPV_C_GroupNonUniformPartitionedNV]>
   ];
 }
 
 def SPV_GroupOperationAttr :
     SPV_I32EnumAttr<"GroupOperation", "valid SPIR-V GroupOperation", [
       SPV_GO_Reduce, SPV_GO_InclusiveScan, SPV_GO_ExclusiveScan,
       SPV_GO_ClusteredReduce, SPV_GO_PartitionedReduceNV,
       SPV_GO_PartitionedInclusiveScanNV, SPV_GO_PartitionedExclusiveScanNV
     ]>;
 
 def SPV_IF_Unknown      : I32EnumAttrCase<"Unknown", 0>;
 def SPV_IF_Rgba32f      : I32EnumAttrCase<"Rgba32f", 1> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_IF_Rgba16f      : I32EnumAttrCase<"Rgba16f", 2> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_IF_R32f         : I32EnumAttrCase<"R32f", 3> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_IF_Rgba8        : I32EnumAttrCase<"Rgba8", 4> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_IF_Rgba8Snorm   : I32EnumAttrCase<"Rgba8Snorm", 5> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_IF_Rg32f        : I32EnumAttrCase<"Rg32f", 6> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 def SPV_IF_Rg16f        : I32EnumAttrCase<"Rg16f", 7> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 def SPV_IF_R11fG11fB10f : I32EnumAttrCase<"R11fG11fB10f", 8> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 def SPV_IF_R16f         : I32EnumAttrCase<"R16f", 9> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 def SPV_IF_Rgba16       : I32EnumAttrCase<"Rgba16", 10> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 def SPV_IF_Rgb10A2      : I32EnumAttrCase<"Rgb10A2", 11> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 def SPV_IF_Rg16         : I32EnumAttrCase<"Rg16", 12> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 def SPV_IF_Rg8          : I32EnumAttrCase<"Rg8", 13> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 def SPV_IF_R16          : I32EnumAttrCase<"R16", 14> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 def SPV_IF_R8           : I32EnumAttrCase<"R8", 15> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 def SPV_IF_Rgba16Snorm  : I32EnumAttrCase<"Rgba16Snorm", 16> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 def SPV_IF_Rg16Snorm    : I32EnumAttrCase<"Rg16Snorm", 17> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 def SPV_IF_Rg8Snorm     : I32EnumAttrCase<"Rg8Snorm", 18> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 def SPV_IF_R16Snorm     : I32EnumAttrCase<"R16Snorm", 19> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 def SPV_IF_R8Snorm      : I32EnumAttrCase<"R8Snorm", 20> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 def SPV_IF_Rgba32i      : I32EnumAttrCase<"Rgba32i", 21> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_IF_Rgba16i      : I32EnumAttrCase<"Rgba16i", 22> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_IF_Rgba8i       : I32EnumAttrCase<"Rgba8i", 23> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_IF_R32i         : I32EnumAttrCase<"R32i", 24> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_IF_Rg32i        : I32EnumAttrCase<"Rg32i", 25> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 def SPV_IF_Rg16i        : I32EnumAttrCase<"Rg16i", 26> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 def SPV_IF_Rg8i         : I32EnumAttrCase<"Rg8i", 27> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 def SPV_IF_R16i         : I32EnumAttrCase<"R16i", 28> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 def SPV_IF_R8i          : I32EnumAttrCase<"R8i", 29> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 def SPV_IF_Rgba32ui     : I32EnumAttrCase<"Rgba32ui", 30> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_IF_Rgba16ui     : I32EnumAttrCase<"Rgba16ui", 31> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_IF_Rgba8ui      : I32EnumAttrCase<"Rgba8ui", 32> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_IF_R32ui        : I32EnumAttrCase<"R32ui", 33> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_IF_Rgb10a2ui    : I32EnumAttrCase<"Rgb10a2ui", 34> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 def SPV_IF_Rg32ui       : I32EnumAttrCase<"Rg32ui", 35> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 def SPV_IF_Rg16ui       : I32EnumAttrCase<"Rg16ui", 36> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 def SPV_IF_Rg8ui        : I32EnumAttrCase<"Rg8ui", 37> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 def SPV_IF_R16ui        : I32EnumAttrCase<"R16ui", 38> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 def SPV_IF_R8ui         : I32EnumAttrCase<"R8ui", 39> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_StorageImageExtendedFormats]>
   ];
 }
 
 def SPV_ImageFormatAttr :
     SPV_I32EnumAttr<"ImageFormat", "valid SPIR-V ImageFormat", [
       SPV_IF_Unknown, SPV_IF_Rgba32f, SPV_IF_Rgba16f, SPV_IF_R32f, SPV_IF_Rgba8,
       SPV_IF_Rgba8Snorm, SPV_IF_Rg32f, SPV_IF_Rg16f, SPV_IF_R11fG11fB10f,
       SPV_IF_R16f, SPV_IF_Rgba16, SPV_IF_Rgb10A2, SPV_IF_Rg16, SPV_IF_Rg8,
       SPV_IF_R16, SPV_IF_R8, SPV_IF_Rgba16Snorm, SPV_IF_Rg16Snorm, SPV_IF_Rg8Snorm,
       SPV_IF_R16Snorm, SPV_IF_R8Snorm, SPV_IF_Rgba32i, SPV_IF_Rgba16i, SPV_IF_Rgba8i,
       SPV_IF_R32i, SPV_IF_Rg32i, SPV_IF_Rg16i, SPV_IF_Rg8i, SPV_IF_R16i, SPV_IF_R8i,
       SPV_IF_Rgba32ui, SPV_IF_Rgba16ui, SPV_IF_Rgba8ui, SPV_IF_R32ui,
       SPV_IF_Rgb10a2ui, SPV_IF_Rg32ui, SPV_IF_Rg16ui, SPV_IF_Rg8ui, SPV_IF_R16ui,
       SPV_IF_R8ui
     ]>;
 
 def SPV_LT_Export : I32EnumAttrCase<"Export", 0> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Linkage]>
   ];
 }
 def SPV_LT_Import : I32EnumAttrCase<"Import", 1> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Linkage]>
   ];
 }
 
 def SPV_LinkageTypeAttr :
     SPV_I32EnumAttr<"LinkageType", "valid SPIR-V LinkageType", [
       SPV_LT_Export, SPV_LT_Import
     ]>;
 
 def SPV_LC_None               : BitEnumAttrCase<"None", 0x0000>;
 def SPV_LC_Unroll             : BitEnumAttrCase<"Unroll", 0x0001>;
 def SPV_LC_DontUnroll         : BitEnumAttrCase<"DontUnroll", 0x0002>;
 def SPV_LC_DependencyInfinite : BitEnumAttrCase<"DependencyInfinite", 0x0004> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_1>
   ];
 }
 def SPV_LC_DependencyLength   : BitEnumAttrCase<"DependencyLength", 0x0008> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_1>
   ];
 }
 def SPV_LC_MinIterations      : BitEnumAttrCase<"MinIterations", 0x0010> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_4>
   ];
 }
 def SPV_LC_MaxIterations      : BitEnumAttrCase<"MaxIterations", 0x0020> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_4>
   ];
 }
 def SPV_LC_IterationMultiple  : BitEnumAttrCase<"IterationMultiple", 0x0040> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_4>
   ];
 }
 def SPV_LC_PeelCount          : BitEnumAttrCase<"PeelCount", 0x0080> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_4>
   ];
 }
 def SPV_LC_PartialCount       : BitEnumAttrCase<"PartialCount", 0x0100> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_4>
   ];
 }
 
 def SPV_LoopControlAttr :
     SPV_BitEnumAttr<"LoopControl", "valid SPIR-V LoopControl", [
       SPV_LC_None, SPV_LC_Unroll, SPV_LC_DontUnroll, SPV_LC_DependencyInfinite,
       SPV_LC_DependencyLength, SPV_LC_MinIterations, SPV_LC_MaxIterations,
       SPV_LC_IterationMultiple, SPV_LC_PeelCount, SPV_LC_PartialCount
     ]>;
 
 def SPV_MA_None                 : BitEnumAttrCase<"None", 0x0000>;
 def SPV_MA_Volatile             : BitEnumAttrCase<"Volatile", 0x0001>;
 def SPV_MA_Aligned              : BitEnumAttrCase<"Aligned", 0x0002>;
 def SPV_MA_Nontemporal          : BitEnumAttrCase<"Nontemporal", 0x0004>;
 def SPV_MA_MakePointerAvailable : BitEnumAttrCase<"MakePointerAvailable", 0x0008> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_5>,
     Capability<[SPV_C_VulkanMemoryModel]>
   ];
 }
 def SPV_MA_MakePointerVisible   : BitEnumAttrCase<"MakePointerVisible", 0x0010> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_5>,
     Capability<[SPV_C_VulkanMemoryModel]>
   ];
 }
 def SPV_MA_NonPrivatePointer    : BitEnumAttrCase<"NonPrivatePointer", 0x0020> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_5>,
     Capability<[SPV_C_VulkanMemoryModel]>
   ];
 }
 
 def SPV_MemoryAccessAttr :
     SPV_BitEnumAttr<"MemoryAccess", "valid SPIR-V MemoryAccess", [
       SPV_MA_None, SPV_MA_Volatile, SPV_MA_Aligned, SPV_MA_Nontemporal,
       SPV_MA_MakePointerAvailable, SPV_MA_MakePointerVisible,
       SPV_MA_NonPrivatePointer
     ]>;
 
 def SPV_MM_Simple  : I32EnumAttrCase<"Simple", 0> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_MM_GLSL450 : I32EnumAttrCase<"GLSL450", 1> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_MM_OpenCL  : I32EnumAttrCase<"OpenCL", 2> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Kernel]>
   ];
 }
 def SPV_MM_Vulkan  : I32EnumAttrCase<"Vulkan", 3> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_vulkan_memory_model]>,
     Capability<[SPV_C_VulkanMemoryModel]>
   ];
 }
 
 def SPV_MemoryModelAttr :
     SPV_I32EnumAttr<"MemoryModel", "valid SPIR-V MemoryModel", [
       SPV_MM_Simple, SPV_MM_GLSL450, SPV_MM_OpenCL, SPV_MM_Vulkan
     ]>;
 
 def SPV_MS_None                   : BitEnumAttrCase<"None", 0x0000>;
 def SPV_MS_Acquire                : BitEnumAttrCase<"Acquire", 0x0002>;
 def SPV_MS_Release                : BitEnumAttrCase<"Release", 0x0004>;
 def SPV_MS_AcquireRelease         : BitEnumAttrCase<"AcquireRelease", 0x0008>;
 def SPV_MS_SequentiallyConsistent : BitEnumAttrCase<"SequentiallyConsistent", 0x0010>;
 def SPV_MS_UniformMemory          : BitEnumAttrCase<"UniformMemory", 0x0040> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_MS_SubgroupMemory         : BitEnumAttrCase<"SubgroupMemory", 0x0080>;
 def SPV_MS_WorkgroupMemory        : BitEnumAttrCase<"WorkgroupMemory", 0x0100>;
 def SPV_MS_CrossWorkgroupMemory   : BitEnumAttrCase<"CrossWorkgroupMemory", 0x0200>;
 def SPV_MS_AtomicCounterMemory    : BitEnumAttrCase<"AtomicCounterMemory", 0x0400> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_AtomicStorage]>
   ];
 }
 def SPV_MS_ImageMemory            : BitEnumAttrCase<"ImageMemory", 0x0800>;
 def SPV_MS_OutputMemory           : BitEnumAttrCase<"OutputMemory", 0x1000> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_5>,
     Capability<[SPV_C_VulkanMemoryModel]>
   ];
 }
 def SPV_MS_MakeAvailable          : BitEnumAttrCase<"MakeAvailable", 0x2000> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_5>,
     Capability<[SPV_C_VulkanMemoryModel]>
   ];
 }
 def SPV_MS_MakeVisible            : BitEnumAttrCase<"MakeVisible", 0x4000> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_5>,
     Capability<[SPV_C_VulkanMemoryModel]>
   ];
 }
 def SPV_MS_Volatile               : BitEnumAttrCase<"Volatile", 0x8000> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_vulkan_memory_model]>,
     Capability<[SPV_C_VulkanMemoryModel]>
   ];
 }
 
 def SPV_MemorySemanticsAttr :
     SPV_BitEnumAttr<"MemorySemantics", "valid SPIR-V MemorySemantics", [
       SPV_MS_None, SPV_MS_Acquire, SPV_MS_Release, SPV_MS_AcquireRelease,
       SPV_MS_SequentiallyConsistent, SPV_MS_UniformMemory, SPV_MS_SubgroupMemory,
       SPV_MS_WorkgroupMemory, SPV_MS_CrossWorkgroupMemory,
       SPV_MS_AtomicCounterMemory, SPV_MS_ImageMemory, SPV_MS_OutputMemory,
       SPV_MS_MakeAvailable, SPV_MS_MakeVisible, SPV_MS_Volatile
     ]>;
 
 def SPV_S_CrossDevice : I32EnumAttrCase<"CrossDevice", 0>;
 def SPV_S_Device      : I32EnumAttrCase<"Device", 1>;
 def SPV_S_Workgroup   : I32EnumAttrCase<"Workgroup", 2>;
 def SPV_S_Subgroup    : I32EnumAttrCase<"Subgroup", 3>;
 def SPV_S_Invocation  : I32EnumAttrCase<"Invocation", 4>;
 def SPV_S_QueueFamily : I32EnumAttrCase<"QueueFamily", 5> {
-  list<Availability> availability = [
+  let availability = [
     MinVersion<SPV_V_1_5>,
     Capability<[SPV_C_VulkanMemoryModel]>
   ];
 }
 
 def SPV_ScopeAttr :
     SPV_I32EnumAttr<"Scope", "valid SPIR-V Scope", [
       SPV_S_CrossDevice, SPV_S_Device, SPV_S_Workgroup, SPV_S_Subgroup,
       SPV_S_Invocation, SPV_S_QueueFamily
     ]>;
 
 def SPV_SC_None        : BitEnumAttrCase<"None", 0x0000>;
 def SPV_SC_Flatten     : BitEnumAttrCase<"Flatten", 0x0001>;
 def SPV_SC_DontFlatten : BitEnumAttrCase<"DontFlatten", 0x0002>;
 
 def SPV_SelectionControlAttr :
     SPV_BitEnumAttr<"SelectionControl", "valid SPIR-V SelectionControl", [
       SPV_SC_None, SPV_SC_Flatten, SPV_SC_DontFlatten
     ]>;
 
 def SPV_SC_UniformConstant        : I32EnumAttrCase<"UniformConstant", 0>;
 def SPV_SC_Input                  : I32EnumAttrCase<"Input", 1>;
 def SPV_SC_Uniform                : I32EnumAttrCase<"Uniform", 2> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_SC_Output                 : I32EnumAttrCase<"Output", 3> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_SC_Workgroup              : I32EnumAttrCase<"Workgroup", 4>;
 def SPV_SC_CrossWorkgroup         : I32EnumAttrCase<"CrossWorkgroup", 5>;
 def SPV_SC_Private                : I32EnumAttrCase<"Private", 6> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_SC_Function               : I32EnumAttrCase<"Function", 7>;
 def SPV_SC_Generic                : I32EnumAttrCase<"Generic", 8> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_GenericPointer]>
   ];
 }
 def SPV_SC_PushConstant           : I32EnumAttrCase<"PushConstant", 9> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_SC_AtomicCounter          : I32EnumAttrCase<"AtomicCounter", 10> {
-  list<Availability> availability = [
+  let availability = [
     Capability<[SPV_C_AtomicStorage]>
   ];
 }
 def SPV_SC_Image                  : I32EnumAttrCase<"Image", 11>;
 def SPV_SC_StorageBuffer          : I32EnumAttrCase<"StorageBuffer", 12> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_KHR_storage_buffer_storage_class, SPV_KHR_variable_pointers]>,
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_SC_CallableDataNV         : I32EnumAttrCase<"CallableDataNV", 5328> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_ray_tracing]>,
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 def SPV_SC_IncomingCallableDataNV : I32EnumAttrCase<"IncomingCallableDataNV", 5329> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_ray_tracing]>,
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 def SPV_SC_RayPayloadNV           : I32EnumAttrCase<"RayPayloadNV", 5338> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_ray_tracing]>,
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 def SPV_SC_HitAttributeNV         : I32EnumAttrCase<"HitAttributeNV", 5339> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_ray_tracing]>,
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 def SPV_SC_IncomingRayPayloadNV   : I32EnumAttrCase<"IncomingRayPayloadNV", 5342> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_ray_tracing]>,
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 def SPV_SC_ShaderRecordBufferNV   : I32EnumAttrCase<"ShaderRecordBufferNV", 5343> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_NV_ray_tracing]>,
     Capability<[SPV_C_RayTracingNV]>
   ];
 }
 def SPV_SC_PhysicalStorageBuffer  : I32EnumAttrCase<"PhysicalStorageBuffer", 5349> {
-  list<Availability> availability = [
+  let availability = [
     Extension<[SPV_EXT_physical_storage_buffer, SPV_KHR_physical_storage_buffer]>,
     Capability<[SPV_C_PhysicalStorageBufferAddresses]>
   ];
 }
 
 def SPV_StorageClassAttr :
     SPV_I32EnumAttr<"StorageClass", "valid SPIR-V StorageClass", [
       SPV_SC_UniformConstant, SPV_SC_Input, SPV_SC_Uniform, SPV_SC_Output,

 // 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 = []> :
-    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>
-       ])> {
-  // Availability specification for this op itself.
-  list<Availability> availability = [
-    MinVersion<SPV_V_1_0>,
-    MaxVersion<SPV_V_1_5>,
-    Extension<[]>,
-    Capability<[]>
-  ];
-
+    Op<SPIRV_Dialect, mnemonic, traits> {
   // For each SPIR-V op, the following static functions need to be defined
   // in SPVOps.cpp:
   //
   // * static ParseResult parse<op-c++-class-name>(OpAsmParser &parser,
   //                                               OperationState &result)
   // * static void print(OpAsmPrinter &p, <op-c++-class-name> op)
   // * static LogicalResult verify(<op-c++-class-name> op)
   let parser = [{ return ::parse$cppClass(parser, result); }];

mlir/include/mlir/IR/OpBase.td

 // StrConcat<["a", "b", "c"]>.result
 //
 // to get the string "abc"
 class StrFunc<string r> {
   string result = r;
 }
 
 //===----------------------------------------------------------------------===//
+// Forward declarations
+//===----------------------------------------------------------------------===//
+
+class Availability;
+
+//===----------------------------------------------------------------------===//
 // Predicate definitions
 //===----------------------------------------------------------------------===//
 
 // Base class for logical predicates.
 //
 // Predicates are used to compose constraints (see next section for details).
 // There are two categories of predicates:
 //
class EnumAttrCaseInfo<string sym, int intVal, string strVal> {
 
   // The C++ enumerant value.
   // If less than zero, there will be no explicit discriminator values assigned
   // to enumerators in the generated enum class.
   int value = intVal;
 
   // The string representation of the enumerant. May be the same as symbol.
   string str = strVal;
+
+  // The list of availability classes controlling this case's availability.
+  list<Availability> availability = ?;
 }
 
 // An enum attribute case stored with StringAttr.
 class StrEnumAttrCase<string sym, int val = -1> :
     EnumAttrCaseInfo<sym, val, sym>,
     StringBasedAttr<
       CPred<"$_self.cast<::mlir::StringAttr>().getValue() == \"" # sym # "\"">,
       "case " # sym>;
class Op<Dialect dialect, string mnemonic, list<OpTrait> props = []> {
 
   // 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;
 
+  // The list of availability classes controlling this op's availability.
+  list<Availability> availability = ?;
+
   // Additional code that will be added to the public part of the generated
   // C++ code of the op declaration.
   code extraClassDeclaration = ?;
 }
 
 // Base class for ops with static/dynamic offset, sizes and strides
 // attributes/arguments.
 class BaseOpWithOffsetSizesAndStrides<Dialect dialect, string mnemonic,

mlir/test/Dialect/SPIRV/IR/availability.mlir

 // RUN: mlir-opt -mlir-disable-threading -test-spirv-op-availability %s | FileCheck %s
 
 // CHECK-LABEL: iadd
 func @iadd(%arg: i32) -> i32 {
-  // CHECK: min version: v1.0
-  // CHECK: max version: v1.5
-  // CHECK: extensions: [ ]
-  // CHECK: capabilities: [ ]
+  // CHECK-NOT: min version
+  // CHECK-NOT: max version
+  // CHECK-NOT: extensions
+  // CHECK-NOT: capabilities
   %0 = spv.IAdd %arg, %arg: i32
   return %0: i32
 }
 
-// CHECK: atomic_compare_exchange_weak
+// CHECK-LABEL: atomic_compare_exchange_weak
 func @atomic_compare_exchange_weak(%ptr: !spv.ptr<i32, Workgroup>, %value: i32, %comparator: i32) -> i32 {
   // CHECK: min version: v1.0
   // CHECK: max version: v1.3
   // CHECK: extensions: [ ]
   // CHECK: capabilities: [ [Kernel] ]
   %0 = spv.AtomicCompareExchangeWeak "Workgroup" "Release" "Acquire" %ptr, %value, %comparator: !spv.ptr<i32, Workgroup>
   return %0: i32
 }
 
 // CHECK-LABEL: subgroup_ballot
 func @subgroup_ballot(%predicate: i1) -> vector<4xi32> {
   // CHECK: min version: v1.3
   // CHECK: max version: v1.5
   // CHECK: extensions: [ ]
   // CHECK: capabilities: [ [GroupNonUniformBallot] ]
   %0 = spv.GroupNonUniformBallot Workgroup %predicate : vector<4xi32>
   return %0: vector<4xi32>
 }
 
 // CHECK-LABEL: module_logical_glsl450
 func @module_logical_glsl450() {
-  // CHECK: spv.module min version: v1.0
-  // CHECK: spv.module max version: v1.5
+  // CHECK-NOT: spv.module min version
+  // CHECK-NOT: spv.module max version
   // CHECK: spv.module extensions: [ ]
   // CHECK: spv.module capabilities: [ [Shader] ]
   spv.module Logical GLSL450 { }
   return
 }
 
 // CHECK-LABEL: module_physical_storage_buffer64_vulkan
 func @module_physical_storage_buffer64_vulkan() {
-  // CHECK: spv.module min version: v1.0
-  // CHECK: spv.module max version: v1.5
+  // CHECK-NOT: spv.module min version
+  // CHECK-NOT: spv.module max version
   // CHECK: spv.module extensions: [ [SPV_EXT_physical_storage_buffer, SPV_KHR_physical_storage_buffer] [SPV_KHR_vulkan_memory_model] ]
   // CHECK: spv.module capabilities: [ [PhysicalStorageBufferAddresses] [VulkanMemoryModel] ]
   spv.module PhysicalStorageBuffer64 Vulkan { }
   return
 }

mlir/tools/mlir-tblgen/EnumsGen.cpp

 //===----------------------------------------------------------------------===//
 // Enum Availability Query AutoGen
 //===----------------------------------------------------------------------===//
 
 // Returns the availability spec of the given `def`.
 static std::vector<Availability> getAvailabilities(const llvm::Record &def) {
   std::vector<Availability> availabilities;
 
-  if (def.getValue("availability")) {
+  if (def.getValue("availability") && !def.isValueUnset("availability")) {
     std::vector<llvm::Record *> availDefs =
         def.getValueAsListOfDefs("availability");
     availabilities.reserve(availDefs.size());
     for (const llvm::Record *avail : availDefs)
       availabilities.emplace_back(avail);
   }
 
   return availabilities;

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

for (auto &it : interfaceEffects) {
     }
   }
 }
 
 // Returns the availability spec of the given `def`.
 static std::vector<Availability> getAvailabilities(const llvm::Record &def) {
   std::vector<Availability> availabilities;
 
-  if (def.getValue("availability")) {
+  if (def.getValue("availability") && !def.isValueUnset("availability")) {
     std::vector<llvm::Record *> availDefs =
         def.getValueAsListOfDefs("availability");
     availabilities.reserve(availDefs.size());
     for (const llvm::Record *avail : availDefs)
       availabilities.emplace_back(avail);
   }
 
   return availabilities;
default:
       opClass.addTrait("::mlir::OpTrait::NOperands<" + Twine(numOperands) +
                        ">::Impl");
       break;
     }
   }
 
   // Add the native and interface traits.
   for (const auto &trait : op.getTraits()) {
-    if (auto opTrait = dyn_cast<tblgen::NativeTrait>(&trait))
+    if (const auto *opTrait = dyn_cast<tblgen::NativeTrait>(&trait))
       opClass.addTrait(opTrait->getFullyQualifiedTraitName());
-    else if (auto opTrait = dyn_cast<tblgen::InterfaceTrait>(&trait))
+    else if (const auto *opTrait = dyn_cast<tblgen::InterfaceTrait>(&trait))
       opClass.addTrait(opTrait->getFullyQualifiedTraitName());
   }
+
+  // Add availability interfact traits.
+  llvm::DenseSet<const llvm::Record *> availClasses;
+
+  // Add availability requirements from the op itself.
+  for (const Availability &avail : getAvailabilities(op.getDef()))
+    availClasses.insert(avail.getDef());
+
+  // Add availability requirements from its attributes.
+  for (const NamedAttribute &namedAttr : op.getAttributes()) {
+    const auto *enumAttr = llvm::dyn_cast<EnumAttr>(&namedAttr.attr);
+    if (!enumAttr)
+      continue;
+
+    for (const EnumAttrCase &enumerant : enumAttr->getAllCases())
+      for (const Availability &caseAvail :
+           getAvailabilities(enumerant.getDef()))
+        availClasses.insert(caseAvail.getDef());
+  }
+
+  for (const auto *a : availClasses) {
+    Availability avail(a);
+    opClass.addTrait(formatv("{0}::{1}::Trait",
+                             avail.getInterfaceClassNamespace(),
+                             avail.getInterfaceClassName()));
+  }
 }
 
 void OpEmitter::genOpNameGetter() {
   auto *method = opClass.addMethodAndPrune(
       "::llvm::StringLiteral", "getOperationName",
       OpMethod::Property(OpMethod::MP_Static | OpMethod::MP_Constexpr));
   method->body() << "  return ::llvm::StringLiteral(\"" << op.getOperationName()
                  << "\");";

mlir/utils/spirv/gen_spirv_dialect.py

def get_availability_spec(enum_case, capability_mapping, for_op, for_cap):
   # For ops, because we have a default in SPV_Op class, omit if the spec
   # is the same.
   if (min_version or max_version or caps or exts) and not (
       for_op and min_version == DEFAULT_MIN_VERSION and
       max_version == DEFAULT_MAX_VERSION and caps == DEFAULT_CAP and
       exts == DEFAULT_EXT):
     joined_spec = ',\n    '.join(
         [e for e in [min_version, max_version, exts, caps] if e])
-    avail = '{} availability = [\n    {}\n  ];'.format(
-        'let' if for_op else 'list<Availability>', joined_spec)
+    avail = 'let availability = [\n    {}\n  ];'.format(joined_spec)
 
   return '{}{}{}'.format(implies, '\n  ' if implies and avail else '', avail)
 
 
 def gen_operand_kind_enum_attr(operand_kind, capability_mapping):
   """Generates the TableGen EnumAttr definition for the given operand kind.
 
   Returns: