[mlir] Graduate op availability to OpBase.td

[antiagainst]

Summary

This commit starts graduating op availability mechanisms
from the SPIR-V dialect into the core.

Op availability was designed in the beginning to be
flexible and extensible, so to support dialects with
versioning/availability requirements. It was prototyped
in the SPIR-V dialect and has been proven to work well
thus far. The prototype was written to be as detached
from SPIR-V as possible, in order to make graduation
easy.

See the RFCs for op availability:
https://groups.google.com/a/tensorflow.org/g/mlir/c/UinSwMkz5Fg/m/n6eNM0NiAwAJ
https://llvm.discourse.group/t/graduate-op-versioning-mechanism-to-opbase-td/3507

Depends on D108312

[jpienaar]

This seems like it is missing directed tests and documentation.

[antiagainst]

In D107846#2937526, @jpienaar wrote:

This seems like it is missing directed tests and documentation.

Yup. I added tests in a following up patch (https://reviews.llvm.org/D107851). Trying to make this patch mostly just shuffling code around so easier to review. I'll have another patch for the documentation. :)

[jpienaar]

mlir/include/mlir/IR/OpBase.td

2305

When would we have multiple? This seems like Availability is an interface and so could have been defined in interfaces instead of OpBase. Why isn't it?

Esp if you allow specifying an interfaceName that implies to me there isn't just one and it should probably not be in OpBase.

[rriddle]

Can you move the docs into this revision? It is a little hard to understand how these components are supposed to connect together which is making some parts a little more difficult to review.

mlir/include/mlir/IR/OpBase.td

2305

Yeah, do we actually need to move any of this into OpBase? This would be a good time to start decentralizing this file.

As to Jacques point, why couldn't this be defined like a normal interface?

[antiagainst]

Address comments

[antiagainst]

In D107846#2949908, @rriddle wrote:

Can you move the docs into this revision? It is a little hard to understand how these components are supposed to connect together which is making some parts a little more difficult to review.

I've added the doc in https://reviews.llvm.org/D108313. I can merge from this one up to D108313 if that's prefered. Let me know. :)

mlir/include/mlir/IR/OpBase.td

2305

Availability is a layer on top of op interface; it generates more stuff than just the op interface. The concrete implementation of those interface methods are automatically synthesized; if availability is attached to enum attributes, helper functions for querying them can also be generated. I've added the doc in https://reviews.llvm.org/D108313 so hopefully that will make things clearer.

When would we have multiple?

Actually MinVersionBase and MaxVersionBase are already two different interfaces. (We need to further customize them with a dialect-specific versioning scheme though given each dialect can have different versioning schemes.) In SPIR-V, I additionally have Extension and Capability. These are four different interfaces, each with its own way.

[rriddle]

In D107846#2952908, @antiagainst wrote:

In D107846#2949908, @rriddle wrote:

Can you move the docs into this revision? It is a little hard to understand how these components are supposed to connect together which is making some parts a little more difficult to review.

I've added the doc in https://reviews.llvm.org/D108313. I can merge from this one up to D108313 if that's prefered. Let me know. :)

Thanks! Can you roll that into this commit? I find the code easier for me to review alongside the docs.

[antiagainst]

Merge everything into one patch

[antiagainst]

Thanks! Can you roll that into this commit? I find the code easier for me to review alongside the docs.

Sure thing. Done now.

[antiagainst]

Add more docs

[mehdi_amini]

What would this look like without being a first class ODS concept?
I mean: this seems like just some sugar on top of interfaces, but how much sugar is there? Could this be less intrusive in ODS itself by exposing C++ helpers and reusing existing ODS concepts?

mlir/docs/OpDefinitions.md

950

so must does not seem grammatically correct to me here, can you reformulate?

956

I don't think "the _availability_ of ops" is all there is about: the characteristics of an op can evolve as well. An attribute can be added or removed, or some attributes values that were previously valid becomes invalid and vice versa.

(here despite the italic, I read "availability of ops" as an English sentence and not as the MLIR specific meaning of "availability").

959

966

1016

Can you add extensive comments in the TableGen code here describing what is each things' purpose and effects?
I can follow, but someone less MLIR savvy may be quickly lost.

1143

[mehdi_amini]

Also: the doc does not seem complete enough to me right now. It does not seem enough for figuring out how to develop a versioning strategy for a dialect, maybe mostly because other than describing some internals and the interface generated, it does not really tell me what do we do with the generated code then?

[antiagainst]

Address comments

[antiagainst]

What would this look like without being a first class ODS concept?
I mean: this seems like just some sugar on top of interfaces, but how much sugar is there? Could this be less intrusive in ODS itself by exposing C++ helpers and reusing existing ODS concepts?

It actually generates a lot more than just the op interface. There are basically there components generated: 1) C++ op interface, 2) concrete C++ impl methods for all ops for every interface, and 3) utility functions for enum attribute. 2) is the major part: each op can have different versioning/capability/extension requirements so each op will have a different impl of every op interface. Taking SPIR-V as an example, a large portion of ops have requirements wrt MinVersion/MaxVersion/Capability/Extension. That's a lot of code to implement (several thousands LOC). Defining it in ODS allows us to have a single source of truth and avoid all those boilerplate. Updating is also trivial given we can just read in the spec and automatically adjust everything. So no manual work here basically (other than running a shell command). :)

Also: the doc does not seem complete enough to me right now. It does not seem enough for figuring out how to develop a versioning strategy for a dialect, maybe mostly because other than describing some internals and the interface generated, it does not really tell me what do we do with the generated code then?

Good catch! Thanks for pointing it out! I tired to lay out the doc in a progressive way and focus on explaining general concepts and then how to use. The details of generated code actually are explained in the very last, if the reader is interested to define its own availability control. But I guess due to the large amount of details under the hood and some of them are necessary to understand the ideas, it can lose focus. So I refined many aspects and included a summary subsection to recap what's needed for using the versioning mechanism, which is also how one use whatever availability controls. Let me know if this is better. :)

mlir/docs/OpDefinitions.md

956

I see your points here. Revised to explain more w.r.t. it.

[antiagainst]

Refine a bit more

[mehdi_amini]

It actually generates a lot more than just the op interface. There are basically there components generated: 1) C++ op interface, 2) concrete C++ impl methods for all ops for every interface, and 3) utility functions for enum attribute. 2) is the major part: each op can have different versioning/capability/extension requirements so each op will have a different impl of every op interface. Taking SPIR-V as an example, a large portion of ops have requirements wrt MinVersion/MaxVersion/Capability/Extension. That's a lot of code to implement (several thousands LOC). Defining it in ODS allows us to have a single source of truth and avoid all those boilerplate.

It still isn't clear to me here: the concrete C++ could be delegated to other mechanism and still be defined in ODS. For example using derived attribute to expose the availability of an operation.
Yes what you're proposing is adding sugar, but I'd like to see the alternative design which would be using as much existing ODS feature as possible before we actually change ODS itself.

[antiagainst]

It still isn't clear to me here: the concrete C++ could be delegated to other mechanism and still be defined in ODS. For example using derived attribute to expose the availability of an operation.
Yes what you're proposing is adding sugar, but I'd like to see the alternative design which would be using as much existing ODS feature as possible before we actually change ODS itself.

Coming back to this. Thanks for the comment, Mehdi! Trying to understand your point and make sure I answer properly. Is the concern about introducing new ODS mechanisms?

My take on whether we should introduce mechanisms is depending on

• how common it is across multiple dialects,
• how much leverage we can have by introducing it.

What version/capability/etc. an op require is not as ubiquitous as op/attribute/etc., but they are common enough (esp. for edge dialects) to have its own modelling and definition. Having that improves consistency across dialects needing it and also brings benefits for better readability/understandability/knowledge transfer/etc.. For the second point, a separate availability concept really drives generating lots of boilerplate C++ code across multiple components (which I explained before), as we can just customize the C++ code generation anchoring on it. Using other mechanisms not designed for this purpose means we need to piggyback/shorehorn in various ways. It's not a clear representation and could be a maintenance burden for other mechanisms too.

Specifically I've checked derived attribute, but I'm not sure that's the suitable mechanism for supporting the availability for the following reasons:

• Derived attribute itself is already one level of interface. Using it for availability will mean we are effectively creating "interfaces" inside interfaces. IMO that's not the proper representation for a common concept like availability.
• Also with this nested level of "interfaces", we are trying to create structures inside the derived attribute itself: all ops will need to have the same exact named attribute and querying will first go through the derived attribute interface symbol DerivedAttributeOpInterface and then a strings like (isDerivedAttribute("min_version")/isDerivedAttribute("max_version")), instead of just one level QueryMinVersionInterface/QueryMaxVersionInterface symbol. I think one of the goals of ODS is to drive C++ code generation to reduce this stringish representations as they are hard to check/validate. So we use ODS to define ops instead of checking their string names in C++. One could argue it's similar here.
• Derived attribute requires having DerivedAttr on the op itself, with some code body embedded. That can introduce a lot of duplication and make it hard for readability. For example, many SPIR-V ops have multiple availability dimensions. It would mean defining multiple extra DerivedAttr on it like

def SPV_SomeOp ... {
  DerivedTypeAttr min_version = DerivedTypeAttr<"::mlir::spirv::Version", "<calling into some separately generated C++ utility function to compute as we cannot inline here given it's too complicated>">,
  DerivedTypeAttr max_version = DerivedTypeAttr<"::mlir::spirv::Version", "...">
  DerivedTypeAttr capabilities = DerivedTypeAttr<"::llvm::SmallVector<::llvm::ArrayRef<::mlir::spirv::Capability>, 1>", "...">
  DerivedTypeAttr extensions = DerivedTypeAttr<"::llvm::SmallVector<::llvm::ArrayRef<::mlir::spirv::Extension>, 1>", "...">
}

I find it hard to compare with the simplicity and conciseness of the following:

let availability = [
  MinVersion<SPV_V_1_3>,
  MaxVersion<SPV_V_1_5>,
  Extension<[]>,
  Capability<[SPV_C_GroupNonUniformBallot]>
];

Note that that above differs at a per-op level, as different ops have different requirements on version/capability/extension/etc.

• Derived attribute interface is for ops and it cannot be used on attributes. In SPIR-V it's fairly common to have enums values requiring different version/capability/etc. Being able to attach that directly on the attribute is better for representation and avoids lots of duplication (in all user ops).

I also checked other existing ODS mechanisms and I don't find other good hosts to handle the problem here. (But I might miss something so recommendations certainly welcome!) The goal is to generate all those boilerplate C++ code so that we have one concise single source of truth in ODS. I think even we can probably piggyback/shorehorn different components on different mechanisms, it looks a disintegrated solution that will cause confusion and maintenance burden: folks will have difficulty to understand how everything fits together and that means harder to debug/improve/etc.

What's introduced in ODS is really quite well isolated. Aside from the main Availability and the MinVersionBase/MaxVersionBase definitions, we just need one additional field on the op and the enum attribute. They defaults to none and it won't affect folks don't care about it at all.

Hopefully this addresses the concerns. Otherwise feel free to let me know where I should explain/improve more. Thanks. :)

[mehdi_amini]

. Is the concern about introducing new ODS mechanisms?

I would say it this way: the concern is about introducing ODS mechanisms instead of building on top of ODS and by composition of existing mechanisms. I believe that this can easily lead to bloating ODS (which is already a complex and not always consistent system), when we'd better modularize and make it possible to build on top of it.

There is also an aspect of maturity: I'm not sure how widespread the concept of "availability" is (you mention edge, we but don't even have a handful of examples right now) and it isn't clear to me that the requirements are clear enough to make it a feature that will work for everyone. It is easy to anchor to one example and provide something that does not generalize to what's needed.

def SPV_SomeOp ... {

DerivedTypeAttr min_version = DerivedTypeAttr<"::mlir::spirv::Version", "<calling into some separately generated C++ utility function to compute as we cannot inline here given it's too complicated>">,
DerivedTypeAttr max_version = DerivedTypeAttr<"::mlir::spirv::Version", "...">
DerivedTypeAttr capabilities = DerivedTypeAttr<"::llvm::SmallVector<::llvm::ArrayRef<::mlir::spirv::Capability>, 1>", "...">
DerivedTypeAttr extensions = DerivedTypeAttr<"::llvm::SmallVector<::llvm::ArrayRef<::mlir::spirv::Extension>, 1>", "...">

}
I find it hard to compare with the simplicity and conciseness of the following:

let availability = [

MinVersion<SPV_V_1_3>,
MaxVersion<SPV_V_1_5>,
Extension<[]>,
Capability<[SPV_C_GroupNonUniformBallot]>

];

Right, that's the kind of examples I'm after. So you showed how to do it inline with DerivedTypeAttr fully specified here. But can this be refactored?
I would expect that (without much change to ODS) we could get to a syntax that would look like:

def SPV_SomeOp : MinVersion<SPV_V_1_3>, MaxVersion<SPV_V_1_4> {
 ...
}

where MinVersion and MaxVersion would be parent classes defining the right derived attribute and hiding the C++ boilerplate.

Similarly for arguments, we have something to annotate them with "decorators" right now, for example the MemRead here:

