[Spv.Generator] Address dotnet-format issues (#5394)

* dotnet format style --severity info

Some changes were manually reverted.

* Restore a few unused methods and variables

* Silence dotnet format IDE0052 warnings

* Address or silence dotnet format IDE1006 warnings

* Address or silence dotnet format CA1069 warnings

* Address review comments

* Address most dotnet format whitespace warnings

* Run dotnet format after rebase and remove unused usings

- analyzers
- style
- whitespace

* Add comments to disabled warnings

* Simplify properties and array initialization, Use const when possible, Remove trailing commas

* Address IDE0251 warnings

* Revert "Simplify properties and array initialization, Use const when possible, Remove trailing commas"

This reverts commit 9462e4136c0a2100dc28b20cf9542e06790aa67e.

* dotnet format whitespace after rebase

* Rename Operand.cs to IOperand.cs

* Update src/Spv.Generator/Module.cs

Co-authored-by: Ac_K <Acoustik666@gmail.com>

* Remove NotNullWhen attribute and use conditional access to avoid NRE

* Fix duplicated enum values

* Remove unread member

---------

Co-authored-by: Ac_K <Acoustik666@gmail.com>

src/Spv.Generator/Autogenerated/CoreGrammar.cs

@@ -180,7 +180,7 @@ namespace Spv.Generator
             return result;
         }
 
-        public Instruction Decorate(Instruction target, Decoration decoration, Operand parameter)
+        public Instruction Decorate(Instruction target, Decoration decoration, IOperand parameter)
         {
             Instruction result = NewInstruction(Op.OpDecorate);
 
@@ -192,7 +192,7 @@ namespace Spv.Generator
             return result;
         }
 
-        public Instruction Decorate(Instruction target, Decoration decoration, params Operand[] parameters)
+        public Instruction Decorate(Instruction target, Decoration decoration, params IOperand[] parameters)
         {
             Instruction result = NewInstruction(Op.OpDecorate);
 
@@ -216,7 +216,7 @@ namespace Spv.Generator
             return result;
         }
 
-        public Instruction MemberDecorate(Instruction structureType, LiteralInteger member, Decoration decoration, Operand parameter)
+        public Instruction MemberDecorate(Instruction structureType, LiteralInteger member, Decoration decoration, IOperand parameter)
         {
             Instruction result = NewInstruction(Op.OpMemberDecorate);
 
@@ -229,7 +229,7 @@ namespace Spv.Generator
             return result;
         }
 
-        public Instruction MemberDecorate(Instruction structureType, LiteralInteger member, Decoration decoration, params Operand[] parameters)
+        public Instruction MemberDecorate(Instruction structureType, LiteralInteger member, Decoration decoration, params IOperand[] parameters)
         {
             Instruction result = NewInstruction(Op.OpMemberDecorate);
 
@@ -262,7 +262,7 @@ namespace Spv.Generator
             return result;
         }
 
-        public Instruction GroupMemberDecorate(Instruction decorationGroup, params Operand[] targets)
+        public Instruction GroupMemberDecorate(Instruction decorationGroup, params IOperand[] targets)
         {
             Instruction result = NewInstruction(Op.OpGroupMemberDecorate);
 
@@ -273,7 +273,7 @@ namespace Spv.Generator
             return result;
         }
 
-        public Instruction DecorateId(Instruction target, Decoration decoration, params Operand[] parameters)
+        public Instruction DecorateId(Instruction target, Decoration decoration, params IOperand[] parameters)
         {
             Instruction result = NewInstruction(Op.OpDecorateId);
 
@@ -285,7 +285,7 @@ namespace Spv.Generator
             return result;
         }
 
-        public Instruction DecorateString(Instruction target, Decoration decoration, params Operand[] parameters)
+        public Instruction DecorateString(Instruction target, Decoration decoration, params IOperand[] parameters)
         {
             Instruction result = NewInstruction(Op.OpDecorateString);
 
@@ -297,7 +297,7 @@ namespace Spv.Generator
             return result;
         }
 
-        public Instruction DecorateStringGOOGLE(Instruction target, Decoration decoration, params Operand[] parameters)
+        public Instruction DecorateStringGOOGLE(Instruction target, Decoration decoration, params IOperand[] parameters)
         {
             Instruction result = NewInstruction(Op.OpDecorateStringGOOGLE);
 
@@ -309,7 +309,7 @@ namespace Spv.Generator
             return result;
         }
 
-        public Instruction MemberDecorateString(Instruction structType, LiteralInteger member, Decoration decoration, params Operand[] parameters)
+        public Instruction MemberDecorateString(Instruction structType, LiteralInteger member, Decoration decoration, params IOperand[] parameters)
         {
             Instruction result = NewInstruction(Op.OpMemberDecorateString);
 
@@ -322,7 +322,7 @@ namespace Spv.Generator
             return result;
         }
 
-        public Instruction MemberDecorateStringGOOGLE(Instruction structType, LiteralInteger member, Decoration decoration, params Operand[] parameters)
+        public Instruction MemberDecorateStringGOOGLE(Instruction structType, LiteralInteger member, Decoration decoration, params IOperand[] parameters)
         {
             Instruction result = NewInstruction(Op.OpMemberDecorateStringGOOGLE);
 
@@ -2815,7 +2815,7 @@ namespace Spv.Generator
             return result;
         }
 
-        public Instruction Switch(Instruction selector, Instruction defaultObj, params Operand[] target)
+        public Instruction Switch(Instruction selector, Instruction defaultObj, params IOperand[] target)
         {
             Instruction result = NewInstruction(Op.OpSwitch);
 

src/Spv.Generator/Autogenerated/GlslStd450Grammar.cs

@@ -26,8 +26,6 @@
 // IN THE MATERIALS.
 #endregion
 
-using static Spv.Specification;
-
 namespace Spv.Generator
 {
     public partial class Module
@@ -36,406 +34,406 @@ namespace Spv.Generator
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 1, x);
         }
-        
+
         public Instruction GlslRoundEven(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 2, x);
         }
-        
+
         public Instruction GlslTrunc(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 3, x);
         }
-        
+
         public Instruction GlslFAbs(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 4, x);
         }
-        
+
         public Instruction GlslSAbs(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 5, x);
         }
-        
+
         public Instruction GlslFSign(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 6, x);
         }
-        
+
         public Instruction GlslSSign(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 7, x);
         }
-        
+
         public Instruction GlslFloor(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 8, x);
         }
-        
+
         public Instruction GlslCeil(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 9, x);
         }
-        
+
         public Instruction GlslFract(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 10, x);
         }
-        
+
         public Instruction GlslRadians(Instruction resultType, Instruction degrees)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 11, degrees);
         }
-        
+
         public Instruction GlslDegrees(Instruction resultType, Instruction radians)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 12, radians);
         }
-        
+
         public Instruction GlslSin(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 13, x);
         }
-        
+
         public Instruction GlslCos(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 14, x);
         }
-        
+
         public Instruction GlslTan(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 15, x);
         }
-        
+
         public Instruction GlslAsin(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 16, x);
         }
-        
+
         public Instruction GlslAcos(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 17, x);
         }
-        
+
         public Instruction GlslAtan(Instruction resultType, Instruction y_over_x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 18, y_over_x);
         }
-        
+
         public Instruction GlslSinh(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 19, x);
         }
-        
+
         public Instruction GlslCosh(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 20, x);
         }
-        
+
         public Instruction GlslTanh(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 21, x);
         }
-        
+
         public Instruction GlslAsinh(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 22, x);
         }
-        
+
         public Instruction GlslAcosh(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 23, x);
         }
-        
+
         public Instruction GlslAtanh(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 24, x);
         }
-        
+
         public Instruction GlslAtan2(Instruction resultType, Instruction y, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 25, y, x);
         }
-        
+
         public Instruction GlslPow(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 26, x, y);
         }
-        
+
         public Instruction GlslExp(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 27, x);
         }
-        
+
         public Instruction GlslLog(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 28, x);
         }
-        
+
         public Instruction GlslExp2(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 29, x);
         }
-        
+
         public Instruction GlslLog2(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 30, x);
         }
-        
+
         public Instruction GlslSqrt(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 31, x);
         }
-        
+
         public Instruction GlslInverseSqrt(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 32, x);
         }
-        
+
         public Instruction GlslDeterminant(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 33, x);
         }
-        
+
         public Instruction GlslMatrixInverse(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 34, x);
         }
-        
+
         public Instruction GlslModf(Instruction resultType, Instruction x, Instruction i)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 35, x, i);
         }
