Fix cyclic ref in WasmerEnv

lib/api/src/exports.rs

@@ -166,6 +166,19 @@ impl Exports {
         }
     }
 
+    /// Like `get_with_generics` but with a WeakReference to the `InstanceRef` internally.
+    /// This is useful for passing data into `WasmerEnv`, for example.
+    pub fn get_with_generics_weak<'a, T, Args, Rets>(&'a self, name: &str) -> Result<T, ExportError>
+    where
+        Args: WasmTypeList,
+        Rets: WasmTypeList,
+        T: ExportableWithGenerics<'a, Args, Rets>,
+    {
+        let mut out: T = self.get_with_generics(name)?;
+        out.into_weak_instance_ref();
+        Ok(out)
+    }
+
     /// Get an export as an `Extern`.
     pub fn get_extern(&self, name: &str) -> Option<&Extern> {
         self.map.get(name)
@@ -294,6 +307,11 @@ pub trait Exportable<'a>: Sized {
     ///
     /// [`Instance`]: crate::Instance
     fn get_self_from_extern(_extern: &'a Extern) -> Result<&'a Self, ExportError>;
+
+    /// Convert the extern internally to hold a weak reference to the `InstanceRef`.
+    /// This is useful for preventing cycles, for example for data stored in a
+    /// type implementing `WasmerEnv`.
+    fn into_weak_instance_ref(&mut self);
 }
 
 /// A trait for accessing exports (like [`Exportable`]) but it takes generic
@@ -302,6 +320,10 @@ pub trait Exportable<'a>: Sized {
 pub trait ExportableWithGenerics<'a, Args: WasmTypeList, Rets: WasmTypeList>: Sized {
     /// Get an export with the given generics.
     fn get_self_from_extern_with_generics(_extern: &'a Extern) -> Result<Self, ExportError>;
+    /// Convert the extern internally to hold a weak reference to the `InstanceRef`.
+    /// This is useful for preventing cycles, for example for data stored in a
+    /// type implementing `WasmerEnv`.
+    fn into_weak_instance_ref(&mut self);
 }
 
 /// We implement it for all concrete [`Exportable`] types (that are `Clone`)
@@ -310,4 +332,8 @@ impl<'a, T: Exportable<'a> + Clone + 'static> ExportableWithGenerics<'a, (), ()>
     fn get_self_from_extern_with_generics(_extern: &'a Extern) -> Result<Self, ExportError> {
         T::get_self_from_extern(_extern).map(|i| i.clone())
     }
+
+    fn into_weak_instance_ref(&mut self) {
+        <Self as Exportable>::into_weak_instance_ref(self);
+    }
 }

lib/api/src/externals/function.rs

@@ -712,6 +712,17 @@ impl Function {
     fn closures_unsupported_panic() -> ! {
         unimplemented!("Closures (functions with captured environments) are currently unsupported with native functions. See: https://github.com/wasmerio/wasmer/issues/1840")
     }
+
+    /// Check if the function holds a strong `InstanceRef`.
+    /// None means there's no `InstanceRef`, strong or weak.
+    // TODO: maybe feature gate this, we only need it for tests...
+    pub fn is_strong_instance_ref(&self) -> Option<bool> {
+        self.exported
+            .vm_function
+            .instance_ref
+            .as_ref()
+            .map(|v| v.is_strong())
+    }
 }
 
 impl<'a> Exportable<'a> for Function {
@@ -725,6 +736,14 @@ impl<'a> Exportable<'a> for Function {
             _ => Err(ExportError::IncompatibleType),
         }
     }
+
+    fn into_weak_instance_ref(&mut self) {
+        self.exported
+            .vm_function
+            .instance_ref
+            .as_mut()
+            .map(|v| v.into_weak());
+    }
 }
 
 impl fmt::Debug for Function {

lib/api/src/externals/global.rs

@@ -208,6 +208,13 @@ impl Global {
     pub fn same(&self, other: &Self) -> bool {
         Arc::ptr_eq(&self.vm_global.from, &other.vm_global.from)
     }
+
+    /// Check if the global holds a strong `InstanceRef`.
+    /// None means there's no `InstanceRef`, strong or weak.
+    // TODO: maybe feature gate this, we only need it for tests...
+    pub fn is_strong_instance_ref(&self) -> Option<bool> {
+        self.vm_global.instance_ref.as_ref().map(|v| v.is_strong())
+    }
 }
 
 impl fmt::Debug for Global {
@@ -231,4 +238,8 @@ impl<'a> Exportable<'a> for Global {
             _ => Err(ExportError::IncompatibleType),
         }
     }
+
+    fn into_weak_instance_ref(&mut self) {
+        self.vm_global.instance_ref.as_mut().map(|v| v.into_weak());
+    }
 }