let arguments = (ins 
    Arg<AnyMemRef, "the reference to load from", [MemRead]>:$base,

I would look into generic extension to such mechanism before adding anything first class for availability.

[chhe]

Any update on this?

mlir/docs/OpDefinitions.md

 long-tail cases that won't be covered. For such cases, you can use
 `extraClassDeclaration`. Code in `extraClassDeclaration` will be copied
 literally to the generated C++ op class.
 
 Note that `extraClassDeclaration` is a mechanism intended for long-tail cases by
 power users; for not-yet-implemented widely-applicable cases, improving the
 infrastructure is preferable.
 
+### Op availability
+
+The form/semantics of an op evolve over time. For a dialect that is used in the
+middle of conversion flows, its ops are meant to facilitate the conversion,
+so backward/forward compatibility is not a main concern. For an edge dialect
+that model some external programming model or hardware, its ops are subject to
+the same backward/forward compatibility requirements as what they model.
+For example, if some accelerator adds a fast convolution implementation in
+the second generation, we can introduce an dedicated convolution op for it.
+But it can only be used to target the second generation and forward.
+
+The typical mechanism to define such compatibility requirements is _versioning_.
+We can specify the minimal/maximal version under which an op are available.
+But there are other ways for controlling compatibility. For example, in SPIR-V,
+some ops are available only under certain _capabilities_ or _extensions_. If a
+program uses ops that require capabilities/extensions missing in the execution
+environment, it's not compatible.
+
+Generally, these are all _availability_ control mechanisms. MLIR uses a generic
+mechanism to support op availability.
+
+Note that an op may evolve in arbitrary ways. For example, its operands can
+support a new type; it can introduce/deprecate some attriubte; its existing enum
+attribute may support a new case that require special hardware capability.
+Still, they all manifest via whether an _dynamic_ op instance is available for
+certain compilation target, because ops are the most basic component for
+MLIR conversion. So we call the generic mechanism as op availability in MLIR.
+
+Op availability is integrated into ODS and tries to follow the same declarative
+manner and auto-generate as much code as possible. Under the hood the generated
+code uses core mechanisms including op interfaces, op traits, etc. Effectively
+it's a layer on top of them, so it offer similar extensibility. The choice of
+ODS integration additionally offers single source of truth to drive lots of
+boilerplate code generation, across op interfaces, op definitions, and attribute
+utility functions, that are cumbersome or difficult to write manually.
+
+As mentioned before, an op's form/semantics can change arbitrarily. One can
+define a v2 version of an op with vastly different semantics and parameters.
+It might even make sense to just introduce another op if the difference is too
+large. Op availability mechanism cannot support all cases. Instead, it is meant
+to cover common cases where we want to still have one op:
+
+MLIR op availability allows to attach controls to different parts of an op.
+Then for a concrete op instance, availability for all parts are considered
+to derive a final availability requirements for the instance. This allows us to
+keep information where it suits best and potentially share across ops (e.g.,
+specifying availability on enum attribute cases immediately enables
+availability control on all ops containing the enum attribute).
+
+Right now the following places can have availability specification attached:
+
+*   The op itself: to support cases where the opcode is present or missing
+    depending on the version/etc.
+*   Enum attribute case: to suppport cases where op instances using the enum
+    case requires special version/etc.
+
+Supporting for the following places might be supported later:
+
+*   Op operands/results: to support cases where operands/results have different
+    existence and type support in different versions/etc.
+*   Op attributes: to support cases where attributes have different existence
+    in different versions/etc.
+
+Again, the goal is to support common use cases where we still want to have one
+op. So it is intentionally conservative.
+
+If an op has availability controls in any of the above places, the following
+corresponding components can be generated from `mlir-tblgen`:
+
+*   Op interface for the availability: via `-gen-avail-interface-decls` and
+    `-gen-avail-interface-defs`.
+*   Op interface method implementation: via `-gen-op-defs`.
+*   Enum availability query utility functions: via `-gen-enum-avail-decls` and
+    `-gen-enum-avail-defs`.
+
+Next we explain how to use op availability with examples.
+
+#### MinVersion and MaxVersion
+
+It's quite common to see minimal/maximal version requirements on ops. To help
+with this common use case, `MinVersionBase` and `MaxVersionBase` are defined in
+[`OpBase.td`][OpBase]. It allows us to plug in a dialect-specific versioning
+scheme, defined as an `I32EnumAttr`. For example,
+
+```tablegen
+// Define all the known versions for an example dialect.
+def Example_V_1_0 : I32EnumAttrCase<"V_1_0", 0, "v1.0">;
+def Example_V_1_1 : I32EnumAttrCase<"V_1_1", 1, "v1.1">;
+def Example_V_1_2 : I32EnumAttrCase<"V_1_2", 2, "v1.2">;
+def Example_V_1_3 : I32EnumAttrCase<"V_1_3", 3, "v1.3">;
+def Example_V_1_4 : I32EnumAttrCase<"V_1_4", 3, "v1.4">;
+
+// Define an IntegerAttr-backed enum attribute including all known versions.
+def Example_VersionAttr : I32EnumAttr<"Version", "supported versions", [
+    Example_V_1_0, Example_V_1_1, Example_V_1_2, Example_V_1_3, Example_V_1_4]>;
+
+// Define the MinVersion class. It takes a concrete version (which is an enum
+// attribute case) to use.
+class Example_MinVersion<I32EnumAttrCase min> : MinVersionBase<
+    "ExampleQueryMinVersionInterface", Example_VersionAttr, min> {
+  // Specify some description for the generated C++ op interface.
+  let interfaceDescription = [{
+    Querying interface for minimal required version.
+  }];
+  // Specify the namespace for the generated C++ op interface.
+  let interfaceNamespace = "::mlir::example";
+  // MinVersionBase provides defaults for other fields; you can also customize
+  // them. See the definition of MinVersionBase for details.
+}
+
+// Similarly for MaxVersion.
+class Example_MaxVersion<I32EnumAttrCase max> : MaxVersionBase<
+    "ExampleQueryMaxVersionInterface", Example_VersionAttr, max> {
+  let interfaceDescription = [{
+    Querying interface for maximal supported version.
+  }];
+  let interfaceNamespace = "::mlir::example";
+}
+```
+
+The above defines min and max version requirements for some `example` dialect.
+With `mlir-tblgen -gen-avail-interface-{decls|defs}`, two op interfaces are
+generated from the above: `mlir::example::ExampleQueryMinVersionInterface` and
+`mlir::example::ExampleQueryMaxVersionInterface`. They have a `getMinVersion()`
+and `getMaxVersion()` method, respectively, for querying the minimal version and
+maximal version requirements for all ops implementing them.
+
+Then we can use them in ops for the `example` dialect:
+
+```tablegen
+def Example_MinMaxVersionOp : Example_Op<"min_max_version_op"> {
+  // ...
+  let availability = [
+    Example_MinVersion<Example_V_1_0>,
+    Example_MaxVersion<Example_V_1_3>
+  ];
+}
+```
+
+The above defines an `example.min_max_version_op` that is introduced in v1.0 and
+removed since v1.4. And that's all we need to do for defining the versioning.
+`example.min_max_version_op`s' ODS is the single source containing the versioning
+information; the rest are automatically generated.
+
+Concretely, there is no need to manually include the
+`mlir::example::EampleQuery{Min|Max}VersionInterface::Trait` in the op trait
+list or implement the `get{Min|Max}Version()` method; they are auto inserted or
+generated when invoking `mlir-tblgen -gen-op-defs`.
+
+For the above op, `getMinVersion()` will always return
+`mlir::example::Version::V_1_0`, and `getMaxVersion()` will always return
+`mlir::example::Version::V_1_3`.
+
+The op interface and the automatically synthesized concrete implementation can
+then be used with other MLIR mechanisms. For example, we can cast a generic
+`mlir::Operation` pointer `example::ExampleQueryMinVersionInterface` and
+check its `getMinVersion()` to decide if it's allowed in the target. This gives
+a generic way to handle all versioned ops in the `example` dialect during
+conversion!
+
+We can also attach version controls on enum attributes:
+
+```tablegen
+def Example_VersionedEnumCaseA : I32EnumAttrCase<"A", 0> {
+  // No version requirements.
+}
+def Example_VersionedEnumCaseB : I32EnumAttrCase<"B", 1> {
+  // Removed since v1.3.
+  let availability = [Example_MaxVersion<Example_V_1_2>];
+}
+def Example_VersionedEnumCaseC : I32EnumAttrCase<"C", 2> {
+  // Added since v1.1.
+  let availability = [Example_MinVersion<Example_V_1_1>];
+}
+
+def Example_VersionedEnumAttr : I32EnumAttr<"VersionedEnum", "valid enum cases", [
+  VersionedEnumCaseA, VersionedEnumCaseB, VersionedEnumCaseC]> {
+  let cppNamespace = "::mlir::example";
+}
+
+def Example_OneVersionedAttrOp : Example_Op<"one_versioned_attr_op"> {
+  let arguments = (ins Example_VersionedEnumAttr:$attr);
+let results = (outs);
+}
+
+def Example_MixVersionedAttrOp : Example_Op<"mix_versioned_attr_op"> {
+  let arguments = (ins
+    Example_VersionedEnumAttr:$attr1,
+    Example_VersionedEnumAttr:$attr2,
+    ...
+  );
+  let results = (outs ...);
+
+  let availability = [
+    Example_MinVersion<Example_V_1_0>,
+    Example_MaxVersion<Example_V_1_3>
+  ];
+}
+```
+
+The above will need `mlir-tblgen -gen-enum-avail-{decls|defs}` to generate the
+utility functions for generated C++ enums:
+
+```c++
+llvm::Optional<mlir::example::Version> getMaxVersion(
+  mlir::example::VersionedEnum value);
+llvm::Optional<mlir::example::Version> getMinVersion(
+  mlir::example::VersionedEnum value);
+```
+
+`example.one_versioned_attr_op` does not have versioning itself; but because it
+has an enum attribute that subjects to versioning, it will still automatically
+declare and implement the min/max version interface. But here the returned
+version depends on the concrete `example.one_versioned_attr_op` instance. For
+example, `example.one_versioned_attr_op attr=A` will have `getMinVersion()` and
+`getMaxVersion()` to be both `llvm::None`. If `attr=B` then they are
+`llvm::None` and `mlir::example::Version::V_1_2`. Similarly, if `attr=C` then
+they are `mlir::example::Version::V_1_1` and `llvm::None`.
+
+`example.mix_versioned_attr_op` has version controls on both itself and two of
+its attributes. The final min/max version takes consideration of all pieces.
+`attr1=A, attr2=B` will have min/max version as v1.0/v1.2. `attr1=A, attr2=C`
+will have min/max version as v1.1/v1.3. `attr1=B attr2=C` will have min/max
+version as v1.1/v1.2.
+
+##### Summary
+
+There are quite some details in the above. To recap and summarize what are
+needed to enable versioning:
+
+*   Define a versioning scheme as an `I32EnumAttr`.
+*   Annotate ops or enum attributes that has version requirements with
+    `let availability = [...]`.
+*   Generate the C++ op interface via `mlir-tblgen -gen-avail-interface-decls`
+    and `mlir-tblgen -gen-avail-interface-defs` and include them.
+*   Op interface method implementation will be generated with `mlir-tblgen
+    -gen-op-defs`. So no extra actions here.
+*   If you have version controls on enum attribute cases, then generate
+*   availability query utility functions via `mlir-tblgen -gen-enum-avail-decls`
+    and `mlir-tblgen -gen-enum-avail-defs` and include them.
+
+Afterwards all participating ops will implement the min/max interfaces and have
+theire concrete implementation synthesized. You can treat them like any ops
+implementing op interfaces, e.g., casting to the interface to query versions,
+check legality during dialect conversion, etc.
+
+#### Other availability controls
+
+Versioning is just one way to control availability. To support others, we can
+subclass `Availability`. It requires specifying a few fields for the generated
+interface and also logic for deducing final availability results from op
+components. Most importantly, we need to define `initializer` as the initial
+availability value before considering any part of the op, and `mergeAction` to
+specify how a new part's availability is merged into the current deduced
+imtermediate availability value.
+
+There is documentation in the `Availability` class itself. The definitions of
+`MinVersionBase`/`MaxVersionBase` can also serve as examples to show how
+everything works together. For `MinVersionBase`, we have the following
+definition:
+
+```tablegen
+class MinVersionBase<string name, I32EnumAttr scheme, I32EnumAttrCase min>
+    : Availability {
+  // ...
+  let queryFnRetType = "llvm::Optional<" # scheme.returnType # ">";
+  let queryFnName = "getMinVersion";
+
+  let mergeAction = "{ "
+    "if ($overall.hasValue()) { "
+      "$overall = static_cast<" # scheme.returnType # ">("
+                  "std::max(*$overall, $instance)); "
+    "} else { $overall = $instance; }}";
+  let initializer = "::llvm::None";
+}
+```
+
+It generates a method in the op interface with the following signature:
+
+```c++
+// <queryFnRetType> <queryFnName>()
+llvm::Optional<mlir::example::Version> getMinVersion();
+```
+
+The synthesized concrete implementation for `example.mix_versioned_attr_op` is:
+
+```c++
+llvm::Optional<mlir::example::Version> MixVersionedAttrOp::getMinVersion() {
+  // <initializer>
+  llvm::Optional<mlir::example::Version> tblgen_overall = ::llvm::None;
+  {
+    // <mergeAction>: versioning from the op itself
+    {
+      if (tblgen_overall.hasValue()) {
+        tblgen_overall = static_cast<mlir::example::Version>(
+          std::max(*tblgen_overall, mlir::example::Version::V_1_0));
+      } else {
+        tblgen_overall = mlir::example::Version::V_1_0;
+      }
+    };
+  }
+  {
+    auto tblgen_attrVal = this->attr1();
+    // Querying versioning requirements from the attribute
+    auto tblgen_instance = ::mlir::example::getMinVersion(tblgen_attrVal);
+    if (tblgen_instance) {
+      // <mergeAction>: versioning from attr1
+      if (tblgen_overall.hasValue()) { /* ... */ } else { /* ... */ }
+    };
+  }
+  {
+    auto tblgen_attrVal = this->attr2();
+    // Querying versioning requirements from the attribute
+    auto tblgen_instance = ::mlir::example::getMinVersion(tblgen_attrVal);
+    if (tblgen_instance) {
+      // <mergeAction>: versioning from attr1
+      if (tblgen_overall.hasValue()) { /* ... */ } else { /* ... */ }
+    };
+  }
+  return tblgen_overall;
+}
+```
+
+The generated utility methods for querying versioning requirements for
+attribute:
+
+```c++
+// <queryFnRetType> <queryFnName>()
+llvm::Optional<mlir::example::Version> getMinVersion(mlir::example::VersionedEnum value) {
+  switch (value) {
+  case mlir::example::VersionedEnum::C: {
+    // <instanceType>(<instance>)
+    return mlir::example::Version(mlir::example::Version::V_1_1);
+  }
+  default: break;
+  }
+  return llvm::None;
+}
+```
+
+In the above generated code, we use `<field-name>` to show how each field in the
+`Availability` class is used. Reading the source code of how the TableGen C++
+`Availability` wrapper is used and the direct output from `mlir-tblgen` can also
+give good hints over how to set them, if you'd like to define a custom
+availability control.
+
 ### Generated C++ code
 
 [OpDefinitionsGen][OpDefinitionsGen] processes the op definition spec file and
 generates two files containing the corresponding C++ code: one for declarations,
 the other for definitions. The former is generated via the `-gen-op-decls`
 command-line option, while the latter is via the `-gen-op-defs` option.
 
 The definition file contains all the op method definitions, which can be

mlir/include/mlir/Dialect/SPIRV/IR/CMakeLists.txt

 add_mlir_dialect(SPIRVOps spv)
 add_mlir_doc(SPIRVOps SPIRVOps Dialects/ -gen-op-doc)
 
 set(LLVM_TARGET_DEFINITIONS SPIRVBase.td)
 mlir_tablegen(SPIRVEnums.h.inc -gen-enum-decls)
 mlir_tablegen(SPIRVEnums.cpp.inc -gen-enum-defs)
 add_public_tablegen_target(MLIRSPIRVEnumsIncGen)
 add_dependencies(mlir-headers MLIRSPIRVEnumsIncGen)
 
 set(LLVM_TARGET_DEFINITIONS SPIRVBase.td)
-mlir_tablegen(SPIRVEnumAvailability.h.inc -gen-spirv-enum-avail-decls)
-mlir_tablegen(SPIRVEnumAvailability.cpp.inc -gen-spirv-enum-avail-defs)
+mlir_tablegen(SPIRVEnumAvailability.h.inc -gen-enum-avail-decls)
+mlir_tablegen(SPIRVEnumAvailability.cpp.inc -gen-enum-avail-defs)
 mlir_tablegen(SPIRVCapabilityImplication.inc -gen-spirv-capability-implication)
 add_public_tablegen_target(MLIRSPIRVEnumAvailabilityIncGen)
 add_dependencies(mlir-headers MLIRSPIRVEnumAvailabilityIncGen)
 
 set(LLVM_TARGET_DEFINITIONS SPIRVOps.td)
 mlir_tablegen(SPIRVAvailability.h.inc -gen-avail-interface-decls)
 mlir_tablegen(SPIRVAvailability.cpp.inc -gen-avail-interface-defs)
-mlir_tablegen(SPIRVOpAvailabilityImpl.inc -gen-spirv-avail-impls)
 add_public_tablegen_target(MLIRSPIRVAvailabilityIncGen)
 add_dependencies(mlir-headers MLIRSPIRVAvailabilityIncGen)
 
 set(LLVM_TARGET_DEFINITIONS SPIRVOps.td)
 mlir_tablegen(SPIRVSerialization.inc -gen-spirv-serialization)
 add_public_tablegen_target(MLIRSPIRVSerializationGen)
 add_dependencies(mlir-headers MLIRSPIRVSerializationGen)
 

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

-//===- SPIRVAvailability.td - Op Availability Base file ----*- tablegen -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef MLIR_DIALECT_SPIRV_IR_AVAILABILITY
-#define MLIR_DIALECT_SPIRV_IR_AVAILABILITY
-
-include "mlir/IR/OpBase.td"
-
-//===----------------------------------------------------------------------===//
-// Op availability definitions
-//===----------------------------------------------------------------------===//
-
-// The base class for defining op availability dimensions.
-class Availability {
-  // The following are fields for controlling the generated C++ OpInterface.
-
-  // The namespace for the generated C++ OpInterface subclass.
-  string cppNamespace = ?;
-  // The name for the generated C++ OpInterface subclass.
-  string interfaceName = ?;
-  // The documentation for the generated C++ OpInterface subclass.
-  string interfaceDescription = "";
-
-  // The following are fields for controlling the query function signature.
-
-  // The query function's return type in the generated C++ OpInterface subclass.
-  string queryFnRetType = ?;
-  // The query function's name in the generated C++ OpInterface subclass.
-  string queryFnName = ?;
-
-  // The following are fields for controlling the query function implementation.
-
-  // The logic for merging two availability requirements. This is used to derive
-  // the final availability requirement when, for example, an op has two
-  // operands and these two operands have different availability requirements.
-  //
-  // The code should use `$overall` as the placeholder for the final requirement
-  // and `$instance` for the current availability requirement instance.
-  code mergeAction = ?;
-  // The initializer for the final availability requirement.
-  string initializer = ?;
-  // An availability instance's type.
-  string instanceType = ?;
-
-  // The following are fields for a concrete availability instance.
-
-  // The code for preparing a concrete instance. This should be C++ statements
-  // and will be generated before the `mergeAction` logic.
-  code instancePreparation = "";
-  // The availability requirement carried by a concrete instance.
-  string instance = ?;
-}
-
-class MinVersionBase<string name, I32EnumAttr scheme, I32EnumAttrCase min>
-    : Availability {
-  let interfaceName = name;
-
-  let queryFnRetType = "llvm::Optional<" # scheme.returnType # ">";
-  let queryFnName = "getMinVersion";
-
-  let mergeAction = "{ "
-    "if ($overall.hasValue()) { "
-      "$overall = static_cast<" # scheme.returnType # ">("
-                  "std::max(*$overall, $instance)); "
-    "} else { $overall = $instance; }}";
-  let initializer = "::llvm::None";
-  let instanceType = scheme.cppNamespace # "::" # scheme.className;
-
-  let instance = scheme.cppNamespace # "::" # scheme.className # "::" #
-                 min.symbol;
-}
-
-class MaxVersionBase<string name, I32EnumAttr scheme, I32EnumAttrCase max>
-    : Availability {
-  let interfaceName = name;
-
-  let queryFnRetType = "llvm::Optional<" # scheme.returnType # ">";
-  let queryFnName = "getMaxVersion";
-
-  let mergeAction = "{ "
-    "if ($overall.hasValue()) { "
-      "$overall = static_cast<" # scheme.returnType # ">("
-                  "std::min(*$overall, $instance)); "
-    "} else { $overall = $instance; }}";
-  let initializer = "::llvm::None";
-  let instanceType = scheme.cppNamespace # "::" # scheme.className;
-
-  let instance = scheme.cppNamespace # "::" # scheme.className # "::" #
-                 max.symbol;
-}
-
-#endif // MLIR_DIALECT_SPIRV_IR_AVAILABILITY

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

 // for facilitating defining SPIR-V ops.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_SPIRV_IR_BASE
 #define MLIR_DIALECT_SPIRV_IR_BASE
 
 include "mlir/IR/OpBase.td"
-include "mlir/Dialect/SPIRV/IR/SPIRVAvailability.td"
 
 //===----------------------------------------------------------------------===//
 // SPIR-V dialect definitions
 //===----------------------------------------------------------------------===//
 
 def SPIRV_Dialect : Dialect {
   let name = "spv";
 
!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,

 }
 
 // The results of an op.
 class Results<dag rets> {
   dag results = rets;
 }
 
 //===----------------------------------------------------------------------===//
+// Availability definitions
+//===----------------------------------------------------------------------===//
+
+// The base class for defining op availability dimensions.
+class Availability {
+  // The following are fields for controlling the generated C++ OpInterface.
+
+  // The namespace for the generated C++ OpInterface subclass.
+  string cppNamespace = ?;
+  // The name for the generated C++ OpInterface subclass.
+  string interfaceName = ?;
+  // The documentation for the generated C++ OpInterface subclass.
+  string interfaceDescription = "";
+
+  // The following are fields for controlling the query function signature.
+
+  // The query function's return type in the generated C++ OpInterface subclass.
+  string queryFnRetType = ?;
+  // The query function's name in the generated C++ OpInterface subclass.
+  string queryFnName = ?;
+
+  // The following are fields for controlling the query function implementation.
+
+  // The logic for merging two availability requirements. This is used to derive
+  // the final availability requirement when, for example, an op has two
+  // operands and these two operands have different availability requirements.
+  //
+  // The code should use `$overall` as the placeholder for the final requirement
+  // and `$instance` for the current availability requirement instance.
+  code mergeAction = ?;
+  // The initializer for the final availability requirement.
+  string initializer = ?;
+  // An availability instance's type.
+  string instanceType = ?;
+
+  // The following are fields for a concrete availability instance.
+
+  // The code for preparing a concrete instance. This should be C++ statements
+  // and will be generated before the `mergeAction` logic.
+  code instancePreparation = "";
+  // The availability requirement carried by a concrete instance.
+  string instance = ?;
+}
+
+class MinVersionBase<string name, I32EnumAttr scheme, I32EnumAttrCase min>
+    : Availability {
+  let interfaceName = name;
+
+  let queryFnRetType = "llvm::Optional<" # scheme.returnType # ">";
+  let queryFnName = "getMinVersion";
+
+  let mergeAction = "{ "
+    "if ($overall.hasValue()) { "
+      "$overall = static_cast<" # scheme.returnType # ">("
+                  "std::max(*$overall, $instance)); "
+    "} else { $overall = $instance; }}";
+  let initializer = "::llvm::None";
+  let instanceType = scheme.cppNamespace # "::" # scheme.className;
+
+  let instance = scheme.cppNamespace # "::" # scheme.className # "::" #
+                 min.symbol;
+}
+
+class MaxVersionBase<string name, I32EnumAttr scheme, I32EnumAttrCase max>
+    : Availability {
+  let interfaceName = name;
+
+  let queryFnRetType = "llvm::Optional<" # scheme.returnType # ">";
+  let queryFnName = "getMaxVersion";
+
+  let mergeAction = "{ "
+    "if ($overall.hasValue()) { "
+      "$overall = static_cast<" # scheme.returnType # ">("
+                  "std::min(*$overall, $instance)); "
+    "} else { $overall = $instance; }}";
+  let initializer = "::llvm::None";
+  let instanceType = scheme.cppNamespace # "::" # scheme.className;
+
+  let instance = scheme.cppNamespace # "::" # scheme.className # "::" #
+                 max.symbol;
+}
+
+//===----------------------------------------------------------------------===//
 // Common value constraints
 //===----------------------------------------------------------------------===//
 
 def HasNoUseOf: Constraint<
     CPred<"$_self.use_empty()">, "has no use">;
 
 //===----------------------------------------------------------------------===//
 // Common op type constraints

mlir/include/mlir/TableGen/Availability.h

+//===- Availability.h - Availability wrapper class --------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Availability wrapper to simplify using TableGen Record defining a MLIR
+// Availability.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TABLEGEN_AVAILABILITY_H_
+#define MLIR_TABLEGEN_AVAILABILITY_H_
+
+#include "mlir/Support/LLVM.h"
+
+namespace llvm {
+class Record;
+} // end namespace llvm
+
+namespace mlir {
+namespace tblgen {
+
+// Wrapper class with helper methods for accessing availability defined in
+// TableGen.
+class Availability {
+public:
+  explicit Availability(const llvm::Record *def);
+
+  // Returns the name of the direct TableGen class for this availability
+  // instance.
+  StringRef getClass() const;
+
+  // Returns the generated C++ interface's class namespace.
+  StringRef getInterfaceClassNamespace() const;
+
+  // Returns the generated C++ interface's class name.
+  StringRef getInterfaceClassName() const;
+
+  // Returns the generated C++ interface's description.
+  StringRef getInterfaceDescription() const;
+
+  // Returns the name of the query function insided the generated C++ interface.
+  StringRef getQueryFnName() const;
+
+  // Returns the return type of the query function insided the generated C++
+  // interface.
+  StringRef getQueryFnRetType() const;
+
+  // Returns the code for merging availability requirements.
+  StringRef getMergeActionCode() const;
+
+  // Returns the initializer expression for initializing the final availability
+  // requirements.
+  StringRef getMergeInitializer() const;
+
+  // Returns the C++ type for an availability instance.
+  StringRef getMergeInstanceType() const;
+
+  // Returns the C++ statements for preparing availability instance.
+  StringRef getMergeInstancePreparation() const;
+
+  // Returns the concrete availability instance carried in this case.
+  StringRef getMergeInstance() const;
+
+  // Returns the underlying LLVM TableGen Record.
+  const llvm::Record *getDef() const { return def; }
+
+private:
+  // The TableGen definition of this availability.
+  const llvm::Record *def;
+};
+
+} // end namespace tblgen
+} // end namespace mlir
+
+#endif // MLIR_TABLEGEN_AVAILABILITY_H_

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

 
 // TableGen'erated operation interfaces for querying versions, extensions, and
 // capabilities.
 #include "mlir/Dialect/SPIRV/IR/SPIRVAvailability.cpp.inc"
 
 // TablenGen'erated operation definitions.
 #define GET_OP_CLASSES
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.cpp.inc"
-
-namespace mlir {
-namespace spirv {
-// TableGen'erated operation availability interface implementations.
-#include "mlir/Dialect/SPIRV/IR/SPIRVOpAvailabilityImpl.inc"
-} // namespace spirv
-} // namespace mlir

mlir/lib/TableGen/Availability.cpp

+//===- Availability.cpp - Availability definitions ------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/TableGen/Availability.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/TableGen/Error.h"
+#include "llvm/TableGen/Record.h"
+
+using namespace mlir;
+using namespace mlir::tblgen;
+
+Availability::Availability(const llvm::Record *def) : def(def) {
+  assert(def->isSubClassOf("Availability") &&
+         "must be subclass of TableGen 'Availability' class");
+}
+
+StringRef Availability::getClass() const {
+  SmallVector<llvm::Record *, 1> parentClass;
+  def->getDirectSuperClasses(parentClass);
+  if (parentClass.size() != 1) {
+    PrintFatalError(def->getLoc(),
+                    "expected to only have one direct superclass");
+  }
+  return parentClass.front()->getName();
+}
+
+StringRef Availability::getInterfaceClassNamespace() const {
+  return def->getValueAsString("cppNamespace");
+}
+
+StringRef Availability::getInterfaceClassName() const {
+  return def->getValueAsString("interfaceName");
+}
+
+StringRef Availability::getInterfaceDescription() const {
+  return def->getValueAsString("interfaceDescription");
+}
+
+StringRef Availability::getQueryFnRetType() const {
+  return def->getValueAsString("queryFnRetType");
+}
+
+StringRef Availability::getQueryFnName() const {
+  return def->getValueAsString("queryFnName");
+}
+
+StringRef Availability::getMergeActionCode() const {
+  return def->getValueAsString("mergeAction");
+}
+
+StringRef Availability::getMergeInitializer() const {
+  return def->getValueAsString("initializer");
+}
+
+StringRef Availability::getMergeInstanceType() const {
+  return def->getValueAsString("instanceType");
+}
+
+StringRef Availability::getMergeInstancePreparation() const {
+  return def->getValueAsString("instancePreparation");
+}
+
+StringRef Availability::getMergeInstance() const {
+  return def->getValueAsString("instance");
+}

mlir/lib/TableGen/CMakeLists.txt

 # This library is unusual, since mlir-tblgen depends on it, which is
 # built with DISABLE_LLVM_LINK_LLVM_DYLIB, this must also be built
 # with that option.  Otherwise builds with LLVM_BUILD_LLVM_DYLIB and
 # LLVM_LINK_LLVM_DYLIB fail.  (Note that even if this has no llvm
 # component dependencies, LLVM_LINK_LLVM_DYLIB tends to introduce a
 # dependence on libLLVM.so)  However, it must also be linkable against
 # libMLIR.so in some contexts (see unittests/Tablegen, for instance, which
 # has a dependence on MLIRIR, which must depend on libLLVM.so).  This works
 # in this special case because this library is static.
 
 llvm_add_library(MLIRTableGen STATIC
   Argument.cpp
   Attribute.cpp
   AttrOrTypeDef.cpp
+  Availability.cpp
   Builder.cpp
   Constraint.cpp
   Dialect.cpp
   Format.cpp
   Interfaces.cpp
   Operator.cpp
   OpClass.cpp
   Pass.cpp

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/test/IR/op-availability.mlir

+// RUN: mlir-opt -mlir-disable-threading -test-op-availability %s | FileCheck %s
+
+// CHECK-LABEL: availability in @min_version
+func @min_version() {
+  // CHECK: test.min_version_op min version: v1.1
+  // CHECK: test.min_version_op has no max version requirements
+  "test.min_version_op"() : () -> ()
+  return
+}
+
+// CHECK-LABEL: availability in @max_version
+func @max_version() {
+  // CHECK: test.max_version_op has no min version requirements
+  // CHECK: test.max_version_op max version: v1.2
+  "test.max_version_op"() : () -> ()
+  return
+}
+
+// CHECK-LABEL: availability in @min_max_version
+func @min_max_version() {
+  // CHECK: test.min_max_version_op min version: v1.0
+  // CHECK: test.min_max_version_op max version: v1.3
+  "test.min_max_version_op"() : () -> ()
+  return
+}
+
+// Enum case A (0): no version requirements
+// Enum case B (1): <= v1.2
+// Enum case C (2): >= v1.1
+
+// CHECK-LABEL: availability in @one_versioned_attr_op
+func @one_versioned_attr_op() {
+  // CHECK: test.one_versioned_attr_op min version: None
+  // CHECK: test.one_versioned_attr_op max version: None
+  "test.one_versioned_attr_op"() {attr = 0: i32} : () -> ()
+
+  // CHECK: test.one_versioned_attr_op min version: None
+  // CHECK: test.one_versioned_attr_op max version: v1.2
+  "test.one_versioned_attr_op"() {attr = 1: i32} : () -> ()
+
+  // CHECK: test.one_versioned_attr_op min version: v1.1
+  // CHECK: test.one_versioned_attr_op max version: None
+  "test.one_versioned_attr_op"() {attr = 2: i32} : () -> ()
+  return
+}
+
+// CHECK-LABEL: availability in @two_versioned_attr_op
+func @two_versioned_attr_op() {
+  // CHECK: test.two_versioned_attr_op min version: None
+  // CHECK: test.two_versioned_attr_op max version: v1.2
+  "test.two_versioned_attr_op"() {attr1 = 0: i32, attr2 = 1: i32} : () -> ()
+
+  // CHECK: test.two_versioned_attr_op min version: v1.1
+  // CHECK: test.two_versioned_attr_op max version: None
+  "test.two_versioned_attr_op"() {attr1 = 0: i32, attr2 = 2: i32} : () -> ()
+
+  // CHECK: test.two_versioned_attr_op min version: v1.1
+  // CHECK: test.two_versioned_attr_op max version: v1.2
+  "test.two_versioned_attr_op"() {attr1 = 1: i32, attr2 = 2: i32} : () -> ()
+  return
+}
+
+
+// CHECK-LABEL: availability in @mix_versioned_attr_op
+func @mix_versioned_attr_op() {
+  // CHECK: test.mix_versioned_attr_op min version: v1.0
+  // CHECK: test.mix_versioned_attr_op max version: v1.2
+  "test.mix_versioned_attr_op"() {attr1 = 0: i32, attr2 = 1: i32} : () -> ()
+
+  // CHECK: test.mix_versioned_attr_op min version: v1.1
+  // CHECK: test.mix_versioned_attr_op max version: v1.3
+  "test.mix_versioned_attr_op"() {attr1 = 0: i32, attr2 = 2: i32} : () -> ()
+
+  // CHECK: test.mix_versioned_attr_op min version: v1.1
+  // CHECK: test.mix_versioned_attr_op max version: v1.2
+  "test.mix_versioned_attr_op"() {attr1 = 1: i32, attr2 = 2: i32} : () -> ()
+  return
+}

mlir/test/lib/Dialect/Test/CMakeLists.txt

 mlir_tablegen(TestOps.cpp.inc -gen-op-defs)
 mlir_tablegen(TestOpsDialect.h.inc -gen-dialect-decls -dialect=test)
 mlir_tablegen(TestOpsDialect.cpp.inc -gen-dialect-defs -dialect=test)
 mlir_tablegen(TestOpEnums.h.inc -gen-enum-decls)
 mlir_tablegen(TestOpEnums.cpp.inc -gen-enum-defs)
 mlir_tablegen(TestOpStructs.h.inc -gen-struct-attr-decls)
 mlir_tablegen(TestOpStructs.cpp.inc -gen-struct-attr-defs)
 mlir_tablegen(TestPatterns.inc -gen-rewriters)
+mlir_tablegen(TestOpAvailability.h.inc -gen-avail-interface-decls)
+mlir_tablegen(TestOpAvailability.cpp.inc -gen-avail-interface-defs)
+mlir_tablegen(TestEnumAvailability.h.inc -gen-enum-avail-decls)
+mlir_tablegen(TestEnumAvailability.cpp.inc -gen-enum-avail-defs)
 add_public_tablegen_target(MLIRTestOpsIncGen)
 
 # Exclude tests from libMLIR.so
 add_mlir_library(MLIRTestDialect
   TestAttributes.cpp
   TestDialect.cpp
   TestInterfaces.cpp
+  TestOpAvailability.cpp
   TestPatterns.cpp
   TestTraits.cpp
   TestTypes.cpp
 
   EXCLUDE_FROM_LIBMLIR
 
   DEPENDS
   MLIRTestAttrDefIncGen

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

 class RewritePatternSet;
 } // namespace mlir
 
 #include "TestOpEnums.h.inc"
 #include "TestOpInterfaces.h.inc"
 #include "TestOpStructs.h.inc"
 #include "TestOpsDialect.h.inc"
 
+// This needs to be included after TestOpEnums.h.inc due to symbol dependency.
+#include "TestEnumAvailability.h.inc"
+
+#include "TestOpAvailability.h.inc"
+
 #define GET_OP_CLASSES
 #include "TestOps.h.inc"
 
 namespace mlir {
 namespace test {
 void registerTestDialect(DialectRegistry &registry);
 void populateTestReductionPatterns(RewritePatternSet &patterns);
 } // namespace test
 } // namespace mlir
 
 #endif // MLIR_TESTDIALECT_H

mlir/test/lib/Dialect/Test/TestOpAvailability.cpp

+//===- TestOpAvailability.cpp - Pass to test op availability --------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "TestDialect.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
+
+using namespace mlir;
+
+#include "TestEnumAvailability.cpp.inc"
+
+namespace mlir {
+namespace test {
+#include "TestOpAvailability.cpp.inc"
+} // namespace test
+} // namespace mlir
+
+//===----------------------------------------------------------------------===//
+// Printing op availability pass
+//===----------------------------------------------------------------------===//
+
+namespace {
+/// A pass for testing op availability.
+struct PrintOpAvailability
+    : public PassWrapper<PrintOpAvailability, FunctionPass> {
+  StringRef getArgument() const final { return "test-op-availability"; }
+  StringRef getDescription() const final { return "Test op availability"; }
+
+  void runOnFunction() override;
+};
+} // end anonymous namespace
+
+void PrintOpAvailability::runOnFunction() {
+  auto f = getFunction();
+  llvm::outs() << "availability in @" << f.getName() << "\n";
+
+  Dialect *spvDialect = getContext().getLoadedDialect("test");
+
+  f->walk([&](Operation *op) {
+    if (op->getDialect() != spvDialect)
+      return WalkResult::advance();
+
+    auto opName = op->getName();
+    auto &os = llvm::outs();
+
+    // Check that we can access TestQueryMinVersionInterface.
+    if (auto minVersionIfx = dyn_cast<test::TestQueryMinVersionInterface>(op)) {
+      auto minVersion = minVersionIfx.getMinVersion();
+      os << opName << " min version: ";
+      if (minVersion.hasValue())
+        os << stringifyVersion(minVersion.getValue()) << "\n";
+      else
+        os << "None\n";
+    } else {
+      os << opName << " has no min version requirements\n";
+    }
+
+    // Check that we can access TestQueryMaxVersionInterface.
+    if (auto maxVersionIfx = dyn_cast<test::TestQueryMaxVersionInterface>(op)) {
+      auto maxVersion = maxVersionIfx.getMaxVersion();
+      os << opName << " max version: ";
+      if (maxVersion.hasValue())
+        os << stringifyVersion(maxVersion.getValue()) << "\n";
+      else
+        os << "None\n";
+    } else {
+      os << opName << " has no max version requirements\n";
+    }
+
+    os.flush();
+
+    return WalkResult::advance();
+  });
+}
+
+namespace mlir {
+void registerPrintOpAvailabilityPass() {
+  PassRegistration<PrintOpAvailability>();
+}
+} // namespace mlir

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

 }
 
 def OpCrashShort : TEST_Op<"op_crash_short"> {
   let results = (outs I32);
 }
 
 def : Pat<(OpCrashLong $_, $_, $_), (OpCrashShort)>;
 
+//===----------------------------------------------------------------------===//
+// Test Op Availability
+//===----------------------------------------------------------------------===//
+
+def Test_V_1_0 : I32EnumAttrCase<"V_1_0", 0, "v1.0">;
+def Test_V_1_1 : I32EnumAttrCase<"V_1_1", 1, "v1.1">;
+def Test_V_1_2 : I32EnumAttrCase<"V_1_2", 2, "v1.2">;
+def Test_V_1_3 : I32EnumAttrCase<"V_1_3", 3, "v1.3">;
+
+def Test_VersionAttr : I32EnumAttr<"Version", "valid version numbers", [
+    Test_V_1_0, Test_V_1_1, Test_V_1_2, Test_V_1_3]>;
+
+class Test_MinVersion<I32EnumAttrCase min> : MinVersionBase<
+    "TestQueryMinVersionInterface", Test_VersionAttr, min> {
+  let interfaceDescription = [{
+    Querying interface for minimal required version.
+  }];
+  let cppNamespace = "::mlir::test";
+}
+
+class Test_MaxVersion<I32EnumAttrCase max> : MaxVersionBase<
+    "TestQueryMaxVersionInterface", Test_VersionAttr, max> {
+  let interfaceDescription = [{
+    Querying interface for maximal supported version.
+  }];
+  let cppNamespace = "::mlir::test";
+}
+
+// Test op with only min version availability.
+def MinVersionOp : TEST_Op<"min_version_op"> {
+  let arguments = (ins);
+  let results = (outs);
+
+  let availability = [Test_MinVersion<Test_V_1_1>];
+}
+
+// Test op with only max version availability.
+def MaxVersionOp : TEST_Op<"max_version_op"> {
+  let arguments = (ins);
+  let results = (outs);
+
+  let availability = [Test_MaxVersion<Test_V_1_2>];
+}
+
+// Test op with both min and max version availability.
+def MinMaxVersionOp : TEST_Op<"min_max_version_op"> {
+  let arguments = (ins);
+  let results = (outs);
+
+  let availability = [
+    Test_MinVersion<Test_V_1_0>,
+    Test_MaxVersion<Test_V_1_3>
+  ];
+}
+
+def VersionedEnumCaseA : I32EnumAttrCase<"A", 0> {
+  // No version requirements.
+}
+def VersionedEnumCaseB : I32EnumAttrCase<"B", 1> {
+  // Removed since v1.3.
+  let availability = [Test_MaxVersion<Test_V_1_2>];
+}
+def VersionedEnumCaseC : I32EnumAttrCase<"C", 2> {
+  // Added since v1.1.
+  let availability = [Test_MinVersion<Test_V_1_1>];
+}
+
+def VersionedEnumAttr : I32EnumAttr<"VersionedEnum", "valid enum cases", [
+  VersionedEnumCaseA, VersionedEnumCaseB, VersionedEnumCaseC]> {
+  let cppNamespace = "::mlir::test";
+}
+
+// Test op having one versioned enum attribute.
+def OneVersionedAttrOp : TEST_Op<"one_versioned_attr_op"> {
+  let arguments = (ins VersionedEnumAttr:$attr);
+  let results = (outs);
+}
+
+// Test op having two versioned enum attribute--the final version requirements
+// need to consider both.
+def TwoVersionedAttrOp : TEST_Op<"two_versioned_attr_op"> {
+  let arguments = (ins VersionedEnumAttr:$attr1, VersionedEnumAttr:$attr2);
+  let results = (outs);
+}
+
+// Test op having availability on itself and two versioned enum attribute--
+// the final version requirements need to consider everything.
+def MixVersionedAttrOp : TEST_Op<"mix_versioned_attr_op"> {
+  let arguments = (ins VersionedEnumAttr:$attr1, VersionedEnumAttr:$attr2);
+  let results = (outs);
+
+  let availability = [
+    Test_MinVersion<Test_V_1_0>,
+    Test_MaxVersion<Test_V_1_3>
+  ];
+}
+
 #endif // TEST_OPS

mlir/tools/mlir-opt/mlir-opt.cpp

 
 using namespace llvm;
 using namespace mlir;
 
 // Defined in the test directory, no public header.
 namespace mlir {
 void registerConvertToTargetEnvPass();
 void registerPassManagerTestPass();
+void registerPrintOpAvailabilityPass();
 void registerPrintSpirvAvailabilityPass();
 void registerShapeFunctionTestPasses();
 void registerSideEffectTestPasses();
 void registerSliceAnalysisTestPass();
 void registerSymbolTestPasses();
 void registerTestAffineDataCopyPass();
 void registerTestAffineLoopUnswitchingPass();
 void registerTestAllReduceLoweringPass();

 void registerTestVectorConversions();
 } // namespace test
 } // namespace mlir
 
 #ifdef MLIR_INCLUDE_TESTS
 void registerTestPasses() {
   registerConvertToTargetEnvPass();
   registerPassManagerTestPass();
+  registerPrintOpAvailabilityPass();
   registerPrintSpirvAvailabilityPass();
   registerShapeFunctionTestPasses();
   registerSideEffectTestPasses();
   registerSliceAnalysisTestPass();
   registerSymbolTestPasses();
   registerTestAffineDataCopyPass();
   registerTestAffineLoopUnswitchingPass();
   registerTestAllReduceLoweringPass();

mlir/tools/mlir-tblgen/AvailabilityInterfaceGen.cpp

+//===- AvailabilityInterfacesGen.cpp --------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// AvailabilityInterfacesGen generates definitions for availability interfaces.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Support/LLVM.h"
+#include "mlir/TableGen/Availability.h"
+#include "mlir/TableGen/CodeGenHelpers.h"
+#include "mlir/TableGen/GenInfo.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/TableGen/Error.h"
+#include "llvm/TableGen/Record.h"
+#include "llvm/TableGen/TableGenBackend.h"
+
+using namespace mlir;
+using llvm::Record;
+using llvm::RecordKeeper;
+using mlir::tblgen::Availability;
+using mlir::tblgen::NamespaceEmitter;
+
+//===----------------------------------------------------------------------===//
+// Availability Interface Declarations AutoGen
+//===----------------------------------------------------------------------===//
+
+static void emitConceptDecl(const Availability &availability, raw_ostream &os) {
+  os << "  class Concept {\n"
+     << "  public:\n"
+     << "    virtual ~Concept() = default;\n"
+     << "    virtual " << availability.getQueryFnRetType() << " "
+     << availability.getQueryFnName()
+     << "(const Concept *impl, Operation *tblgen_opaque_op) const = 0;\n"
+     << "  };\n";
+}
+
+static void emitModelDecl(const Availability &availability, raw_ostream &os) {
+  for (const char *modelClass : {"Model", "FallbackModel"}) {
+    os << "  template<typename ConcreteOp>\n";
+    os << "  class " << modelClass << " : public Concept {\n"
+       << "  public:\n"
+       << "    " << availability.getQueryFnRetType() << " "
+       << availability.getQueryFnName()
+       << "(const Concept *impl, Operation *tblgen_opaque_op) const final {\n"
+       << "      auto op = llvm::cast<ConcreteOp>(tblgen_opaque_op);\n"
+       << "      (void)op;\n"
+       // Forward to the method on the concrete operation type.
+       << "      return op." << availability.getQueryFnName() << "();\n"
+       << "    }\n"
+       << "  };\n";
+  }
+  os << "  template<typename ConcreteModel, typename ConcreteOp>\n";
+  os << "  class ExternalModel : public FallbackModel<ConcreteOp> {};\n";
+}
+
+static void emitInterfaceDecl(const Availability &availability,
+                              raw_ostream &os) {
+  StringRef interfaceName = availability.getInterfaceClassName();
+  std::string interfaceTraitsName =
+      std::string(formatv("{0}Traits", interfaceName));
+
+  StringRef cppNamespace = availability.getInterfaceClassNamespace();
+  NamespaceEmitter nsEmitter(os, cppNamespace);
+
+  // Emit the traits struct containing the concept and model declarations.
+  os << "namespace detail {\n"
+     << "struct " << interfaceTraitsName << " {\n";
+  emitConceptDecl(availability, os);
+  os << '\n';
+  emitModelDecl(availability, os);
+  os << "};\n} // namespace detail\n\n";
+
+  // Emit the main interface class declaration.
+  os << "/*\n" << availability.getInterfaceDescription().trim() << "\n*/\n";
+  os << llvm::formatv("class {0} : public OpInterface<{1}, detail::{2}> {\n"
+                      "public:\n"
+                      "  using OpInterface<{1}, detail::{2}>::OpInterface;\n",
+                      interfaceName, interfaceName, interfaceTraitsName);
+
+  // Emit query function declaration.
+  os << "  " << availability.getQueryFnRetType() << " "
+     << availability.getQueryFnName() << "();\n";
+  os << "};\n\n";
+}
+
+static bool emitInterfaceDecls(const RecordKeeper &recordKeeper,
+                               raw_ostream &os) {
+  llvm::emitSourceFileHeader("Availability Interface Declarations", os);
+
+  auto defs = recordKeeper.getAllDerivedDefinitions("Availability");
+  SmallVector<const Record *, 4> handledClasses;
+  for (const Record *def : defs) {
+    SmallVector<Record *, 1> parent;
+    def->getDirectSuperClasses(parent);
+    if (parent.size() != 1) {
+      PrintFatalError(def->getLoc(),
+                      "expected to only have one direct superclass");
+    }
+    if (llvm::is_contained(handledClasses, parent.front()))
+      continue;
+
+    Availability avail(def);
+    emitInterfaceDecl(avail, os);
+    handledClasses.push_back(parent.front());
+  }
+  return false;
+}
+
+//===----------------------------------------------------------------------===//
+// Availability Interface Definitions AutoGen
+//===----------------------------------------------------------------------===//
+
+static void emitInterfaceDef(const Availability &availability,
+                             raw_ostream &os) {
+  os << availability.getQueryFnRetType() << " ";
+
+  StringRef cppNamespace = availability.getInterfaceClassNamespace();
+  cppNamespace.consume_front("::");
+  if (!cppNamespace.empty())
+    os << cppNamespace << "::";
+
+  StringRef methodName = availability.getQueryFnName();
+  os << availability.getInterfaceClassName() << "::" << methodName << "() {\n"
+     << "  return getImpl()->" << methodName << "(getImpl(), getOperation());\n"
+     << "}\n";
+}
+
+static bool emitInterfaceDefs(const RecordKeeper &recordKeeper,
+                              raw_ostream &os) {
+  llvm::emitSourceFileHeader("Availability Interface Definitions", os);
+
+  auto defs = recordKeeper.getAllDerivedDefinitions("Availability");
+  SmallVector<const Record *, 1> handledClasses;
+  for (const Record *def : defs) {
+    SmallVector<Record *, 1> parent;
+    def->getDirectSuperClasses(parent);
+    if (parent.size() != 1) {
+      PrintFatalError(def->getLoc(),
+                      "expected to only have one direct superclass");
+    }
+    if (llvm::is_contained(handledClasses, parent.front()))
+      continue;
+
+    Availability availability(def);
+    emitInterfaceDef(availability, os);
+    handledClasses.push_back(parent.front());
+  }
+  return false;
+}
+
+//===----------------------------------------------------------------------===//
+// Availability Interface Hook Registration
+//===----------------------------------------------------------------------===//
+
+// Registers the operation interface generator to mlir-tblgen.
+static mlir::GenRegistration
+    genInterfaceDecls("gen-avail-interface-decls",
+                      "Generate availability interface declarations",
+                      [](const RecordKeeper &records, raw_ostream &os) {
+                        return emitInterfaceDecls(records, os);
+                      });
+
+// Registers the operation interface generator to mlir-tblgen.
+static mlir::GenRegistration
+    genInterfaceDefs("gen-avail-interface-defs",
+                     "Generate op interface definitions",
+                     [](const RecordKeeper &records, raw_ostream &os) {
+                       return emitInterfaceDefs(records, os);
+                     });

mlir/tools/mlir-tblgen/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Demangle
   Support
   TableGen
 )
 
 add_tablegen(mlir-tblgen MLIR
   AttrOrTypeDefGen.cpp
+  AvailabilityInterfaceGen.cpp
   DialectGen.cpp
   DirectiveCommonGen.cpp
   EnumsGen.cpp
   LLVMIRConversionGen.cpp
   LLVMIRIntrinsicGen.cpp
   mlir-tblgen.cpp
   OpDefinitionsGen.cpp
   OpDocGen.cpp

mlir/tools/mlir-tblgen/EnumsGen.cpp

 //===- EnumsGen.cpp - MLIR enum utility generator -------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // EnumsGen generates common utility functions for enums.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/TableGen/Attribute.h"
+#include "mlir/TableGen/Availability.h"
 #include "mlir/TableGen/Format.h"
 #include "mlir/TableGen/GenInfo.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringSet.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/TableGenBackend.h"
 
 using llvm::formatv;
 using llvm::isDigit;
 using llvm::PrintFatalError;
 using llvm::raw_ostream;
 using llvm::Record;
 using llvm::RecordKeeper;
 using llvm::StringRef;
 using mlir::tblgen::Attribute;
+using mlir::tblgen::Availability;
 using mlir::tblgen::EnumAttr;
 using mlir::tblgen::EnumAttrCase;
 using mlir::tblgen::FmtContext;
 using mlir::tblgen::tgfmt;
 
 static std::string makeIdentifier(StringRef str) {
   if (!str.empty() && isDigit(static_cast<unsigned char>(str.front()))) {
     std::string newStr = std::string("_") + str.str();
     return newStr;
   }
   return str.str();
 }
 
+//===----------------------------------------------------------------------===//
+// Enum Utility AutoGen
+//===----------------------------------------------------------------------===//
+
 static void emitEnumClass(const Record &enumDef, StringRef enumName,
                           StringRef underlyingType, StringRef description,
                           const std::vector<EnumAttrCase> &enumerants,
                           raw_ostream &os) {
   os << "// " << description << "\n";
   os << "enum class " << enumName;
 
   if (!underlyingType.empty())
static bool emitEnumDefs(const RecordKeeper &recordKeeper, raw_ostream &os) {
 
   auto defs = recordKeeper.getAllDerivedDefinitions("EnumAttrInfo");
   for (const auto *def : defs)
     emitEnumDef(*def, os);
 
   return false;
 }
 
+//===----------------------------------------------------------------------===//
+// Enum Utility Query Hook Registration
+//===----------------------------------------------------------------------===//
+
 // Registers the enum utility generator to mlir-tblgen.
 static mlir::GenRegistration
     genEnumDecls("gen-enum-decls", "Generate enum utility declarations",
                  [](const RecordKeeper &records, raw_ostream &os) {
                    return emitEnumDecls(records, os);
                  });
 
 // Registers the enum utility generator to mlir-tblgen.
 static mlir::GenRegistration
     genEnumDefs("gen-enum-defs", "Generate enum utility definitions",
                 [](const RecordKeeper &records, raw_ostream &os) {
                   return emitEnumDefs(records, os);
                 });
+
+//===----------------------------------------------------------------------===//
+// 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") && !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;
+}
+
+static void emitAvailabilityQueryForIntEnum(const Record &enumDef,
+                                            raw_ostream &os) {
+  EnumAttr enumAttr(enumDef);
+  StringRef enumName = enumAttr.getEnumClassName();
+  std::vector<EnumAttrCase> enumerants = enumAttr.getAllCases();
+
+  // Mapping from availability class name to (enumerant, availability
+  // specification) pairs.
+  llvm::StringMap<llvm::SmallVector<std::pair<EnumAttrCase, Availability>, 1>>
+      classCaseMap;
+
+  // Place all availability specifications to their corresponding
+  // availability classes.
+  for (const EnumAttrCase &enumerant : enumerants)
+    for (const Availability &avail : getAvailabilities(enumerant.getDef()))
+      classCaseMap[avail.getClass()].push_back({enumerant, avail});
+
+  for (const auto &classCasePair : classCaseMap) {
+    Availability avail = classCasePair.getValue().front().second;
+
+    os << formatv("llvm::Optional<{0}> {1}({2} value) {{\n",
+                  avail.getMergeInstanceType(), avail.getQueryFnName(),
+                  enumName);
+
+    os << "  switch (value) {\n";
+    for (const auto &caseSpecPair : classCasePair.getValue()) {
+      EnumAttrCase enumerant = caseSpecPair.first;
+      Availability avail = caseSpecPair.second;
+      os << formatv("  case {0}::{1}: { {2} return {3}({4}); }\n", enumName,
+                    enumerant.getSymbol(), avail.getMergeInstancePreparation(),
+                    avail.getMergeInstanceType(), avail.getMergeInstance());
+    }
+    // Only emit default if uncovered cases.
+    if (classCasePair.getValue().size() < enumAttr.getAllCases().size())
+      os << "  default: break;\n";
+    os << "  }\n"
+       << "  return llvm::None;\n"
+       << "}\n";
+  }
+}
+
+static void emitAvailabilityQueryForBitEnum(const Record &enumDef,
+                                            raw_ostream &os) {
+  EnumAttr enumAttr(enumDef);
+  StringRef enumName = enumAttr.getEnumClassName();
+  std::string underlyingType = std::string(enumAttr.getUnderlyingType());
+  std::vector<EnumAttrCase> enumerants = enumAttr.getAllCases();
+
+  // Mapping from availability class name to (enumerant, availability
+  // specification) pairs.
+  llvm::StringMap<llvm::SmallVector<std::pair<EnumAttrCase, Availability>, 1>>
+      classCaseMap;
+
+  // Place all availability specifications to their corresponding
+  // availability classes.
+  for (const EnumAttrCase &enumerant : enumerants)
+    for (const Availability &avail : getAvailabilities(enumerant.getDef()))
+      classCaseMap[avail.getClass()].push_back({enumerant, avail});
+
+  for (const auto &classCasePair : classCaseMap) {
+    Availability avail = classCasePair.getValue().front().second;
+
+    os << formatv("llvm::Optional<{0}> {1}({2} value) {{\n",
+                  avail.getMergeInstanceType(), avail.getQueryFnName(),
+                  enumName);
+
+    os << formatv(
+        "  assert(::llvm::countPopulation(static_cast<{0}>(value)) <= 1"
+        " && \"cannot have more than one bit set\");\n",
+        underlyingType);
+
+    os << "  switch (value) {\n";
+    for (const auto &caseSpecPair : classCasePair.getValue()) {
+      EnumAttrCase enumerant = caseSpecPair.first;
+      Availability avail = caseSpecPair.second;
+      os << formatv("  case {0}::{1}: { {2} return {3}({4}); }\n", enumName,
+                    enumerant.getSymbol(), avail.getMergeInstancePreparation(),
+                    avail.getMergeInstanceType(), avail.getMergeInstance());
+    }
+    os << "  default: break;\n";
+    os << "  }\n"
+       << "  return llvm::None;\n"
+       << "}\n";
+  }
+}
+
+static void emitEnumAvailDecl(const Record &enumDef, raw_ostream &os) {
+  EnumAttr enumAttr(enumDef);
+  StringRef enumName = enumAttr.getEnumClassName();
+  StringRef cppNamespace = enumAttr.getCppNamespace();
+  auto enumerants = enumAttr.getAllCases();
+
+  llvm::SmallVector<StringRef, 2> namespaces;
+  llvm::SplitString(cppNamespace, namespaces, "::");
+
+  for (auto ns : namespaces)
+    os << "namespace " << ns << " {\n";
+
+  llvm::StringSet<> handledClasses;
+
+  // Place all availability specifications to their corresponding
+  // availability classes.
+  for (const EnumAttrCase &enumerant : enumerants)
+    for (const Availability &avail : getAvailabilities(enumerant.getDef())) {
+      StringRef className = avail.getClass();
+      if (handledClasses.count(className))
+        continue;
+      os << formatv("llvm::Optional<{0}> {1}({2} value);\n",
+                    avail.getMergeInstanceType(), avail.getQueryFnName(),
+                    enumName);
+      handledClasses.insert(className);
+    }
+
+  for (auto ns : llvm::reverse(namespaces))
+    os << "} // namespace " << ns << "\n";
+}
+
+static bool emitEnumAvailDecls(const RecordKeeper &recordKeeper,
+                               raw_ostream &os) {
+  llvm::emitSourceFileHeader("Enum Availability Declarations", os);
+
+  auto defs = recordKeeper.getAllDerivedDefinitions("EnumAttrInfo");
+  for (const auto *def : defs)
+    emitEnumAvailDecl(*def, os);
+
+  return false;
+}
+
+static void emitEnumAvailDef(const Record &enumDef, raw_ostream &os) {
+  EnumAttr enumAttr(enumDef);
+  StringRef cppNamespace = enumAttr.getCppNamespace();
+
+  llvm::SmallVector<StringRef, 2> namespaces;
+  llvm::SplitString(cppNamespace, namespaces, "::");
+
+  for (auto ns : namespaces)
+    os << "namespace " << ns << " {\n";
+
+  if (enumAttr.isBitEnum()) {
+    emitAvailabilityQueryForBitEnum(enumDef, os);
+  } else {
+    emitAvailabilityQueryForIntEnum(enumDef, os);
+  }
+
+  for (auto ns : llvm::reverse(namespaces))
+    os << "} // namespace " << ns << "\n";
+  os << "\n";
+}
+
+static bool emitEnumAvailDefs(const RecordKeeper &recordKeeper,
+                              raw_ostream &os) {
+  llvm::emitSourceFileHeader("Enum Availability Definitions", os);
+
+  auto defs = recordKeeper.getAllDerivedDefinitions("EnumAttrInfo");
+  for (const auto *def : defs)
+    emitEnumAvailDef(*def, os);
+
+  return false;
+}
+
+//===----------------------------------------------------------------------===//
+// Enum Availability Query Hook Registration
+//===----------------------------------------------------------------------===//
+
+// Registers the enum utility generator to mlir-tblgen.
+static mlir::GenRegistration
+    genEnumAvailDecls("gen-enum-avail-decls",
+                      "Generate enum availability declarations",
+                      [](const RecordKeeper &records, raw_ostream &os) {
+                        return emitEnumAvailDecls(records, os);
+                      });
+
+// Registers the enum utility generator to mlir-tblgen.
+static mlir::GenRegistration
+    genEnumAvailDefs("gen-enum-avail-defs",
+                     "Generate enum availability definitions",
+                     [](const RecordKeeper &records, raw_ostream &os) {
+                       return emitEnumAvailDefs(records, os);
+                     });

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 //===- OpDefinitionsGen.cpp - MLIR op definitions generator ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // OpDefinitionsGen uses the description of operations to generate C++
 // definitions for ops.
 //
 //===----------------------------------------------------------------------===//
 
 #include "OpFormatGen.h"
 #include "OpGenHelpers.h"
+#include "mlir/TableGen/Availability.h"
 #include "mlir/TableGen/CodeGenHelpers.h"
 #include "mlir/TableGen/Format.h"
 #include "mlir/TableGen/GenInfo.h"
 #include "mlir/TableGen/Interfaces.h"
 #include "mlir/TableGen/OpClass.h"
 #include "mlir/TableGen/Operator.h"
 #include "mlir/TableGen/SideEffects.h"
 #include "mlir/TableGen/Trait.h"
OpMethod *genOpInterfaceMethod(const tblgen::InterfaceMethod &method,
                                  bool declaration = true);
 
   // Generate the side effect interface methods.
   void genSideEffectInterfaceMethods();
 
   // Generate the type inference interface methods.
   void genTypeInterfaceMethods();
 
+  // Generate availability interface methods.
+  void genAvailabilityInterfaceMethods();
+
 private:
   // The TableGen record for this op.
   // TODO: OpEmitter should not have a Record directly,
   // it should rather go through the Operator for better abstraction.
   const Record &def;
 
   // The wrapper operator class for querying information from this op.
   Operator op;
OpEmitter::OpEmitter(const Operator &op,
   genAttrSetters();
   genOptionalAttrRemovers();
   genBuilder();
   genParser();
   genPrinter();
   genVerifier();
   genCanonicalizerDecls();
   genFolderDecls();
+  genAvailabilityInterfaceMethods();
   genTypeInterfaceMethods();
   genOpInterfaceMethods();
   generateOpFormat(op, opClass);
   genSideEffectInterfaceMethods();
 }
 void OpEmitter::emitDecl(
     const Operator &op, raw_ostream &os,
     const StaticVerifierFunctionEmitter &staticVerifierEmitter) {
for (auto &location : it.second) {
              << (location.kind == EffectKind::Operand ? "Operands" : "Results")
              << "(" << location.index << "))\n  "
              << llvm::formatv(addEffectCode, effect, "value, ", resource).str();
       }
     }
   }
 }
 