-        
+
         public Instruction GlslModfStruct(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 36, x);
         }
-        
+
         public Instruction GlslFMin(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 37, x, y);
         }
-        
+
         public Instruction GlslUMin(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 38, x, y);
         }
-        
+
         public Instruction GlslSMin(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 39, x, y);
         }
-        
+
         public Instruction GlslFMax(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 40, x, y);
         }
-        
+
         public Instruction GlslUMax(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 41, x, y);
         }
-        
+
         public Instruction GlslSMax(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 42, x, y);
         }
-        
+
         public Instruction GlslFClamp(Instruction resultType, Instruction x, Instruction minVal, Instruction maxVal)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 43, x, minVal, maxVal);
         }
-        
+
         public Instruction GlslUClamp(Instruction resultType, Instruction x, Instruction minVal, Instruction maxVal)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 44, x, minVal, maxVal);
         }
-        
+
         public Instruction GlslSClamp(Instruction resultType, Instruction x, Instruction minVal, Instruction maxVal)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 45, x, minVal, maxVal);
         }
-        
+
         public Instruction GlslFMix(Instruction resultType, Instruction x, Instruction y, Instruction a)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 46, x, y, a);
         }
-        
+
         public Instruction GlslIMix(Instruction resultType, Instruction x, Instruction y, Instruction a)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 47, x, y, a);
         }
-        
+
         public Instruction GlslStep(Instruction resultType, Instruction edge, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 48, edge, x);
         }
-        
+
         public Instruction GlslSmoothStep(Instruction resultType, Instruction edge0, Instruction edge1, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 49, edge0, edge1, x);
         }
-        
+
         public Instruction GlslFma(Instruction resultType, Instruction a, Instruction b, Instruction c)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 50, a, b, c);
         }
-        
+
         public Instruction GlslFrexp(Instruction resultType, Instruction x, Instruction exp)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 51, x, exp);
         }
-        
+
         public Instruction GlslFrexpStruct(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 52, x);
         }
-        
+
         public Instruction GlslLdexp(Instruction resultType, Instruction x, Instruction exp)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 53, x, exp);
         }
-        
+
         public Instruction GlslPackSnorm4x8(Instruction resultType, Instruction v)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 54, v);
         }
-        
+
         public Instruction GlslPackUnorm4x8(Instruction resultType, Instruction v)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 55, v);
         }
-        
+
         public Instruction GlslPackSnorm2x16(Instruction resultType, Instruction v)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 56, v);
         }
-        
+
         public Instruction GlslPackUnorm2x16(Instruction resultType, Instruction v)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 57, v);
         }
-        
+
         public Instruction GlslPackHalf2x16(Instruction resultType, Instruction v)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 58, v);
         }
-        
+
         public Instruction GlslPackDouble2x32(Instruction resultType, Instruction v)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 59, v);
         }
-        
+
         public Instruction GlslUnpackSnorm2x16(Instruction resultType, Instruction p)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 60, p);
         }
-        
+
         public Instruction GlslUnpackUnorm2x16(Instruction resultType, Instruction p)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 61, p);
         }
-        
+
         public Instruction GlslUnpackHalf2x16(Instruction resultType, Instruction v)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 62, v);
         }
-        
+
         public Instruction GlslUnpackSnorm4x8(Instruction resultType, Instruction p)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 63, p);
         }
-        
+
         public Instruction GlslUnpackUnorm4x8(Instruction resultType, Instruction p)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 64, p);
         }
-        
+
         public Instruction GlslUnpackDouble2x32(Instruction resultType, Instruction v)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 65, v);
         }
-        
+
         public Instruction GlslLength(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 66, x);
         }
-        
+
         public Instruction GlslDistance(Instruction resultType, Instruction p0, Instruction p1)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 67, p0, p1);
         }
-        
+
         public Instruction GlslCross(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 68, x, y);
         }
-        
+
         public Instruction GlslNormalize(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 69, x);
         }
-        
+
         public Instruction GlslFaceForward(Instruction resultType, Instruction n, Instruction i, Instruction nref)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 70, n, i, nref);
         }
-        
+
         public Instruction GlslReflect(Instruction resultType, Instruction i, Instruction n)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 71, i, n);
         }
-        
+
         public Instruction GlslRefract(Instruction resultType, Instruction i, Instruction n, Instruction eta)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 72, i, n, eta);
         }
-        
+
         public Instruction GlslFindILsb(Instruction resultType, Instruction value)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 73, value);
         }
-        
+
         public Instruction GlslFindSMsb(Instruction resultType, Instruction value)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 74, value);
         }
-        
+
         public Instruction GlslFindUMsb(Instruction resultType, Instruction value)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 75, value);
         }
-        
+
         public Instruction GlslInterpolateAtCentroid(Instruction resultType, Instruction interpolant)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 76, interpolant);
         }
-        
+
         public Instruction GlslInterpolateAtSample(Instruction resultType, Instruction interpolant, Instruction sample)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 77, interpolant, sample);
         }
-        
+
         public Instruction GlslInterpolateAtOffset(Instruction resultType, Instruction interpolant, Instruction offset)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 78, interpolant, offset);
         }
-        
+
         public Instruction GlslNMin(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 79, x, y);
         }
-        
+
         public Instruction GlslNMax(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 80, x, y);
         }
-        
+
         public Instruction GlslNClamp(Instruction resultType, Instruction x, Instruction minVal, Instruction maxVal)
         {
             return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 81, x, minVal, maxVal);
         }
-        
+
     }
 }

src/Spv.Generator/Autogenerated/OpenClGrammar.cs

@@ -36,806 +36,806 @@ namespace Spv.Generator
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 0, x);
         }
-        
+
         public Instruction OpenClAcosh(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 1, x);
         }
-        
+
         public Instruction OpenClAcospi(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 2, x);
         }
-        
+
         public Instruction OpenClAsin(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 3, x);
         }
-        
+
         public Instruction OpenClAsinh(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 4, x);
         }
-        
+
         public Instruction OpenClAsinpi(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 5, x);
         }
-        
+
         public Instruction OpenClAtan(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 6, x);
         }
-        
+
         public Instruction OpenClAtan2(Instruction resultType, Instruction y, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 7, y, x);
         }
-        
+
         public Instruction OpenClAtanh(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 8, x);
         }
-        
+
         public Instruction OpenClAtanpi(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 9, x);
         }
-        
+
         public Instruction OpenClAtan2pi(Instruction resultType, Instruction y, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 10, y, x);
         }
-        
+
         public Instruction OpenClCbrt(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 11, x);
         }
-        
+
         public Instruction OpenClCeil(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 12, x);
         }
-        
+
         public Instruction OpenClCopysign(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 13, x, y);
         }
-        
+
         public Instruction OpenClCos(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 14, x);
         }
-        
+
         public Instruction OpenClCosh(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 15, x);
         }
-        
+
         public Instruction OpenClCospi(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 16, x);
         }
-        
+
         public Instruction OpenClErfc(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 17, x);
         }
-        
+
         public Instruction OpenClErf(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 18, x);
         }
-        
+
         public Instruction OpenClExp(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 19, x);
         }
-        
+
         public Instruction OpenClExp2(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 20, x);
         }
-        
+
         public Instruction OpenClExp10(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 21, x);
         }
-        
+
         public Instruction OpenClExpm1(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 22, x);
         }
-        
+
         public Instruction OpenClFabs(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 23, x);
         }
-        
+
         public Instruction OpenClFdim(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 24, x, y);
         }
-        
+
         public Instruction OpenClFloor(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 25, x);
         }
-        
+
         public Instruction OpenClFma(Instruction resultType, Instruction a, Instruction b, Instruction c)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 26, a, b, c);
         }
-        
+
         public Instruction OpenClFmax(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 27, x, y);
         }
-        
+
         public Instruction OpenClFmin(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 28, x, y);
         }
-        
+
         public Instruction OpenClFmod(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 29, x, y);
         }
-        
+
         public Instruction OpenClFract(Instruction resultType, Instruction x, Instruction ptr)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 30, x, ptr);
         }
-        
+
         public Instruction OpenClFrexp(Instruction resultType, Instruction x, Instruction exp)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 31, x, exp);
         }
-        
+
         public Instruction OpenClHypot(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 32, x, y);
         }
-        
+
         public Instruction OpenClIlogb(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 33, x);
         }
-        
+
         public Instruction OpenClLdexp(Instruction resultType, Instruction x, Instruction k)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 34, x, k);
         }
-        
+
         public Instruction OpenClLgamma(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 35, x);
         }
