Additional type system support (#388)

Author: kennykerr

crates/gen/src/constant.rs

@@ -18,8 +18,64 @@ impl Constant {
     pub fn gen(&self) -> TokenStream {
         let name = format_ident(self.field.name());
 
+        let constant = self
+            .field
+            .constants()
+            .next()
+            .expect("Missing constant value");
+
+        let mut value = constant.value();
+
+        let value = match constant.value_type() {
+            winmd::ElementType::I8 => ConstantValue::I8(value.read_i8()),
+            winmd::ElementType::U8 => ConstantValue::U8(value.read_u8()),
+            winmd::ElementType::I16 => ConstantValue::I16(value.read_i16()),
+            winmd::ElementType::U16 => ConstantValue::U16(value.read_u16()),
+            winmd::ElementType::I32 => ConstantValue::I32(value.read_i32()),
+            winmd::ElementType::U32 => ConstantValue::U32(value.read_u32()),
+            winmd::ElementType::F32 => ConstantValue::F32(value.read_f32()),
+            winmd::ElementType::F64 => ConstantValue::F64(value.read_f64()),
+            winmd::ElementType::String => ConstantValue::String(value.read_utf16()),
+            value_type => panic!(
+                "Unsupported constant: {} ({:?})",
+                self.field.name(),
+                value_type
+            ),
+        };
+
+        let value = value.gen();
+
         quote! {
-            pub const  #name: i32 = 0;
+            pub const  #name: #value;
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum ConstantValue {
+    U8(u8),
+    I8(i8),
+    U16(u16),
+    I16(i16),
+    U32(u32),
+    I32(i32),
+    F32(f32),
+    F64(f64),
+    String(String),
+}
+
+impl ConstantValue {
+    fn gen(&self) -> TokenStream {
+        match self {
+            Self::U8(value) => quote! { u8 = #value },
+            Self::I8(value) => quote! { i8 = #value },
+            Self::U16(value) => quote! { u16 = #value },
+            Self::I16(value) => quote! { i16 = #value },
+            Self::U32(value) => quote! { u32 = #value },
+            Self::I32(value) => quote! { i32 = #value },
+            Self::F32(value) => quote! { f32 = #value },
+            Self::F64(value) => quote! { f64 = #value },
+            Self::String(value) => quote! { &'static str = #value },
         }
     }
 }

crates/gen/src/type_namespaces.rs

@@ -21,6 +21,7 @@ impl TypeNamespaces {
             quote! {
                 // TODO: remove this allowance when https://github.com/microsoft/winrt-rs/issues/212 is fixed
                 #[allow(unused_variables)]
+                #[allow(non_upper_case_globals)]
                 pub mod #name {
                     #(#tokens)*
                     #foundation

crates/tests/build.rs

@@ -26,12 +26,14 @@ fn main() {
         // Test for https://github.com/microsoft/winrt-rs/issues/361
         windows::ui::xaml::{IApplicationOverrides, IApplicationOverrides2}
 
+        // Test for https://github.com/microsoft/winrt-rs/issues/386
         windows::ui::xaml::data::ICustomPropertyProvider
 
         // Used to test Win32 support
         windows::win32::{
             ACCESS_MODE, CHOOSECOLORW, DXGI_ADAPTER_FLAG, DXGI_FORMAT, DXGI_MODE_DESC, DXGI_MODE_SCALING,
-            DXGI_MODE_SCANLINE_ORDER, DXGI_RATIONAL, RECT, WM_KEYUP,
+            DXGI_MODE_SCANLINE_ORDER, DXGI_RATIONAL, RECT, WM_KEYUP, ALLJOYN_BIG_ENDIAN, ALLJOYN_CRED_CERT_CHAIN,
+            D3D12_DEFAULT_BLEND_FACTOR_ALPHA, UIA_ScrollPatternNoScroll, D3DCOMPILER_DLL
         }
     );
 }

crates/tests/tests/win32.rs

@@ -1,6 +1,8 @@
 use tests::windows::win32::{
-    ACCESS_MODE, CHOOSECOLORW, DXGI_ADAPTER_FLAG, DXGI_FORMAT, DXGI_MODE_DESC, DXGI_MODE_SCALING,
-    DXGI_MODE_SCANLINE_ORDER, DXGI_RATIONAL, RECT, WM_KEYUP,
+    UIA_ScrollPatternNoScroll, ACCESS_MODE, ALLJOYN_BIG_ENDIAN, ALLJOYN_CRED_CERT_CHAIN,
+    CHOOSECOLORW, D3D12_DEFAULT_BLEND_FACTOR_ALPHA, D3DCOMPILER_DLL, DXGI_ADAPTER_FLAG,
+    DXGI_FORMAT, DXGI_MODE_DESC, DXGI_MODE_SCALING, DXGI_MODE_SCANLINE_ORDER, DXGI_RATIONAL, RECT,
+    WM_KEYUP,
 };
 use winrt::Abi;
 
@@ -87,5 +89,10 @@ fn size32() {
 
 #[test]
 fn constant() {
-    assert!(WM_KEYUP == 0);
+    assert!(ALLJOYN_BIG_ENDIAN == 66u8);
+    assert!(ALLJOYN_CRED_CERT_CHAIN == 4u16);
+    assert!(WM_KEYUP == 257i32);
+    assert!(D3D12_DEFAULT_BLEND_FACTOR_ALPHA == 1f32);
+    assert!(UIA_ScrollPatternNoScroll == -1f64);
+    assert!(D3DCOMPILER_DLL == "d3dcompiler_47.dll");
 }

crates/winmd/macros/src/lib.rs

@@ -51,7 +51,7 @@ pub fn type_code(args: TokenStream, input: TokenStream) -> TokenStream {
     let encodes = TokenStream2::from_iter(encodes);
 
     let output = quote!(
-        #[derive(Copy, Clone, Debug)]// PartialEq, PartialOrd, Eq, Ord, Debug)]
+        #[derive(Copy, Clone, Debug)] // TODO: PartialEq, PartialOrd, Eq, Ord, Debug)]
         pub enum #name {
             #variants
         }

crates/winmd/src/parsed/blob.rs

@@ -6,11 +6,12 @@ pub struct Blob {
     pub reader: &'static TypeReader,
     pub file_index: u16,
     pub offset: usize,
+    pub size: usize,
 }
 
 impl Blob {
-    fn bytes(&self) -> &[u8] {
-        &self.file().bytes[self.offset..]
+    fn bytes(&self) -> &'static [u8] {
+        &self.reader.files[self.file_index as usize].bytes[self.offset..]
     }
 
     pub fn peek_unsigned(&self) -> (u32, usize) {
@@ -67,10 +68,24 @@ impl Blob {
         mods
     }
 
-    pub fn read_str(&mut self) -> &str {
+    pub fn read_str(&mut self) -> &'static str {
         let len = self.read_unsigned() as usize;
         self.offset += len;
-        std::str::from_utf8(&self.file().bytes[self.offset - len..self.offset]).unwrap()
+        std::str::from_utf8(
+            &self.reader.files[self.file_index as usize].bytes[self.offset - len..self.offset],
+        )
+        .unwrap()
+    }
+
+    pub fn read_utf16(&self) -> String {
+        let bytes = self.reader.files[self.file_index as usize].bytes[self.offset..].as_ptr();
+        unsafe {
+            String::from_utf16(std::slice::from_raw_parts(
+                bytes as *const u16,
+                self.size / 2,
+            ))
+            .unwrap()
+        }
     }
 
     pub fn read_i8(&mut self) -> i8 {
@@ -121,7 +136,15 @@ impl Blob {
         value
     }
 
-    fn file(&self) -> &File {
-        &self.reader.files[self.file_index as usize]
+    pub fn read_f32(&mut self) -> f32 {
+        let value = f32::from_le_bytes(self.bytes()[..4].try_into().unwrap());
+        self.offset += 4;
+        value
+    }
+
+    pub fn read_f64(&mut self) -> f64 {
+        let value = f64::from_le_bytes(self.bytes()[..8].try_into().unwrap());
+        self.offset += 8;
+        value
     }
 }

crates/winmd/src/type_reader.rs

@@ -254,19 +254,21 @@ impl TypeReader {
         let file = &self.files[row.file_index as usize];
         let offset = (file.blobs + self.u32(row, column)) as usize;
         let initial_byte = file.bytes[offset];
-        let (mut blob_size, blob_size_bytes) = match initial_byte >> 5 {
+        let (blob_size, blob_size_bytes) = match initial_byte >> 5 {
             0..=3 => (initial_byte & 0x7f, 1),
             4..=5 => (initial_byte & 0x3f, 2),
             6 => (initial_byte & 0x1f, 4),
             _ => panic!("Invalid blob size"),
         };
+        let mut blob_size = blob_size as usize;
         for byte in &file.bytes[offset + 1..offset + blob_size_bytes] {
-            blob_size = blob_size.checked_shl(8).unwrap_or(0) + byte;
+            blob_size = blob_size.checked_shl(8).unwrap_or(0) + (*byte as usize);
         }
         Blob {
             reader: self,
             file_index: row.file_index,
             offset: offset + blob_size_bytes,
+            size: blob_size,
         }
     }