WIP: Handle enum-constants via vk-parse

Author: MarijnS95

ash/src/vk/constants.rs

@@ -28,4 +28,3 @@ pub const MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT: usize = 32;
 pub const MAX_PIPELINE_BINARY_KEY_SIZE_KHR: usize = 32;
 pub const MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR: usize = 7;
 pub const SHADER_INDEX_UNUSED_AMDX: u32 = !0;
-pub const SHADER_UNUSED_NV: u32 = SHADER_UNUSED_KHR;

generator/Cargo.toml

@@ -1,8 +1,12 @@
 [package]
 name = "generator"
 version = "0.1.0"
-authors = ["Maik Klein <[email protected]>"]
-edition = "2021"
+authors = [
+    "Maik Klein <[email protected]>",
+    "Benjamin Saunders <[email protected]>",
+    "Marijn Suijten <[email protected]>",
+]
+edition = "2024"
 publish = false
 
 [dependencies]

generator/src/lib.rs

@@ -11,6 +11,7 @@
 use heck::{ToShoutySnakeCase, ToSnakeCase, ToUpperCamelCase};
 use itertools::Itertools;
 use nom::{
+    IResult, Parser,
     branch::alt,
     bytes::complete::{tag, take_until, take_while1},
     character::complete::{
@@ -19,7 +20,6 @@ use nom::{
     combinator::{map, map_res, opt, value},
     multi::{many1, separated_list1},
     sequence::{delimited, pair, preceded, separated_pair, terminated},
-    IResult, Parser,
 };
 use proc_macro2::{Delimiter, Group, Literal, Span, TokenStream, TokenTree};
 use quote::*;
@@ -84,15 +84,20 @@ impl quote::ToTokens for CType {
 }
 
 fn parse_ctype(i: &str) -> IResult<&str, CType> {
-    (alt((value(CType::U64, tag("ULL")), value(CType::U32, tag("U"))))).parse(i)
+    (alt((
+        value(CType::U64, tag("ULL")),
+        value(CType::U32, tag("U")),
+        // success(CType::U32), // Only for `0x1234` hexadecimals without type-suffix
+    )))
+    .parse(i)
 }
 
 fn parse_cexpr(i: &str) -> IResult<&str, (CType, String)> {
     (alt((
         map(parse_cfloat, |f| (CType::Float, format!("{f:.2}"))),
+        parse_hexadecimal_number,
         parse_inverse_number,
         parse_decimal_number,
-        parse_hexadecimal_number,
     )))
     .parse(i)
 }
@@ -398,7 +403,10 @@ pub enum Constant {
     Number(i32),
     Hex(String),
     BitPos(u32),
-    CExpr(vkxml::CExpression),
+    /// A C expression, also used for floating point (`1000.0F`) and some integer representations (`(~0ULL)`).
+    ///
+    /// Hexadecimals could use this path, but are currently handled separately.
+    CExpr(String),
     Text(String),
     Alias(Ident),
 }
@@ -417,7 +425,7 @@ impl quote::ToTokens for Constant {
             Self::Text(ref text) => text.to_tokens(tokens),
             Self::CExpr(ref expr) => {
                 let (rem, (_, rexpr)) = parse_cexpr(expr).expect("Unable to parse cexpr");
-                assert!(rem.is_empty());
+                assert!(rem.is_empty(), "{rem}");
                 tokens.extend(rexpr.parse::<TokenStream>());
             }
             Self::BitPos(pos) => {
@@ -471,10 +479,10 @@ impl Constant {
             Self::Number(_) | Self::Hex(_) => CType::USize,
             Self::CExpr(expr) => {
                 let (rem, (ty, _)) = parse_cexpr(expr).expect("Unable to parse cexpr");
-                assert!(rem.is_empty());
+                assert!(rem.is_empty(), "{rem}");
                 ty
             }
-            _ => unimplemented!(),
+            x => unimplemented!("{x:?}"),
         }
     }
 
@@ -528,19 +536,25 @@ impl Constant {
                 Some((Self::Number(value as i32), Some(extends.clone()), false))
             }
             EnumSpec::Value { value, extends } => {
-                let value = value
-                    .strip_prefix("0x")
-                    .map(|hex| Self::Hex(hex.to_owned()))
-                    .or_else(|| value.parse::<i32>().ok().map(Self::Number))?;
+                let value = if let Ok(value) = value.parse::<i32>() {
+                    Self::Number(value)
+                } else if let Some(hex) = value.strip_prefix("0x") {
+                    Self::Hex(hex.to_owned())
+                } else {
+                    Self::CExpr(value.to_owned())
+                };
+
                 Some((value, extends.clone(), false))
             }
             EnumSpec::Alias { alias, extends } => {
-                let base_type = extends.as_deref().or(enum_name)?;
-                let key = variant_ident(base_type, alias);
+                let base_type = extends.as_deref().or(enum_name);
+                let key = base_type.map_or(format_ident!("{}", alias), |base_type| {
+                    variant_ident(base_type, alias)
+                });
                 if key == "DISPATCH_BASE" {
                     None
                 } else {
-                    Some((Self::Alias(key), Some(base_type.to_owned()), true))
+                    Some((Self::Alias(key), base_type.map(str::to_owned), true))
                 }
             }
             _ => None,
@@ -2804,12 +2818,13 @@ pub fn constant_name(name: &str) -> &str {
     name.strip_prefix("VK_").unwrap_or(name)
 }
 
-pub fn generate_constant<'a>(
-    constant: &'a vkxml::Constant,
-    cache: &mut HashSet<&'a str>,
-) -> TokenStream {
-    cache.insert(constant.name.as_str());
-    let c = Constant::from_constant(constant);
+pub fn generate_constant(constant: &vk_parse::Enum) -> TokenStream {
+    let (c, _, is_alias) = Constant::from_vk_parse_enum(constant, None, None).unwrap();
+    // This requires knowing the type of the alias, that is unavailable here.  Besides
+    // backwards-compatibility, stabilization aliases serve no purpose.
+    if is_alias {
+        return quote!();
+    }
     let name = constant_name(&constant.name);
     let ident = format_ident!("{}", name);
     let notation = constant.doc_attribute();
@@ -3064,11 +3079,13 @@ pub fn write_source_code<P: AsRef<Path>>(vk_headers_dir: &Path, src_dir: P) {
         .flat_map(|definitions| &definitions.elements)
         .collect();
 
-    let constants: Vec<&vkxml::Constant> = spec
-        .elements
+    let constants: Vec<_> = spec2
+        .0
         .iter()
-        .filter_map(get_variant!(vkxml::RegistryElement::Constants))
-        .flat_map(|constants| &constants.elements)
+        .filter_map(get_variant!(vk_parse::RegistryChild::Enums))
+        .filter(|enums| enums.kind.as_deref() == Some("constants"))
+        .flat_map(|enums| &enums.children)
+        .filter_map(get_variant!(vk_parse::EnumsChild::Enum))
         .collect();
 
     let features_children = spec2
@@ -3080,23 +3097,29 @@ pub fn write_source_code<P: AsRef<Path>>(vk_headers_dir: &Path, src_dir: P) {
 
     let extension_children = extensions.iter().flat_map(|extension| &extension.children);
 
-    let (required_types, required_commands) = features_children
+    let (required_types, required_commands, required_enums) = features_children
         .chain(extension_children)
         .filter_map(get_variant!(vk_parse::FeatureChild::Require { api, items }))
         .filter(|(api, _items)| matches!(api.as_deref(), None | Some(DESIRED_API)))
         .flat_map(|(_api, items)| items)
-        .fold((HashSet::new(), HashSet::new()), |mut acc, elem| {
-            match elem {
-                vk_parse::InterfaceItem::Type { name, .. } => {
-                    acc.0.insert(name.as_str());
-                }
-                vk_parse::InterfaceItem::Command { name, .. } => {
-                    acc.1.insert(name.as_str());
-                }
-                _ => {}
-            };
-            acc
-        });
+        .fold(
+            (HashSet::new(), HashSet::new(), HashSet::new()),
+            |mut acc, elem| {
+                match elem {
+                    vk_parse::InterfaceItem::Type { name, .. } => {
+                        acc.0.insert(name.as_str());
+                    }
+                    vk_parse::InterfaceItem::Command { name, .. } => {
+                        acc.1.insert(name.as_str());
+                    }
+                    vk_parse::InterfaceItem::Enum(vk_parse::Enum { name, spec, .. }) => {
+                        acc.2.insert(name.as_str());
+                    }
+                    _ => {}
+                };
+                acc
+            },
+        );
 
     let commands: CommandMap<'_> = spec2
         .0
@@ -3144,13 +3167,11 @@ pub fn write_source_code<P: AsRef<Path>>(vk_headers_dir: &Path, src_dir: P) {
             acc
         });
 
-    let mut constants_code: Vec<_> = constants
+    let constants_code: Vec<_> = constants
         .iter()
-        .map(|constant| generate_constant(constant, &mut const_cache))
+        .map(|constant| generate_constant(constant))
         .collect();
 
-    constants_code.push(quote! { pub const SHADER_UNUSED_NV : u32 = SHADER_UNUSED_KHR;});
-
     let union_types = definitions
         .iter()
         .filter_map(get_variant!(vkxml::DefinitionsElement::Union))