windows-clang constant repr (#4962)

Author: kennykerr

crates/libs/clang/src/lib.rs

@@ -738,19 +738,17 @@ impl Snapshot {
                 return Err(Error(format!("duplicate planned name `{}`", function.name)));
             }
         }
-        for constant in plan.constants {
+        for planned in plan.constants {
+            let constant = planned.constant;
             let encoding = match &constant.value {
                 Value::Utf8(_) => "    #[encoding(\"ansi\")]\n",
                 Value::Utf16(_) => "    #[encoding(\"utf-16\")]\n",
                 _ => "",
             };
-            let ty = match &constant.value {
-                Value::Utf8(_) | Value::Utf16(_) => "String".to_string(),
-                _ => constant_type_name(&constant.ty, &plan.type_names),
-            };
             let item = format!(
-                "{encoding}    const {}: {ty} = {};\n",
+                "{encoding}    const {}: {} = {};\n",
                 rdl_ident(&constant.name),
+                planned.ty,
                 value_name(&constant.value)
             );
             if items
@@ -1617,10 +1615,52 @@ impl Snapshot {
                 )));
             }
         }
+        let mut pointer_aliases: BTreeMap<&str, Vec<&str>> = BTreeMap::new();
+        for fact in &self.facts {
+            let FactData::Typedef {
+                target: TypeRef::Named { name: target, .. } | TypeRef::Generic { name: target, .. },
+            } = &fact.data
+            else {
+                continue;
+            };
+            pointer_aliases.entry(target).or_default().push(&fact.name);
+        }
+        let mut pointer_alias_queue: Vec<_> = pointer_interface_aliases.keys().cloned().collect();
+        while let Some(target) = pointer_alias_queue.pop() {
+            let projected = pointer_interface_aliases[&target].clone();
+            for alias in pointer_aliases.get(target.as_str()).into_iter().flatten() {
+                if let Some(previous) = pointer_interface_aliases.get(*alias) {
+                    if previous != &projected {
+                        return Err(Error(format!(
+                            "interface pointer alias `{alias}` has conflicting targets"
+                        )));
+                    }
+                } else {
+                    pointer_interface_aliases.insert((*alias).to_string(), projected.clone());
+                    pointer_alias_queue.push((*alias).to_string());
+                }
+            }
+        }
         for (alias, target) in &pointer_interface_aliases {
             type_names.insert(alias.clone(), target.clone());
         }
         types.retain(|planned| !pointer_interface_aliases.contains_key(&planned.fact.name));
