Move types to a separate crate

This way we can change the macro without breaking back-compat on the
traits.

Cargo.toml

@@ -1,4 +1,5 @@
 [workspace]
 members = [
-    "foreign-types"
+    "foreign-types",
+    "foreign-types-shared"
 ]

foreign-types-shared/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "foreign-types-shared"
+version = "0.1.0"
+authors = ["Steven Fackler <sfackler@gmail.com>"]
+
+[dependencies]

foreign-types-shared/src/lib.rs

@@ -0,0 +1,51 @@
+//! Internal crate used by foreign-types
+
+#![no_std]
+#![warn(missing_docs)]
+#![doc(html_root_url="https://docs.rs/foreign-types-shared/0.1")]
+
+use core::cell::UnsafeCell;
+
+/// An opaque type used to define `ForeignTypeRef` types.
+///
+/// A type implementing `ForeignTypeRef` should simply be a newtype wrapper around this type.
+pub struct Opaque(UnsafeCell<()>);
+
+/// A type implemented by wrappers over foreign types.
+pub trait ForeignType: Sized {
+    /// The raw C type.
+    type CType;
+
+    /// The type representing a reference to this type.
+    type Ref: ForeignTypeRef<CType = Self::CType>;
+
+    /// Constructs an instance of this type from its raw type.
+    unsafe fn from_ptr(ptr: *mut Self::CType) -> Self;
+
+    /// Returns a raw pointer to the wrapped value.
+    fn as_ptr(&self) -> *mut Self::CType;
+}
+
+/// A trait implemented by types which reference borrowed foreign types.
+pub trait ForeignTypeRef: Sized {
+    /// The raw C type.
+    type CType;
+
+    /// Constructs a shared instance of this type from its raw type.
+    #[inline]
+    unsafe fn from_ptr<'a>(ptr: *mut Self::CType) -> &'a Self {
+        &*(ptr as *mut _)
+    }
+
+    /// Constructs a mutable reference of this type from its raw type.
+    #[inline]
+    unsafe fn from_ptr_mut<'a>(ptr: *mut Self::CType) -> &'a mut Self {
+        &mut *(ptr as *mut _)
+    }
+
+    /// Returns a raw pointer to the wrapped value.
+    #[inline]
+    fn as_ptr(&self) -> *mut Self::CType {
+        self as *const _ as *mut _
+    }
+}

foreign-types/Cargo.toml

@@ -8,3 +8,4 @@ repository = "https://github.com/sfackler/foreign-types"
 readme = "README.md"
 
 [dependencies]
+foreign-types-shared = { path = "../foreign-types-shared" }

foreign-types/src/lib.rs

@@ -178,52 +178,10 @@
 #![no_std]
 #![warn(missing_docs)]
 #![doc(html_root_url="https://docs.rs/foreign-types/0.3")]
+extern crate foreign_types_shared;
 
-use core::cell::UnsafeCell;
-
-/// An opaque type used to define `ForeignTypeRef` types.
-///
-/// A type implementing `ForeignTypeRef` should simply be a newtype wrapper around this type.
-pub struct Opaque(UnsafeCell<()>);
-
-/// A type implemented by wrappers over foreign types.
-pub trait ForeignType: Sized {
-    /// The raw C type.
-    type CType;
-
-    /// The type representing a reference to this type.
-    type Ref: ForeignTypeRef<CType = Self::CType>;
-
-    /// Constructs an instance of this type from its raw type.
-    unsafe fn from_ptr(ptr: *mut Self::CType) -> Self;
-
-    /// Returns a raw pointer to the wrapped value.
-    fn as_ptr(&self) -> *mut Self::CType;
-}
-
-/// A trait implemented by types which reference borrowed foreign types.
-pub trait ForeignTypeRef: Sized {
-    /// The raw C type.
-    type CType;
-
-    /// Constructs a shared instance of this type from its raw type.
-    #[inline]
-    unsafe fn from_ptr<'a>(ptr: *mut Self::CType) -> &'a Self {
-        &*(ptr as *mut _)
-    }
-
-    /// Constructs a mutable reference of this type from its raw type.
-    #[inline]
-    unsafe fn from_ptr_mut<'a>(ptr: *mut Self::CType) -> &'a mut Self {
-        &mut *(ptr as *mut _)
-    }
-
-    /// Returns a raw pointer to the wrapped value.
-    #[inline]
-    fn as_ptr(&self) -> *mut Self::CType {
-        self as *const _ as *mut _
-    }
-}
+#[doc(inline)]
+pub use foreign_types_shared::*;
 
 /// A macro to easily define wrappers for foreign types.
 ///