factors: Fix derive macro

Signed-off-by: Lann Martin <[email protected]>

Author: lann

Cargo.lock

@@ -1,8 +1,6 @@
 pub mod preview1;
 
-use spin_factors::{
-    Factor, FactorInstancePreparer, InitContext, PrepareContext, Result, SpinFactors,
-};
+use spin_factors::{Factor, InitContext, InstancePreparer, PrepareContext, Result, SpinFactors};
 use wasmtime_wasi::{ResourceTable, WasiCtx, WasiCtxBuilder, WasiView};
 
 pub struct WasiFactor;
@@ -48,7 +46,7 @@ pub struct Builder {
     wasi_ctx: WasiCtxBuilder,
 }
 
-impl FactorInstancePreparer<WasiFactor> for Builder {
+impl InstancePreparer<WasiFactor> for Builder {
     fn new<Factors: SpinFactors>(
         _factor: &WasiFactor,
         _ctx: PrepareContext<Factors>,

crates/factor-wasi/src/lib.rs

@@ -1,5 +1,5 @@
 use spin_factors::{
-    Factor, FactorInstancePreparer, ModuleInitContext, PrepareContext, Result, SpinFactors,
+    Factor, InstancePreparer, ModuleInitContext, PrepareContext, Result, SpinFactors,
 };
 use wasmtime_wasi::{preview1::WasiP1Ctx, WasiCtxBuilder};
 
@@ -21,7 +21,7 @@ pub struct Builder {
     wasi_ctx: WasiCtxBuilder,
 }
 
-impl FactorInstancePreparer<WasiPreview1Factor> for Builder {
+impl InstancePreparer<WasiPreview1Factor> for Builder {
     fn new<Factors: SpinFactors>(
         _factor: &WasiPreview1Factor,
         _ctx: PrepareContext<Factors>,

crates/factor-wasi/src/preview1.rs

@@ -20,8 +20,8 @@ fn expand_factors(input: &DeriveInput) -> syn::Result<TokenStream> {
     let name = &input.ident;
     let vis = &input.vis;
 
-    let builders_name = format_ident!("{name}Builders");
-    let data_name = format_ident!("{name}InstanceState");
+    let preparers_name = format_ident!("{name}InstancePreparers");
+    let state_name = format_ident!("{name}InstanceState");
 
     if !input.generics.params.is_empty() {
         return Err(Error::new_spanned(
@@ -63,50 +63,53 @@ fn expand_factors(input: &DeriveInput) -> syn::Result<TokenStream> {
         impl #name {
             pub fn init(
                 &mut self,
-                linker: &mut #wasmtime::component::Linker<#data_name>
+                linker: &mut #wasmtime::component::Linker<#state_name>
             ) -> #Result<()> {
                 #(
-                    self.#factor_names.init(
+                    #Factor::init::<Self>(
+                        &mut self.#factor_names,
                         #factors_path::InitContext::<Self, #factor_types>::new(
                             linker,
-                            |data| &mut data.#factor_names,
+                            |state| &mut state.#factor_names,
                         )
                     )?;
                 )*
                 Ok(())
             }
 
+            #[allow(dead_code)]
             pub fn module_init(
                 &mut self,
-                linker: &mut #wasmtime::Linker<#data_name>
+                linker: &mut #wasmtime::Linker<#state_name>
             ) -> #Result<()> {
                 #(
-                    self.#factor_names.module_init::<Self>(
+                    #Factor::module_init::<Self>(
+                        &mut self.#factor_names,
                         #factors_path::ModuleInitContext::<Self, #factor_types>::new(
                             linker,
-                            |data| &mut data.#factor_names,
+                            |state| &mut state.#factor_names,
                         )
                     )?;
                 )*
                 Ok(())
             }
 
-            pub fn build_data(&self) -> #Result<#data_name> {
-                let mut builders = #builders_name {
+            pub fn build_store_data(&self) -> #Result<#state_name> {
+                let mut preparers = #preparers_name {
                     #( #factor_names: None, )*
                 };
                 #(
-                    builders.#factor_names = Some(
-                        #factors_path::FactorBuilder::<#factor_types>::prepare::<#name>(
+                    preparers.#factor_names = Some(
+                        #factors_path::InstancePreparer::<#factor_types>::new::<#name>(
                             &self.#factor_names,
-                            #factors_path::PrepareContext::new(&mut builders),
+                            #factors_path::PrepareContext::new(&mut preparers),
                         )?
                     );
                 )*
