factors: trait InstancePreparer -> FactorInstancePreparer

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

Author: lann

crates/factor-wasi/src/lib.rs

@@ -1,12 +1,14 @@
 pub mod preview1;
 
-use spin_factors::{Factor, InitContext, InstancePreparer, PrepareContext, Result, SpinFactors};
+use spin_factors::{
+    Factor, FactorInstancePreparer, InitContext, PrepareContext, Result, SpinFactors,
+};
 use wasmtime_wasi::{ResourceTable, WasiCtx, WasiCtxBuilder, WasiView};
 
 pub struct WasiFactor;
 
 impl Factor for WasiFactor {
-    type InstancePreparer = Builder;
+    type InstancePreparer = InstancePreparer;
     type InstanceState = InstanceState;
 
     fn init<Factors: SpinFactors>(&mut self, mut ctx: InitContext<Factors, Self>) -> Result<()> {
@@ -42,11 +44,11 @@ impl Factor for WasiFactor {
     }
 }
 
-pub struct Builder {
+pub struct InstancePreparer {
     wasi_ctx: WasiCtxBuilder,
 }
 
-impl InstancePreparer<WasiFactor> for Builder {
+impl FactorInstancePreparer<WasiFactor> for InstancePreparer {
     fn new<Factors: SpinFactors>(
         _factor: &WasiFactor,
         _ctx: PrepareContext<Factors>,

crates/factor-wasi/src/preview1.rs

@@ -1,12 +1,12 @@
 use spin_factors::{
-    Factor, InstancePreparer, ModuleInitContext, PrepareContext, Result, SpinFactors,
+    Factor, FactorInstancePreparer, ModuleInitContext, PrepareContext, Result, SpinFactors,
 };
 use wasmtime_wasi::{preview1::WasiP1Ctx, WasiCtxBuilder};
 
 pub struct WasiPreview1Factor;
 
 impl Factor for WasiPreview1Factor {
-    type InstancePreparer = Builder;
+    type InstancePreparer = InstancePreparer;
     type InstanceState = WasiP1Ctx;
 
     fn module_init<Factors: SpinFactors>(
@@ -17,11 +17,11 @@ impl Factor for WasiPreview1Factor {
     }
 }
 
-pub struct Builder {
+pub struct InstancePreparer {
     wasi_ctx: WasiCtxBuilder,
 }
 
-impl InstancePreparer<WasiPreview1Factor> for Builder {
+impl FactorInstancePreparer<WasiPreview1Factor> for InstancePreparer {
     fn new<Factors: SpinFactors>(
         _factor: &WasiPreview1Factor,
         _ctx: PrepareContext<Factors>,

crates/factors-derive/src/lib.rs

@@ -100,15 +100,15 @@ fn expand_factors(input: &DeriveInput) -> syn::Result<TokenStream> {
                 };
                 #(
                     preparers.#factor_names = Some(
-                        #factors_path::InstancePreparer::<#factor_types>::new::<#name>(
+                        #factors_path::FactorInstancePreparer::<#factor_types>::new::<#name>(
                             &self.#factor_names,
                             #factors_path::PrepareContext::new(&mut preparers),
                         )?
                     );
                 )*
                 Ok(#state_name {
                     #(
-                        #factor_names: #factors_path::InstancePreparer::<#factor_types>::prepare(
+                        #factor_names: #factors_path::FactorInstancePreparer::<#factor_types>::prepare(
                             preparers.#factor_names.unwrap()
                         )?,
                     )*

crates/factors/src/lib.rs

@@ -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: InstancePreparer<Self>;
+    type InstancePreparer: FactorInstancePreparer<Self>;
     type InstanceState;
 
     /// Initializes this Factor for a runtime. This will be called exactly once
@@ -35,9 +35,12 @@ pub trait Factor: Any + Sized {
     }
 }
 
+type GetDataFn<Factors, Fact> =
+    fn(&mut <Factors as SpinFactors>::InstanceState) -> &mut <Fact as Factor>::InstanceState;
+
 pub struct FactorInitContext<'a, Factors: SpinFactors, Fact: Factor, Linker> {
     linker: &'a mut Linker,
-    get_data: fn(&mut Factors::InstanceState) -> &mut Fact::InstanceState,
+    get_data: GetDataFn<Factors, Fact>,
 }
 
 pub type InitContext<'a, Factors, Fact> = FactorInitContext<'a, Factors, Fact, Linker<Factors>>;
@@ -47,17 +50,18 @@ pub type ModuleInitContext<'a, Factors, Fact> =
 
 impl<'a, Factors: SpinFactors, Fact: Factor, Linker> FactorInitContext<'a, Factors, Fact, Linker> {
     #[doc(hidden)]
-    pub fn new(
-        linker: &'a mut Linker,
-        get_data: fn(&mut Factors::InstanceState) -> &mut Fact::InstanceState,
-    ) -> Self {
+    pub fn new(linker: &'a mut Linker, get_data: GetDataFn<Factors, Fact>) -> Self {
         Self { linker, get_data }
     }
 
     pub fn linker(&mut self) -> &mut Linker {
         self.linker
     }
 
+    pub fn get_data_fn(&self) -> GetDataFn<Factors, Fact> {
+        self.get_data
+    }
+
     pub fn link_bindings(
         &mut self,
         add_to_linker: impl Fn(
@@ -70,7 +74,23 @@ where {
     }
 }
 
+pub trait FactorInstancePreparer<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> {
+    instance_preparers: &'a mut Factors::InstancePreparers,
+    // TODO: component: &'a AppComponent,
+}
+
 impl<'a, Factors: SpinFactors> PrepareContext<'a, Factors> {
+    #[doc(hidden)]
+    pub fn new(instance_preparers: &'a mut Factors::InstancePreparers) -> Self {
+        Self { instance_preparers }
+    }
+
     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),
@@ -84,6 +104,22 @@ impl<'a, Factors: SpinFactors> PrepareContext<'a, Factors> {
     }
 }
 
+pub type DefaultInstancePreparer = ();
+
+impl<T: Factor> FactorInstancePreparer<T> for DefaultInstancePreparer
+where
+    T::InstanceState: Default,
+{
+    fn new<Factors: SpinFactors>(factor: &T, ctx: PrepareContext<Factors>) -> Result<Self> {
+        (_, _) = (factor, ctx);
+        Ok(())
+    }
+
+    fn prepare(self) -> Result<T::InstanceState> {
+        Ok(Default::default())
+    }
+}
+
 /// Implemented by `#[derive(SpinFactors)]`
 pub trait SpinFactors: Sized {
     type InstancePreparers;
@@ -179,37 +215,3 @@ impl<T, U, V> Clone for Getter2<T, U, V> {
     }
 }
 impl<T, U, V> Copy for Getter2<T, U, V> {}
-
-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> {
-    instance_preparers: &'a mut Factors::InstancePreparers,
-    // TODO: component: &'a AppComponent,
-}
-
-impl<'a, Factors: SpinFactors> PrepareContext<'a, Factors> {
-    #[doc(hidden)]
-    pub fn new(instance_preparers: &'a mut Factors::InstancePreparers) -> Self {
-        Self { instance_preparers }
-    }
-}
-
-pub type DefaultInstancePreparer = ();
-
-impl<T: Factor> InstancePreparer<T> for DefaultInstancePreparer
-where
-    T::InstanceState: Default,
-{
-    fn new<Factors: SpinFactors>(factor: &T, ctx: PrepareContext<Factors>) -> Result<Self> {
-        (_, _) = (factor, ctx);
-        Ok(())
-    }
-
-    fn prepare(self) -> Result<T::InstanceState> {
-        Ok(Default::default())
-    }
-}