fix(c): ensure we can compile on MSVC in pre-C23 mode

We can't do things like this:

    static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT_KHR = VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT;

Because to MSVC, that's not a compile-time constant. Annoying, but we
can follow the pattern used by vulkan_core.h which is to just use the
value literal.

Signed-off-by: Steven Noonan <steven@uplinklabs.net>

Author: tycho

Cargo.lock

@@ -27,5 +27,6 @@ xxhash-rust    = { version = "0.8", features = ["xxh3"] }
 
 [dev-dependencies]
 assert_cmd     = "2"
+cc             = "1"
 predicates     = "3"
 tempfile       = "3"

Cargo.toml

@@ -230,6 +230,13 @@ fn main() {
         pkg_version.clone()
     };
 
+    // Expose the target triple to integration tests via env!("TARGET").
+    // The cc crate needs this to find the correct compiler.
+    println!(
+        "cargo:rustc-env=TARGET={}",
+        env::var("TARGET").unwrap()
+    );
+
     let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
     let dest = out_dir.join("build_info.rs");
 

build.rs

@@ -202,6 +202,7 @@ fn build_env() -> Result<Environment<'static>> {
     env.add_filter("spec_display", filter_spec_display);
     env.add_filter("c_ident", filter_c_ident);
     env.add_filter("vk_max_enum_name", filter_enum_max_name);
+    env.add_filter("ull", filter_ull);
 
     Ok(env)
 }
@@ -244,6 +245,22 @@ fn filter_c_ident(value: Value) -> String {
     }
 }
 