-                Ok(#data_name {
+                Ok(#state_name {
                     #(
-                        #factor_names: #factors_path::FactorBuilder::<#factor_types>::build(
-                            builders.#factor_names.unwrap()
+                        #factor_names: #factors_path::InstancePreparer::<#factor_types>::prepare(
+                            preparers.#factor_names.unwrap()
                         )?,
                     )*
                 })
@@ -115,20 +118,20 @@ fn expand_factors(input: &DeriveInput) -> syn::Result<TokenStream> {
         }
 
         impl #factors_path::SpinFactors for #name {
-            type Builders = #builders_name;
-            type InstanceState = #data_name;
+            type InstancePreparers = #preparers_name;
+            type InstanceState = #state_name;
 
-            unsafe fn factor_builder_offset<T: #Factor>() -> Option<usize> {
+            unsafe fn instance_preparer_offset<T: #Factor>() -> Option<usize> {
                 let type_id = #TypeId::of::<T>();
                 #(
                     if type_id == #TypeId::of::<#factor_types>() {
-                        return Some(std::mem::offset_of!(Self::Builders, #factor_names));
+                        return Some(std::mem::offset_of!(Self::InstancePreparers, #factor_names));
                     }
                 )*
                 None
             }
 
-            unsafe fn factor_data_offset<T: #Factor>() -> Option<usize> {
+            unsafe fn instance_state_offset<T: #Factor>() -> Option<usize> {
                 let type_id = #TypeId::of::<T>();
                 #(
                     if type_id == #TypeId::of::<#factor_types>() {
@@ -140,13 +143,13 @@ fn expand_factors(input: &DeriveInput) -> syn::Result<TokenStream> {
             }
         }
 
-        #vis struct #builders_name {
+        #vis struct #preparers_name {
             #(
-                pub #factor_names: Option<<#factor_types as #Factor>::Builder>,
+                pub #factor_names: Option<<#factor_types as #Factor>::InstancePreparer>,
             )*
         }
 
-        #vis struct #data_name {
+        #vis struct #state_name {
             #(
                 pub #factor_names: <#factor_types as #Factor>::InstanceState,
             )*

crates/factors-derive/src/lib.rs

@@ -12,6 +12,7 @@ wasmtime = { workspace = true }
 
 [dev-dependencies]
 spin-factors-derive = { path = "../factors-derive", features = ["expander"] }
+spin-factor-wasi = { path = "../factor-wasi" }
 
 [lints]
 workspace = true

crates/factors/Cargo.toml

