Add Generic<'a, T> type alias for generic parameters in _Impl traits

crates/libs/bindgen/src/types/method.rs

@@ -150,9 +150,12 @@ impl Method {
                     quote! { &[#default_type] }
                 } else if p.is_primitive(config.reader) {
                     quote! { #default_type }
-                } else if p.is_interface() || matches!(&p.ty, Type::Generic(_)) {
+                } else if p.is_interface() {
                     let type_name = p.write_name(config);
                     quote! { windows_core::Ref<#type_name> }
+                } else if matches!(&p.ty, Type::Generic(_)) {
+                    let type_name = p.write_name(config);
+                    quote! { windows_core::Generic<#type_name> }
                 } else {
                     quote! { &#default_type }
                 }

crates/libs/collections/src/bindings.rs

@@ -679,16 +679,16 @@ where
     K: windows_core::RuntimeType + 'static,
     V: windows_core::RuntimeType + 'static,
 {
-    fn Lookup(&self, key: windows_core::Ref<K>) -> windows_core::Result<V>;
+    fn Lookup(&self, key: windows_core::Generic<K>) -> windows_core::Result<V>;
     fn Size(&self) -> windows_core::Result<u32>;
-    fn HasKey(&self, key: windows_core::Ref<K>) -> windows_core::Result<bool>;
+    fn HasKey(&self, key: windows_core::Generic<K>) -> windows_core::Result<bool>;
     fn GetView(&self) -> windows_core::Result<IMapView<K, V>>;
     fn Insert(
         &self,
-        key: windows_core::Ref<K>,
-        value: windows_core::Ref<V>,
+        key: windows_core::Generic<K>,
+        value: windows_core::Generic<V>,
     ) -> windows_core::Result<bool>;
-    fn Remove(&self, key: windows_core::Ref<K>) -> windows_core::Result<()>;
+    fn Remove(&self, key: windows_core::Generic<K>) -> windows_core::Result<()>;
     fn Clear(&self) -> windows_core::Result<()>;
 }
 impl<K: windows_core::RuntimeType + 'static, V: windows_core::RuntimeType + 'static>
@@ -1166,9 +1166,9 @@ where
     K: windows_core::RuntimeType + 'static,
     V: windows_core::RuntimeType + 'static,
 {
-    fn Lookup(&self, key: windows_core::Ref<K>) -> windows_core::Result<V>;
+    fn Lookup(&self, key: windows_core::Generic<K>) -> windows_core::Result<V>;
     fn Size(&self) -> windows_core::Result<u32>;
-    fn HasKey(&self, key: windows_core::Ref<K>) -> windows_core::Result<bool>;
+    fn HasKey(&self, key: windows_core::Generic<K>) -> windows_core::Result<bool>;
     fn Split(
         &self,
         first: windows_core::OutRef<IMapView<K, V>>,
@@ -2121,11 +2121,15 @@ where
     fn GetAt(&self, index: u32) -> windows_core::Result<T>;
     fn Size(&self) -> windows_core::Result<u32>;
     fn GetView(&self) -> windows_core::Result<IVectorView<T>>;
-    fn IndexOf(&self, value: windows_core::Ref<T>, index: &mut u32) -> windows_core::Result<bool>;
-    fn SetAt(&self, index: u32, value: windows_core::Ref<T>) -> windows_core::Result<()>;
-    fn InsertAt(&self, index: u32, value: windows_core::Ref<T>) -> windows_core::Result<()>;
+    fn IndexOf(
+        &self,
+        value: windows_core::Generic<T>,
+        index: &mut u32,
+    ) -> windows_core::Result<bool>;
+    fn SetAt(&self, index: u32, value: windows_core::Generic<T>) -> windows_core::Result<()>;
+    fn InsertAt(&self, index: u32, value: windows_core::Generic<T>) -> windows_core::Result<()>;
     fn RemoveAt(&self, index: u32) -> windows_core::Result<()>;
-    fn Append(&self, value: windows_core::Ref<T>) -> windows_core::Result<()>;
+    fn Append(&self, value: windows_core::Generic<T>) -> windows_core::Result<()>;
     fn RemoveAtEnd(&self) -> windows_core::Result<()>;
     fn Clear(&self) -> windows_core::Result<()>;
     fn GetMany(
@@ -2666,7 +2670,11 @@ where
 {
     fn GetAt(&self, index: u32) -> windows_core::Result<T>;
     fn Size(&self) -> windows_core::Result<u32>;
-    fn IndexOf(&self, value: windows_core::Ref<T>, index: &mut u32) -> windows_core::Result<bool>;
+    fn IndexOf(
+        &self,
+        value: windows_core::Generic<T>,
+        index: &mut u32,
+    ) -> windows_core::Result<bool>;
     fn GetMany(
         &self,
         startIndex: u32,

crates/libs/collections/src/map.rs

@@ -35,35 +35,44 @@ where
     K::Default: Clone + Ord,
     V::Default: Clone,
 {
-    fn Lookup(&self, key: Ref<K>) -> Result<V> {
+    fn Lookup(&self, key: Generic<K>) -> Result<V> {
         let map = self.map.read().unwrap();
-        let value = map.get(&*key).ok_or_else(|| Error::from(E_BOUNDS))?;
+        let value = map
+            .get(generic_as_default::<K>(&key))
+            .ok_or_else(|| Error::from(E_BOUNDS))?;
         V::from_default(value)
     }
 
     fn Size(&self) -> Result<u32> {
         Ok(self.map.read().unwrap().len().try_into()?)
     }
 
-    fn HasKey(&self, key: Ref<K>) -> Result<bool> {
-        Ok(self.map.read().unwrap().contains_key(&*key))
+    fn HasKey(&self, key: Generic<K>) -> Result<bool> {
+        Ok(self
+            .map
+            .read()
+            .unwrap()
+            .contains_key(generic_as_default::<K>(&key)))
     }
 
     fn GetView(&self) -> Result<IMapView<K, V>> {
         let snapshot = self.map.read().unwrap().clone();
         Ok(IMapView::<K, V>::from(snapshot))
     }
 
-    fn Insert(&self, key: Ref<K>, value: Ref<V>) -> Result<bool> {
+    fn Insert(&self, key: Generic<K>, value: Generic<V>) -> Result<bool> {
         let mut map = self.map.write().unwrap();
-        let replaced = map.contains_key(&*key);
-        map.insert((*key).clone(), (*value).clone());
+        let replaced = map.contains_key(generic_as_default::<K>(&key));
+        map.insert(
+            generic_as_default::<K>(&key).clone(),
+            generic_as_default::<V>(&value).clone(),
+        );
         Ok(replaced)
     }
 
-    fn Remove(&self, key: Ref<K>) -> Result<()> {
+    fn Remove(&self, key: Generic<K>) -> Result<()> {
         let mut map = self.map.write().unwrap();
-        if map.remove(&*key).is_none() {
+        if map.remove(generic_as_default::<K>(&key)).is_none() {
             return Err(Error::from(E_BOUNDS));
         }
         Ok(())

crates/libs/collections/src/map_view.rs

@@ -35,8 +35,11 @@ where
     K::Default: Clone + Ord,
     V::Default: Clone,
 {
-    fn Lookup(&self, key: Ref<K>) -> Result<V> {
-        let value = self.map.get(&*key).ok_or_else(|| Error::from(E_BOUNDS))?;
+    fn Lookup(&self, key: Generic<K>) -> Result<V> {
+        let value = self
+            .map
+            .get(generic_as_default::<K>(&key))
+            .ok_or_else(|| Error::from(E_BOUNDS))?;
 
         V::from_default(value)
     }
@@ -45,8 +48,8 @@ where
         Ok(self.map.len().try_into()?)
     }
 
-    fn HasKey(&self, key: Ref<K>) -> Result<bool> {
-        Ok(self.map.contains_key(&*key))
+    fn HasKey(&self, key: Generic<K>) -> Result<bool> {
+        Ok(self.map.contains_key(generic_as_default::<K>(&key)))
     }
 
     fn Split(&self, first: OutRef<IMapView<K, V>>, second: OutRef<IMapView<K, V>>) -> Result<()> {

crates/libs/collections/src/observable_map.rs

@@ -53,46 +53,55 @@ where
     K::Default: Clone + Ord,
     V::Default: Clone,
 {
-    fn Lookup(&self, key: Ref<K>) -> Result<V> {
+    fn Lookup(&self, key: Generic<K>) -> Result<V> {
         let map = self.map.read().unwrap();
-        let value = map.get(&*key).ok_or_else(|| Error::from(E_BOUNDS))?;
+        let value = map
+            .get(generic_as_default::<K>(&key))
+            .ok_or_else(|| Error::from(E_BOUNDS))?;
         V::from_default(value)
     }
 
     fn Size(&self) -> Result<u32> {
         Ok(self.map.read().unwrap().len().try_into()?)
     }
 
-    fn HasKey(&self, key: Ref<K>) -> Result<bool> {
-        Ok(self.map.read().unwrap().contains_key(&*key))
+    fn HasKey(&self, key: Generic<K>) -> Result<bool> {
+        Ok(self
+            .map
+            .read()
+            .unwrap()
+            .contains_key(generic_as_default::<K>(&key)))
     }
 
     fn GetView(&self) -> Result<IMapView<K, V>> {
         let snapshot = self.map.read().unwrap().clone();
         Ok(IMapView::<K, V>::from(snapshot))
     }
 
-    fn Insert(&self, key: Ref<K>, value: Ref<V>) -> Result<bool> {
+    fn Insert(&self, key: Generic<K>, value: Generic<V>) -> Result<bool> {
         let replaced = {
             let mut map = self.map.write().unwrap();
-            let replaced = map.contains_key(&*key);
-            map.insert((*key).clone(), (*value).clone());
+            let replaced = map.contains_key(generic_as_default::<K>(&key));
+            map.insert(
+                generic_as_default::<K>(&key).clone(),
+                generic_as_default::<V>(&value).clone(),
+            );
             replaced
         };
         let change = if replaced {
             CollectionChange::ItemChanged
         } else {
             CollectionChange::ItemInserted
         };
-        self.fire_changed(change, Some((*key).clone()));
+        self.fire_changed(change, Some(generic_as_default::<K>(&key).clone()));
         Ok(replaced)
     }
 
-    fn Remove(&self, key: Ref<K>) -> Result<()> {
-        let key_clone = (*key).clone();
+    fn Remove(&self, key: Generic<K>) -> Result<()> {
+        let key_clone = generic_as_default::<K>(&key).clone();
         {
             let mut map = self.map.write().unwrap();
-            if map.remove(&*key).is_none() {
+            if map.remove(generic_as_default::<K>(&key)).is_none() {
                 return Err(Error::from(E_BOUNDS));
             }
         }

crates/libs/collections/src/observable_vector.rs

@@ -62,9 +62,12 @@ where
         Ok(IVectorView::<T>::from(snapshot))
     }
 
-    fn IndexOf(&self, value: Ref<T>, result: &mut u32) -> Result<bool> {
+    fn IndexOf(&self, value: Generic<T>, result: &mut u32) -> Result<bool> {
         let values = self.values.read().unwrap();
-        match values.iter().position(|element| element == &*value) {
+        match values
+            .iter()
+            .position(|element| element == generic_as_default::<T>(&value))
+        {
             Some(index) => {
                 *result = index as u32;
                 Ok(true)
@@ -76,26 +79,26 @@ where
         }
     }
 
-    fn SetAt(&self, index: u32, value: Ref<T>) -> Result<()> {
+    fn SetAt(&self, index: u32, value: Generic<T>) -> Result<()> {
         {
             let mut values = self.values.write().unwrap();
             let item = values
                 .get_mut(index as usize)
                 .ok_or_else(|| Error::from(E_BOUNDS))?;
-            *item = (*value).clone();
+            *item = generic_as_default::<T>(&value).clone();
         }
         self.fire_changed(CollectionChange::ItemChanged, index);
         Ok(())
     }
 
-    fn InsertAt(&self, index: u32, value: Ref<T>) -> Result<()> {
+    fn InsertAt(&self, index: u32, value: Generic<T>) -> Result<()> {
         {
             let mut values = self.values.write().unwrap();
             let index = index as usize;
             if index > values.len() {
                 return Err(Error::from(E_BOUNDS));
             }
-            values.insert(index, (*value).clone());
+            values.insert(index, generic_as_default::<T>(&value).clone());
         }
         self.fire_changed(CollectionChange::ItemInserted, index);
         Ok(())
@@ -113,10 +116,10 @@ where
         Ok(())
     }
 
-    fn Append(&self, value: Ref<T>) -> Result<()> {
+    fn Append(&self, value: Generic<T>) -> Result<()> {
         let index = {
             let mut values = self.values.write().unwrap();
-            values.push((*value).clone());
+            values.push(generic_as_default::<T>(&value).clone());
             (values.len() - 1) as u32
         };
         self.fire_changed(CollectionChange::ItemInserted, index);

crates/libs/collections/src/vector.rs

@@ -46,9 +46,12 @@ where
         Ok(IVectorView::<T>::from(snapshot))
     }
 
-    fn IndexOf(&self, value: Ref<T>, result: &mut u32) -> Result<bool> {
+    fn IndexOf(&self, value: Generic<T>, result: &mut u32) -> Result<bool> {
         let values = self.values.read().unwrap();
-        match values.iter().position(|element| element == &*value) {
+        match values
+            .iter()
+            .position(|element| element == generic_as_default::<T>(&value))
+        {
             Some(index) => {
                 *result = index as u32;
                 Ok(true)
@@ -60,22 +63,22 @@ where
         }
     }
 
-    fn SetAt(&self, index: u32, value: Ref<T>) -> Result<()> {
+    fn SetAt(&self, index: u32, value: Generic<T>) -> Result<()> {
         let mut values = self.values.write().unwrap();
         let item = values
             .get_mut(index as usize)
             .ok_or_else(|| Error::from(E_BOUNDS))?;
-        *item = (*value).clone();
+        *item = generic_as_default::<T>(&value).clone();
         Ok(())
     }
 
-    fn InsertAt(&self, index: u32, value: Ref<T>) -> Result<()> {
+    fn InsertAt(&self, index: u32, value: Generic<T>) -> Result<()> {
         let mut values = self.values.write().unwrap();
         let index = index as usize;
         if index > values.len() {
             return Err(Error::from(E_BOUNDS));
         }
-        values.insert(index, (*value).clone());
+        values.insert(index, generic_as_default::<T>(&value).clone());
         Ok(())
     }
 
@@ -88,8 +91,11 @@ where
         Ok(())
     }
 
-    fn Append(&self, value: Ref<T>) -> Result<()> {
-        self.values.write().unwrap().push((*value).clone());
+    fn Append(&self, value: Generic<T>) -> Result<()> {
+        self.values
+            .write()
+            .unwrap()
+            .push(generic_as_default::<T>(&value).clone());
         Ok(())
     }
 

crates/libs/collections/src/vector_view.rs

@@ -42,8 +42,12 @@ where
         Ok(self.values.len().try_into()?)
     }
 
-    fn IndexOf(&self, value: Ref<T>, result: &mut u32) -> Result<bool> {
-        match self.values.iter().position(|element| element == &*value) {
+    fn IndexOf(&self, value: Generic<T>, result: &mut u32) -> Result<bool> {
+        match self
+            .values
+            .iter()
+            .position(|element| element == generic_as_default::<T>(&value))
+        {
             Some(index) => {
                 *result = index as u32;
                 Ok(true)