-        
+
         public Instruction OpenClLgamma_r(Instruction resultType, Instruction x, Instruction signp)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 36, x, signp);
         }
-        
+
         public Instruction OpenClLog(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 37, x);
         }
-        
+
         public Instruction OpenClLog2(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 38, x);
         }
-        
+
         public Instruction OpenClLog10(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 39, x);
         }
-        
+
         public Instruction OpenClLog1p(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 40, x);
         }
-        
+
         public Instruction OpenClLogb(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 41, x);
         }
-        
+
         public Instruction OpenClMad(Instruction resultType, Instruction a, Instruction b, Instruction c)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 42, a, b, c);
         }
-        
+
         public Instruction OpenClMaxmag(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 43, x, y);
         }
-        
+
         public Instruction OpenClMinmag(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 44, x, y);
         }
-        
+
         public Instruction OpenClModf(Instruction resultType, Instruction x, Instruction iptr)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 45, x, iptr);
         }
-        
+
         public Instruction OpenClNan(Instruction resultType, Instruction nancode)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 46, nancode);
         }
-        
+
         public Instruction OpenClNextafter(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 47, x, y);
         }
-        
+
         public Instruction OpenClPow(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 48, x, y);
         }
-        
+
         public Instruction OpenClPown(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 49, x, y);
         }
-        
+
         public Instruction OpenClPowr(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 50, x, y);
         }
-        
+
         public Instruction OpenClRemainder(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 51, x, y);
         }
-        
+
         public Instruction OpenClRemquo(Instruction resultType, Instruction x, Instruction y, Instruction quo)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 52, x, y, quo);
         }
-        
+
         public Instruction OpenClRint(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 53, x);
         }
-        
+
         public Instruction OpenClRootn(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 54, x, y);
         }
-        
+
         public Instruction OpenClRound(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 55, x);
         }
-        
+
         public Instruction OpenClRsqrt(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 56, x);
         }
-        
+
         public Instruction OpenClSin(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 57, x);
         }
-        
+
         public Instruction OpenClSincos(Instruction resultType, Instruction x, Instruction cosval)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 58, x, cosval);
         }
-        
+
         public Instruction OpenClSinh(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 59, x);
         }
-        
+
         public Instruction OpenClSinpi(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 60, x);
         }
-        
+
         public Instruction OpenClSqrt(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 61, x);
         }
-        
+
         public Instruction OpenClTan(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 62, x);
         }
-        
+
         public Instruction OpenClTanh(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 63, x);
         }
-        
+
         public Instruction OpenClTanpi(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 64, x);
         }
-        
+
         public Instruction OpenClTgamma(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 65, x);
         }
-        
+
         public Instruction OpenClTrunc(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 66, x);
         }
-        
+
         public Instruction OpenClHalf_cos(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 67, x);
         }
-        
+
         public Instruction OpenClHalf_divide(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 68, x, y);
         }
-        
+
         public Instruction OpenClHalf_exp(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 69, x);
         }
-        
+
         public Instruction OpenClHalf_exp2(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 70, x);
         }
-        
+
         public Instruction OpenClHalf_exp10(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 71, x);
         }
-        
+
         public Instruction OpenClHalf_log(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 72, x);
         }
-        
+
         public Instruction OpenClHalf_log2(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 73, x);
         }
-        
+
         public Instruction OpenClHalf_log10(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 74, x);
         }
-        
+
         public Instruction OpenClHalf_powr(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 75, x, y);
         }
-        
+
         public Instruction OpenClHalf_recip(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 76, x);
         }
-        
+
         public Instruction OpenClHalf_rsqrt(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 77, x);
         }
-        
+
         public Instruction OpenClHalf_sin(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 78, x);
         }
-        
+
         public Instruction OpenClHalf_sqrt(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 79, x);
         }
-        
+
         public Instruction OpenClHalf_tan(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 80, x);
         }
-        
+
         public Instruction OpenClNative_cos(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 81, x);
         }
-        
+
         public Instruction OpenClNative_divide(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 82, x, y);
         }
-        
+
         public Instruction OpenClNative_exp(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 83, x);
         }
-        
+
         public Instruction OpenClNative_exp2(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 84, x);
         }
-        
+
         public Instruction OpenClNative_exp10(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 85, x);
         }
-        
+
         public Instruction OpenClNative_log(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 86, x);
         }
-        
+
         public Instruction OpenClNative_log2(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 87, x);
         }
-        
+
         public Instruction OpenClNative_log10(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 88, x);
         }
-        
+
         public Instruction OpenClNative_powr(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 89, x, y);
         }
-        
+
         public Instruction OpenClNative_recip(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 90, x);
         }
-        
+
         public Instruction OpenClNative_rsqrt(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 91, x);
         }
-        
+
         public Instruction OpenClNative_sin(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 92, x);
         }
-        
+
         public Instruction OpenClNative_sqrt(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 93, x);
         }
-        
+
         public Instruction OpenClNative_tan(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 94, x);
         }
-        
+
         public Instruction OpenClS_abs(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 141, x);
         }
-        
+
         public Instruction OpenClS_abs_diff(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 142, x, y);
         }
-        
+
         public Instruction OpenClS_add_sat(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 143, x, y);
         }
-        
+
         public Instruction OpenClU_add_sat(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 144, x, y);
         }
-        
+
         public Instruction OpenClS_hadd(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 145, x, y);
         }
-        
+
         public Instruction OpenClU_hadd(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 146, x, y);
         }
-        
+
         public Instruction OpenClS_rhadd(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 147, x, y);
         }
-        
+
         public Instruction OpenClU_rhadd(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 148, x, y);
         }
-        
+
         public Instruction OpenClS_clamp(Instruction resultType, Instruction x, Instruction minval, Instruction maxval)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 149, x, minval, maxval);
         }
-        
+
         public Instruction OpenClU_clamp(Instruction resultType, Instruction x, Instruction minval, Instruction maxval)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 150, x, minval, maxval);
         }
-        
+
         public Instruction OpenClClz(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 151, x);
         }
-        
+
         public Instruction OpenClCtz(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 152, x);
         }
-        
+
         public Instruction OpenClS_mad_hi(Instruction resultType, Instruction a, Instruction b, Instruction c)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 153, a, b, c);
         }
-        
+
         public Instruction OpenClU_mad_sat(Instruction resultType, Instruction x, Instruction y, Instruction z)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 154, x, y, z);
         }
-        
+
         public Instruction OpenClS_mad_sat(Instruction resultType, Instruction x, Instruction y, Instruction z)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 155, x, y, z);
         }
-        
+
         public Instruction OpenClS_max(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 156, x, y);
         }
-        
+
         public Instruction OpenClU_max(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 157, x, y);
         }
-        
+
         public Instruction OpenClS_min(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 158, x, y);
         }
-        
+
         public Instruction OpenClU_min(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 159, x, y);
         }
-        
+
         public Instruction OpenClS_mul_hi(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 160, x, y);
         }
-        
+
         public Instruction OpenClRotate(Instruction resultType, Instruction v, Instruction i)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 161, v, i);
         }
-        
+
         public Instruction OpenClS_sub_sat(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 162, x, y);
         }
-        
+
         public Instruction OpenClU_sub_sat(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 163, x, y);
         }
-        
+
         public Instruction OpenClU_upsample(Instruction resultType, Instruction hi, Instruction lo)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 164, hi, lo);
         }
-        
+
         public Instruction OpenClS_upsample(Instruction resultType, Instruction hi, Instruction lo)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 165, hi, lo);
         }
-        
+
         public Instruction OpenClPopcount(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 166, x);
         }
-        
+
         public Instruction OpenClS_mad24(Instruction resultType, Instruction x, Instruction y, Instruction z)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 167, x, y, z);
         }
-        
+
         public Instruction OpenClU_mad24(Instruction resultType, Instruction x, Instruction y, Instruction z)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 168, x, y, z);
         }
-        
+
         public Instruction OpenClS_mul24(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 169, x, y);
         }
-        
+
         public Instruction OpenClU_mul24(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 170, x, y);
         }
-        
+
         public Instruction OpenClU_abs(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 201, x);
         }
-        
+
         public Instruction OpenClU_abs_diff(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 202, x, y);
         }
-        
+
         public Instruction OpenClU_mul_hi(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 203, x, y);
         }
-        
+
         public Instruction OpenClU_mad_hi(Instruction resultType, Instruction a, Instruction b, Instruction c)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 204, a, b, c);
         }
