bindgen

microsoft · Feb 29, 2024 · 5f4268f · 5f4268f
1 parent f3aa338
commit 5f4268f
Show file tree

Hide file tree

Showing 5 changed files with 31 additions and 70 deletions.
diff --git a/crates/libs/bindgen/src/rust/classes.rs b/crates/libs/bindgen/src/rust/classes.rs
@@ -2,6 +2,10 @@ use super::*;
 use metadata::HasAttributes;
 
 pub fn writer(writer: &Writer, def: metadata::TypeDef) -> TokenStream {
+    if !def.flags().contains(metadata::TypeAttributes::WindowsRuntime) {
+        return quote! {};
+    }
+
     if writer.sys {
         if def.interface_impls().next().is_some() {
             let name = to_ident(def.name());

diff --git a/crates/libs/bindgen/src/rust/mod.rs b/crates/libs/bindgen/src/rust/mod.rs
@@ -177,36 +177,7 @@ fn namespace(writer: &Writer, tree: &Tree) -> String {
                 if writer.reader.core_types().any(|(x, _)| x == &type_name) {
                     continue;
                 }
-                let name = type_name.name;
-                let mut kind = def.kind();
-
-                let tokens = match kind {
-                    metadata::TypeKind::Class => {
-                        if def.flags().contains(metadata::TypeAttributes::WindowsRuntime) {
-                            classes::writer(writer, def)
-                        } else {
-                            quote! {}
-                        }
-                    }
-                    metadata::TypeKind::Interface => interfaces::writer(writer, def),
-                    metadata::TypeKind::Enum => enums::writer(writer, def),
-                    metadata::TypeKind::Struct => {
-                        if let Some(guid) = clsid(def) {
-                            kind = metadata::TypeKind::Class;
-                            let ident = to_ident(name);
-                            let value = writer.guid(&guid);
-                            let guid = writer.type_name(&metadata::Type::GUID);
-                            quote! {
-                                pub const #ident: #guid = #value;
-                            }
-                        } else {
-                            structs::writer(writer, def)
-                        }
-                    }
-                    metadata::TypeKind::Delegate => delegates::writer(writer, def),
-                };
-
-                types.entry(kind).or_default().entry(name).or_default().combine(&tokens);
+                types.entry(def.kind()).or_default().entry(type_name.name).or_default().combine(&writer.type_def(def));
             }
             metadata::Item::Fn(def, namespace) => {
                 let name = def.name();
@@ -236,13 +207,6 @@ fn namespace(writer: &Writer, tree: &Tree) -> String {
     tokens.into_string()
 }
 
-fn clsid(def: metadata::TypeDef) -> Option<metadata::Guid> {
-    if def.fields().next().is_none() {
-        return metadata::type_def_guid(def);
-    }
-    None
-}
-
 fn namespace_impl(writer: &Writer, tree: &Tree) -> String {
     let writer = &mut writer.clone();
     writer.namespace = tree.namespace;

diff --git a/crates/libs/bindgen/src/rust/standalone.rs b/crates/libs/bindgen/src/rust/standalone.rs
@@ -85,39 +85,7 @@ pub fn standalone_imp(writer: &Writer) -> String {
                 );
             }
             metadata::Type::TypeDef(def, _) => {
-                let kind = def.kind();
-                match kind {
-                    metadata::TypeKind::Class => {
-                        sorted.insert(def.name(), classes::writer(writer, def));
-                    }
-                    metadata::TypeKind::Interface => {
-                        sorted.insert(def.name(), interfaces::writer(writer, def));
-                    }
-                    metadata::TypeKind::Enum => {
-                        sorted.insert(def.name(), enums::writer(writer, def));
-                    }
-                    metadata::TypeKind::Struct => {
-                        let name = def.name();
-                        if def.fields().next().is_none() {
-                            if let Some(guid) = metadata::type_def_guid(def) {
-                                let ident = to_ident(name);
-                                let value = writer.guid(&guid);
-                                let guid = writer.type_name(&metadata::Type::GUID);
-                                sorted.insert(
-                                    name,
-                                    quote! {
-                                        pub const #ident: #guid = #value;
-                                    },
-                                );
-                                continue;
-                            }
-                        }
-                        sorted.insert(name, structs::writer(writer, def));
-                    }
-                    metadata::TypeKind::Delegate => {
-                        sorted.insert(def.name(), delegates::writer(writer, def));
-                    }
-                }
+                sorted.insert(def.name(), writer.type_def(def));
             }
             _ => {}
         }

diff --git a/crates/libs/bindgen/src/rust/structs.rs b/crates/libs/bindgen/src/rust/structs.rs
@@ -10,6 +10,15 @@ pub fn writer(writer: &Writer, def: metadata::TypeDef) -> TokenStream {
         return handles::writer(writer, def);
     }
 
+    if let Some(guid) = clsid(def) {
+        let ident = to_ident(def.name());
+        let value = writer.guid(&guid);
+        let guid = writer.type_name(&metadata::Type::GUID);
+        return quote! {
+            pub const #ident: #guid = #value;
+        };
+    }
+
     gen_struct_with_name(writer, def, def.name(), &cfg::Cfg::default())
 }
 
@@ -285,3 +294,10 @@ fn gen_struct_constants(writer: &Writer, def: metadata::TypeDef, struct_name: &T
 
     tokens
 }
+
+fn clsid(def: metadata::TypeDef) -> Option<metadata::Guid> {
+    if def.fields().next().is_none() {
+        return metadata::type_def_guid(def);
+    }
+    None
+}
diff --git a/crates/libs/bindgen/src/rust/writer.rs b/crates/libs/bindgen/src/rust/writer.rs
@@ -74,6 +74,15 @@ impl Writer {
             }
         }
     }
+    pub fn type_def(&self, def: metadata::TypeDef) -> TokenStream {
+        match def.kind() {
+            metadata::TypeKind::Class => classes::writer(self, def),
+            metadata::TypeKind::Interface => interfaces::writer(self, def),
+            metadata::TypeKind::Enum => enums::writer(self, def),
+            metadata::TypeKind::Struct => structs::writer(self, def),
+            metadata::TypeKind::Delegate => delegates::writer(self, def),
+        }
+    }
 
     //
     // Type