Merge branch 'master' into fix-cross-compilation

Author: kennykerr

.github/workflows/build.yml

@@ -1,6 +1,6 @@
 name: Build and Test
 
-on: 
+on:
   pull_request:
   push:
     branches:
@@ -12,7 +12,7 @@ env:
 jobs:
   test:
     runs-on: ${{ matrix.os }}
-    strategy: 
+    strategy:
       matrix:
         include:
         - os: windows-latest
@@ -50,3 +50,21 @@ jobs:
     - name: fmt
       run: cargo fmt --all -- --check
       if: matrix.os == 'windows-latest' && matrix.rust == 'stable'
+
+    - name: generate bindings
+      run: |
+        cargo run -p windows_bindings --target ${{ matrix.other }}
+        git diff --exit-code || (echo '::error::Generated bindings are out-of-date. Make sure to update them by running `cargo run -p windows_bindings`'; exit 1)
+      shell: bash
+      if: matrix.os == 'windows-latest' && matrix.rust == 'stable'
+
+  format-macro:
+    runs-on: windows-latest
+    name: Format `build!` macros
+    steps:
+    - uses: actions/checkout@v2
+    - name: Invoke `windows_fmt`
+      run: cargo r -p windows_fmt
+    - name: Diff formatting result
+      shell: bash
+      run: git diff --exit-code || (echo '::error::Some `build!` macros were improperly formatted. Please run `cargo run -p windows_fmt` and push again'; exit 1)

crates/bindings/src/main.rs