@@ -12,7 +12,7 @@ pub type Linker<Factors> = wasmtime::component::Linker<<Factors as SpinFactors>:
 pub type ModuleLinker<Factors> = wasmtime::Linker<<Factors as SpinFactors>::InstanceState>;
 
 pub trait Factor: Any + Sized {
-    type InstancePreparer: FactorInstancePreparer<Self>;
+    type InstancePreparer: InstancePreparer<Self>;
     type InstanceState;
 
     /// Initializes this Factor for a runtime. This will be called exactly once
@@ -71,45 +71,45 @@ where {
 }
 
 impl<'a, Factors: SpinFactors> PrepareContext<'a, Factors> {
-    pub fn builder_mut<T: Factor>(&mut self) -> Result<&mut T::InstancePreparer> {
-        let err_msg = match Factors::builder_mut::<T>(self.builders) {
-            Some(Some(builder)) => return Ok(builder),
-            Some(None) => "builder not yet prepared",
+    pub fn instance_preparer_mut<T: Factor>(&mut self) -> Result<&mut T::InstancePreparer> {
+        let err_msg = match Factors::instance_preparer_mut::<T>(self.instance_preparers) {
+            Some(Some(preparer)) => return Ok(preparer),
+            Some(None) => "preparer not yet initialized",
             None => "no such factor",
         };
         Err(Error::msg(format!(
-            "could not get builder for {ty}: {err_msg}",
+            "could not get instance preparer for {ty}: {err_msg}",
             ty = std::any::type_name::<T>()
         )))
     }
 }
 
 /// Implemented by `#[derive(SpinFactors)]`
 pub trait SpinFactors: Sized {
-    type Builders;
+    type InstancePreparers;
     type InstanceState: Send + 'static;
 
     #[doc(hidden)]
-    unsafe fn factor_builder_offset<T: Factor>() -> Option<usize>;
+    unsafe fn instance_preparer_offset<T: Factor>() -> Option<usize>;
 
     #[doc(hidden)]
-    unsafe fn factor_data_offset<T: Factor>() -> Option<usize>;
+    unsafe fn instance_state_offset<T: Factor>() -> Option<usize>;
 
-    fn data_getter<T: Factor>() -> Option<Getter<Self::InstanceState, T::InstanceState>> {
-        let offset = unsafe { Self::factor_data_offset::<T>()? };
+    fn instance_state_getter<T: Factor>() -> Option<Getter<Self::InstanceState, T::InstanceState>> {
+        let offset = unsafe { Self::instance_state_offset::<T>()? };
         Some(Getter {
             offset,
             _phantom: PhantomData,
         })
     }
 
-    fn data_getter2<T1: Factor, T2: Factor>(
+    fn instance_state_getter2<T1: Factor, T2: Factor>(
     ) -> Option<Getter2<Self::InstanceState, T1::InstanceState, T2::InstanceState>> {
-        let offset1 = unsafe { Self::factor_data_offset::<T1>()? };
-        let offset2 = unsafe { Self::factor_data_offset::<T2>()? };
+        let offset1 = unsafe { Self::instance_state_offset::<T1>()? };
+        let offset2 = unsafe { Self::instance_state_offset::<T2>()? };
         assert_ne!(
             offset1, offset2,
-            "data_getter2 with same factor twice would alias"
+            "instance_state_getter2 with same factor twice would alias"
         );
         Some(Getter2 {
             offset1,
@@ -118,12 +118,12 @@ pub trait SpinFactors: Sized {
         })
     }
 
-    fn builder_mut<T: Factor>(
-        builders: &mut Self::Builders,
+    fn instance_preparer_mut<T: Factor>(
+        preparers: &mut Self::InstancePreparers,
     ) -> Option<Option<&mut T::InstancePreparer>> {
         unsafe {
-            let offset = Self::factor_builder_offset::<T>()?;
-            let ptr = builders as *mut Self::Builders;
+            let offset = Self::instance_preparer_offset::<T>()?;
+            let ptr = preparers as *mut Self::InstancePreparers;
             let opt = &mut *ptr.add(offset).cast::<Option<T::InstancePreparer>>();
             Some(opt.as_mut())
         }
@@ -180,27 +180,27 @@ impl<T, U, V> Clone for Getter2<T, U, V> {
 }
 impl<T, U, V> Copy for Getter2<T, U, V> {}
 
-pub trait FactorInstancePreparer<T: Factor>: Sized {
+pub trait InstancePreparer<T: Factor>: Sized {
     fn new<Factors: SpinFactors>(_factor: &T, _ctx: PrepareContext<Factors>) -> Result<Self>;
 
     fn prepare(self) -> Result<T::InstanceState>;
 }
 
 pub struct PrepareContext<'a, Factors: SpinFactors> {
-    builders: &'a mut Factors::Builders,
+    instance_preparers: &'a mut Factors::InstancePreparers,
     // TODO: component: &'a AppComponent,
 }
 
 impl<'a, Factors: SpinFactors> PrepareContext<'a, Factors> {
     #[doc(hidden)]
-    pub fn new(builders: &'a mut Factors::Builders) -> Self {
-        Self { builders }
+    pub fn new(instance_preparers: &'a mut Factors::InstancePreparers) -> Self {
+        Self { instance_preparers }
     }
 }
 
-pub type DefaultBuilder = ();
+pub type DefaultInstancePreparer = ();
 
-impl<T: Factor> FactorInstancePreparer<T> for DefaultBuilder
+impl<T: Factor> InstancePreparer<T> for DefaultInstancePreparer
 where
     T::InstanceState: Default,
 {

crates/factors/src/lib.rs

@@ -1,21 +1,22 @@
+use spin_factor_wasi::WasiFactor;
 use spin_factors::SpinFactors;
 
 #[derive(SpinFactors)]
-struct Factors {}
+struct Factors {
+    wasi: WasiFactor,
+}
 
 fn main() -> anyhow::Result<()> {
-    let mut factors = Factors {};
-
     let engine = wasmtime::Engine::default();
     let mut linker = wasmtime::component::Linker::new(&engine);
-    factors.init(&mut linker).unwrap();
 
-    let factors = Factors {
-        // wasi: WasiFactor,
+    let mut factors = Factors {
+        wasi: WasiFactor,
         // outbound_networking_factor: OutboundNetworkingFactor,
         // outbound_http_factor: OutboundHttpFactor,
     };
-    let data = factors.build_data().unwrap();
+    factors.init(&mut linker).unwrap();
+    let data = factors.build_store_data().unwrap();
 
     let mut store = wasmtime::Store::new(&engine, data);
     let component = wasmtime::component::Component::new(&engine, b"(component)").unwrap();