rdl reader: drop TypeAttributes::Public for ExclusiveTo interfaces

crates/libs/rdl/src/reader/attribute_ref.rs

@@ -491,6 +491,12 @@ impl Encoder<'_> {
             .unwrap_or(false)
     }
 
+    pub fn is_exclusive_to_attribute(&self, attr: &syn::Attribute) -> bool {
+        self.find_attribute_type(attr.path())
+            .map(|info| &info.type_name == ("Windows.Foundation.Metadata", "ExclusiveToAttribute"))
+            .unwrap_or(false)
+    }
+
     /// Processes `#[guid(0x…)]` and `#[no_guid]` pseudo-attributes in `attrs`, emitting a
     /// `GuidAttribute` on `target` when an explicit GUID is supplied.  Returns `true` when the
     /// attribute list already carries GUID information (explicit `#[guid]`, `#[no_guid]`, or an

crates/libs/rdl/src/reader/interface.rs

@@ -120,9 +120,16 @@ impl syn::parse::Parse for Interface {
 
 impl Encoder<'_> {
     pub fn encode_interface(&mut self, item: &Interface) -> Result<(), Error> {
-        let mut flags = metadata::TypeAttributes::Public
-            | metadata::TypeAttributes::Abstract
-            | metadata::TypeAttributes::Interface;
+        let has_exclusive_to = item
+            .attrs
+            .iter()
+            .any(|attr| self.is_exclusive_to_attribute(attr));
+
+        let mut flags = metadata::TypeAttributes::Abstract | metadata::TypeAttributes::Interface;
+
+        if !has_exclusive_to {
+            flags |= metadata::TypeAttributes::Public;
+        }
 
         if item.winrt {
             flags |= metadata::TypeAttributes::WindowsRuntime;

crates/tests/libs/rdl/tests/roundtrip/exclusive-to.rdl

@@ -0,0 +1,6 @@
+#[winrt]
+mod Test {
+    class Foo {}
+    #[Windows::Foundation::Metadata::ExclusiveTo(Foo)]
+    interface IFoo {}
+}

crates/tests/libs/rdl/tests/use-declarations.rs

@@ -1,3 +1,5 @@
+use windows_metadata::reader::TypeIndex;
+use windows_metadata::TypeAttributes;
 use windows_rdl::*;
 
 #[test]
@@ -32,3 +34,40 @@ pub fn parse_with_reference() {
         .write()
         .unwrap();
 }
+
+// Verify that `#[ExclusiveTo(Foo)]` written with a `use` glob import correctly suppresses
+// `TypeAttributes::Public` on the exclusive interface (while the class remains public).
+#[test]
+pub fn exclusive_to_with_use() {
+    reader()
+        .input_str(
+            r#"
+use Windows::Foundation::Metadata::*;
+
+#[winrt]
+mod Test {
+    class Foo {}
+    #[ExclusiveTo(Foo)]
+    interface IFoo {}
+}
+"#,
+        )
+        .input("../../../libs/bindgen/default/Windows.winmd")
+        .output("tests/exclusive-to-use.winmd")
+        .write()
+        .unwrap();
+
+    let index = TypeIndex::read("tests/exclusive-to-use.winmd").expect("failed to read winmd");
+
+    let foo = index.expect("Test", "Foo");
+    assert!(
+        foo.flags().contains(TypeAttributes::Public),
+        "class Foo should be Public"
+    );
+
+    let ifoo = index.expect("Test", "IFoo");
+    assert!(
+        !ifoo.flags().contains(TypeAttributes::Public),
+        "exclusive interface IFoo should not be Public"
+    );
+}