Move HostRef<T> into the C API crate

It isn't used by anything except for the C API and all of our embedder-exposed
APIs are already internally `Rc`-based, so it doesn't make sense to use with
them.

crates/wasmtime/src/lib.rs

@@ -29,7 +29,7 @@ pub use crate::func::*;
 pub use crate::instance::Instance;
 pub use crate::linker::*;
 pub use crate::module::Module;
-pub use crate::r#ref::{ExternRef, HostRef};
+pub use crate::r#ref::ExternRef;
 pub use crate::runtime::*;
 pub use crate::trap::Trap;
 pub use crate::types::*;

crates/wasmtime/src/ref.rs

@@ -1,10 +1,8 @@
 #![allow(missing_docs)]
 
 use std::any::Any;
-use std::cell::{self, RefCell};
-use std::convert::TryFrom;
+use std::cell::RefCell;
 use std::fmt;
-use std::marker::PhantomData;
 use std::rc::{Rc, Weak};
 use wasmtime_runtime::VMExternRef;
 
@@ -81,99 +79,3 @@ impl fmt::Debug for ExternRef {
             .finish()
     }
 }
-
-/// Represents a piece of data located in the host environment.
-#[derive(Debug)]
-pub struct HostRef<T>
-where
-    T: 'static + Any,
-{
-    externref: ExternRef,
-    _phantom: PhantomData<T>,
-}
-
-impl<T> HostRef<T>
-where
-    T: 'static + Any,
-{
-    /// Creates a new `HostRef<T>` from `T`.
-    pub fn new(store: &crate::Store, item: T) -> HostRef<T> {
-        HostRef {
-            externref: ExternRef::new(store, RefCell::new(item)),
-            _phantom: PhantomData,
-        }
-    }
-
-    /// Immutably borrows the wrapped data.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the value is currently mutably borrowed.
-    pub fn borrow(&self) -> cell::Ref<T> {
-        self.inner().borrow()
-    }
-
-    /// Mutably borrows the wrapped data.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the `HostRef<T>` is already borrowed.
-    pub fn borrow_mut(&self) -> cell::RefMut<T> {
-        self.inner().borrow_mut()
-    }
-
-    /// Returns true if the two `HostRef<T>`'s point to the same value (not just
-    /// values that compare as equal).
-    pub fn ptr_eq(&self, other: &HostRef<T>) -> bool {
-        self.externref.ptr_eq(&other.externref)
-    }
-
-    fn inner(&self) -> &RefCell<T> {
-        self.externref
-            .inner
-            .downcast_ref::<RefCell<T>>()
-            .expect("`HostRef<T>`s always wrap an `ExternRef` of `RefCell<T>`")
-    }
-}
-
-impl<T> AsRef<ExternRef> for HostRef<T> {
-    fn as_ref(&self) -> &ExternRef {
-        &self.externref
-    }
-}
-
-impl<T> From<HostRef<T>> for ExternRef
-where
-    T: 'static + Any,
-{
-    fn from(host: HostRef<T>) -> ExternRef {
-        host.externref
-    }
-}
-
-impl<T> TryFrom<ExternRef> for HostRef<T>
-where
-    T: 'static + Any,
-{
-    type Error = ExternRef;
-
-    fn try_from(externref: ExternRef) -> Result<Self, ExternRef> {
-        if externref.inner.is::<RefCell<T>>() {
-            Ok(HostRef {
-                externref,
-                _phantom: PhantomData,
-            })
-        } else {
-            Err(externref)
-        }
-    }
-}
-
-impl<T> Clone for HostRef<T> {
-    fn clone(&self) -> HostRef<T> {
-        HostRef {
-            externref: self.externref.clone(),
-            _phantom: PhantomData,
-        }
-    }
-}