Move most of the wit-bindgen crate into generated code (#868)

* Prepare for the eventual removal of the `wit-bindgen` crate

Instead of assuming that the entire crate exists start requesting
individual items from the crate throughout the generator so the
generated code can codegen precisely what's needed.

* Start moving items from `wit-bindgen` into generated code

* Move the `run_ctors_once` workaround into generate code

Also make it optional

* Move integer `as_*` helpers into generated code.

* Move the `Resource` type and supporting traits into generated code.

Author: alexcrichton

Cargo.lock

@@ -10,14 +10,6 @@
 
 #![no_std]
 
-extern crate alloc;
-
-use alloc::boxed::Box;
-use core::fmt;
-use core::marker;
-use core::ops::{Deref, DerefMut};
-use core::sync::atomic::{AtomicU32, Ordering::Relaxed};
-
 /// Generate bindings for an input WIT document.
 ///
 /// This macro is the bread-and-butter of the `wit-bindgen` crate. The macro
@@ -301,6 +293,10 @@ use core::sync::atomic::{AtomicU32, Ordering::Relaxed};
 ///     // for generated types. This is a niche option that is only here to
 ///     // support the standard library itself depending on this crate one day.
 ///     std_feature,
+///
+///     // Force a workaround to be emitted for pre-Rust-1.69.0 modules to
+///     // ensure that libc ctors run only once.
+///     run_ctors_once_workaround: true,
 /// });
 /// ```
 ///
@@ -318,44 +314,8 @@ mod cabi_realloc;
 
 #[doc(hidden)]
 pub mod rt {
-    use crate::alloc::string::String;
-    use crate::alloc::vec::Vec;
-
-    pub use crate::{Resource, RustResource, WasmResource};
-
-    /// Provide a hook for generated export functions to run static
-    /// constructors at most once. wit-bindgen-rust generates a call to this
-    /// function at the start of all component export functions. Importantly,
-    /// it is not called as part of `cabi_realloc`, which is a *core* export
-    /// func, but may not execute ctors, because the environment ctor in
-    /// wasi-libc (before rust 1.69.0) calls an import func, which is not
-    /// permitted by the Component Model when inside realloc.
-    ///
-    /// We intend to remove this once rust 1.69.0 stabilizes.
-    #[cfg(target_arch = "wasm32")]
-    pub fn run_ctors_once() {
-        static mut RUN: bool = false;
-        unsafe {
-            if !RUN {
-                // This function is synthesized by `wasm-ld` to run all static
-                // constructors. wasm-ld will either provide an implementation
-                // of this symbol, or synthesize a wrapper around each
-                // exported function to (unconditionally) run ctors. By using
-                // this function, the linked module is opting into "manually"
-                // running ctors.
-                extern "C" {
-                    fn __wasm_call_ctors();
-                }
-                __wasm_call_ctors();
-                RUN = true;
-            }
-        }
-    }
 
-    use super::alloc::alloc::Layout;
-
-    // Re-export things from liballoc for convenient use.
-    pub use super::alloc::{alloc, boxed, string, vec};
+    extern crate alloc;
 
     /// This function is called from generated bindings and will be deleted by
     /// the linker. The purpose of this function is to force a reference to the
@@ -405,6 +365,8 @@ pub mod rt {
         align: usize,
         new_len: usize,
     ) -> *mut u8 {
+        use self::alloc::alloc::{self, Layout};
+
         let layout;
         let ptr = if old_len == 0 {
             if new_len == 0 {
@@ -432,249 +394,4 @@ pub mod rt {
         }
         return ptr;
     }
-
-    pub unsafe fn dealloc(ptr: i32, size: usize, align: usize) {
-        if size == 0 {
-            return;
-        }
-        let layout = Layout::from_size_align_unchecked(size, align);
-        alloc::dealloc(ptr as *mut u8, layout);
-    }
-
-    macro_rules! as_traits {
-        ($(($trait_:ident $func:ident $ty:ident <=> $($tys:ident)*))*) => ($(
-            pub fn $func<T: $trait_>(t: T) -> $ty {
-                t.$func()
-            }
-
-            pub trait $trait_ {
-                fn $func(self) -> $ty;
-            }
-
-            impl<'a, T: Copy + $trait_> $trait_ for &'a T {
-                fn $func(self) -> $ty{
-                    (*self).$func()
-                }
-            }
-
-            $(
-                impl $trait_ for $tys {
-                    #[inline]
-                    fn $func(self) -> $ty {
-                        self as $ty
-                    }
-                }
-            )*
-
-        )*)
-    }
-
-    as_traits! {
-        (AsI64 as_i64 i64 <=> i64 u64)
-        (AsI32 as_i32 i32 <=> i32 u32 i16 u16 i8 u8 char usize)
-        (AsF32 as_f32 f32 <=> f32)
-        (AsF64 as_f64 f64 <=> f64)
-    }
-
-    pub unsafe fn string_lift(bytes: Vec<u8>) -> String {
-        if cfg!(debug_assertions) {
-            String::from_utf8(bytes).unwrap()
-        } else {
-            String::from_utf8_unchecked(bytes)
-        }
-    }
-
-    pub unsafe fn invalid_enum_discriminant<T>() -> T {
-        if cfg!(debug_assertions) {
-            panic!("invalid enum discriminant")
-        } else {
-            core::hint::unreachable_unchecked()
-        }
-    }
-
-    pub unsafe fn char_lift(val: u32) -> char {
-        if cfg!(debug_assertions) {
-            core::char::from_u32(val).unwrap()
-        } else {
-            core::char::from_u32_unchecked(val)
-        }
-    }
-
-    pub unsafe fn bool_lift(val: u8) -> bool {
-        if cfg!(debug_assertions) {
-            match val {
-                0 => false,
-                1 => true,
-                _ => panic!("invalid bool discriminant"),
-            }
-        } else {
-            core::mem::transmute::<u8, bool>(val)
-        }
-    }
-}
-
-type RawRep<T> = Option<T>;
-
-/// A type which represents a component model resource, either imported or
-/// exported into this component.
-///
-/// This is a low-level wrapper which handles the lifetime of the resource
-/// (namely this has a destructor). The `T` provided defines the component model
-/// intrinsics that this wrapper uses.
-///
-/// One of the chief purposes of this type is to provide `Deref` implementations
-/// to access the underlying data when it is owned.
-///
-/// This type is primarily used in generated code for exported and imported
-/// resources.
-#[repr(transparent)]
-pub struct Resource<T: WasmResource> {
-    // NB: This would ideally be `u32` but it is not. The fact that this has
-    // interior mutability is not exposed in the API of this type except for the
-    // `take_handle` method which is supposed to in theory be private.
-    //
-    // This represents, almost all the time, a valid handle value. When it's
-    // invalid it's stored as `u32::MAX`.
-    handle: AtomicU32,
-    _marker: marker::PhantomData<Box<T>>,
-}
-
-/// A trait which all wasm resources implement, namely providing the ability to
-/// drop a resource.
-///
-/// This generally is implemented by generated code, not user-facing code.
-pub unsafe trait WasmResource {
-    /// Invokes the `[resource-drop]...` intrinsic.
-    unsafe fn drop(handle: u32);
-}
-
-/// A trait which extends [`WasmResource`] used for Rust-defined resources, or
-/// those exported from this component.
-///
-/// This generally is implemented by generated code, not user-facing code.
-pub unsafe trait RustResource: WasmResource {
-    /// Invokes the `[resource-new]...` intrinsic.
-    unsafe fn new(rep: usize) -> u32;
-    /// Invokes the `[resource-rep]...` intrinsic.
-    unsafe fn rep(handle: u32) -> usize;
-}
-
-impl<T: WasmResource> Resource<T> {
-    #[doc(hidden)]
-    pub unsafe fn from_handle(handle: u32) -> Self {
-        debug_assert!(handle != u32::MAX);
-        Self {
-            handle: AtomicU32::new(handle),
-            _marker: marker::PhantomData,
-        }
-    }
-
-    /// Takes ownership of the handle owned by `resource`.
-    ///
-    /// Note that this ideally would be `into_handle` taking `Resource<T>` by
-    /// ownership. The code generator does not enable that in all situations,
-    /// unfortunately, so this is provided instead.
-    ///
-    /// Also note that `take_handle` is in theory only ever called on values
-    /// owned by a generated function. For example a generated function might
-    /// take `Resource<T>` as an argument but then call `take_handle` on a
-    /// reference to that argument. In that sense the dynamic nature of
-    /// `take_handle` should only be exposed internally to generated code, not
-    /// to user code.
-    #[doc(hidden)]
-    pub fn take_handle(resource: &Resource<T>) -> u32 {
-        resource.handle.swap(u32::MAX, Relaxed)
-    }
-
-    #[doc(hidden)]
-    pub fn handle(resource: &Resource<T>) -> u32 {
-        resource.handle.load(Relaxed)
-    }
-
-    /// Creates a new Rust-defined resource from the underlying representation
-    /// `T`.
-    ///
-    /// This will move `T` onto the heap to create a single pointer to represent
-    /// it which is then wrapped up in a component model resource.
-    pub fn new(val: T) -> Resource<T>
-    where
-        T: RustResource,
-    {
-        let rep = Box::into_raw(Box::new(Some(val))) as usize;
-        unsafe {
-            let handle = T::new(rep);
-            Resource::from_handle(handle)
-        }
-    }
-
-    #[doc(hidden)]
-    pub unsafe fn dtor(rep: usize)
-    where
-        T: RustResource,
-    {
-        let _ = Box::from_raw(rep as *mut RawRep<T>);
-    }
-
-    /// Takes back ownership of the object, dropping the resource handle.
-    pub fn into_inner(resource: Self) -> T
-    where
-        T: RustResource,
-    {
-        unsafe {
-            let rep = T::rep(resource.handle.load(Relaxed));
-            RawRep::take(&mut *(rep as *mut RawRep<T>)).unwrap()
-        }
-    }
-
-    #[doc(hidden)]
-    pub unsafe fn lift_borrow<'a>(rep: usize) -> &'a T
-    where
-        T: RustResource,
-    {
-        RawRep::as_ref(&*(rep as *const RawRep<T>)).unwrap()
-    }
-}
-
-impl<T: RustResource> Deref for Resource<T> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
-        unsafe {
-            let rep = T::rep(self.handle.load(Relaxed));
-            RawRep::as_ref(&*(rep as *const RawRep<T>)).unwrap()
-        }
-    }
-}
-
-impl<T: RustResource> DerefMut for Resource<T> {
-    fn deref_mut(&mut self) -> &mut T {
-        unsafe {
-            let rep = T::rep(self.handle.load(Relaxed));
-            RawRep::as_mut(&mut *(rep as *mut RawRep<T>)).unwrap()
-        }
-    }
-}
-
-impl<T: WasmResource> fmt::Debug for Resource<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Resource")
-            .field("handle", &self.handle)
-            .finish()
-    }
-}
-
-impl<T: WasmResource> Drop for Resource<T> {
-    fn drop(&mut self) {
-        unsafe {
-            match self.handle.load(Relaxed) {
-                // If this handle was "taken" then don't do anything in the
-                // destructor.
-                u32::MAX => {}
-
-                // ... but otherwise do actually destroy it with the imported
-                // component model intrinsic as defined through `T`.
-                other => T::drop(other),
-            }
-        }
-    }
 }