+// 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") && !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;
+}
+
+void OpEmitter::genAvailabilityInterfaceMethods() {
+  mlir::tblgen::FmtContext fctx;
+  fctx.addSubst("overall", "tblgen_overall");
+
+  std::vector<Availability> opAvailabilities = getAvailabilities(op.getDef());
+
+  // First collect all availability classes this op should implement.
+  // All availability instances keep information for the generated interface and
+  // the instance's specific requirement. Here we remember a random instance so
+  // we can get the information regarding the generated interface.
+  llvm::StringMap<Availability> availClasses;
+  for (const Availability &avail : opAvailabilities)
+    availClasses.try_emplace(avail.getClass(), avail);
+  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.try_emplace(caseAvail.getClass(), caseAvail);
+  }
+
+  // Then generate implementation for each availability class.
+  for (const auto &availClass : availClasses) {
+    StringRef availClassName = availClass.getKey();
+    Availability avail = availClass.getValue();
+
+    auto *method = opClass.addMethodAndPrune(avail.getQueryFnRetType(),
+                                             avail.getQueryFnName());
+    assert(method && "method already registered!");
+    auto &body = method->body();
+
+    // Create the variable for the final requirement and initialize it.
+    body << formatv("  {0} tblgen_overall = {1};\n", avail.getQueryFnRetType(),
+                    avail.getMergeInitializer());
+
+    // Update with the op's specific availability spec.
+    for (const Availability &avail : opAvailabilities) {
+      if (avail.getClass() == availClassName &&
+          (!avail.getMergeInstancePreparation().empty() ||
+           !avail.getMergeActionCode().empty())) {
+        body << "  {\n    "
+             // Prepare this instance.
+             << avail.getMergeInstancePreparation()
+             << "\n    "
+             // Merge this instance.
+             << std::string(
+                    tgfmt(avail.getMergeActionCode(),
+                          &fctx.addSubst("instance", avail.getMergeInstance())))
+             << ";\n  }\n";
+      }
+    }
+
+    // Update with enum attributes' specific availability spec.
+    for (const NamedAttribute &namedAttr : op.getAttributes()) {
+      const auto *enumAttr = llvm::dyn_cast<EnumAttr>(&namedAttr.attr);
+      if (!enumAttr)
+        continue;
+
+      // (enumerant, availability specification) pairs for this availability
+      // class.
+      SmallVector<std::pair<EnumAttrCase, Availability>, 1> caseSpecs;
+
+      // Collect all cases' availability specs.
+      for (const EnumAttrCase &enumerant : enumAttr->getAllCases())
+        for (const Availability &caseAvail :
+             getAvailabilities(enumerant.getDef()))
+          if (availClassName == caseAvail.getClass())
+            caseSpecs.push_back({enumerant, caseAvail});
+
+      // If this attribute kind does not have any availability spec from any of
+      // its cases, no more work to do.
+      if (caseSpecs.empty())
+        continue;
+
+      if (enumAttr->isBitEnum()) {
+        // For BitEnumAttr, we need to iterate over each bit to query its
+        // availability spec.
+        body << formatv("  for (unsigned i = 0; "
+                        "i < std::numeric_limits<{0}>::digits; ++i) {{\n",
+                        enumAttr->getUnderlyingType());
+        body << formatv("    {0}::{1} tblgen_attrVal = this->{2}() & "
+                        "static_cast<{0}::{1}>(1 << i);\n",
+                        enumAttr->getCppNamespace(),
+                        enumAttr->getEnumClassName(), namedAttr.name);
+        body << formatv(
+            "    if (static_cast<{0}>(tblgen_attrVal) == 0) continue;\n",
+            enumAttr->getUnderlyingType());
+      } else {
+        // For IntEnumAttr, we just need to query the value as a whole.
+        body << "  {\n";
+        body << formatv("    auto tblgen_attrVal = this->{0}();\n",
+                        namedAttr.name);
+      }
+      body << formatv("    auto tblgen_instance = {0}::{1}(tblgen_attrVal);\n",
+                      enumAttr->getCppNamespace(), avail.getQueryFnName());
+      body << "    if (tblgen_instance) "
+           // TODO` here once ODS supports
+           // dialect-specific contents so that we can use not implementing the
+           // availability interface as indication of no requirements.
+           << std::string(tgfmt(caseSpecs.front().second.getMergeActionCode(),
+                                &fctx.addSubst("instance", "*tblgen_instance")))
+           << ";\n";
+      body << "  }\n";
+    }
+
+    body << "  return tblgen_overall;\n";
+  }
+}
+
 void OpEmitter::genTypeInterfaceMethods() {
   if (!op.allResultTypesKnown())
     return;
   // Generate 'inferReturnTypes' method declaration using the interface method
   // declared in 'InferTypeOpInterface' op interface.
   const auto *trait = dyn_cast<InterfaceTrait>(
       op.getTrait("::mlir::InferTypeOpInterface::Trait"));
   Interface interface = trait->getInterface();
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/tools/mlir-tblgen/SPIRVUtilsGen.cpp

 #include <list>
 
 using llvm::ArrayRef;
 using llvm::formatv;
 using llvm::raw_ostream;
 using llvm::raw_string_ostream;
 using llvm::Record;
 using llvm::RecordKeeper;
-using llvm::SmallVector;
 using llvm::SMLoc;
 using llvm::StringMap;
 using llvm::StringRef;
 using llvm::Twine;
 using mlir::tblgen::Attribute;
 using mlir::tblgen::EnumAttr;
 using mlir::tblgen::EnumAttrCase;
 using mlir::tblgen::NamedAttribute;
 using mlir::tblgen::NamedTypeConstraint;
-using mlir::tblgen::NamespaceEmitter;
 using mlir::tblgen::Operator;
 
 //===----------------------------------------------------------------------===//
-// Availability Wrapper Class
-//===----------------------------------------------------------------------===//
-
-namespace {
-// Wrapper class with helper methods for accessing availability defined in
-// TableGen.
-class Availability {
-public:
-  explicit Availability(const Record *def);
-
-  // Returns the name of the direct TableGen class for this availability
-  // instance.
-  StringRef getClass() const;
-
-  // Returns the generated C++ interface's class namespace.
-  StringRef getInterfaceClassNamespace() const;
-
-  // Returns the generated C++ interface's class name.
-  StringRef getInterfaceClassName() const;
-
-  // Returns the generated C++ interface's description.
-  StringRef getInterfaceDescription() const;
-
-  // Returns the name of the query function insided the generated C++ interface.
-  StringRef getQueryFnName() const;
-
-  // Returns the return type of the query function insided the generated C++
-  // interface.
-  StringRef getQueryFnRetType() const;
-
-  // Returns the code for merging availability requirements.
-  StringRef getMergeActionCode() const;
-
-  // Returns the initializer expression for initializing the final availability
-  // requirements.
-  StringRef getMergeInitializer() const;
-
-  // Returns the C++ type for an availability instance.
-  StringRef getMergeInstanceType() const;
-
-  // Returns the C++ statements for preparing availability instance.
-  StringRef getMergeInstancePreparation() const;
-
-  // Returns the concrete availability instance carried in this case.
-  StringRef getMergeInstance() const;
-
-  // Returns the underlying LLVM TableGen Record.
-  const llvm::Record *getDef() const { return def; }
-
-private:
-  // The TableGen definition of this availability.
-  const llvm::Record *def;
-};
-} // namespace
-
-Availability::Availability(const llvm::Record *def) : def(def) {
-  assert(def->isSubClassOf("Availability") &&
-         "must be subclass of TableGen 'Availability' class");
-}
-
-StringRef Availability::getClass() const {
-  SmallVector<Record *, 1> parentClass;
-  def->getDirectSuperClasses(parentClass);
-  if (parentClass.size() != 1) {
-    PrintFatalError(def->getLoc(),
-                    "expected to only have one direct superclass");
-  }
-  return parentClass.front()->getName();
-}
-
-StringRef Availability::getInterfaceClassNamespace() const {
-  return def->getValueAsString("cppNamespace");
-}
-
-StringRef Availability::getInterfaceClassName() const {
-  return def->getValueAsString("interfaceName");
-}
-
-StringRef Availability::getInterfaceDescription() const {
-  return def->getValueAsString("interfaceDescription");
-}
-
-StringRef Availability::getQueryFnRetType() const {
-  return def->getValueAsString("queryFnRetType");
-}
-
-StringRef Availability::getQueryFnName() const {
-  return def->getValueAsString("queryFnName");
-}
-
-StringRef Availability::getMergeActionCode() const {
-  return def->getValueAsString("mergeAction");
-}
-
-StringRef Availability::getMergeInitializer() const {
-  return def->getValueAsString("initializer");
-}
-
-StringRef Availability::getMergeInstanceType() const {
-  return def->getValueAsString("instanceType");
-}
-
-StringRef Availability::getMergeInstancePreparation() const {
-  return def->getValueAsString("instancePreparation");
-}
-
-StringRef Availability::getMergeInstance() const {
-  return def->getValueAsString("instance");
-}
-
-// Returns the availability spec of the given `def`.
-std::vector<Availability> getAvailabilities(const Record &def) {
-  std::vector<Availability> availabilities;
-
-  if (def.getValue("availability")) {
-    std::vector<Record *> availDefs = def.getValueAsListOfDefs("availability");
-    availabilities.reserve(availDefs.size());
-    for (const Record *avail : availDefs)
-      availabilities.emplace_back(avail);
-  }
-
-  return availabilities;
-}
-
-//===----------------------------------------------------------------------===//
-// Availability Interface Definitions AutoGen
-//===----------------------------------------------------------------------===//
-
-static void emitInterfaceDef(const Availability &availability,
-                             raw_ostream &os) {
-
-  os << availability.getQueryFnRetType() << " ";
-
-  StringRef cppNamespace = availability.getInterfaceClassNamespace();
-  cppNamespace.consume_front("::");
-  if (!cppNamespace.empty())
-    os << cppNamespace << "::";
-
-  StringRef methodName = availability.getQueryFnName();
-  os << availability.getInterfaceClassName() << "::" << methodName << "() {\n"
-     << "  return getImpl()->" << methodName << "(getImpl(), getOperation());\n"
-     << "}\n";
-}
-
-static bool emitInterfaceDefs(const RecordKeeper &recordKeeper,
-                              raw_ostream &os) {
-  llvm::emitSourceFileHeader("Availability Interface Definitions", os);
-
-  auto defs = recordKeeper.getAllDerivedDefinitions("Availability");
-  SmallVector<const Record *, 1> handledClasses;
-  for (const Record *def : defs) {
-    SmallVector<Record *, 1> parent;
-    def->getDirectSuperClasses(parent);
-    if (parent.size() != 1) {
-      PrintFatalError(def->getLoc(),
-                      "expected to only have one direct superclass");
-    }
-    if (llvm::is_contained(handledClasses, parent.front()))
-      continue;
-
-    Availability availability(def);
-    emitInterfaceDef(availability, os);
-    handledClasses.push_back(parent.front());
-  }
-  return false;
-}
-
-//===----------------------------------------------------------------------===//
-// Availability Interface Declarations AutoGen
-//===----------------------------------------------------------------------===//
-
-static void emitConceptDecl(const Availability &availability, raw_ostream &os) {
-  os << "  class Concept {\n"
-     << "  public:\n"
-     << "    virtual ~Concept() = default;\n"
-     << "    virtual " << availability.getQueryFnRetType() << " "
-     << availability.getQueryFnName()
-     << "(const Concept *impl, Operation *tblgen_opaque_op) const = 0;\n"
-     << "  };\n";
-}
-
-static void emitModelDecl(const Availability &availability, raw_ostream &os) {
-  for (const char *modelClass : {"Model", "FallbackModel"}) {
-    os << "  template<typename ConcreteOp>\n";
-    os << "  class " << modelClass << " : public Concept {\n"
-       << "  public:\n"
-       << "    " << availability.getQueryFnRetType() << " "
-       << availability.getQueryFnName()
-       << "(const Concept *impl, Operation *tblgen_opaque_op) const final {\n"
-       << "      auto op = llvm::cast<ConcreteOp>(tblgen_opaque_op);\n"
-       << "      (void)op;\n"
-       // Forward to the method on the concrete operation type.
-       << "      return op." << availability.getQueryFnName() << "();\n"
-       << "    }\n"
-       << "  };\n";
-  }
-  os << "  template<typename ConcreteModel, typename ConcreteOp>\n";
-  os << "  class ExternalModel : public FallbackModel<ConcreteOp> {};\n";
-}
-
-static void emitInterfaceDecl(const Availability &availability,
-                              raw_ostream &os) {
-  StringRef interfaceName = availability.getInterfaceClassName();
-  std::string interfaceTraitsName =
-      std::string(formatv("{0}Traits", interfaceName));
-
-  StringRef cppNamespace = availability.getInterfaceClassNamespace();
-  NamespaceEmitter nsEmitter(os, cppNamespace);
-
-  // Emit the traits struct containing the concept and model declarations.
-  os << "namespace detail {\n"
-     << "struct " << interfaceTraitsName << " {\n";
-  emitConceptDecl(availability, os);
-  os << '\n';
-  emitModelDecl(availability, os);
-  os << "};\n} // namespace detail\n\n";
-
-  // Emit the main interface class declaration.
-  os << "/*\n" << availability.getInterfaceDescription().trim() << "\n*/\n";
-  os << llvm::formatv("class {0} : public OpInterface<{1}, detail::{2}> {\n"
-                      "public:\n"
-                      "  using OpInterface<{1}, detail::{2}>::OpInterface;\n",
-                      interfaceName, interfaceName, interfaceTraitsName);
-
-  // Emit query function declaration.
-  os << "  " << availability.getQueryFnRetType() << " "
-     << availability.getQueryFnName() << "();\n";
-  os << "};\n\n";
-}
-
-static bool emitInterfaceDecls(const RecordKeeper &recordKeeper,
-                               raw_ostream &os) {
-  llvm::emitSourceFileHeader("Availability Interface Declarations", os);
-
-  auto defs = recordKeeper.getAllDerivedDefinitions("Availability");
-  SmallVector<const Record *, 4> handledClasses;
-  for (const Record *def : defs) {
-    SmallVector<Record *, 1> parent;
-    def->getDirectSuperClasses(parent);
-    if (parent.size() != 1) {
-      PrintFatalError(def->getLoc(),
-                      "expected to only have one direct superclass");
-    }
-    if (llvm::is_contained(handledClasses, parent.front()))
-      continue;
-
-    Availability avail(def);
-    emitInterfaceDecl(avail, os);
-    handledClasses.push_back(parent.front());
-  }
-  return false;
-}
-
-//===----------------------------------------------------------------------===//
-// Availability Interface Hook Registration
-//===----------------------------------------------------------------------===//
-
-// Registers the operation interface generator to mlir-tblgen.
-static mlir::GenRegistration
-    genInterfaceDecls("gen-avail-interface-decls",
-                      "Generate availability interface declarations",
-                      [](const RecordKeeper &records, raw_ostream &os) {
-                        return emitInterfaceDecls(records, os);
-                      });
-
-// Registers the operation interface generator to mlir-tblgen.
-static mlir::GenRegistration
-    genInterfaceDefs("gen-avail-interface-defs",
-                     "Generate op interface definitions",
-                     [](const RecordKeeper &records, raw_ostream &os) {
-                       return emitInterfaceDefs(records, os);
-                     });
-
-//===----------------------------------------------------------------------===//
-// Enum Availability Query AutoGen
-//===----------------------------------------------------------------------===//
-
-static void emitAvailabilityQueryForIntEnum(const Record &enumDef,
-                                            raw_ostream &os) {
-  EnumAttr enumAttr(enumDef);
-  StringRef enumName = enumAttr.getEnumClassName();
-  std::vector<EnumAttrCase> enumerants = enumAttr.getAllCases();
-
-  // Mapping from availability class name to (enumerant, availability
-  // specification) pairs.
-  llvm::StringMap<llvm::SmallVector<std::pair<EnumAttrCase, Availability>, 1>>
-      classCaseMap;
-
-  // Place all availability specifications to their corresponding
-  // availability classes.
-  for (const EnumAttrCase &enumerant : enumerants)
-    for (const Availability &avail : getAvailabilities(enumerant.getDef()))
-      classCaseMap[avail.getClass()].push_back({enumerant, avail});
-
-  for (const auto &classCasePair : classCaseMap) {
-    Availability avail = classCasePair.getValue().front().second;
-
-    os << formatv("llvm::Optional<{0}> {1}({2} value) {{\n",
-                  avail.getMergeInstanceType(), avail.getQueryFnName(),
-                  enumName);
-
-    os << "  switch (value) {\n";
-    for (const auto &caseSpecPair : classCasePair.getValue()) {
-      EnumAttrCase enumerant = caseSpecPair.first;
-      Availability avail = caseSpecPair.second;
-      os << formatv("  case {0}::{1}: { {2} return {3}({4}); }\n", enumName,
-                    enumerant.getSymbol(), avail.getMergeInstancePreparation(),
-                    avail.getMergeInstanceType(), avail.getMergeInstance());
-    }
-    // Only emit default if uncovered cases.
-    if (classCasePair.getValue().size() < enumAttr.getAllCases().size())
-      os << "  default: break;\n";
-    os << "  }\n"
-       << "  return llvm::None;\n"
-       << "}\n";
-  }
-}
-
-static void emitAvailabilityQueryForBitEnum(const Record &enumDef,
-                                            raw_ostream &os) {
-  EnumAttr enumAttr(enumDef);
-  StringRef enumName = enumAttr.getEnumClassName();
-  std::string underlyingType = std::string(enumAttr.getUnderlyingType());
-  std::vector<EnumAttrCase> enumerants = enumAttr.getAllCases();
-
-  // Mapping from availability class name to (enumerant, availability
-  // specification) pairs.
-  llvm::StringMap<llvm::SmallVector<std::pair<EnumAttrCase, Availability>, 1>>
-      classCaseMap;
-
-  // Place all availability specifications to their corresponding
-  // availability classes.
-  for (const EnumAttrCase &enumerant : enumerants)
-    for (const Availability &avail : getAvailabilities(enumerant.getDef()))
-      classCaseMap[avail.getClass()].push_back({enumerant, avail});
-
-  for (const auto &classCasePair : classCaseMap) {
-    Availability avail = classCasePair.getValue().front().second;
-
-    os << formatv("llvm::Optional<{0}> {1}({2} value) {{\n",
-                  avail.getMergeInstanceType(), avail.getQueryFnName(),
-                  enumName);
-
-    os << formatv(
-        "  assert(::llvm::countPopulation(static_cast<{0}>(value)) <= 1"
-        " && \"cannot have more than one bit set\");\n",
-        underlyingType);
-
-    os << "  switch (value) {\n";
-    for (const auto &caseSpecPair : classCasePair.getValue()) {
-      EnumAttrCase enumerant = caseSpecPair.first;
-      Availability avail = caseSpecPair.second;
-      os << formatv("  case {0}::{1}: { {2} return {3}({4}); }\n", enumName,
-                    enumerant.getSymbol(), avail.getMergeInstancePreparation(),
-                    avail.getMergeInstanceType(), avail.getMergeInstance());
-    }
-    os << "  default: break;\n";
-    os << "  }\n"
-       << "  return llvm::None;\n"
-       << "}\n";
-  }
-}
-
-static void emitEnumDecl(const Record &enumDef, raw_ostream &os) {
-  EnumAttr enumAttr(enumDef);
-  StringRef enumName = enumAttr.getEnumClassName();
-  StringRef cppNamespace = enumAttr.getCppNamespace();
-  auto enumerants = enumAttr.getAllCases();
-
-  llvm::SmallVector<StringRef, 2> namespaces;
-  llvm::SplitString(cppNamespace, namespaces, "::");
-
-  for (auto ns : namespaces)
-    os << "namespace " << ns << " {\n";
-
-  llvm::StringSet<> handledClasses;
-
-  // Place all availability specifications to their corresponding
-  // availability classes.
-  for (const EnumAttrCase &enumerant : enumerants)
-    for (const Availability &avail : getAvailabilities(enumerant.getDef())) {
-      StringRef className = avail.getClass();
-      if (handledClasses.count(className))
-        continue;
-      os << formatv("llvm::Optional<{0}> {1}({2} value);\n",
-                    avail.getMergeInstanceType(), avail.getQueryFnName(),
-                    enumName);
-      handledClasses.insert(className);
-    }
-
-  for (auto ns : llvm::reverse(namespaces))
-    os << "} // namespace " << ns << "\n";
-}
-
-static bool emitEnumDecls(const RecordKeeper &recordKeeper, raw_ostream &os) {
-  llvm::emitSourceFileHeader("SPIR-V Enum Availability Declarations", os);
-
-  auto defs = recordKeeper.getAllDerivedDefinitions("EnumAttrInfo");
-  for (const auto *def : defs)
-    emitEnumDecl(*def, os);
-
-  return false;
-}
-
-static void emitEnumDef(const Record &enumDef, raw_ostream &os) {
-  EnumAttr enumAttr(enumDef);
-  StringRef cppNamespace = enumAttr.getCppNamespace();
-
-  llvm::SmallVector<StringRef, 2> namespaces;
-  llvm::SplitString(cppNamespace, namespaces, "::");
-
-  for (auto ns : namespaces)
-    os << "namespace " << ns << " {\n";
-
-  if (enumAttr.isBitEnum()) {
-    emitAvailabilityQueryForBitEnum(enumDef, os);
-  } else {
-    emitAvailabilityQueryForIntEnum(enumDef, os);
-  }
-
-  for (auto ns : llvm::reverse(namespaces))
-    os << "} // namespace " << ns << "\n";
-  os << "\n";
-}
-
-static bool emitEnumDefs(const RecordKeeper &recordKeeper, raw_ostream &os) {
-  llvm::emitSourceFileHeader("SPIR-V Enum Availability Definitions", os);
-
-  auto defs = recordKeeper.getAllDerivedDefinitions("EnumAttrInfo");
-  for (const auto *def : defs)
-    emitEnumDef(*def, os);
-
-  return false;
-}
-
-//===----------------------------------------------------------------------===//
-// Enum Availability Query Hook Registration
-//===----------------------------------------------------------------------===//
-
-// Registers the enum utility generator to mlir-tblgen.
-static mlir::GenRegistration
-    genEnumDecls("gen-spirv-enum-avail-decls",
-                 "Generate SPIR-V enum availability declarations",
-                 [](const RecordKeeper &records, raw_ostream &os) {
-                   return emitEnumDecls(records, os);
-                 });
-
-// Registers the enum utility generator to mlir-tblgen.
-static mlir::GenRegistration
-    genEnumDefs("gen-spirv-enum-avail-defs",
-                "Generate SPIR-V enum availability definitions",
-                [](const RecordKeeper &records, raw_ostream &os) {
-                  return emitEnumDefs(records, os);
-                });
-
-//===----------------------------------------------------------------------===//
 // Serialization AutoGen
 //===----------------------------------------------------------------------===//
 
 /// Generates code to serialize attributes of a SPV_Op `op` into `os`. The
 /// generates code extracts the attribute with name `attrName` from
 /// `operandList` of `op`.
 static void emitAttributeSerialization(const Attribute &attr,
                                        ArrayRef<SMLoc> loc, StringRef tabs,

 static mlir::GenRegistration
     genOpUtils("gen-spirv-attr-utils",
                "Generate SPIR-V attribute utility definitions",
                [](const RecordKeeper &records, raw_ostream &os) {
                  return emitAttrUtils(records, os);
                });
 
 //===----------------------------------------------------------------------===//
-// SPIR-V Availability Impl AutoGen
-//===----------------------------------------------------------------------===//
-
-static void emitAvailabilityImpl(const Operator &srcOp, raw_ostream &os) {
-  mlir::tblgen::FmtContext fctx;
-  fctx.addSubst("overall", "tblgen_overall");
-
-  std::vector<Availability> opAvailabilities =
-      getAvailabilities(srcOp.getDef());
-
-  // First collect all availability classes this op should implement.
-  // All availability instances keep information for the generated interface and
-  // the instance's specific requirement. Here we remember a random instance so
-  // we can get the information regarding the generated interface.
-  llvm::StringMap<Availability> availClasses;
-  for (const Availability &avail : opAvailabilities)
-    availClasses.try_emplace(avail.getClass(), avail);
-  for (const NamedAttribute &namedAttr : srcOp.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.try_emplace(caseAvail.getClass(), caseAvail);
-  }
-
-  // Then generate implementation for each availability class.
-  for (const auto &availClass : availClasses) {
-    StringRef availClassName = availClass.getKey();
-    Availability avail = availClass.getValue();
-
-    // Generate the implementation method signature.
-    os << formatv("{0} {1}::{2}() {{\n", avail.getQueryFnRetType(),
-                  srcOp.getCppClassName(), avail.getQueryFnName());
-
-    // Create the variable for the final requirement and initialize it.
-    os << formatv("  {0} tblgen_overall = {1};\n", avail.getQueryFnRetType(),
-                  avail.getMergeInitializer());
-
-    // Update with the op's specific availability spec.
-    for (const Availability &avail : opAvailabilities)
-      if (avail.getClass() == availClassName &&
-          (!avail.getMergeInstancePreparation().empty() ||
-           !avail.getMergeActionCode().empty())) {
-        os << "  {\n    "
-           // Prepare this instance.
-           << avail.getMergeInstancePreparation()
-           << "\n    "
-           // Merge this instance.
-           << std::string(
-                  tgfmt(avail.getMergeActionCode(),
-                        &fctx.addSubst("instance", avail.getMergeInstance())))
-           << ";\n  }\n";
-      }
-
-    // Update with enum attributes' specific availability spec.
-    for (const NamedAttribute &namedAttr : srcOp.getAttributes()) {
-      const auto *enumAttr = llvm::dyn_cast<EnumAttr>(&namedAttr.attr);
-      if (!enumAttr)
-        continue;
-
-      // (enumerant, availability specification) pairs for this availability
-      // class.
-      SmallVector<std::pair<EnumAttrCase, Availability>, 1> caseSpecs;
-
-      // Collect all cases' availability specs.
-      for (const EnumAttrCase &enumerant : enumAttr->getAllCases())
-        for (const Availability &caseAvail :
-             getAvailabilities(enumerant.getDef()))
-          if (availClassName == caseAvail.getClass())
-            caseSpecs.push_back({enumerant, caseAvail});
-
-      // If this attribute kind does not have any availability spec from any of
-      // its cases, no more work to do.
-      if (caseSpecs.empty())
-        continue;
-
-      if (enumAttr->isBitEnum()) {
-        // For BitEnumAttr, we need to iterate over each bit to query its
-        // availability spec.
-        os << formatv("  for (unsigned i = 0; "
-                      "i < std::numeric_limits<{0}>::digits; ++i) {{\n",
-                      enumAttr->getUnderlyingType());
-        os << formatv("    {0}::{1} tblgen_attrVal = this->{2}() & "
-                      "static_cast<{0}::{1}>(1 << i);\n",
-                      enumAttr->getCppNamespace(), enumAttr->getEnumClassName(),
-                      namedAttr.name);
-        os << formatv(
-            "    if (static_cast<{0}>(tblgen_attrVal) == 0) continue;\n",
-            enumAttr->getUnderlyingType());
-      } else {
-        // For IntEnumAttr, we just need to query the value as a whole.
-        os << "  {\n";
-        os << formatv("    auto tblgen_attrVal = this->{0}();\n",
-                      namedAttr.name);
-      }
-      os << formatv("    auto tblgen_instance = {0}::{1}(tblgen_attrVal);\n",
-                    enumAttr->getCppNamespace(), avail.getQueryFnName());
-      os << "    if (tblgen_instance) "
-         // TODO` here once ODS supports
-         // dialect-specific contents so that we can use not implementing the
-         // availability interface as indication of no requirements.
-         << std::string(tgfmt(caseSpecs.front().second.getMergeActionCode(),
-                              &fctx.addSubst("instance", "*tblgen_instance")))
-         << ";\n";
-      os << "  }\n";
-    }
-
-    os << "  return tblgen_overall;\n";
-    os << "}\n";
-  }
-}
-
-static bool emitAvailabilityImpl(const RecordKeeper &recordKeeper,
-                                 raw_ostream &os) {
-  llvm::emitSourceFileHeader("SPIR-V Op Availability Implementations", os);
-
-  auto defs = recordKeeper.getAllDerivedDefinitions("SPV_Op");
-  for (const auto *def : defs) {
-    Operator op(def);
-    emitAvailabilityImpl(op, os);
-  }
-  return false;
-}
-
-//===----------------------------------------------------------------------===//
-// Op Availability Implementation Hook Registration
-//===----------------------------------------------------------------------===//
-
-static mlir::GenRegistration
-    genOpAvailabilityImpl("gen-spirv-avail-impls",
-                          "Generate SPIR-V operation utility definitions",
-                          [](const RecordKeeper &records, raw_ostream &os) {
-                            return emitAvailabilityImpl(records, os);
-                          });
-
-//===----------------------------------------------------------------------===//
 // SPIR-V Capability Implication AutoGen
 //===----------------------------------------------------------------------===//
 
 static bool emitCapabilityImplication(const RecordKeeper &recordKeeper,
                                       raw_ostream &os) {
   llvm::emitSourceFileHeader("SPIR-V Capability Implication", os);
 
   EnumAttr enumAttr(recordKeeper.getDef("SPV_CapabilityAttr"));

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:

utils/bazel/llvm-project-overlay/mlir/BUILD.bazel

tbl_outs = [
             ["-gen-enum-decls"],
             "include/mlir/Dialect/SPIRV/IR/SPIRVEnums.h.inc",
         ),
         (
             ["-gen-enum-defs"],
             "include/mlir/Dialect/SPIRV/IR/SPIRVEnums.cpp.inc",
         ),
         (
-            ["-gen-spirv-enum-avail-decls"],
+            ["-gen-enum-avail-decls"],
             "include/mlir/Dialect/SPIRV/IR/SPIRVEnumAvailability.h.inc",
         ),
         (
-            ["-gen-spirv-enum-avail-defs"],
+            ["-gen-enum-avail-defs"],
             "include/mlir/Dialect/SPIRV/IR/SPIRVEnumAvailability.cpp.inc",
         ),
         (
             ["-gen-spirv-capability-implication"],
             "include/mlir/Dialect/SPIRV/IR/SPIRVCapabilityImplication.inc",
         ),
     ],
     tblgen = ":mlir-tblgen",
tbl_outs = [
         (
             ["-gen-avail-interface-decls"],
             "include/mlir/Dialect/SPIRV/IR/SPIRVAvailability.h.inc",
         ),
         (
             ["-gen-avail-interface-defs"],
             "include/mlir/Dialect/SPIRV/IR/SPIRVAvailability.cpp.inc",
         ),
-        (
-            ["-gen-spirv-avail-impls"],
-            "include/mlir/Dialect/SPIRV/IR/SPIRVOpAvailabilityImpl.inc",
-        ),
     ],
     tblgen = ":mlir-tblgen",
     td_file = "include/mlir/Dialect/SPIRV/IR/SPIRVOps.td",
     deps = [":SPIRVOpsTdFiles"],
 )
 
 gentbl_cc_library(
     name = "SPIRVTargetAndABIStructGen",

utils/bazel/llvm-project-overlay/mlir/test/BUILD.bazel

tbl_outs = [
         (
             ["-gen-struct-attr-defs"],
             "lib/Dialect/Test/TestOpStructs.cpp.inc",
         ),
         (
             ["-gen-rewriters"],
             "lib/Dialect/Test/TestPatterns.inc",
         ),
+        (
+            ["-gen-avail-interface-decls"],
+            "lib/Dialect/Test/TestOpAvailability.h.inc",
+        ),
+        (
+            ["-gen-avail-interface-defs"],
+            "lib/Dialect/Test/TestOpAvailability.cpp.inc",
+        ),
+        (
+            ["-gen-enum-avail-decls"],
+            "lib/Dialect/Test/TestEnumAvailability.h.inc",
+        ),
+        (
+            ["-gen-enum-avail-defs"],
+            "lib/Dialect/Test/TestEnumAvailability.cpp.inc",
+        ),
     ],
     tblgen = "//mlir:mlir-tblgen",
     td_file = "lib/Dialect/Test/TestOps.td",
     test = True,
     deps = [
         ":TestOpTdFiles",
     ],
 )

 )
 
 cc_library(
     name = "TestDialect",
     srcs = [
         "lib/Dialect/Test/TestAttributes.cpp",
         "lib/Dialect/Test/TestDialect.cpp",
         "lib/Dialect/Test/TestInterfaces.cpp",
+        "lib/Dialect/Test/TestOpAvailability.cpp",
         "lib/Dialect/Test/TestPatterns.cpp",
         "lib/Dialect/Test/TestTraits.cpp",
         "lib/Dialect/Test/TestTypes.cpp",
     ],
     hdrs = [
         "lib/Dialect/Test/TestAttributes.h",
         "lib/Dialect/Test/TestDialect.h",
         "lib/Dialect/Test/TestInterfaces.h",