factors: Naming updates

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

Author: lann

crates/factor-wasi/src/lib.rs

@@ -1,13 +1,15 @@
 pub mod preview1;
 
-use spin_factors::{Factor, FactorBuilder, InitContext, 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 Builder = Builder;
-    type Data = Data;
+    type InstancePreparer = Builder;
+    type InstanceState = InstanceState;
 
     fn init<Factors: SpinFactors>(&mut self, mut ctx: InitContext<Factors, Self>) -> Result<()> {
         use wasmtime_wasi::bindings;
@@ -46,8 +48,8 @@ pub struct Builder {
     wasi_ctx: WasiCtxBuilder,
 }
 
-impl FactorBuilder<WasiFactor> for Builder {
-    fn prepare<Factors: SpinFactors>(
+impl FactorInstancePreparer<WasiFactor> for Builder {
+    fn new<Factors: SpinFactors>(
         _factor: &WasiFactor,
         _ctx: PrepareContext<Factors>,
     ) -> Result<Self> {
@@ -56,20 +58,20 @@ impl FactorBuilder<WasiFactor> for Builder {
         })
     }
 
-    fn build(mut self) -> Result<Data> {
-        Ok(Data {
+    fn prepare(mut self) -> Result<InstanceState> {
+        Ok(InstanceState {
             ctx: self.wasi_ctx.build(),
             table: Default::default(),
         })
     }
 }
 
-pub struct Data {
+pub struct InstanceState {
     ctx: WasiCtx,
     table: ResourceTable,
 }
 
-impl WasiView for Data {
+impl WasiView for InstanceState {
     fn ctx(&mut self) -> &mut WasiCtx {
         &mut self.ctx
     }

crates/factor-wasi/src/preview1.rs

@@ -1,13 +1,18 @@
-use spin_factors::{Factor, FactorBuilder, ModuleInitContext, PrepareContext, Result, SpinFactors};
+use spin_factors::{
+    Factor, FactorInstancePreparer, ModuleInitContext, PrepareContext, Result, SpinFactors,
+};
 use wasmtime_wasi::{preview1::WasiP1Ctx, WasiCtxBuilder};
 
 pub struct WasiPreview1Factor;
 
 impl Factor for WasiPreview1Factor {
-    type Builder = Builder;
-    type Data = WasiP1Ctx;
+    type InstancePreparer = Builder;
+    type InstanceState = WasiP1Ctx;
 
-    fn module_init<Factors: SpinFactors>(&mut self, mut ctx: ModuleInitContext<Factors, Self>) -> Result<()> {
+    fn module_init<Factors: SpinFactors>(
+        &mut self,
+        mut ctx: ModuleInitContext<Factors, Self>,
+    ) -> Result<()> {
         ctx.link_bindings(wasmtime_wasi::preview1::add_to_linker_async)
     }
 }
@@ -16,8 +21,8 @@ pub struct Builder {
     wasi_ctx: WasiCtxBuilder,
 }
 
-impl FactorBuilder<WasiPreview1Factor> for Builder {
-    fn prepare<Factors: SpinFactors>(
+impl FactorInstancePreparer<WasiPreview1Factor> for Builder {
+    fn new<Factors: SpinFactors>(
         _factor: &WasiPreview1Factor,
         _ctx: PrepareContext<Factors>,
     ) -> Result<Self> {
@@ -26,7 +31,7 @@ impl FactorBuilder<WasiPreview1Factor> for Builder {
         })
     }
 
-    fn build(mut self) -> Result<<WasiPreview1Factor as Factor>::Data> {
+    fn prepare(mut self) -> Result<<WasiPreview1Factor as Factor>::InstanceState> {
         Ok(self.wasi_ctx.build_p1())
     }
 }

crates/factors-derive/src/lib.rs

@@ -21,7 +21,7 @@ fn expand_factors(input: &DeriveInput) -> syn::Result<TokenStream> {
     let vis = &input.vis;
 
     let builders_name = format_ident!("{name}Builders");
-    let data_name = format_ident!("{name}Data");
+    let data_name = format_ident!("{name}InstanceState");
 
     if !input.generics.params.is_empty() {
         return Err(Error::new_spanned(
@@ -116,7 +116,7 @@ fn expand_factors(input: &DeriveInput) -> syn::Result<TokenStream> {
 
         impl #factors_path::SpinFactors for #name {
             type Builders = #builders_name;
-            type Data = #data_name;
+            type InstanceState = #data_name;
 
             unsafe fn factor_builder_offset<T: #Factor>() -> Option<usize> {
                 let type_id = #TypeId::of::<T>();
@@ -132,7 +132,7 @@ fn expand_factors(input: &DeriveInput) -> syn::Result<TokenStream> {
                 let type_id = #TypeId::of::<T>();
                 #(
                     if type_id == #TypeId::of::<#factor_types>() {
-                        return Some(std::mem::offset_of!(Self::Data, #factor_names));
+                        return Some(std::mem::offset_of!(Self::InstanceState, #factor_names));
                     }
                 )*
                 None
@@ -148,7 +148,7 @@ fn expand_factors(input: &DeriveInput) -> syn::Result<TokenStream> {
 
         #vis struct #data_name {
             #(
-                pub #factor_names: <#factor_types as #Factor>::Data,
+                pub #factor_names: <#factor_types as #Factor>::InstanceState,
             )*
         }
     })

crates/factors/src/lib.rs

@@ -8,12 +8,12 @@ pub use wasmtime;
 pub type Error = wasmtime::Error;
 pub type Result<T, E = Error> = std::result::Result<T, E>;
 
-pub type Linker<Factors> = wasmtime::component::Linker<<Factors as SpinFactors>::Data>;
-pub type ModuleLinker<Factors> = wasmtime::Linker<<Factors as SpinFactors>::Data>;
+pub type Linker<Factors> = wasmtime::component::Linker<<Factors as SpinFactors>::InstanceState>;
+pub type ModuleLinker<Factors> = wasmtime::Linker<<Factors as SpinFactors>::InstanceState>;
 
 pub trait Factor: Any + Sized {
-    type Builder: FactorBuilder<Self>;
-    type Data;
+    type InstancePreparer: FactorInstancePreparer<Self>;
+    type InstanceState;
 
     /// Initializes this Factor for a runtime. This will be called exactly once
     fn init<Factors: SpinFactors>(&mut self, mut ctx: InitContext<Factors, Self>) -> Result<()> {
@@ -37,7 +37,7 @@ pub trait Factor: Any + Sized {
 
 pub struct FactorInitContext<'a, Factors: SpinFactors, Fact: Factor, Linker> {
     linker: &'a mut Linker,
-    get_data: fn(&mut Factors::Data) -> &mut Fact::Data,
+    get_data: fn(&mut Factors::InstanceState) -> &mut Fact::InstanceState,
 }
 
 pub type InitContext<'a, Factors, Fact> = FactorInitContext<'a, Factors, Fact, Linker<Factors>>;
@@ -49,7 +49,7 @@ impl<'a, Factors: SpinFactors, Fact: Factor, Linker> FactorInitContext<'a, Facto
     #[doc(hidden)]
     pub fn new(
         linker: &'a mut Linker,
-        get_data: fn(&mut Factors::Data) -> &mut Fact::Data,
+        get_data: fn(&mut Factors::InstanceState) -> &mut Fact::InstanceState,
     ) -> Self {
         Self { linker, get_data }
     }
@@ -60,15 +60,18 @@ impl<'a, Factors: SpinFactors, Fact: Factor, Linker> FactorInitContext<'a, Facto
 
     pub fn link_bindings(
         &mut self,
-        add_to_linker: impl Fn(&mut Linker, fn(&mut Factors::Data) -> &mut Fact::Data) -> Result<()>,
+        add_to_linker: impl Fn(
+            &mut Linker,
+            fn(&mut Factors::InstanceState) -> &mut Fact::InstanceState,
+        ) -> Result<()>,
     ) -> Result<()>
 where {
         add_to_linker(self.linker, self.get_data)
     }
 }
 
 impl<'a, Factors: SpinFactors> PrepareContext<'a, Factors> {
-    pub fn builder_mut<T: Factor>(&mut self) -> Result<&mut T::Builder> {
+    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",
@@ -84,23 +87,24 @@ impl<'a, Factors: SpinFactors> PrepareContext<'a, Factors> {
 /// Implemented by `#[derive(SpinFactors)]`
 pub trait SpinFactors: Sized {
     type Builders;
-    type Data: Send + 'static;
+    type InstanceState: Send + 'static;
 
     #[doc(hidden)]
     unsafe fn factor_builder_offset<T: Factor>() -> Option<usize>;
 
     #[doc(hidden)]
     unsafe fn factor_data_offset<T: Factor>() -> Option<usize>;
 
-    fn data_getter<T: Factor>() -> Option<Getter<Self::Data, T::Data>> {
+    fn data_getter<T: Factor>() -> Option<Getter<Self::InstanceState, T::InstanceState>> {
         let offset = unsafe { Self::factor_data_offset::<T>()? };
         Some(Getter {
             offset,
             _phantom: PhantomData,
         })
     }
 
-    fn data_getter2<T1: Factor, T2: Factor>() -> Option<Getter2<Self::Data, T1::Data, T2::Data>> {
+    fn data_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>()? };
         assert_ne!(
@@ -114,11 +118,13 @@ pub trait SpinFactors: Sized {
         })
     }
 
-    fn builder_mut<T: Factor>(builders: &mut Self::Builders) -> Option<Option<&mut T::Builder>> {
+    fn builder_mut<T: Factor>(
+        builders: &mut Self::Builders,
+    ) -> Option<Option<&mut T::InstancePreparer>> {
         unsafe {
             let offset = Self::factor_builder_offset::<T>()?;
             let ptr = builders as *mut Self::Builders;
-            let opt = &mut *ptr.add(offset).cast::<Option<T::Builder>>();
+            let opt = &mut *ptr.add(offset).cast::<Option<T::InstancePreparer>>();
             Some(opt.as_mut())
         }
     }
@@ -174,10 +180,10 @@ impl<T, U, V> Clone for Getter2<T, U, V> {
 }
 impl<T, U, V> Copy for Getter2<T, U, V> {}
 
-pub trait FactorBuilder<T: Factor>: Sized {
-    fn prepare<Factors: SpinFactors>(_factor: &T, _ctx: PrepareContext<Factors>) -> Result<Self>;
+pub trait FactorInstancePreparer<T: Factor>: Sized {
+    fn new<Factors: SpinFactors>(_factor: &T, _ctx: PrepareContext<Factors>) -> Result<Self>;
 
-    fn build(self) -> Result<T::Data>;
+    fn prepare(self) -> Result<T::InstanceState>;
 }
 
 pub struct PrepareContext<'a, Factors: SpinFactors> {
@@ -194,16 +200,16 @@ impl<'a, Factors: SpinFactors> PrepareContext<'a, Factors> {
 
 pub type DefaultBuilder = ();
 
-impl<T: Factor> FactorBuilder<T> for DefaultBuilder
+impl<T: Factor> FactorInstancePreparer<T> for DefaultBuilder
 where
-    T::Data: Default,
+    T::InstanceState: Default,
 {
-    fn prepare<Factors: SpinFactors>(factor: &T, ctx: PrepareContext<Factors>) -> Result<Self> {
+    fn new<Factors: SpinFactors>(factor: &T, ctx: PrepareContext<Factors>) -> Result<Self> {
         (_, _) = (factor, ctx);
         Ok(())
     }
 
-    fn build(self) -> Result<T::Data> {
+    fn prepare(self) -> Result<T::InstanceState> {
         Ok(Default::default())
     }
 }