@@ -1,31 +1,25 @@
 use std::io::prelude::*;
 
 fn main() -> std::io::Result<()> {
-    let tokens = windows_macros::generate!(
+    let tokens = windows_macros::generate! {
         Windows::Foundation::{IReference, IStringable, PropertyValue},
         Windows::Win32::System::Com::{
-            CoCreateGuid, CoTaskMemAlloc, CoTaskMemFree, CLSIDFromProgID, CoInitializeEx, CoCreateInstance,
-            IAgileObject, COINIT_MULTITHREADED, COINIT_APARTMENTTHREADED, CLSCTX_ALL,
+            CLSIDFromProgID, CoCreateGuid, CoCreateInstance, CoInitializeEx, CoTaskMemAlloc,
+            CoTaskMemFree, IAgileObject,
         },
-        Windows::Win32::System::Diagnostics::Debug::{
-            GetLastError, FormatMessageW, FORMAT_MESSAGE_ALLOCATE_BUFFER, FORMAT_MESSAGE_FROM_SYSTEM,
-            FORMAT_MESSAGE_IGNORE_INSERTS,
-        },
-        Windows::Win32::System::Memory::{
-            GetProcessHeap, HeapAlloc, HeapFree, HEAP_NONE,
-        },
-        Windows::Win32::System::OleAutomation::{BSTR, GetErrorInfo, IErrorInfo, SetErrorInfo},
+        Windows::Win32::System::Diagnostics::Debug::{FormatMessageW, GetLastError},
+        Windows::Win32::System::Memory::{GetProcessHeap, HeapAlloc, HeapFree},
+        Windows::Win32::System::OleAutomation::{GetErrorInfo, IErrorInfo, SetErrorInfo, BSTR},
         Windows::Win32::System::SystemServices::{
-            GetProcAddress, LoadLibraryA, FreeLibrary, CO_E_NOTINITIALIZED, E_POINTER,
-        },
-        Windows::Win32::System::Threading::{
-            CreateEventA, SetEvent, WaitForSingleObject,
+            FreeLibrary, GetProcAddress, LoadLibraryA, CO_E_NOTINITIALIZED, E_POINTER,
         },
-        Windows::Win32::System::WindowsProgramming::CloseHandle,
+        Windows::Win32::System::Threading::{CreateEventA, SetEvent, WaitForSingleObject},
         Windows::Win32::System::WinRT::{
-            IRestrictedErrorInfo, ILanguageExceptionErrorInfo2, IWeakReference, IWeakReferenceSource,
+            ILanguageExceptionErrorInfo2, IRestrictedErrorInfo, IWeakReference,
+            IWeakReferenceSource,
         },
-    );
+        Windows::Win32::System::WindowsProgramming::CloseHandle,
+    };
 
     let mut path = windows_gen::workspace_dir();
     path.push("src");

crates/fmt/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "windows_fmt"
+version = "0.0.0"
+edition = "2018"
+
+[dependencies]
+windows_gen = { path = "../gen" }

crates/fmt/src/main.rs

@@ -0,0 +1,60 @@
+use std::ffi::OsStr;
+use std::io::Result;
+use std::io::Write;
+use std::path::*;
+use std::process::Command;
+use std::process::Stdio;
+
+fn format_file(file: &Path, pattern: &str) -> Result<()> {
+    const SHIM: &str = "use format_build_macro::{";
+
+    let contents = std::fs::read(file)?;
+    let contents = String::from_utf8(contents).expect("Failed to parse UTF-8");
+
+    // Replace macro call with our `use` pattern
+    let contents = contents.replace(pattern, SHIM);
+
+    // Spawn `rustfmt` and pipe string through it, instead of writing it to disk
+    let mut child = Command::new("rustfmt")
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .spawn()
+        .expect("Failed to spawn `rustfmt`");
+    let mut stdin = child.stdin.take().expect("Failed to open stdin");
+    stdin.write_all(contents.as_bytes())?;
+    drop(stdin);
+
+    // Read formatted output from `rustfmt`
+    let output = child.wait_with_output().expect("Failed to read stdout");
+    let contents = String::from_utf8(output.stdout).expect("Failed to parse UTF-8");
+
+    // Some build macros contain a single item, where curly braces are removed. Those
+    // cannot easily be formatted yet.
+    if contents.contains(SHIM) {
+        std::fs::write(file, contents.replace(SHIM, pattern))?;
+    }
+
+    Ok(())
+}
+
+fn walk_path(path: &Path) -> Result<()> {
+    if path.is_dir() {
+        for entry in path.read_dir()? {
+            walk_path(&entry?.path())?;
+        }
+    } else if path.file_name() == Some(OsStr::new("build.rs")) {
+        format_file(path, "windows::build! {")?;
+    }
+
+    Ok(())
+}
+
+fn main() -> Result<()> {
+    let dir = windows_gen::workspace_dir();
+    walk_path(&dir)?;
+
+    format_file(
+        &dir.join("crates/bindings/src/main.rs"),
+        "let tokens = windows_macros::generate! {",
+    )
+}

crates/gen/src/async.rs

@@ -1,7 +1,7 @@
-use super::*;
+use crate::*;
 
 pub fn gen_async(
-    def: &GenericType,
+    def: &tables::TypeDef,
     interfaces: &[InterfaceInfo],
     gen: &Gen,
 ) -> (TokenStream, TokenStream) {
@@ -31,12 +31,12 @@ pub enum AsyncKind {
     OperationWithProgress,
 }
 
-pub fn async_kind(def: &GenericType) -> AsyncKind {
-    if def.def.namespace() != "Windows.Foundation" {
+pub fn async_kind(def: &tables::TypeDef) -> AsyncKind {
+    if def.namespace() != "Windows.Foundation" {
         return AsyncKind::None;
     }
 
-    match def.def.name() {
+    match def.name() {
         "IAsyncAction" => AsyncKind::Action,
         "IAsyncActionWithProgress`1" => AsyncKind::ActionWithProgress,
         "IAsyncOperation`1" => AsyncKind::Operation,
@@ -47,8 +47,8 @@ pub fn async_kind(def: &GenericType) -> AsyncKind {
 
 fn gen_async_kind(
     kind: AsyncKind,
-    name: &GenericType,
-    self_name: &GenericType,
+    name: &tables::TypeDef,
+    self_name: &tables::TypeDef,
     gen: &Gen,
 ) -> (TokenStream, TokenStream) {
     let return_type = match kind {

crates/gen/src/iterator.rs

@@ -5,8 +5,8 @@ use super::*;
 // only falls back to IIterator<T> if nothing faster is available. VectorIterator and
 // VectorViewIterator are faster iterators than IIterator<T> because they only require a single
 // vcall per iteration wheras IIterator<T> requires two.
-pub fn gen_iterator(def: &GenericType, interfaces: &[InterfaceInfo], gen: &Gen) -> TokenStream {
-    let name = def.def.full_name();
+pub fn gen_iterator(def: &tables::TypeDef, interfaces: &[InterfaceInfo], gen: &Gen) -> TokenStream {
+    let name = def.full_name();
 
     // If the type is IIterator<T> then simply implement the Iterator trait over top.
     if name == ("Windows.Foundation.Collections", "IIterator`1") {
@@ -154,7 +154,7 @@ pub fn gen_iterator(def: &GenericType, interfaces: &[InterfaceInfo], gen: &Gen)
     // If the class or interface is not one of the well-known collection interfaces, we then see whether it
     // implements any one of them. Here is where we favor IVectorView/IVector over IIterable.
     for interface in interfaces {
-        let name = interface.def.def.full_name();
+        let name = interface.def.full_name();
 
         if name == ("Windows.Foundation.Collections", "IVectorView`1") {
             let constraints = def.gen_constraints(gen);

crates/gen/src/parser/codes.rs

@@ -4,7 +4,7 @@ pub trait Decode {
     fn decode(file: &'static File, code: u32) -> Self;
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
+#[derive(Clone, Debug)]
 pub enum TypeDefOrRef {
     TypeDef(tables::TypeDef),
     TypeRef(tables::TypeRef),
@@ -15,7 +15,7 @@ impl Decode for TypeDefOrRef {
     fn decode(file: &'static File, code: u32) -> Self {
         let code = (code & ((1 << 2) - 1), (code >> 2) - 1);
         match code.0 {
-            0 => Self::TypeDef(tables::TypeDef(Row::new(code.1, TableIndex::TypeDef, file))),
+            0 => Self::TypeDef(Row::new(code.1, TableIndex::TypeDef, file).into()),
             1 => Self::TypeRef(tables::TypeRef(Row::new(code.1, TableIndex::TypeRef, file))),
             2 => Self::TypeSpec(tables::TypeSpec(Row::new(
                 code.1,
@@ -30,14 +30,14 @@ impl Decode for TypeDefOrRef {
 impl TypeDefOrRef {
     pub fn encode(&self) -> u32 {
         match self {
-            Self::TypeDef(value) => ((value.0.row + 1) << 2),
+            Self::TypeDef(value) => ((value.row.row + 1) << 2),
             Self::TypeRef(value) => ((value.0.row + 1) << 2) | 1,
             Self::TypeSpec(value) => ((value.0.row + 1) << 2) | 2,
         }
     }
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
+#[derive(Clone, Debug)]
 pub enum TypeOrMethodDef {
     TypeDef(tables::TypeDef),
     MethodDef(tables::MethodDef),
@@ -47,7 +47,7 @@ impl Decode for TypeOrMethodDef {
     fn decode(file: &'static File, code: u32) -> Self {
         let code = (code & ((1 << 1) - 1), (code >> 1) - 1);
         match code.0 {
-            0 => Self::TypeDef(tables::TypeDef(Row::new(code.1, TableIndex::TypeDef, file))),
+            0 => Self::TypeDef(Row::new(code.1, TableIndex::TypeDef, file).into()),
             1 => Self::MethodDef(tables::MethodDef(Row::new(
                 code.1,
                 TableIndex::MethodDef,
@@ -61,13 +61,13 @@ impl Decode for TypeOrMethodDef {
 impl TypeOrMethodDef {
     pub fn encode(&self) -> u32 {
         match self {
-            Self::TypeDef(value) => ((value.0.row + 1) << 1),
+            Self::TypeDef(value) => ((value.row.row + 1) << 1),
             Self::MethodDef(value) => ((value.0.row + 1) << 1) | 1,
         }
     }
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
+#[derive(Clone, Debug)]
 pub enum HasAttribute {
     MethodDef(tables::MethodDef),
     Field(tables::Field),
@@ -91,7 +91,7 @@ impl Decode for HasAttribute {
             ))),
             1 => Self::Field(tables::Field(Row::new(code.1, TableIndex::Field, file))),
             2 => Self::TypeRef(tables::TypeRef(Row::new(code.1, TableIndex::TypeRef, file))),
-            3 => Self::TypeDef(tables::TypeDef(Row::new(code.1, TableIndex::TypeDef, file))),
+            3 => Self::TypeDef(Row::new(code.1, TableIndex::TypeDef, file).into()),
             4 => Self::Param(tables::Param(Row::new(code.1, TableIndex::Param, file))),
             5 => Self::InterfaceImpl(tables::InterfaceImpl(Row::new(
                 code.1,
@@ -124,7 +124,7 @@ impl HasAttribute {
             Self::MethodDef(value) => ((value.0.row + 1) << 5),
             Self::Field(value) => ((value.0.row + 1) << 5) | 1,
             Self::TypeRef(value) => ((value.0.row + 1) << 5) | 2,
-            Self::TypeDef(value) => ((value.0.row + 1) << 5) | 3,
+            Self::TypeDef(value) => ((value.row.row + 1) << 5) | 3,
             Self::Param(value) => ((value.0.row + 1) << 5) | 4,
             Self::InterfaceImpl(value) => ((value.0.row + 1) << 5) | 5,
             Self::MemberRef(value) => ((value.0.row + 1) << 5) | 6,
@@ -134,7 +134,7 @@ impl HasAttribute {
     }
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
+#[derive(Clone, Debug)]
 pub enum MemberRefParent {
     TypeDef(tables::TypeDef),
     TypeRef(tables::TypeRef),
@@ -146,7 +146,7 @@ impl Decode for MemberRefParent {
     fn decode(file: &'static File, code: u32) -> Self {
         let code = (code & ((1 << 3) - 1), (code >> 3) - 1);
         match code.0 {
-            0 => Self::TypeDef(tables::TypeDef(Row::new(code.1, TableIndex::TypeDef, file))),
+            0 => Self::TypeDef(Row::new(code.1, TableIndex::TypeDef, file).into()),
             1 => Self::TypeRef(tables::TypeRef(Row::new(code.1, TableIndex::TypeRef, file))),
             3 => Self::MethodDef(tables::MethodDef(Row::new(
                 code.1,
@@ -166,15 +166,15 @@ impl Decode for MemberRefParent {
 impl MemberRefParent {
     pub fn encode(&self) -> u32 {
         match self {
-            Self::TypeDef(value) => ((value.0.row + 1) << 3),
+            Self::TypeDef(value) => ((value.row.row + 1) << 3),
             Self::TypeRef(value) => ((value.0.row + 1) << 3) | 1,
             Self::MethodDef(value) => ((value.0.row + 1) << 3) | 3,
             Self::TypeSpec(value) => ((value.0.row + 1) << 3) | 4,
         }
     }
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
+#[derive(Clone, Debug)]
 pub enum HasConstant {
     Field(tables::Field),
     Param(tables::Param),
@@ -200,7 +200,7 @@ impl HasConstant {
     }
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
+#[derive(Clone, Debug)]
 pub enum AttributeType {
     MethodDef(tables::MethodDef),
     MemberRef(tables::MemberRef),
@@ -234,7 +234,7 @@ impl AttributeType {
     }
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
+#[derive(Clone, Debug)]
 pub enum MemberForwarded {
     Field(tables::Field),
     MethodDef(tables::MethodDef),
@@ -264,7 +264,7 @@ impl MemberForwarded {
     }
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
+#[derive(Clone, Debug)]
 pub enum ResolutionScope {
     Module(tables::Module),
     ModuleRef(tables::ModuleRef),
@@ -331,7 +331,7 @@ impl TypeDefOrRef {
 
     pub fn resolve(&self) -> tables::TypeDef {
         match self {
-            Self::TypeDef(value) => *value,
+            Self::TypeDef(value) => value.clone(),
             Self::TypeRef(value) => value.resolve(),
             _ => unexpected!(),
         }