crates/guest-rust/src/lib.rs

@@ -104,7 +104,10 @@ impl Parse for Config {
                     }
                     Opt::With(with) => opts.with.extend(with),
                     Opt::TypeSectionSuffix(suffix) => {
-                        opts.type_section_suffix = Some(suffix.value())
+                        opts.type_section_suffix = Some(suffix.value());
+                    }
+                    Opt::RunCtorsOnceWorkaround(enable) => {
+                        opts.run_ctors_once_workaround = enable.value();
                     }
                 }
             }
@@ -220,6 +223,7 @@ mod kw {
     syn::custom_keyword!(additional_derives);
     syn::custom_keyword!(with);
     syn::custom_keyword!(type_section_suffix);
+    syn::custom_keyword!(run_ctors_once_workaround);
 }
 
 #[derive(Clone)]
@@ -281,6 +285,7 @@ enum Opt {
     AdditionalDerives(Vec<syn::Path>),
     With(HashMap<String, String>),
     TypeSectionSuffix(syn::LitStr),
+    RunCtorsOnceWorkaround(syn::LitBool),
 }
 
 impl Parse for Opt {
@@ -390,6 +395,10 @@ impl Parse for Opt {
             input.parse::<kw::type_section_suffix>()?;
             input.parse::<Token![:]>()?;
             Ok(Opt::TypeSectionSuffix(input.parse()?))
+        } else if l.peek(kw::run_ctors_once_workaround) {
+            input.parse::<kw::run_ctors_once_workaround>()?;
+            input.parse::<Token![:]>()?;
+            Ok(Opt::RunCtorsOnceWorkaround(input.parse()?))
         } else {
             Err(l.error())
         }

crates/rust-macro/src/lib.rs

@@ -22,6 +22,7 @@ wit-component = { workspace = true }
 wasm-metadata = { workspace = true }
 heck = { workspace = true }
 clap = { workspace = true, optional = true }
+indexmap = { workspace = true }
 
 [dev-dependencies]
 wit-bindgen = { path = '../guest-rust' }