feat(rust) make link_native_symbols default

Author: BjornTheProgrammer

crates/guest-rust/macro/src/lib.rs

@@ -175,9 +175,6 @@ impl Parse for Config {
                     Opt::MergeStructurallyEqualTypes(enable) => {
                         opts.merge_structurally_equal_types = Some(Some(enable.value()))
                     }
-                    Opt::LinkNativeSymbols(enable) => {
-                        opts.link_native_symbols = enable.value();
-                    }
                 }
             }
         } else {
@@ -335,7 +332,6 @@ mod kw {
     syn::custom_keyword!(debug);
     syn::custom_keyword!(enable_method_chaining);
     syn::custom_keyword!(merge_structurally_equal_types);
-    syn::custom_keyword!(link_native_symbols);
 }
 
 #[derive(Clone)]
@@ -420,7 +416,6 @@ enum Opt {
     Debug(syn::LitBool),
     EnableMethodChaining(syn::LitBool),
     MergeStructurallyEqualTypes(syn::LitBool),
-    LinkNativeSymbols(syn::LitBool),
 }
 
 impl Parse for Opt {
@@ -628,10 +623,6 @@ impl Parse for Opt {
             input.parse::<kw::merge_structurally_equal_types>()?;
             input.parse::<Token![:]>()?;
             Ok(Opt::MergeStructurallyEqualTypes(input.parse()?))
-        } else if l.peek(kw::link_native_symbols) {
-            input.parse::<kw::link_native_symbols>()?;
-            input.parse::<Token![:]>()?;
-            Ok(Opt::LinkNativeSymbols(input.parse()?))
         } else {
             Err(l.error())
         }

crates/guest-rust/src/lib.rs

@@ -891,27 +891,42 @@ extern crate std;
 ///     // structurally equal, which is useful when import and export the same
 ///     // interface.
 ///     merge_structurally_equal_types: true,
-///
-///     // Make the same generated bindings usable on a native (non-wasm)
-///     // target as well as on wasm32.
-///     //
-///     // Imports normally compile to `unreachable!()` off wasm32. With this
-///     // enabled each one instead calls through a function pointer that a host
-///     // installs at load time via a generated
-///     // `__wit_bindgen_register_*` symbol, and exports additionally get a
-///     // native symbol whose name encodes the characters a linker cannot
-///     // accept. Both targets still build from one source.
-///     //
-///     // The registration symbols are prefixed with a hex-encoded
-///     // `<package>/<world>` so that two `generate!` invocations in one crate
-///     // don't collide. Binding the *same* world twice in one linkage unit
-///     // still does; use `type_section_suffix` to tell them apart. See
-///     // `wit_bindgen_rust::Opts::link_native_symbols` for the full list of
-///     // symbols a host can expect.
-///     link_native_symbols: true,
 /// });
 /// ```
 ///
+/// ## Native (non-WebAssembly) targets
+///
+/// Generated bindings also compile for native targets, which is useful for
+/// testing component code without a wasm runtime or for building it as a
+/// `cdylib` plugin. Native linkers don't accept the `:`, `/`, `#`, `[` and
+/// `]` characters that canonical ABI symbol names use, so on native targets
+/// symbols are hex-encoded with the scheme in
+/// `wit_bindgen_core::symbol_name` (the same one the C++ generator uses).
+///
+/// Imports are not resolved by the native linker. Each import calls through
+/// a function pointer that starts out null, and a host provides an
+/// implementation at load time by calling the generated
+/// `__wit_bindgen_register_<world><import>` function with a function pointer
+/// of the import's core signature (`<import>` here is
+/// `make_external_symbol(module, name, GuestImport)`). This means everything
+/// links whether or not a host is present: a host only needs to register the
+/// imports it actually implements, and calling an import that was never
+/// registered aborts with a message naming the import and its registration
+/// function.
+///
+/// Exports, including post-return functions, async callbacks, and resource
+/// destructors, are exported under their hex-encoded core export names. A
+/// `__wit_bindgen_cabi_realloc_<world>` function is also exported so hosts
+/// can allocate guest-owned memory when lowering arguments, as the canonical
+/// ABI requires.
+///
+/// The `<world>` prefix above is a hex-encoded
+/// `<package>/<world><type_section_suffix>`, which keeps two `generate!`
+/// invocations in one binary from defining the same symbols. Note that
+/// binding the same world twice in one native binary will fail to link with
+/// duplicate symbols unless `type_section_suffix` is used to tell the two
+/// apart.
+///
 /// [WIT package]: https://component-model.bytecodealliance.org/design/packages.html
 #[cfg(feature = "macros")]
 pub use wit_bindgen_rust_macro::generate;

crates/rust/src/interface.rs

@@ -357,25 +357,23 @@ macro_rules! {macro_name} {{
                 }
             };
             let camel = name.to_upper_camel_case();
-            for (cfg, symbol) in self.core_export_symbols(&format!("{module}#[dtor]{name}")) {
-                uwriteln!(
-                    self.src,
-                    r#"
-                    const _: () = {{
-                        #[doc(hidden)]
-                        {cfg}#[unsafe(export_name = "{symbol}")]
-                        #[allow(non_snake_case)]
-                        unsafe extern "C" fn dtor(rep: *mut u8) {{
-                            unsafe {{
-                                $($path_to_types)*::{camel}::dtor::<
-                                    <$ty as $($path_to_types)*::Guest>::{camel}
-                                >(rep)
-                            }}
+            let attrs = self.core_export_attrs(&format!("{module}#[dtor]{name}"));
+            uwriteln!(
+                self.src,
+                r#"
+                const _: () = {{
+                    #[doc(hidden)]
+                    {attrs}#[allow(non_snake_case)]
+                    unsafe extern "C" fn dtor(rep: *mut u8) {{
+                        unsafe {{
+                            $($path_to_types)*::{camel}::dtor::<
+                                <$ty as $($path_to_types)*::Guest>::{camel}
+                            >(rep)
                         }}
-                    }};
-                    "#
-                );
-            }
+                    }}
+                }};
+                "#
+            );
         }
         uwriteln!(self.src, "}};);");
         uwriteln!(self.src, "}}");
@@ -1292,86 +1290,69 @@ unsafe fn call_import(&mut self, _params: Self::ParamsLower, _results: *mut u8)
             export_name.to_string()
         };
 
-        for (cfg, symbol) in self.core_export_symbols(&export_name) {
+        let attrs = self.core_export_attrs(&export_name);
+        uwrite!(
+            self.src,
+            "\
+                {attrs}unsafe extern \"C\" fn export_{name_snake}\
+",
+        );
+        let params = self.print_export_sig(func, async_);
+        self.push_str(" {\n");
+        uwriteln!(
+            self.src,
+            "unsafe {{ {path_to_self}::_export_{name_snake}_cabi::<{ty}>({}) }}",
+            params.join(", ")
+        );
+        self.push_str("}\n");
+
+        if async_ {
+            let attrs = self.core_export_attrs(&format!("[callback]{export_name}"));
             uwrite!(
                 self.src,
                 "\
-                    {cfg}#[unsafe(export_name = \"{symbol}\")]
-                    unsafe extern \"C\" fn export_{name_snake}\
-",
+                    {attrs}unsafe extern \"C\" fn _callback_{name_snake}(event0: u32, event1: u32, event2: u32) -> u32 {{
+                        unsafe {{
+                            {path_to_self}::__callback_{name_snake}(event0, event1, event2)
+                        }}
+                    }}
+                "
             );
-            let params = self.print_export_sig(func, async_);
-            self.push_str(" {\n");
+        } else if abi::guest_export_needs_post_return(self.resolve, func) {
+            let attrs = self.core_export_attrs(&format!("cabi_post_{export_name}"));
+            uwrite!(
+                self.src,
+                "\
+                    {attrs}unsafe extern \"C\" fn _post_return_{name_snake}\
+"
+            );
+            let params = self.print_post_return_sig(func);
+            self.src.push_str("{\n");
             uwriteln!(
                 self.src,
-                "unsafe {{ {path_to_self}::_export_{name_snake}_cabi::<{ty}>({}) }}",
+                "unsafe {{ {path_to_self}::__post_return_{name_snake}::<{ty}>({}) }}",
                 params.join(", ")
             );
-            self.push_str("}\n");
-        }
-
-        if async_ {
-            for (cfg, symbol) in self.core_export_symbols(&format!("[callback]{export_name}")) {
-                uwrite!(
-                    self.src,
-                    "\
-                        {cfg}#[unsafe(export_name = \"{symbol}\")]
-                        unsafe extern \"C\" fn _callback_{name_snake}(event0: u32, event1: u32, event2: u32) -> u32 {{
-                            unsafe {{
-                                {path_to_self}::__callback_{name_snake}(event0, event1, event2)
-                            }}
-                        }}
-                    "
-                );
-            }
-        } else if abi::guest_export_needs_post_return(self.resolve, func) {
-            for (cfg, symbol) in self.core_export_symbols(&format!("cabi_post_{export_name}")) {
-                uwrite!(
-                    self.src,
-                    "\
-                        {cfg}#[unsafe(export_name = \"{symbol}\")]
-                        unsafe extern \"C\" fn _post_return_{name_snake}\
-"
-                );
-                let params = self.print_post_return_sig(func);
-                self.src.push_str("{\n");
-                uwriteln!(
-                    self.src,
-                    "unsafe {{ {path_to_self}::__post_return_{name_snake}::<{ty}>({}) }}",
-                    params.join(", ")
-                );
-                self.src.push_str("}\n");
-            }
+            self.src.push_str("}\n");
         }
     }
 
