Replace unimplemented! panics with conditional #[link] attribute for WSL/Linux support

MarijnS95 · MarijnS95 · commit c769eb916e5f · 2022-07-05T21:42:41.000+02:00
The `#[cfg]` structure is verbose and not needed for cross-compilation
(where `target_os = "windows"` anyway).  Furthermore, the
`unimplemented!("Unsupported target OS")` panic prevents using all but
the most basic features windows-rs provides on non-Windows systems.
Use-cases relying on linking external functions include calling `dxcore`
from WSL and `DirectXShaderCompiler` from Linux, both using a COM
interface.

By removing this `#[cfg]` and `unimplemented!()` panic altogether
`windows`, just like `windows-sys`, now unconditionally link using
`-lwindows`.  This allows crates compiling on non-Windows targets to
provide their own fallbacks for needed functions.  Any required but
missing symbol becomes a linker error rather than a runtime panic.

However, such linking may not be desired or complicated to set up, and
doesn't prevent the `tool_*` applications (needed to propagate `bindgen`
changes in this PR to the final codebase, while working from a Linux
environment) through the `metadata` -&gt; `windows-sys` crate from linking
against a `-lwindows` library (and failing).
For this reason a `cfg_attr` with `windows` predicate has been chosen:
`link(name = "windows")` will be enabled on `target_os = "windows"`
exclusively.

The guard is applied to `windows-sys` which previously didn't have any
guarding at all (once again confirming that there's no impact on
cross-compiling) to unblock `tool_*` usage on non-Windows systems.

Users are able to provide fallbacks on their own within their consumer
crate through a simple:

    #[no_mangle]
    pub extern "system" fn SysStringLen(..) -&gt; ...;

for example, without having to resort to compiling that inside a
separate crate that emits a static library or shared object on the
search path.  This is however still possible, though.