-        
+
         public Instruction OpenClFclamp(Instruction resultType, Instruction x, Instruction minval, Instruction maxval)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 95, x, minval, maxval);
         }
-        
+
         public Instruction OpenClDegrees(Instruction resultType, Instruction radians)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 96, radians);
         }
-        
+
         public Instruction OpenClFmax_common(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 97, x, y);
         }
-        
+
         public Instruction OpenClFmin_common(Instruction resultType, Instruction x, Instruction y)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 98, x, y);
         }
-        
+
         public Instruction OpenClMix(Instruction resultType, Instruction x, Instruction y, Instruction a)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 99, x, y, a);
         }
-        
+
         public Instruction OpenClRadians(Instruction resultType, Instruction degrees)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 100, degrees);
         }
-        
+
         public Instruction OpenClStep(Instruction resultType, Instruction edge, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 101, edge, x);
         }
-        
+
         public Instruction OpenClSmoothstep(Instruction resultType, Instruction edge0, Instruction edge1, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 102, edge0, edge1, x);
         }
-        
+
         public Instruction OpenClSign(Instruction resultType, Instruction x)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 103, x);
         }
-        
+
         public Instruction OpenClCross(Instruction resultType, Instruction p0, Instruction p1)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 104, p0, p1);
         }
-        
+
         public Instruction OpenClDistance(Instruction resultType, Instruction p0, Instruction p1)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 105, p0, p1);
         }
-        
+
         public Instruction OpenClLength(Instruction resultType, Instruction p)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 106, p);
         }
-        
+
         public Instruction OpenClNormalize(Instruction resultType, Instruction p)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 107, p);
         }
-        
+
         public Instruction OpenClFast_distance(Instruction resultType, Instruction p0, Instruction p1)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 108, p0, p1);
         }
-        
+
         public Instruction OpenClFast_length(Instruction resultType, Instruction p)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 109, p);
         }
-        
+
         public Instruction OpenClFast_normalize(Instruction resultType, Instruction p)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 110, p);
         }
-        
+
         public Instruction OpenClBitselect(Instruction resultType, Instruction a, Instruction b, Instruction c)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 186, a, b, c);
         }
-        
+
         public Instruction OpenClSelect(Instruction resultType, Instruction a, Instruction b, Instruction c)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 187, a, b, c);
         }
-        
+
         public Instruction OpenClVloadn(Instruction resultType, Instruction offset, Instruction p, LiteralInteger n)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 171, offset, p, n);
         }
-        
+
         public Instruction OpenClVstoren(Instruction resultType, Instruction data, Instruction offset, Instruction p)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 172, data, offset, p);
         }
-        
+
         public Instruction OpenClVload_half(Instruction resultType, Instruction offset, Instruction p)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 173, offset, p);
         }
-        
+
         public Instruction OpenClVload_halfn(Instruction resultType, Instruction offset, Instruction p, LiteralInteger n)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 174, offset, p, n);
         }
-        
+
         public Instruction OpenClVstore_half(Instruction resultType, Instruction data, Instruction offset, Instruction p)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 175, data, offset, p);
         }
-        
+
         public Instruction OpenClVstore_half_r(Instruction resultType, Instruction data, Instruction offset, Instruction p, FPRoundingMode mode)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 176, data, offset, p, LiteralInteger.CreateForEnum(mode));
         }
-        
+
         public Instruction OpenClVstore_halfn(Instruction resultType, Instruction data, Instruction offset, Instruction p)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 177, data, offset, p);
         }
-        
+
         public Instruction OpenClVstore_halfn_r(Instruction resultType, Instruction data, Instruction offset, Instruction p, FPRoundingMode mode)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 178, data, offset, p, LiteralInteger.CreateForEnum(mode));
         }
-        
+
         public Instruction OpenClVloada_halfn(Instruction resultType, Instruction offset, Instruction p, LiteralInteger n)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 179, offset, p, n);
         }
-        
+
         public Instruction OpenClVstorea_halfn(Instruction resultType, Instruction data, Instruction offset, Instruction p)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 180, data, offset, p);
         }
-        
+
         public Instruction OpenClVstorea_halfn_r(Instruction resultType, Instruction data, Instruction offset, Instruction p, FPRoundingMode mode)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 181, data, offset, p, LiteralInteger.CreateForEnum(mode));
         }
-        
+
         public Instruction OpenClShuffle(Instruction resultType, Instruction x, Instruction shufflemask)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 182, x, shufflemask);
         }
-        
+
         public Instruction OpenClShuffle2(Instruction resultType, Instruction x, Instruction y, Instruction shufflemask)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 183, x, y, shufflemask);
         }
-        
+
         public Instruction OpenClPrefetch(Instruction resultType, Instruction ptr, Instruction numelements)
         {
             return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 185, ptr, numelements);
         }
-        
+
     }
 }

src/Spv.Generator/ConstantKey.cs

@@ -3,7 +3,7 @@ using System.Diagnostics.CodeAnalysis;
 
 namespace Spv.Generator
 {
-    internal struct ConstantKey : IEquatable<ConstantKey>
+    internal readonly struct ConstantKey : IEquatable<ConstantKey>
     {
         private readonly Instruction _constant;
 
@@ -24,7 +24,7 @@ namespace Spv.Generator
 
         public override bool Equals([NotNullWhen(true)] object obj)
         {
-            return obj is ConstantKey && Equals((ConstantKey)obj);
+            return obj is ConstantKey key && Equals(key);
         }
     }
 }

src/Spv.Generator/DeterministicStringKey.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Diagnostics.CodeAnalysis;
 
 namespace Spv.Generator
 {
@@ -19,12 +18,12 @@ namespace Spv.Generator
 
         public bool Equals(DeterministicStringKey other)
         {
-            return _value == other._value;
+            return _value == other?._value;
         }
 
-        public override bool Equals([NotNullWhen(true)] object obj)
+        public override bool Equals(object obj)
         {
-            return obj is DeterministicStringKey && Equals((DeterministicStringKey)obj);
+            return obj is DeterministicStringKey key && Equals(key);
         }
     }
 }

src/Spv.Generator/GeneratorPool.cs

