Multiple OperandKinds are incompatible

Author: MarijnS95

autogen/external/SPIRV-Headers

@@ -174,14 +174,20 @@ fn main() {
     tables.push_str("include!(\"autogen_table.rs\");\n");
     write_formatted(
         &autogen_src_dir.join("../rspirv/grammar/autogen_table.rs"),
-        table::gen_grammar_inst_table_operand_kinds(&grammar),
+        table::gen_grammar_inst_table_operand_kinds(
+            &grammar.operand_kinds,
+            &grammar.instructions,
+            None,
+            "INSTRUCTION",
+        ),
     );
     // Extended instruction sets
     for (ext, spirv_op, _, grammar) in extended_instruction_sets {
         let autogen_file = format!("autogen_{}.rs", ext.replace(".", "_").to_lowercase());
         write_formatted(
             &autogen_src_dir.join(format!("../rspirv/grammar/{autogen_file}")),
-            table::gen_instruction_table(
+            table::gen_grammar_inst_table_operand_kinds(
+                &grammar.operand_kinds,
                 &grammar.instructions,
                 Some(spirv_op),
                 &format!("{}_INSTRUCTION", ext.replace(".", "_").to_uppercase()),

autogen/src/main.rs

@@ -94,7 +94,11 @@ fn num_or_hex<'de, D: de::Deserializer<'de>>(d: D) -> result::Result<u32, D::Err
         }
 
         fn visit_str<E: de::Error>(self, value: &str) -> result::Result<Self::Value, E> {
-            let hex = value.strip_prefix("0x").unwrap();
+            // let hex = value.strip_prefix("0x").unwrap();
+            let Some(hex) = value.strip_prefix("0x") else {
+                // TODO: Remove this edge-case again when https://github.com/KhronosGroup/SPIRV-Headers/pull/550 is merged
+                return Ok(value.parse().unwrap());
+            };
             Ok(u32::from_str_radix(hex, 16).unwrap())
         }
 

autogen/src/structs.rs

@@ -13,19 +13,18 @@ fn convert_quantifier(quantifier: structs::Quantifier) -> Ident {
     })
 }
 
-/// Returns the code for the whole instruction table by walking the given
-/// `grammar`.
+/// Returns the code for the whole instruction table.
 ///
-/// `grammar` is expected to be an array of SPIR-V instructions.
+/// `instructions` is expected to be an array of SPIR-V instructions.
 /// `name` is the name of the generated table.
 /// `is_ext` indicates whether the grammar is for an extended instruction set.
 pub(crate) fn gen_instruction_table(
-    grammar: &[structs::Instruction],
+    instructions: &[structs::Instruction],
     ext_op_name: Option<&str>,
     name: &str,
 ) -> TokenStream {
     // Vector for strings for all instructions.
-    let instructions = grammar.iter().map(|inst| {
+    let instructions = instructions.iter().map(|inst| {
         // Vector of strings for all operands.
         let operands = inst.operands.iter().map(|e| {
             let kind = as_ident(&e.kind);
@@ -65,24 +64,33 @@ pub(crate) fn gen_instruction_table(
 
 /// Returns the generated grammar::INSTRUCTION_TABLE and grammar::OperandKind
 /// by walking the given SPIR-V `grammar`.
-pub fn gen_grammar_inst_table_operand_kinds(grammar: &structs::Grammar) -> TokenStream {
+pub fn gen_grammar_inst_table_operand_kinds(
+    operand_kinds: &[structs::OperandKind],
+    instructions: &[structs::Instruction],
+    ext_op_name: Option<&str>,
+    name: &str,
+) -> TokenStream {
     // Enum for all operand kinds.
-    let elements = grammar
-        .operand_kinds
-        .iter()
-        .map(|kind| as_ident(&kind.kind));
+    let elements = operand_kinds.iter().map(|kind| as_ident(&kind.kind));
 
     // Instruction table.
-    let table = gen_instruction_table(&grammar.instructions, None, "INSTRUCTION");
+    let table = gen_instruction_table(instructions, ext_op_name, name);
 
-    quote! {
-        #[doc = "All operand kinds in the SPIR-V grammar."]
-        #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-        #[allow(clippy::upper_case_acronyms)]
-        pub enum OperandKind {
-            #(#elements),*
-        }
+    let operand_kinds = if operand_kinds.is_empty() {
+        None
+    } else {
+        Some(quote! {
+            #[doc = "All operand kinds in the SPIR-V grammar."]
+            #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+            #[allow(clippy::upper_case_acronyms)]
+            pub enum OperandKind {
+                #(#elements),*
+            }
+        })
+    };
 
+    quote! {
+        #operand_kinds
         #table
     }
 }

autogen/src/table.rs

@@ -2,6 +2,16 @@
 //   external/spirv.core.grammar.json.
 // DO NOT MODIFY!
 
+#[doc = "All operand kinds in the SPIR-V grammar."]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[allow(clippy::upper_case_acronyms)]
+pub enum OperandKind {
+    DebugInfoFlags,
+    DebugBaseTypeAttributeEncoding,
+    DebugCompositeType,
+    DebugTypeQualifier,
+    DebugOperation,
+}
 static DEBUGINFO_INSTRUCTIONS: &[ExtendedInstruction<'static>] = &[
     ext_inst!(DebugInfoOp, DebugInfoNone, [], [], []),
     ext_inst!(

rspirv/grammar/autogen_debuginfo.rs

@@ -2,6 +2,17 @@
 //   external/spirv.core.grammar.json.
 // DO NOT MODIFY!
 
+#[doc = "All operand kinds in the SPIR-V grammar."]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[allow(clippy::upper_case_acronyms)]
+pub enum OperandKind {
+    DebugInfoFlags,
+    DebugBaseTypeAttributeEncoding,
+    DebugCompositeType,
+    DebugTypeQualifier,
+    DebugOperation,
+    DebugImportedEntity,
+}
 static OPENCL_DEBUGINFO_100_INSTRUCTIONS: &[ExtendedInstruction<'static>] = &[
     ext_inst!(CLDebugInfoOp, DebugInfoNone, [], [], []),
     ext_inst!(