There are a few more issues to work out before this crate can _run_ on
Linux and WSL, which have to be fleshed out before we can officially
(build-)test this use-case in CI.
diff --git a/crates/libs/bindgen/src/functions.rs b/crates/libs/bindgen/src/functions.rs
@@ -50,7 +50,7 @@ fn gen_win_function(gen: &Gen, def: MethodDef) -> TokenStream {
         Some(link) => quote! { #[link(name = #link, kind = "static")] },
         None => {
             if gen.namespace.starts_with("Windows.") {
-                quote! { #[link(name = "windows")] }
+                quote! { #[cfg_attr(windows, link(name = "windows"))] }
             } else {
                 let impl_map = gen.reader.method_def_impl_map(def).expect("ImplMap not found");
                 let scope = gen.reader.impl_map_scope(impl_map);
@@ -75,17 +75,12 @@ fn gen_win_function(gen: &Gen, def: MethodDef) -> TokenStream {
                 #features
                 #[inline]
                 pub unsafe fn #name<#constraints T: ::windows::core::Interface>(#params) -> ::windows::core::Result<T> {
-                    #[cfg(windows)]
-                    {
-                        #link_attr
-                        extern "system" {
-                            fn #name(#(#abi_params),*) #abi_return_type;
-                        }
-                        let mut result__ = ::core::option::Option::None;
-                        #name(#args).and_some(result__)
+                    #link_attr
+                    extern "system" {
+                        fn #name(#(#abi_params),*) #abi_return_type;
                     }
-                    #[cfg(not(windows))]
-                    unimplemented!("Unsupported target OS");
+                    let mut result__ = ::core::option::Option::None;
+                    #name(#args).and_some(result__)
                 }
             }
         }
@@ -98,16 +93,11 @@ fn gen_win_function(gen: &Gen, def: MethodDef) -> TokenStream {
                 #features
                 #[inline]
                 pub unsafe fn #name<#constraints T: ::windows::core::Interface>(#params result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
-                    #[cfg(windows)]
-                    {
-                        #link_attr
-                        extern "system" {
-                            fn #name(#(#abi_params),*) #abi_return_type;
-                        }
-                        #name(#args).ok()
+                    #link_attr
+                    extern "system" {
+                        fn #name(#(#abi_params),*) #abi_return_type;
                     }
-                    #[cfg(not(windows))]
-                    unimplemented!("Unsupported target OS");
+                    #name(#args).ok()
                 }
             }
         }
@@ -124,17 +114,12 @@ fn gen_win_function(gen: &Gen, def: MethodDef) -> TokenStream {
                 #features
                 #[inline]
                 pub unsafe fn #name<#constraints>(#params) -> ::windows::core::Result<#return_type_tokens> {
-                    #[cfg(windows)]
-                    {
-                        #link_attr
-                        extern "system" {
-                            fn #name(#(#abi_params),*) #abi_return_type;
-                        }
-                        let mut result__ = ::core::mem::MaybeUninit::<#abi_return_type_tokens>::zeroed();
-                        #name(#args ::core::mem::transmute(result__.as_mut_ptr())).from_abi::<#return_type_tokens>(result__)
+                    #link_attr
+                    extern "system" {
+                        fn #name(#(#abi_params),*) #abi_return_type;
                     }
-                    #[cfg(not(windows))]
-                    unimplemented!("Unsupported target OS");
+                    let mut result__ = ::core::mem::MaybeUninit::<#abi_return_type_tokens>::zeroed();
+                    #name(#args ::core::mem::transmute(result__.as_mut_ptr())).from_abi::<#return_type_tokens>(result__)
                 }
             }
         }
@@ -147,16 +132,11 @@ fn gen_win_function(gen: &Gen, def: MethodDef) -> TokenStream {
                 #features
                 #[inline]
                 pub unsafe fn #name<#constraints>(#params) -> ::windows::core::Result<()> {
-                    #[cfg(windows)]
-                    {
-                        #link_attr
-                        extern "system" {
-                            fn #name(#(#abi_params),*) #abi_return_type;
-                        }
-                        #name(#args).ok()
+                    #link_attr
+                    extern "system" {
+                        fn #name(#(#abi_params),*) #abi_return_type;
                     }
-                    #[cfg(not(windows))]
-                    unimplemented!("Unsupported target OS");
+                    #name(#args).ok()
                 }
             }
         }
@@ -171,17 +151,12 @@ fn gen_win_function(gen: &Gen, def: MethodDef) -> TokenStream {
                     #features
                     #[inline]
                     pub unsafe fn #name<#constraints>(#params) -> ::windows::core::Result<#return_type> {
-                        #[cfg(windows)]
-                        {
-                            #link_attr
-                            extern "system" {
-                                fn #name(#(#abi_params),*) -> #return_type;
-                            }
-                            let result__ = #name(#args);
-                            (!result__.is_invalid()).then(||result__).ok_or_else(::windows::core::Error::from_win32)
+                        #link_attr
+                        extern "system" {
+                            fn #name(#(#abi_params),*) -> #return_type;
                         }
-                        #[cfg(not(windows))]
-                        unimplemented!("Unsupported target OS");
+                        let result__ = #name(#args);
+                        (!result__.is_invalid()).then(||result__).ok_or_else(::windows::core::Error::from_win32)
                     }
                 }
             } else {
@@ -193,16 +168,11 @@ fn gen_win_function(gen: &Gen, def: MethodDef) -> TokenStream {
                     #features
                     #[inline]
                     pub unsafe fn #name<#constraints>(#params) #abi_return_type {
-                        #[cfg(windows)]
-                        {
-                            #link_attr
-                            extern "system" {
-                                fn #name(#(#abi_params),*) #abi_return_type;
-                            }
-                            ::core::mem::transmute(#name(#args))
+                        #link_attr
+                        extern "system" {
+                            fn #name(#(#abi_params),*) #abi_return_type;
                         }
-                        #[cfg(not(windows))]
-                        unimplemented!("Unsupported target OS");
+                        ::core::mem::transmute(#name(#args))
                     }
                 }
             }
@@ -217,16 +187,11 @@ fn gen_win_function(gen: &Gen, def: MethodDef) -> TokenStream {
                 #features
                 #[inline]
                 pub unsafe fn #name<#constraints>(#params) #does_not_return {
-                    #[cfg(windows)]
-                    {
-                        #link_attr
-                        extern "system" {
-                            fn #name(#(#abi_params),*) #does_not_return;
-                        }
-                        #name(#args)
+                    #link_attr
+                    extern "system" {
+                        fn #name(#(#abi_params),*) #does_not_return;
                     }
-                    #[cfg(not(windows))]
-                    unimplemented!("Unsupported target OS");
+                    #name(#args)
                 }
             }
         }
diff --git a/crates/libs/bindgen/src/lib.rs b/crates/libs/bindgen/src/lib.rs
@@ -80,7 +80,7 @@ pub fn namespace(gen: &Gen, tree: &Tree) -> String {
             if !methods.is_empty() {
                 let methods = methods.values();
                 functions = vec![quote! {
-                    #[link(name = "windows")]
+                    #[cfg_attr(windows, link(name = "windows"))]
                     extern "system" {
                         #(#methods)*
                     }
diff --git a/crates/libs/metadata/Cargo.toml b/crates/libs/metadata/Cargo.toml
@@ -12,7 +12,8 @@ default-target = "x86_64-pc-windows-msvc"
 targets = []
 
 [dependencies.windows-sys]
-version = "0.36.1"
+path = "../sys"
+version = "0.38"
 features = [
     "Win32_System_SystemServices",
     "Win32_System_Diagnostics_Debug",

Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ pub fn namespace(gen: &Gen, tree: &Tree) -> String {`
`80`	`80`	`if !methods.is_empty() {`
`81`	`81`	`let methods = methods.values();`
`82`	`82`	`functions = vec![quote! {`
`83`		`- #[link(name = "windows")]`
	`83`	`+ #[cfg_attr(windows, link(name = "windows"))]`
`84`	`84`	`extern "system" {`
`85`	`85`	`#(#methods)*`
`86`	`86`	`}`