Improvedf hashing/ids of function envs

lib/api/src/sys/function_env.rs

@@ -10,11 +10,11 @@ use crate::{AsStoreMut, AsStoreRef, StoreMut, StoreRef};
 /// The function environment data is owned by the `Store`.
 pub struct FunctionEnv<T> {
     pub(crate) handle: StoreHandle<VMFunctionEnvironment>,
-    _phantom: PhantomData<T>,
+    marker: PhantomData<T>,
 }
 
 impl<T> FunctionEnv<T> {
-    /// Make a new extern reference
+    /// Make a new FunctionEnv
     pub fn new(store: &mut impl AsStoreMut, value: T) -> Self
     where
         T: Any + Send + 'static + Sized,
@@ -24,7 +24,7 @@ impl<T> FunctionEnv<T> {
                 store.as_store_mut().objects_mut(),
                 VMFunctionEnvironment::new(value),
             ),
-            _phantom: PhantomData,
+            marker: PhantomData,
         }
     }
 
@@ -64,11 +64,26 @@ impl<T> FunctionEnv<T> {
     }
 }
 
+impl<T> PartialEq for FunctionEnv<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.handle == other.handle
+    }
+}
+
+impl<T> Eq for FunctionEnv<T> {}
+
+impl<T> std::hash::Hash for FunctionEnv<T> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.handle.hash(state);
+        self.marker.hash(state);
+    }
+}
+
 impl<T> Clone for FunctionEnv<T> {
     fn clone(&self) -> Self {
         Self {
             handle: self.handle.clone(),
-            _phantom: self._phantom,
+            marker: self.marker,
         }
     }
 }

lib/vm/src/store.rs

@@ -16,7 +16,7 @@ use crate::{InstanceHandle, VMFunction, VMFunctionEnvironment, VMGlobal, VMMemor
 /// Every handle to an object managed by a context also contains the ID of the
 /// context. This is used to check that a handle is always used with the
 /// correct context.
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
 pub struct StoreId(NonZeroU64);
 
 impl Default for StoreId {
@@ -116,6 +116,13 @@ impl<T> Clone for StoreHandle<T> {
     }
 }
 
+impl<T> std::hash::Hash for StoreHandle<T> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.id.hash(state);
+        self.internal.idx.hash(state);
+    }
+}
+
 impl<T: StoreObject> fmt::Debug for StoreHandle<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("StoreHandle")