+        let mut constants: Vec<_> = constants
+            .into_iter()
+            .filter_map(|constant| {
+                let ty = match &constant.value {
+                    Value::Utf8(_) | Value::Utf16(_) => Some("String".to_string()),
+                    _ => constant_type_name(
+                        &constant.ty,
+                        &type_names,
+                        &interface_names,
+                        &pointer_interface_aliases,
+                        &constant.root.tu,
+                    ),
+                }?;
+                Some(PlannedConstant { constant, ty })
+            })
+            .collect();
         if timing {
             eprintln!(
                 "clang plan interfaces: {:.2}s",
@@ -1651,9 +1691,12 @@ impl Snapshot {
                 return Err(Error(format!("duplicate planned name `{}`", planned.name)));
             }
         }
-        for constant in &constants {
-            if !value_output_names.insert(constant.name.as_str()) {
-                return Err(Error(format!("duplicate planned name `{}`", constant.name)));
+        for planned in &constants {
+            if !value_output_names.insert(planned.constant.name.as_str()) {
+                return Err(Error(format!(
+                    "duplicate planned name `{}`",
+                    planned.constant.name
+                )));
             }
         }
         for function in &functions {
@@ -1663,7 +1706,7 @@ impl Snapshot {
                 return Err(Error(format!("duplicate planned name `{}`", function.name)));
             }
         }
-        constants.sort_by(|left, right| left.name.cmp(&right.name));
+        constants.sort_by(|left, right| left.constant.name.cmp(&right.constant.name));
         functions.sort_by(|left, right| left.name.cmp(&right.name));
         if timing {
             eprintln!(
@@ -1722,6 +1765,11 @@ struct PlannedFact<'a> {
     name: String,
 }
 
+struct PlannedConstant<'a> {
+    constant: &'a Constant,
+    ty: String,
+}
+
 #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
 enum OutputKind {
     Value,
@@ -1732,7 +1780,7 @@ struct Plan<'a> {
     types: Vec<PlannedFact<'a>>,
     values: Vec<PlannedFact<'a>>,
     functions: Vec<&'a Fact>,
-    constants: Vec<&'a Constant>,
+    constants: Vec<PlannedConstant<'a>>,
     type_names: BTreeMap<String, String>,
     interface_names: BTreeSet<(String, String)>,
     interface_guids: BTreeMap<String, String>,
@@ -3806,16 +3854,36 @@ fn pointer_run(mut ty: &TypeRef) -> (bool, usize, &TypeRef) {
     (mutable, depth, ty)
 }
 
-fn constant_type_name(ty: &TypeRef, type_names: &BTreeMap<String, String>) -> String {
-    match ty {
+fn constant_type_name(
+    ty: &TypeRef,
+    type_names: &BTreeMap<String, String>,
+    interface_names: &BTreeSet<(String, String)>,
+    pointer_interface_aliases: &BTreeMap<String, String>,
+    tu: &str,
+) -> Option<String> {
+    let name = match ty {
         TypeRef::Scalar(Scalar::Bool) => "u32".to_string(),
+        TypeRef::Named { name, .. } if pointer_interface_aliases.contains_key(name) => {
+            return None;
+        }
+        TypeRef::Named { name, .. } | TypeRef::Generic { name, .. }
+            if interface_names.contains(&(tu.to_string(), name.clone())) =>
+        {
+            return None;
+        }
         TypeRef::Named { name, .. } if type_names.contains_key(name) => {
             planned_type_name(ty, type_names)
         }
         TypeRef::Named { name, .. } => canonical_named_type(name)
             .map_or_else(|| planned_type_name(ty, type_names), str::to_string),
+        TypeRef::Void
+        | TypeRef::Object
+        | TypeRef::Generic { .. }
+        | TypeRef::Array { .. }
+        | TypeRef::InlineRecord(_) => return None,
         _ => planned_type_name(ty, type_names),
-    }
+    };
+    Some(name)
 }
 
 fn value_name(value: &Value) -> String {

crates/tests/libs/clang/expected/interface_pointer_constants.rdl

@@ -0,0 +1,5 @@
+#[win32]
+mod Test {
+    const DIRECT_POINTER: *mut Windows::Win32::IDataObject = 1;
+    const TEXT_CALLBACK: *mut i8 = -1;
+}

crates/tests/libs/clang/input/interface_pointer_constants.h

@@ -0,0 +1,13 @@
+//! reference-default
+//! args -x c++ --target=x86_64-pc-windows-msvc -fms-extensions
+
+typedef struct IDataObject IDataObject;
+typedef IDataObject* LPDATAOBJECT;
+typedef LPDATAOBJECT DATAOBJECTPTR;
+typedef DATAOBJECTPTR DATAOBJECTPTR2;
+
+#define DOBJ_NULL ((LPDATAOBJECT)0)
+#define DOBJ_CUSTOMOCX ((LPDATAOBJECT)-1)
+#define DOBJ_CUSTOMWEB ((DATAOBJECTPTR2)-2)
+#define TEXT_CALLBACK ((char*)-1)
+#define DIRECT_POINTER ((IDataObject*)1)

docs/crates/windows-clang.md

@@ -205,6 +205,10 @@ while their referenced types still participate in dependency closure.
 
 Native NaN and infinity constants are omitted because RDL and ECMA metadata cannot represent them.
 This includes `f64` values that become non-finite when narrowed to their declared `f32` type.
+Integer-valued pointer constants remain supported. If a typedef chain resolves to an
+interface-pointer alias that is projected as the interface itself, constants declared with that
+typedef are omitted because ECMA metadata cannot encode an interface-valued constant. An explicit
+pointer to the same interface remains a pointer and is emitted.
 
 ### Bit-field member scraping