lib/api/src/externals/memory.rs

@@ -248,6 +248,13 @@ impl Memory {
     pub fn same(&self, other: &Self) -> bool {
         Arc::ptr_eq(&self.vm_memory.from, &other.vm_memory.from)
     }
+
+    /// Check if the memory holds a strong `InstanceRef`.
+    /// None means there's no `InstanceRef`, strong or weak.
+    // TODO: maybe feature gate this, we only need it for tests...
+    pub fn is_strong_instance_ref(&self) -> Option<bool> {
+        self.vm_memory.instance_ref.as_ref().map(|v| v.is_strong())
+    }
 }
 
 impl<'a> Exportable<'a> for Memory {
@@ -261,4 +268,8 @@ impl<'a> Exportable<'a> for Memory {
             _ => Err(ExportError::IncompatibleType),
         }
     }
+
+    fn into_weak_instance_ref(&mut self) {
+        self.vm_memory.instance_ref.as_mut().map(|v| v.into_weak());
+    }
 }

lib/api/src/externals/mod.rs

@@ -72,6 +72,15 @@ impl<'a> Exportable<'a> for Extern {
         // Since this is already an extern, we can just return it.
         Ok(_extern)
     }
+
+    fn into_weak_instance_ref(&mut self) {
+        match self {
+            Self::Function(f) => f.into_weak_instance_ref(),
+            Self::Global(g) => g.into_weak_instance_ref(),
+            Self::Memory(m) => m.into_weak_instance_ref(),
+            Self::Table(t) => t.into_weak_instance_ref(),
+        }
+    }
 }
 
 impl StoreObject for Extern {

lib/api/src/externals/table.rs

@@ -146,6 +146,13 @@ impl Table {
     pub fn same(&self, other: &Self) -> bool {
         Arc::ptr_eq(&self.vm_table.from, &other.vm_table.from)
     }
+
+    /// Check if the table holds a strong `InstanceRef`.
+    /// None means there's no `InstanceRef`, strong or weak.
+    // TODO: maybe feature gate this, we only need it for tests...
+    pub fn is_strong_instance_ref(&self) -> Option<bool> {
+        self.vm_table.instance_ref.as_ref().map(|v| v.is_strong())
+    }
 }
 
 impl<'a> Exportable<'a> for Table {
@@ -159,4 +166,8 @@ impl<'a> Exportable<'a> for Table {
             _ => Err(ExportError::IncompatibleType),
         }
     }
+
+    fn into_weak_instance_ref(&mut self) {
+        self.vm_table.instance_ref.as_mut().map(|v| v.into_weak());
+    }
 }

lib/api/src/native.rs

@@ -196,6 +196,12 @@ macro_rules! impl_native_traits {
                 }
 
             }
+            /// Check if the function holds a strong `InstanceRef`.
+            /// None means there's no `InstanceRef`, strong or weak.
+            // TODO: maybe feature gate this, we only need it for tests...
+            pub fn is_strong_instance_ref(&self) -> Option<bool> {
+                self.exported.vm_function.instance_ref.as_ref().map(|v| v.is_strong())
+            }
         }
 
         #[allow(unused_parens)]
@@ -208,6 +214,10 @@ macro_rules! impl_native_traits {
                 use crate::exports::Exportable;
                 crate::Function::get_self_from_extern(_extern)?.native().map_err(|_| crate::exports::ExportError::IncompatibleType)
             }
+
+            fn into_weak_instance_ref(&mut self) {
+                self.exported.vm_function.instance_ref.as_mut().map(|v| v.into_weak());
+            }
         }
     };
 }