-    /// Returns each copy of a core export named `export_name` that needs to be
-    /// emitted, as `(cfg, symbol)`: the `cfg` attribute to gate the copy with
-    /// and the symbol to export it as.
+    /// Returns the `export_name` attributes for a core export named
+    /// `export_name`.
     ///
-    /// Normally there's just one copy: the canonical ABI name with no `cfg`.
-    /// With `link_native_symbols` enabled a second, hex-encoded copy is emitted
-    /// for native targets as well, because native linkers reject the `:`, `/`,
-    /// `#`, `[` and `]` characters that canonical names contain. Names that
-    /// survive encoding unchanged (`$root` exports, for instance) are emitted
-    /// once with no `cfg` rather than twice.
-    fn core_export_symbols(&self, export_name: &str) -> Vec<(&'static str, String)> {
+    /// Has to exist due to the fact that native names cannot contain
+    /// special characters that wasm32 can like '/'.
+    ///
+    /// `cfg_attr` conditions are mutually exclusive, so exactly one attribute
+    /// applies on any target (for names that survive encoding unchanged, such
+    /// as `$root` exports, both carry the same string).
+    fn core_export_attrs(&self, export_name: &str) -> String {
         let prefix = self.r#gen.opts.export_prefix.as_deref().unwrap_or("");
-        let wasm = format!("{prefix}{export_name}");
-        if self.r#gen.native_symbols().is_none() {
-            return vec![("", wasm)];
-        }
-        let native = format!(
-            "{prefix}{}",
-            symbol_name::make_external_component(export_name)
-        );
-        if native == wasm {
-            return vec![("", wasm)];
-        }
-        vec![
-            ("#[cfg(target_arch = \"wasm32\")]\n", wasm),
-            ("#[cfg(not(target_arch = \"wasm32\"))]\n", native),
-        ]
+        let native = symbol_name::make_external_component(export_name);
+        format!(
+            "#[cfg_attr(target_arch = \"wasm32\", unsafe(export_name = \"{prefix}{export_name}\"))]\n\
+             #[cfg_attr(not(target_arch = \"wasm32\"), unsafe(export_name = \"{prefix}{native}\"))]\n"
+        )
     }
 
     fn print_export_sig(&mut self, func: &Function, async_: bool) -> Vec<String> {