+/// Append `ULL` suffix to a value if it is a numeric literal (decimal, hex,
+/// or negative).  Alias references (identifiers) are left unchanged.
+/// Used for 64-bit enum constants in the pre-C23 `#define` path.
+fn filter_ull(value: Value) -> String {
+    let s = value.as_str().unwrap_or("");
+    let trimmed = s.strip_prefix('-').unwrap_or(s);
+    let is_numeric = trimmed.starts_with(|c: char| c.is_ascii_digit())
+        || trimmed.starts_with("0x")
+        || trimmed.starts_with("0X");
+    if is_numeric {
+        format!("{s}ULL")
+    } else {
+        s.to_string()
+    }
+}
+
 /// Used to build public function names like `gloamLoadGLES2Context`.
 fn filter_spec_display(value: Value) -> String {
     match value.as_str().unwrap_or("") {
@@ -402,4 +419,33 @@ mod tests {
         assert_eq!(filter_hex4(Value::from(0x0100_i64)), "0x0100");
         assert_eq!(filter_hex4(Value::from(0_i64)), "0x0000");
     }
+
+    // ---- filter_ull ----
+
+    fn ull(s: &str) -> String {
+        filter_ull(Value::from(s))
+    }
+
+    #[test]
+    fn ull_appends_to_decimal() {
+        assert_eq!(ull("0"), "0ULL");
+        assert_eq!(ull("42"), "42ULL");
+    }
+
+    #[test]
+    fn ull_appends_to_hex() {
+        assert_eq!(ull("0x0000000000000001"), "0x0000000000000001ULL");
+        assert_eq!(ull("0X1F"), "0X1FULL");
+    }
+
+    #[test]
+    fn ull_appends_to_negative() {
+        assert_eq!(ull("-1"), "-1ULL");
+    }
+
+    #[test]
+    fn ull_leaves_identifier_unchanged() {
+        assert_eq!(ull("VK_PIPELINE_STAGE_2_NONE"), "VK_PIPELINE_STAGE_2_NONE");
+        assert_eq!(ull("VK_ACCESS_2_NONE_KHR"), "VK_ACCESS_2_NONE_KHR");
+    }
 }

src/generator/c/mod.rs

@@ -51,6 +51,14 @@
 #  define GLOAM_PLATFORM_LINUX 1
 #endif
 #endif /* GLOAM_PLATFORM_DETECTED_ */
+
+#ifndef GLOAM_HAS_ENUM_BASE_TYPE
+#if defined(__cplusplus) || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L)
+#  define GLOAM_HAS_ENUM_BASE_TYPE 1
+#else
+#  define GLOAM_HAS_ENUM_BASE_TYPE 0
+#endif
+#endif
 {% if fs.spec_name == "glx" %}
 #ifdef GLOAM_PLATFORM_LINUX
 
@@ -177,12 +185,8 @@ struct _cl_event;
 /* ---- Vulkan enum groups -------------------------------------------------- */
 {% for group in fs.enum_groups %}
 {%- if group.bitwidth == 64 %}
-/* {{ group.name }} — 64-bit bitmask.
-   C++/C23: emitted as an enum with explicit underlying type so all values
-   are strongly typed and the tag name is valid for typedef aliases.
-   Pre-C23 C: emitted as typedef uint64_t + static const, since C99/C11 do
-   not support fixed underlying types for enums. */
-#if defined(__cplusplus) || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L)
+/* {{ group.name }} — 64-bit; uses enum : uint64_t in C++/C23, static const otherwise. */
+#if GLOAM_HAS_ENUM_BASE_TYPE
 typedef enum {{ group.name }} : uint64_t {
 {%- for val in group.values %}
     {{ val.name }} = {{ val.value }}{% if not loop.last %},{% endif %}{% if val.comment %} /* {{ val.comment }} */{% endif %}
@@ -191,7 +195,7 @@ typedef enum {{ group.name }} : uint64_t {
 #else
 typedef uint64_t {{ group.name }};
 {%- for val in group.values %}
-static const {{ group.name }} {{ val.name | rjust(48) }} = {{ val.value }};{% if val.comment %} /* {{ val.comment }} */{% endif %}
+static const {{ group.name }} {{ val.name | rjust(48) }} = {{ val.literal_value | ull }};{% if val.comment %} /* {{ val.comment }} */{% endif %}
 {%- endfor %}
 #endif
 

src/generator/c/templates/header.h.j2

@@ -35,6 +35,7 @@ pub(super) fn build_flat_enums(
                 .unwrap_or_default();
             Some(FlatEnum {
                 name: e.name.clone(),
+                literal_value: value.to_string(),
                 value: value.to_string(),
                 comment: e.comment.clone(),
                 protect,
@@ -78,22 +79,39 @@ pub(super) fn build_enum_groups(raw: &RawSpec) -> Vec<EnumGroup> {
                     Some(FlatEnum {
                         name: v.name.clone(),
                         value: val.to_string(),
+                        literal_value: String::new(), // resolved below
                         comment: v.comment.clone(),
                         protect: vec![],
                     })
                 })
                 .collect();
 
+            let mut sorted = sort_enum_values(raw_values);
+            resolve_literal_values(&mut sorted);
+
             EnumGroup {
                 name: g.name.clone(),
                 is_bitmask: false,
                 bitwidth: g.bitwidth.unwrap_or(32),
-                values: sort_enum_values(raw_values),
+                values: sorted,
             }
         })
         .collect()
 }
 
+/// Fill `literal_value` for each entry.  For numeric literals, it's the value
+/// itself.  For aliases (value is another enum name), look up the target's
+/// `literal_value`.  Assumes topological order (canonical before alias).
+fn resolve_literal_values(values: &mut [FlatEnum]) {
+    // Build a name→literal map as we go (topo order guarantees targets are resolved first).
+    let mut literals: HashMap<String, String> = HashMap::new();
+    for v in values.iter_mut() {
+        let resolved = literals.get(&v.value).cloned().unwrap_or_else(|| v.value.clone());
+        v.literal_value = resolved.clone();
+        literals.insert(v.name.clone(), resolved);
+    }
+}
+
 // ---------------------------------------------------------------------------
 // Value-dependency sort
 // ---------------------------------------------------------------------------
@@ -176,6 +194,7 @@ mod tests {
         FlatEnum {
             name: name.to_string(),
             value: value.to_string(),
+            literal_value: String::new(),
             comment: String::new(),
             protect: vec![],
         }

src/resolve/enums.rs

@@ -173,6 +173,10 @@ pub struct TypeDef {
 pub struct FlatEnum {
     pub name: String,
     pub value: String,
+    /// Always a numeric literal, even for aliases.  Used in the pre-C23
+    /// `static const` path where referencing another variable is not a
+    /// constant expression on some compilers (MSVC C2099).
+    pub literal_value: String,
     pub comment: String,
     /// Platform protection macros.  Empty = unconditional.
     pub protect: Vec<String>,

src/resolve/types.rs

@@ -4,7 +4,6 @@
 //! They also attempt a C compile step if `cc` is available on PATH.
 
 use std::path::Path;
-use std::process::Command;
 
 use tempfile::TempDir;
 
@@ -16,61 +15,60 @@ fn gloam() -> assert_cmd::Command {
     assert_cmd::Command::cargo_bin("gloam").expect("gloam binary not found")
 }
 
-/// Attempt to compile a generated C source with the system C compiler.
-/// Silently skips if `cc` is not on PATH (expected in CI, optional locally).
+/// Attempt to compile generated C sources with the system C compiler.
+/// Uses the `cc` crate for compiler detection (handles MSVC, GCC, Clang,
+/// cross-compilation toolchains, CC env override, etc.).
+/// Silently skips if no compiler is available.
 fn try_compile_c(out: &Path) {
-    // Find a .c file in out/src/.
     let src_dir = out.join("src");
-    let c_file = match std::fs::read_dir(&src_dir).ok().and_then(|mut d| {
-        d.find(|e| {
-            e.as_ref()
-                .is_ok_and(|e| e.path().extension() == Some("c".as_ref()))
-        })
-    }) {
-        Some(Ok(entry)) => entry.path(),
-        _ => return, // nothing to compile
-    };
-
-    let cc = match find_cc() {
-        Some(c) => c,
-        None => {
-            eprintln!("compile check skipped: no C compiler on PATH");
-            return;
+    let c_files: Vec<_> = std::fs::read_dir(&src_dir)
+        .ok()
+        .into_iter()
+        .flatten()
+        .filter_map(|e| e.ok())
+        .map(|e| e.path())
+        .filter(|p| p.extension() == Some("c".as_ref()))
+        .collect();
+
+    if c_files.is_empty() {
+        return;
+    }
+
+    // The cc crate expects TARGET/HOST env vars (normally set by Cargo during
+    // build.rs).  In test context they're absent, so provide them.
+    let target = env!("TARGET");
+    let mut build = cc::Build::new();
+    build
+        .target(target)
+        .host(target)
+        .opt_level(0)
+        .out_dir(&src_dir)
+        .include(out.join("include"))
+        .warnings(true)
+        .cargo_warnings(false)
+        .std("c11")
+        .flag_if_supported("-Wno-unused-function");
+
+    for f in &c_files {
+        build.file(f);
+    }
+
+    if let Err(e) = build.try_compile("gloam_test") {
+        // Distinguish "no compiler" from "compilation failed".
+        let msg = e.to_string();
+        if msg.contains("Failed to find tool")
+            || msg.contains("not found")
+            || msg.contains("couldn't find")
+        {
+            eprintln!("compile check skipped: no C compiler found");
+        } else {
+            panic!(
+                "generated C files in {} failed to compile: {}",
+                src_dir.display(),
+                e
+            );
         }
-    };
-
-    let status = Command::new(cc)
-        .args([
-            "-c",
-            "-std=c11",
-            "-Wall",
-            "-Wno-unused-function",
-            "-o",
-            "/dev/null",
-            &format!("-I{}", out.join("include").display()),
-            c_file.to_str().unwrap(),
-        ])
-        .status()
-        .expect("failed to spawn C compiler");
-
-    assert!(
-        status.success(),
-        "generated C file {} failed to compile",
-        c_file.display()
-    );
-}
-
-fn find_cc() -> Option<&'static str> {
-    ["cc", "gcc", "clang"]
-        .iter()
-        .find(|&candidate| {
-            Command::new(candidate)
-                .arg("--version")
-                .output()
-                .map(|o| o.status.success())
-                .unwrap_or(false)
-        })
-        .map(|v| v as _)
+    }
 }
 
 fn assert_c_output_exists(out: &Path, stem: &str) {