@@ -4,17 +4,15 @@ namespace Spv.Generator
 {
     public class GeneratorPool<T> where T : class, new()
     {
-        private List<T[]> _pool;
+        private readonly List<T[]> _pool;
         private int _chunkIndex = -1;
         private int _poolIndex = -1;
-        private int _initialSize;
+        private readonly int _poolSizeIncrement;
-        private int _poolSizeIncrement;
 
-        public GeneratorPool(): this(1000, 200) { }
+        public GeneratorPool() : this(1000, 200) { }
 
         public GeneratorPool(int chunkSizeLimit, int poolSizeIncrement)
         {
-            _initialSize = chunkSizeLimit;
             _poolSizeIncrement = poolSizeIncrement;
 
             _pool = new(chunkSizeLimit * 2);

src/Spv.Generator/IOperand.cs

@@ -3,7 +3,7 @@ using System.IO;
 
 namespace Spv.Generator
 {
-    public interface Operand : IEquatable<Operand>
+    public interface IOperand : IEquatable<IOperand>
     {
         OperandType Type { get; }
 

src/Spv.Generator/Instruction.cs

@@ -5,7 +5,7 @@ using System.IO;
 
 namespace Spv.Generator
 {
-    public sealed class Instruction : Operand, IEquatable<Instruction>
+    public sealed class Instruction : IOperand, IEquatable<Instruction>
     {
         public const uint InvalidId = uint.MaxValue;
 
@@ -47,7 +47,7 @@ namespace Spv.Generator
                 result += _resultType.WordCount;
             }
 
-            Span<Operand> operands = _operands.AsSpan();
+            Span<IOperand> operands = _operands.AsSpan();
             for (int i = 0; i < operands.Length; i++)
             {
                 result += operands[i].WordCount;
@@ -58,15 +58,15 @@ namespace Spv.Generator
 
         public ushort WordCount => 1;
 
-        public void AddOperand(Operand value)
+        public void AddOperand(IOperand value)
         {
             Debug.Assert(value != null);
             _operands.Add(value);
         }
 
-        public void AddOperand(Operand[] value)
+        public void AddOperand(IOperand[] value)
         {
-            foreach (Operand instruction in value)
+            foreach (IOperand instruction in value)
             {
                 AddOperand(instruction);
             }
@@ -82,7 +82,7 @@ namespace Spv.Generator
 
         public void AddOperand(LiteralInteger value)
         {
-            AddOperand((Operand)value);
+            AddOperand((IOperand)value);
         }
 
         public void AddOperand(Instruction[] value)
@@ -95,7 +95,7 @@ namespace Spv.Generator
 
         public void AddOperand(Instruction value)
         {
-            AddOperand((Operand)value);
+            AddOperand((IOperand)value);
         }
 
         public void AddOperand(string value)
@@ -103,7 +103,7 @@ namespace Spv.Generator
             AddOperand(new LiteralString(value));
         }
 
-        public void AddOperand<T>(T value) where T: Enum
+        public void AddOperand<T>(T value) where T : Enum
         {
             AddOperand(LiteralInteger.CreateForEnum(value));
         }
@@ -121,7 +121,7 @@ namespace Spv.Generator
                 writer.Write(Id);
             }
 
-            Span<Operand> operands = _operands.AsSpan();
+            Span<IOperand> operands = _operands.AsSpan();
             for (int i = 0; i < operands.Length; i++)
             {
                 operands[i].WriteOperand(writer);
@@ -186,8 +186,8 @@ namespace Spv.Generator
 
         public bool EqualsContent(Instruction cmpObj)
         {
-            Span<Operand> thisOperands = _operands.AsSpan();
+            Span<IOperand> thisOperands = _operands.AsSpan();
-            Span<Operand> cmpOperands = cmpObj._operands.AsSpan();
+            Span<IOperand> cmpOperands = cmpObj._operands.AsSpan();
 
             if (thisOperands.Length != cmpOperands.Length)
             {
@@ -212,7 +212,7 @@ namespace Spv.Generator
 
         public int GetHashCodeContent()
         {
-            return DeterministicHashCode.Combine<Operand>(_operands.AsSpan());
+            return DeterministicHashCode.Combine<IOperand>(_operands.AsSpan());
         }
 
         public int GetHashCodeResultType()
@@ -222,14 +222,14 @@ namespace Spv.Generator
 
         public override int GetHashCode()
         {
-            return DeterministicHashCode.Combine(Opcode, Id, _resultType, DeterministicHashCode.Combine<Operand>(_operands.AsSpan()));
+            return DeterministicHashCode.Combine(Opcode, Id, _resultType, DeterministicHashCode.Combine<IOperand>(_operands.AsSpan()));
         }
 
-        public bool Equals(Operand obj)
+        public bool Equals(IOperand obj)
         {
             return obj is Instruction instruction && Equals(instruction);
         }
-        
+
         private static readonly Dictionary<Specification.Op, string[]> _operandLabels = new()
         {
             { Specification.Op.OpConstant, new [] { "Value" } },

src/Spv.Generator/InstructionOperands.cs

@@ -10,14 +10,14 @@ namespace Spv.Generator
         private const int InternalCount = 5;
 
         public int Count;
-        public Operand Operand1;
+        public IOperand Operand1;
-        public Operand Operand2;
+        public IOperand Operand2;
-        public Operand Operand3;
+        public IOperand Operand3;
-        public Operand Operand4;
+        public IOperand Operand4;
-        public Operand Operand5;
+        public IOperand Operand5;
-        public Operand[] Overflow;
+        public IOperand[] Overflow;
 
-        public Span<Operand> AsSpan()
+        public Span<IOperand> AsSpan()
         {
             if (Count > InternalCount)
             {
@@ -29,7 +29,7 @@ namespace Spv.Generator
             }
         }
 
-        public void Add(Operand operand)
+        public void Add(IOperand operand)
         {
             if (Count < InternalCount)
             {
@@ -40,7 +40,7 @@ namespace Spv.Generator
             {
                 if (Overflow == null)
                 {
-                    Overflow = new Operand[InternalCount * 2];
+                    Overflow = new IOperand[InternalCount * 2];
                     MemoryMarshal.CreateSpan(ref this.Operand1, InternalCount).CopyTo(Overflow.AsSpan());
                 }
                 else if (Count == Overflow.Length)
@@ -52,16 +52,16 @@ namespace Spv.Generator
             }
         }
 
-        private IEnumerable<Operand> AllOperands => new[] { Operand1, Operand2, Operand3, Operand4, Operand5 }
+        private readonly IEnumerable<IOperand> AllOperands => new[] { Operand1, Operand2, Operand3, Operand4, Operand5 }
-            .Concat(Overflow ?? Array.Empty<Operand>())
+            .Concat(Overflow ?? Array.Empty<IOperand>())
             .Take(Count);
 
-        public override string ToString()
+        public readonly override string ToString()
         {
             return $"({string.Join(", ", AllOperands)})";
         }
 
-        public string ToString(string[] labels)
+        public readonly string ToString(string[] labels)
         {
             var labeledParams = AllOperands.Zip(labels, (op, label) => $"{label}: {op}");
             var unlabeledParams = AllOperands.Skip(labels.Length).Select(op => op.ToString());

src/Spv.Generator/LiteralInteger.cs

@@ -3,7 +3,7 @@ using System.IO;
 
 namespace Spv.Generator
 {
-    public class LiteralInteger : Operand, IEquatable<LiteralInteger>
+    public class LiteralInteger : IOperand, IEquatable<LiteralInteger>
     {
         [ThreadStatic]
         private static GeneratorPool<LiteralInteger> _pool;
@@ -95,7 +95,7 @@ namespace Spv.Generator
             return DeterministicHashCode.Combine(Type, _data);
         }
 
-        public bool Equals(Operand obj)
+        public bool Equals(IOperand obj)
         {
             return obj is LiteralInteger literalInteger && Equals(literalInteger);
         }

src/Spv.Generator/LiteralString.cs

@@ -4,7 +4,7 @@ using System.Text;
 
 namespace Spv.Generator
 {
-    public class LiteralString : Operand, IEquatable<LiteralString>
+    public class LiteralString : IOperand, IEquatable<LiteralString>
     {
         public OperandType Type => OperandType.String;
 
@@ -44,7 +44,7 @@ namespace Spv.Generator
             return DeterministicHashCode.Combine(Type, DeterministicHashCode.GetHashCode(_value));
         }
 
-        public bool Equals(Operand obj)
+        public bool Equals(IOperand obj)
         {
             return obj is LiteralString literalString && Equals(literalString);
         }

src/Spv.Generator/Module.cs

@@ -15,30 +15,30 @@ namespace Spv.Generator
         private uint _bound;
 
         // Follow spec order here while keeping it as simple as possible.
-        private List<Capability> _capabilities;
+        private readonly List<Capability> _capabilities;
-        private List<string> _extensions;
+        private readonly List<string> _extensions;
-        private Dictionary<DeterministicStringKey, Instruction> _extInstImports;
+        private readonly Dictionary<DeterministicStringKey, Instruction> _extInstImports;
         private AddressingModel _addressingModel;
         private MemoryModel _memoryModel;
 
-        private List<Instruction> _entrypoints;
+        private readonly List<Instruction> _entrypoints;
-        private List<Instruction> _executionModes;
+        private readonly List<Instruction> _executionModes;
-        private List<Instruction> _debug;
+        private readonly List<Instruction> _debug;
-        private List<Instruction> _annotations;
+        private readonly List<Instruction> _annotations;
 
         // In the declaration block.
-        private Dictionary<TypeDeclarationKey, Instruction> _typeDeclarations;
+        private readonly Dictionary<TypeDeclarationKey, Instruction> _typeDeclarations;
         // In the declaration block.
-        private List<Instruction> _globals;
+        private readonly List<Instruction> _globals;
         // In the declaration block.
-        private Dictionary<ConstantKey, Instruction> _constants;
+        private readonly Dictionary<ConstantKey, Instruction> _constants;
         // In the declaration block, for function that aren't defined in the module.
-        private List<Instruction> _functionsDeclarations;
+        private readonly List<Instruction> _functionsDeclarations;
 
-        private List<Instruction> _functionsDefinitions;
+        private readonly List<Instruction> _functionsDefinitions;
 
-        private GeneratorPool<Instruction> _instPool;
+        private readonly GeneratorPool<Instruction> _instPool;
-        private GeneratorPool<LiteralInteger> _integerPool;
+        private readonly GeneratorPool<LiteralInteger> _integerPool;
 
         public Module(uint version, GeneratorPool<Instruction> instPool = null, GeneratorPool<LiteralInteger> integerPool = null)
         {
@@ -143,7 +143,7 @@ namespace Spv.Generator
             _entrypoints.Add(entryPoint);
         }
 
-        public void AddExecutionMode(Instruction function, ExecutionMode mode, params Operand[] parameters)
+        public void AddExecutionMode(Instruction function, ExecutionMode mode, params IOperand[] parameters)
         {
             Debug.Assert(function.Opcode == Op.OpFunction);
 
@@ -225,7 +225,7 @@ namespace Spv.Generator
             _constants.Add(key, constant);
         }
 
-        public Instruction ExtInst(Instruction resultType, Instruction set, LiteralInteger instruction, params Operand[] parameters)
+        public Instruction ExtInst(Instruction resultType, Instruction set, LiteralInteger instruction, params IOperand[] parameters)
         {
             Instruction result = NewInstruction(Op.OpExtInst, GetNewId(), resultType);
 
@@ -262,104 +262,103 @@ namespace Spv.Generator
             // Estimate the size needed for the generated code, to avoid expanding the MemoryStream.
             int sizeEstimate = 1024 + _functionsDefinitions.Count * 32;
 
-            using (MemoryStream stream = new MemoryStream(sizeEstimate))
+            using MemoryStream stream = new(sizeEstimate);
+
+            BinaryWriter writer = new(stream, System.Text.Encoding.ASCII);
+
+            // Header
+            writer.Write(MagicNumber);
+            writer.Write(_version);
+            writer.Write(GeneratorId);
+            writer.Write(_bound);
+            writer.Write(0u);
+
+            // 1.
+            foreach (Capability capability in _capabilities)
             {
-                BinaryWriter writer = new BinaryWriter(stream, System.Text.Encoding.ASCII);
+                Instruction capabilityInstruction = NewInstruction(Op.OpCapability);
 
-                // Header
+                capabilityInstruction.AddOperand(capability);
-                writer.Write(MagicNumber);
+                capabilityInstruction.Write(writer);
-                writer.Write(_version);
-                writer.Write(GeneratorId);
-                writer.Write(_bound);
-                writer.Write(0u);
-
-                // 1.
-                foreach (Capability capability in _capabilities)
-                {
-                    Instruction capabilityInstruction = NewInstruction(Op.OpCapability);
-
-                    capabilityInstruction.AddOperand(capability);
-                    capabilityInstruction.Write(writer);
-                }
-
-                // 2.
-                foreach (string extension in _extensions)
-                {
-                    Instruction extensionInstruction = NewInstruction(Op.OpExtension);
-
-                    extensionInstruction.AddOperand(extension);
-                    extensionInstruction.Write(writer);
-                }
-
-                // 3.
-                foreach (Instruction extInstImport in _extInstImports.Values)
-                {
-                    extInstImport.Write(writer);
-                }
-
-                // 4.
-                Instruction memoryModelInstruction = NewInstruction(Op.OpMemoryModel);
-                memoryModelInstruction.AddOperand(_addressingModel);
-                memoryModelInstruction.AddOperand(_memoryModel);
-                memoryModelInstruction.Write(writer);
-
-                // 5.
-                foreach (Instruction entrypoint in _entrypoints)
-                {
-                    entrypoint.Write(writer);
-                }
-
-                // 6.
-                foreach (Instruction executionMode in _executionModes)
-                {
-                    executionMode.Write(writer);
-                }
-
-                // 7.
-                // TODO: Order debug information correctly.
-                foreach (Instruction debug in _debug)
-                {
-                    debug.Write(writer);
-                }
-
-                // 8.
-                foreach (Instruction annotation in _annotations)
-                {
-                    annotation.Write(writer);
-                }
-
-                // Ensure that everything is in the right order in the declarations section.
-                List<Instruction> declarations = new List<Instruction>();
-                declarations.AddRange(_typeDeclarations.Values);
-                declarations.AddRange(_globals);
-                declarations.AddRange(_constants.Values);
-                declarations.Sort((Instruction x, Instruction y) => x.Id.CompareTo(y.Id));
-
-                // 9.
-                foreach (Instruction declaration in declarations)
-                {
-                    declaration.Write(writer);
-                }
-
-                // 10.
-                foreach (Instruction functionDeclaration in _functionsDeclarations)
-                {
-                    functionDeclaration.Write(writer);
-                }
-
-                // 11.
-                foreach (Instruction functionDefinition in _functionsDefinitions)
-                {
-                    functionDefinition.Write(writer);
-                }
-
-                _instPool.Clear();
-                _integerPool.Clear();
-
-                LiteralInteger.UnregisterPool();
-
-                return stream.ToArray();
             }
+
+            // 2.
+            foreach (string extension in _extensions)
+            {
+                Instruction extensionInstruction = NewInstruction(Op.OpExtension);
+
+                extensionInstruction.AddOperand(extension);
+                extensionInstruction.Write(writer);
+            }
+
+            // 3.
+            foreach (Instruction extInstImport in _extInstImports.Values)
+            {
+                extInstImport.Write(writer);
+            }
+
+            // 4.
+            Instruction memoryModelInstruction = NewInstruction(Op.OpMemoryModel);
+            memoryModelInstruction.AddOperand(_addressingModel);
+            memoryModelInstruction.AddOperand(_memoryModel);
+            memoryModelInstruction.Write(writer);
+
+            // 5.
+            foreach (Instruction entrypoint in _entrypoints)
+            {
+                entrypoint.Write(writer);
+            }
+
+            // 6.
+            foreach (Instruction executionMode in _executionModes)
+            {
+                executionMode.Write(writer);
+            }
+
+            // 7.
+            // TODO: Order debug information correctly.
+            foreach (Instruction debug in _debug)
+            {
+                debug.Write(writer);
+            }
+
+            // 8.
+            foreach (Instruction annotation in _annotations)
+            {
+                annotation.Write(writer);
+            }
+
+            // Ensure that everything is in the right order in the declarations section.
+            List<Instruction> declarations = new();
+            declarations.AddRange(_typeDeclarations.Values);
+            declarations.AddRange(_globals);
+            declarations.AddRange(_constants.Values);
+            declarations.Sort((Instruction x, Instruction y) => x.Id.CompareTo(y.Id));
+
+            // 9.
+            foreach (Instruction declaration in declarations)
+            {
+                declaration.Write(writer);
+            }
+
+            // 10.
+            foreach (Instruction functionDeclaration in _functionsDeclarations)
+            {
+                functionDeclaration.Write(writer);
+            }
+
+            // 11.
+            foreach (Instruction functionDefinition in _functionsDefinitions)
+            {
+                functionDefinition.Write(writer);
+            }
+
+            _instPool.Clear();
+            _integerPool.Clear();
+
+            LiteralInteger.UnregisterPool();
+
+            return stream.ToArray();
         }
     }
 }

src/Spv.Generator/TypeDeclarationKey.cs

@@ -3,7 +3,7 @@ using System.Diagnostics.CodeAnalysis;
 
 namespace Spv.Generator
 {
-    internal struct TypeDeclarationKey : IEquatable<TypeDeclarationKey>
+    internal readonly struct TypeDeclarationKey : IEquatable<TypeDeclarationKey>
     {
         private readonly Instruction _typeDeclaration;
 
@@ -24,7 +24,7 @@ namespace Spv.Generator
 
         public override bool Equals([NotNullWhen(true)] object obj)
         {
-            return obj is TypeDeclarationKey && Equals((TypeDeclarationKey)obj);
+            return obj is TypeDeclarationKey key && Equals(key);
         }
     }
 }

src/Spv.Generator/spirv.cs

@@ -75,17 +75,17 @@ namespace Spv
             TaskNV = 5267,
             MeshNV = 5268,
             RayGenerationKHR = 5313,
-            RayGenerationNV = 5313,
+            RayGenerationNV = RayGenerationKHR,
             IntersectionKHR = 5314,
-            IntersectionNV = 5314,
+            IntersectionNV = IntersectionKHR,
             AnyHitKHR = 5315,
-            AnyHitNV = 5315,
+            AnyHitNV = AnyHitKHR,
             ClosestHitKHR = 5316,
-            ClosestHitNV = 5316,
+            ClosestHitNV = ClosestHitKHR,
             MissKHR = 5317,
-            MissNV = 5317,
+            MissNV = MissKHR,
             CallableKHR = 5318,
-            CallableNV = 5318,
+            CallableNV = CallableKHR,
         }
 
         public enum AddressingModel
@@ -94,7 +94,7 @@ namespace Spv
             Physical32 = 1,
             Physical64 = 2,
             PhysicalStorageBuffer64 = 5348,
-            PhysicalStorageBuffer64EXT = 5348,
+            PhysicalStorageBuffer64EXT = PhysicalStorageBuffer64,
         }
 
         public enum MemoryModel
@@ -103,7 +103,7 @@ namespace Spv
             GLSL450 = 1,
             OpenCL = 2,
             Vulkan = 3,
-            VulkanKHR = 3,
+            VulkanKHR = Vulkan,
         }
 
         public enum ExecutionMode
@@ -186,19 +186,19 @@ namespace Spv
             Image = 11,
             StorageBuffer = 12,
             CallableDataKHR = 5328,
-            CallableDataNV = 5328,
+            CallableDataNV = CallableDataKHR,
             IncomingCallableDataKHR = 5329,
-            IncomingCallableDataNV = 5329,
+            IncomingCallableDataNV = IncomingCallableDataKHR,
             RayPayloadKHR = 5338,
-            RayPayloadNV = 5338,
+            RayPayloadNV = RayPayloadKHR,
             HitAttributeKHR = 5339,
-            HitAttributeNV = 5339,
+            HitAttributeNV = HitAttributeKHR,
             IncomingRayPayloadKHR = 5342,
-            IncomingRayPayloadNV = 5342,
+            IncomingRayPayloadNV = IncomingRayPayloadKHR,
             ShaderRecordBufferKHR = 5343,
-            ShaderRecordBufferNV = 5343,
+            ShaderRecordBufferNV = ShaderRecordBufferKHR,
             PhysicalStorageBuffer = 5349,
-            PhysicalStorageBufferEXT = 5349,
+            PhysicalStorageBufferEXT = PhysicalStorageBuffer,
             CodeSectionINTEL = 5605,
         }
 
@@ -330,13 +330,13 @@ namespace Spv
             Sample = 6,
             MinLod = 7,
             MakeTexelAvailable = 8,
-            MakeTexelAvailableKHR = 8,
+            MakeTexelAvailableKHR = MakeTexelAvailable,
             MakeTexelVisible = 9,
-            MakeTexelVisibleKHR = 9,
+            MakeTexelVisibleKHR = MakeTexelVisible,
             NonPrivateTexel = 10,
-            NonPrivateTexelKHR = 10,
+            NonPrivateTexelKHR = NonPrivateTexel,
             VolatileTexel = 11,
-            VolatileTexelKHR = 11,
+            VolatileTexelKHR = VolatileTexel,
             SignExtend = 12,
             ZeroExtend = 13,
         }
@@ -353,13 +353,13 @@ namespace Spv
             Sample = 0x00000040,
             MinLod = 0x00000080,
             MakeTexelAvailable = 0x00000100,
-            MakeTexelAvailableKHR = 0x00000100,
+            MakeTexelAvailableKHR = MakeTexelAvailable,
             MakeTexelVisible = 0x00000200,
-            MakeTexelVisibleKHR = 0x00000200,
+            MakeTexelVisibleKHR = MakeTexelVisible,
             NonPrivateTexel = 0x00000400,
-            NonPrivateTexelKHR = 0x00000400,
+            NonPrivateTexelKHR = NonPrivateTexel,
             VolatileTexel = 0x00000800,
-            VolatileTexelKHR = 0x00000800,
+            VolatileTexelKHR = VolatileTexel,
             SignExtend = 0x00001000,
             ZeroExtend = 0x00002000,
             Offsets = 0x00010000,
@@ -478,16 +478,16 @@ namespace Spv
             PerTaskNV = 5273,
             PerVertexNV = 5285,
             NonUniform = 5300,
-            NonUniformEXT = 5300,
+            NonUniformEXT = NonUniform,
             RestrictPointer = 5355,
-            RestrictPointerEXT = 5355,
+            RestrictPointerEXT = RestrictPointer,
             AliasedPointer = 5356,
-            AliasedPointerEXT = 5356,
+            AliasedPointerEXT = AliasedPointer,
             ReferencedIndirectlyINTEL = 5602,
             CounterBuffer = 5634,
-            HlslCounterBufferGOOGLE = 5634,
+            HlslCounterBufferGOOGLE = CounterBuffer,
             HlslSemanticGOOGLE = 5635,
-            UserSemantic = 5635,
+            UserSemantic = HlslSemanticGOOGLE,
             UserTypeGOOGLE = 5636,
             RegisterINTEL = 5825,
             MemoryINTEL = 5826,
@@ -547,15 +547,15 @@ namespace Spv
             VertexIndex = 42,
             InstanceIndex = 43,
             SubgroupEqMask = 4416,
-            SubgroupEqMaskKHR = 4416,
+            SubgroupEqMaskKHR = SubgroupEqMask,
             SubgroupGeMask = 4417,
-            SubgroupGeMaskKHR = 4417,
+            SubgroupGeMaskKHR = SubgroupGeMask,
             SubgroupGtMask = 4418,
-            SubgroupGtMaskKHR = 4418,
+            SubgroupGtMaskKHR = SubgroupGtMask,
             SubgroupLeMask = 4419,
-            SubgroupLeMaskKHR = 4419,
+            SubgroupLeMaskKHR = SubgroupLeMask,
             SubgroupLtMask = 4420,
-            SubgroupLtMaskKHR = 4420,
+            SubgroupLtMaskKHR = SubgroupLtMask,
             BaseVertex = 4424,
             BaseInstance = 4425,
             DrawIndex = 4426,
@@ -588,36 +588,36 @@ namespace Spv
             BaryCoordNV = 5286,
             BaryCoordNoPerspNV = 5287,
             FragSizeEXT = 5292,
-            FragmentSizeNV = 5292,
+            FragmentSizeNV = FragSizeEXT,
             FragInvocationCountEXT = 5293,
-            InvocationsPerPixelNV = 5293,
+            InvocationsPerPixelNV = FragInvocationCountEXT,
             LaunchIdKHR = 5319,
-            LaunchIdNV = 5319,
+            LaunchIdNV = LaunchIdKHR,
             LaunchSizeKHR = 5320,
-            LaunchSizeNV = 5320,
+            LaunchSizeNV = LaunchSizeKHR,
             WorldRayOriginKHR = 5321,
-            WorldRayOriginNV = 5321,
+            WorldRayOriginNV = WorldRayOriginKHR,
             WorldRayDirectionKHR = 5322,
-            WorldRayDirectionNV = 5322,
+            WorldRayDirectionNV = WorldRayDirectionKHR,
             ObjectRayOriginKHR = 5323,
-            ObjectRayOriginNV = 5323,
+            ObjectRayOriginNV = ObjectRayOriginKHR,
             ObjectRayDirectionKHR = 5324,
-            ObjectRayDirectionNV = 5324,
+            ObjectRayDirectionNV = ObjectRayDirectionKHR,
             RayTminKHR = 5325,
-            RayTminNV = 5325,
+            RayTminNV = RayTminKHR,
             RayTmaxKHR = 5326,
-            RayTmaxNV = 5326,
+            RayTmaxNV = RayTmaxKHR,
             InstanceCustomIndexKHR = 5327,
-            InstanceCustomIndexNV = 5327,
+            InstanceCustomIndexNV = InstanceCustomIndexKHR,
             ObjectToWorldKHR = 5330,
-            ObjectToWorldNV = 5330,
+            ObjectToWorldNV = ObjectToWorldKHR,
             WorldToObjectKHR = 5331,
-            WorldToObjectNV = 5331,
+            WorldToObjectNV = WorldToObjectKHR,
             HitTNV = 5332,
             HitKindKHR = 5333,
-            HitKindNV = 5333,
+            HitKindNV = HitKindKHR,
             IncomingRayFlagsKHR = 5351,
-            IncomingRayFlagsNV = 5351,
+            IncomingRayFlagsNV = IncomingRayFlagsKHR,
             RayGeometryIndexKHR = 5352,
             WarpsPerSMNV = 5374,
             SMCountNV = 5375,
@@ -709,11 +709,11 @@ namespace Spv
             AtomicCounterMemory = 10,
             ImageMemory = 11,
             OutputMemory = 12,
-            OutputMemoryKHR = 12,
+            OutputMemoryKHR = OutputMemory,
             MakeAvailable = 13,
-            MakeAvailableKHR = 13,
+            MakeAvailableKHR = MakeAvailable,
             MakeVisible = 14,
-            MakeVisibleKHR = 14,
+            MakeVisibleKHR = MakeVisible,
             Volatile = 15,
         }
 
@@ -731,11 +731,11 @@ namespace Spv
             AtomicCounterMemory = 0x00000400,
             ImageMemory = 0x00000800,
             OutputMemory = 0x00001000,
-            OutputMemoryKHR = 0x00001000,
+            OutputMemoryKHR = OutputMemory,
             MakeAvailable = 0x00002000,
-            MakeAvailableKHR = 0x00002000,
+            MakeAvailableKHR = MakeAvailable,
             MakeVisible = 0x00004000,
-            MakeVisibleKHR = 0x00004000,
+            MakeVisibleKHR = MakeVisible,
             Volatile = 0x00008000,
         }
 
@@ -745,11 +745,11 @@ namespace Spv
             Aligned = 1,
             Nontemporal = 2,
             MakePointerAvailable = 3,
-            MakePointerAvailableKHR = 3,
+            MakePointerAvailableKHR = MakePointerAvailable,
             MakePointerVisible = 4,
-            MakePointerVisibleKHR = 4,
+            MakePointerVisibleKHR = MakePointerVisible,
             NonPrivatePointer = 5,
-            NonPrivatePointerKHR = 5,
+            NonPrivatePointerKHR = NonPrivatePointer,
         }
 
         public enum MemoryAccessMask
@@ -759,11 +759,11 @@ namespace Spv
             Aligned = 0x00000002,
             Nontemporal = 0x00000004,
             MakePointerAvailable = 0x00000008,
-            MakePointerAvailableKHR = 0x00000008,
+            MakePointerAvailableKHR = MakePointerAvailable,
             MakePointerVisible = 0x00000010,
-            MakePointerVisibleKHR = 0x00000010,
+            MakePointerVisibleKHR = MakePointerVisible,
             NonPrivatePointer = 0x00000020,
-            NonPrivatePointerKHR = 0x00000020,
+            NonPrivatePointerKHR = NonPrivatePointer,
         }
 
         public enum Scope
@@ -774,7 +774,7 @@ namespace Spv
             Subgroup = 3,
             Invocation = 4,
             QueueFamily = 5,
-            QueueFamilyKHR = 5,
+            QueueFamilyKHR = QueueFamily,
             ShaderCallKHR = 6,
         }
 
@@ -883,9 +883,9 @@ namespace Spv
             DrawParameters = 4427,
             SubgroupVoteKHR = 4431,
             StorageBuffer16BitAccess = 4433,
-            StorageUniformBufferBlock16 = 4433,
+            StorageUniformBufferBlock16 = StorageBuffer16BitAccess,
             StorageUniform16 = 4434,
-            UniformAndStorageBuffer16BitAccess = 4434,
+            UniformAndStorageBuffer16BitAccess = StorageUniform16,
             StoragePushConstant16 = 4435,
             StorageInputOutput16 = 4436,
             DeviceGroup = 4437,
@@ -916,7 +916,7 @@ namespace Spv
             SampleMaskOverrideCoverageNV = 5249,
             GeometryShaderPassthroughNV = 5251,
             ShaderViewportIndexLayerEXT = 5254,
-            ShaderViewportIndexLayerNV = 5254,
+            ShaderViewportIndexLayerNV = ShaderViewportIndexLayerEXT,
             ShaderViewportMaskNV = 5255,
             ShaderStereoViewNV = 5259,
             PerViewAttributesNV = 5260,
@@ -926,39 +926,39 @@ namespace Spv
             FragmentBarycentricNV = 5284,
             ComputeDerivativeGroupQuadsNV = 5288,
             FragmentDensityEXT = 5291,
-            ShadingRateNV = 5291,
+            ShadingRateNV = FragmentDensityEXT,
             GroupNonUniformPartitionedNV = 5297,
             ShaderNonUniform = 5301,
-            ShaderNonUniformEXT = 5301,
+            ShaderNonUniformEXT = ShaderNonUniform,
             RuntimeDescriptorArray = 5302,
-            RuntimeDescriptorArrayEXT = 5302,
+            RuntimeDescriptorArrayEXT = RuntimeDescriptorArray,
             InputAttachmentArrayDynamicIndexing = 5303,
-            InputAttachmentArrayDynamicIndexingEXT = 5303,
+            InputAttachmentArrayDynamicIndexingEXT = InputAttachmentArrayDynamicIndexing,
             UniformTexelBufferArrayDynamicIndexing = 5304,
-            UniformTexelBufferArrayDynamicIndexingEXT = 5304,
+            UniformTexelBufferArrayDynamicIndexingEXT = UniformTexelBufferArrayDynamicIndexing,
             StorageTexelBufferArrayDynamicIndexing = 5305,
-            StorageTexelBufferArrayDynamicIndexingEXT = 5305,
+            StorageTexelBufferArrayDynamicIndexingEXT = StorageTexelBufferArrayDynamicIndexing,
             UniformBufferArrayNonUniformIndexing = 5306,
-            UniformBufferArrayNonUniformIndexingEXT = 5306,
+            UniformBufferArrayNonUniformIndexingEXT = UniformBufferArrayNonUniformIndexing,
             SampledImageArrayNonUniformIndexing = 5307,
-            SampledImageArrayNonUniformIndexingEXT = 5307,
+            SampledImageArrayNonUniformIndexingEXT = SampledImageArrayNonUniformIndexing,
             StorageBufferArrayNonUniformIndexing = 5308,
-            StorageBufferArrayNonUniformIndexingEXT = 5308,
+            StorageBufferArrayNonUniformIndexingEXT = StorageBufferArrayNonUniformIndexing,
             StorageImageArrayNonUniformIndexing = 5309,
-            StorageImageArrayNonUniformIndexingEXT = 5309,
+            StorageImageArrayNonUniformIndexingEXT = StorageImageArrayNonUniformIndexing,
             InputAttachmentArrayNonUniformIndexing = 5310,
-            InputAttachmentArrayNonUniformIndexingEXT = 5310,
+            InputAttachmentArrayNonUniformIndexingEXT = InputAttachmentArrayNonUniformIndexing,
             UniformTexelBufferArrayNonUniformIndexing = 5311,
-            UniformTexelBufferArrayNonUniformIndexingEXT = 5311,
+            UniformTexelBufferArrayNonUniformIndexingEXT = UniformTexelBufferArrayNonUniformIndexing,
             StorageTexelBufferArrayNonUniformIndexing = 5312,
-            StorageTexelBufferArrayNonUniformIndexingEXT = 5312,
+            StorageTexelBufferArrayNonUniformIndexingEXT = StorageTexelBufferArrayNonUniformIndexing,
             RayTracingNV = 5340,
             VulkanMemoryModel = 5345,
-            VulkanMemoryModelKHR = 5345,
+            VulkanMemoryModelKHR = VulkanMemoryModel,
             VulkanMemoryModelDeviceScope = 5346,
-            VulkanMemoryModelDeviceScopeKHR = 5346,
+            VulkanMemoryModelDeviceScopeKHR = VulkanMemoryModelDeviceScope,
             PhysicalStorageBufferAddresses = 5347,
-            PhysicalStorageBufferAddressesEXT = 5347,
+            PhysicalStorageBufferAddressesEXT = PhysicalStorageBufferAddresses,
             ComputeDerivativeGroupLinearNV = 5350,
             RayTracingProvisionalKHR = 5353,
             CooperativeMatrixNV = 5357,
@@ -1433,12 +1433,12 @@ namespace Spv
             OpGroupNonUniformPartitionNV = 5296,
             OpWritePackedPrimitiveIndices4x8NV = 5299,
             OpReportIntersectionKHR = 5334,
-            OpReportIntersectionNV = 5334,
+            OpReportIntersectionNV = OpReportIntersectionKHR,
             OpIgnoreIntersectionNV = 5335,
             OpTerminateRayNV = 5336,
             OpTraceNV = 5337,
             OpTypeAccelerationStructureKHR = 5341,
-            OpTypeAccelerationStructureNV = 5341,
+            OpTypeAccelerationStructureNV = OpTypeAccelerationStructureKHR,
             OpExecuteCallableNV = 5344,
             OpTypeCooperativeMatrixNV = 5358,
             OpCooperativeMatrixLoadNV = 5359,
@@ -1476,9 +1476,9 @@ namespace Spv
             OpFunctionPointerINTEL = 5600,
             OpFunctionPointerCallINTEL = 5601,
             OpDecorateString = 5632,
-            OpDecorateStringGOOGLE = 5632,
+            OpDecorateStringGOOGLE = OpDecorateString,
             OpMemberDecorateString = 5633,
-            OpMemberDecorateStringGOOGLE = 5633,
+            OpMemberDecorateStringGOOGLE = OpMemberDecorateString,
             OpVmeImageINTEL = 5699,
             OpTypeVmeImageINTEL = 5700,
             OpTypeAvcImePayloadINTEL = 5701,
@@ -1622,4 +1622,3 @@ namespace Spv
         }
     }
 }
-