Change `std::kinds` to `std::markers`; flatten `std::kinds::marker`

[breaking-change]

154 files changed, 635 insertions, 623 deletions

diff --git a/src/doc/guide-unsafe.md b/src/doc/guide-unsafe.md
index bda1b345632..11bc0bc30f2 100644
--- a/src/doc/guide-unsafe.md
+++ b/src/doc/guide-unsafe.md
@@ -703,10 +703,10 @@ Other features provided by lang items include:
   `deref`, and `add` respectively.
 - stack unwinding and general failure; the `eh_personality`, `fail`
   and `fail_bounds_checks` lang items.
-- the traits in `std::kinds` used to indicate types that satisfy
+- the traits in `std::markers` used to indicate types of
   various kinds; lang items `send`, `sync` and `copy`.
 - the marker types and variance indicators found in
-  `std::kinds::markers`; lang items `covariant_type`,
+  `std::markers`; lang items `covariant_type`,
   `contravariant_lifetime`, `no_sync_bound`, etc.
 
 Lang items are loaded lazily by the compiler; e.g. if one never uses
diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs
index 25f80ad11bd..a3b77ccb6db 100644
--- a/src/liballoc/arc.rs
+++ b/src/liballoc/arc.rs
@@ -74,7 +74,7 @@ use core::clone::Clone;
 use core::fmt::{self, Show};
 use core::cmp::{Eq, Ord, PartialEq, PartialOrd, Ordering};
 use core::default::Default;
-use core::kinds::{Sync, Send};
+use core::markers::{Sync, Send};
 use core::mem::{min_align_of, size_of, drop};
 use core::mem;
 use core::nonzero::NonZero;
diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs
index 6df8bb5f7aa..0b211c7c212 100644
--- a/src/liballoc/boxed.rs
+++ b/src/liballoc/boxed.rs
@@ -18,7 +18,7 @@ use core::cmp::{PartialEq, PartialOrd, Eq, Ord, Ordering};
 use core::default::Default;
 use core::fmt;
 use core::hash::{self, Hash};
-use core::kinds::Sized;
+use core::markers::Sized;
 use core::mem;
 use core::option::Option;
 use core::ptr::Unique;
diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs
index 175bba4e71d..c6eaaaeecca 100644
--- a/src/liballoc/rc.rs
+++ b/src/liballoc/rc.rs
@@ -148,7 +148,7 @@ use core::cmp::{PartialEq, PartialOrd, Eq, Ord, Ordering};
 use core::default::Default;
 use core::fmt;
 use core::hash::{self, Hash};
-use core::kinds::marker;
+use core::markers;
 use core::mem::{transmute, min_align_of, size_of, forget};
 use core::nonzero::NonZero;
 use core::ops::{Deref, Drop};
@@ -175,8 +175,8 @@ pub struct Rc<T> {
     // FIXME #12808: strange names to try to avoid interfering with field accesses of the contained
     // type via Deref
     _ptr: NonZero<*mut RcBox<T>>,
-    _nosend: marker::NoSend,
-    _noshare: marker::NoSync
+    _nosend: markers::NoSend,
+    _noshare: markers::NoSync
 }
 
 impl<T> Rc<T> {
@@ -201,8 +201,8 @@ impl<T> Rc<T> {
                     strong: Cell::new(1),
                     weak: Cell::new(1)
                 })),
-                _nosend: marker::NoSend,
-                _noshare: marker::NoSync
+                _nosend: markers::NoSend,
+                _noshare: markers::NoSync
             }
         }
     }
@@ -223,8 +223,8 @@ impl<T> Rc<T> {
         self.inc_weak();
         Weak {
             _ptr: self._ptr,
-            _nosend: marker::NoSend,
-            _noshare: marker::NoSync
+            _nosend: markers::NoSend,
+            _noshare: markers::NoSync
         }
     }
 }
@@ -431,7 +431,7 @@ impl<T> Clone for Rc<T> {
     #[inline]
     fn clone(&self) -> Rc<T> {
         self.inc_strong();
-        Rc { _ptr: self._ptr, _nosend: marker::NoSend, _noshare: marker::NoSync }
+        Rc { _ptr: self._ptr, _nosend: markers::NoSend, _noshare: markers::NoSync }
     }
 }
 
@@ -622,8 +622,8 @@ pub struct Weak<T> {
     // FIXME #12808: strange names to try to avoid interfering with
     // field accesses of the contained type via Deref
     _ptr: NonZero<*mut RcBox<T>>,
-    _nosend: marker::NoSend,
-    _noshare: marker::NoSync
+    _nosend: markers::NoSend,
+    _noshare: markers::NoSync
 }
 
 #[experimental = "Weak pointers may not belong in this module."]
@@ -650,7 +650,7 @@ impl<T> Weak<T> {
             None
         } else {
             self.inc_strong();
-            Some(Rc { _ptr: self._ptr, _nosend: marker::NoSend, _noshare: marker::NoSync })
+            Some(Rc { _ptr: self._ptr, _nosend: markers::NoSend, _noshare: markers::NoSync })
         }
     }
 }
@@ -717,7 +717,7 @@ impl<T> Clone for Weak<T> {
     #[inline]
     fn clone(&self) -> Weak<T> {
         self.inc_weak();
-        Weak { _ptr: self._ptr, _nosend: marker::NoSend, _noshare: marker::NoSync }
+        Weak { _ptr: self._ptr, _nosend: markers::NoSend, _noshare: markers::NoSync }
     }
 }
 
diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs
index b85ea65f5ce..73cc46091e9 100644
--- a/src/libcollections/btree/map.rs
+++ b/src/libcollections/btree/map.rs
@@ -480,7 +480,7 @@ enum Continuation<A, B> {
 /// boilerplate gets cut out.
 mod stack {
     use core::prelude::*;
-    use core::kinds::marker;
+    use core::markers;
     use core::mem;
     use core::ops::{Deref, DerefMut};
     use super::BTreeMap;
@@ -494,7 +494,7 @@ mod stack {
     /// where `&'static` can be used in any function expecting any lifetime reference.
     pub struct IdRef<'id, T: 'id> {
         inner: &'id mut T,
-        marker: marker::InvariantLifetime<'id>
+        marker: markers::InvariantLifetime<'id>
     }
 
     impl<'id, T> Deref for IdRef<'id, T> {
@@ -536,7 +536,7 @@ mod stack {
     pub struct Pusher<'id, 'a, K:'a, V:'a> {
         map: &'a mut BTreeMap<K, V>,
         stack: Stack<K, V>,
-        marker: marker::InvariantLifetime<'id>
+        marker: markers::InvariantLifetime<'id>
     }
 
     impl<'a, K, V> PartialSearchStack<'a, K, V> {
@@ -571,11 +571,11 @@ mod stack {
             let pusher = Pusher {
                 map: self.map,
                 stack: self.stack,
-                marker: marker::InvariantLifetime
+                marker: markers::InvariantLifetime
             };
             let node = IdRef {
                 inner: unsafe { &mut *self.next },
-                marker: marker::InvariantLifetime
+                marker: markers::InvariantLifetime
             };
 
             closure(pusher, node)
diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs
index 5bf5f78af94..cbe5d2404e7 100644
--- a/src/libcollections/lib.rs
+++ b/src/libcollections/lib.rs
@@ -123,7 +123,9 @@ mod std {
     pub use core::option;   // necessary for panic!()
     pub use core::clone;    // deriving(Clone)
     pub use core::cmp;      // deriving(Eq, Ord, etc.)
-    pub use core::kinds;    // deriving(Copy)
+    #[cfg(stage0)]
+    pub use core::markers as kinds;
+    pub use core::markers;  // deriving(Copy)
     pub use core::hash;     // deriving(Hash)
 }
 
@@ -138,7 +140,7 @@ mod prelude {
     pub use core::iter::{FromIterator, Extend, IteratorExt};
     pub use core::iter::{Iterator, DoubleEndedIterator, RandomAccessIterator};
     pub use core::iter::{ExactSizeIterator};
-    pub use core::kinds::{Copy, Send, Sized, Sync};
+    pub use core::markers::{Copy, Send, Sized, Sync};
     pub use core::mem::drop;
     pub use core::ops::{Drop, Fn, FnMut, FnOnce};
     pub use core::option::Option;
diff --git a/src/libcollections/ring_buf.rs b/src/libcollections/ring_buf.rs
index 11775f62b1c..3c1cd101e3b 100644
--- a/src/libcollections/ring_buf.rs
+++ b/src/libcollections/ring_buf.rs
@@ -20,7 +20,7 @@ use core::cmp::Ordering;
 use core::default::Default;
 use core::fmt;
 use core::iter::{self, repeat, FromIterator, RandomAccessIterator};
-use core::kinds::marker;
+use core::markers;
 use core::mem;
 use core::num::{Int, UnsignedInt};
 use core::ops::{Index, IndexMut};
@@ -534,7 +534,7 @@ impl<T> RingBuf<T> {
             head: self.head,
             cap: self.cap,
             ptr: self.ptr,
-            marker: marker::ContravariantLifetime::<'a>,
+            marker: markers::ContravariantLifetime::<'a>,
         }
     }
 
@@ -1414,7 +1414,7 @@ pub struct IterMut<'a, T:'a> {
     tail: uint,
     head: uint,
     cap: uint,
-    marker: marker::ContravariantLifetime<'a>,
+    marker: markers::ContravariantLifetime<'a>,
 }
 
 #[stable]
diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs
index 9e5aa7d645b..d7e0b3d9353 100644
--- a/src/libcollections/slice.rs
+++ b/src/libcollections/slice.rs
@@ -95,7 +95,7 @@ use core::cmp::Ordering::{self, Greater, Less};
 use core::cmp::{self, Ord, PartialEq};
 use core::iter::{Iterator, IteratorExt};
 use core::iter::{range, range_step, MultiplicativeIterator};
-use core::kinds::Sized;
+use core::markers::Sized;
 use core::mem::size_of;
 use core::mem;
 use core::ops::{FnMut, SliceMut};
diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
index 99231e7253c..b3b560a23bd 100644
--- a/src/libcollections/vec.rs
+++ b/src/libcollections/vec.rs
@@ -55,7 +55,7 @@ use core::default::Default;
 use core::fmt;
 use core::hash::{self, Hash};
 use core::iter::{repeat, FromIterator};
-use core::kinds::marker::{ContravariantLifetime, InvariantType};
+use core::markers::{ContravariantLifetime, InvariantType};
 use core::mem;
 use core::nonzero::NonZero;
 use core::num::{Int, UnsignedInt};
diff --git a/src/libcore/array.rs b/src/libcore/array.rs
index ba7714ad9bc..f85b17fb7f0 100644
--- a/src/libcore/array.rs
+++ b/src/libcore/array.rs
@@ -17,7 +17,7 @@
 use clone::Clone;
 use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
 use fmt;
-use kinds::Copy;
+use markers::Copy;
 use ops::Deref;
 use option::Option;
 
diff --git a/src/libcore/atomic.rs b/src/libcore/atomic.rs
index 15c20253c8b..9e5bda4bf43 100644
--- a/src/libcore/atomic.rs
+++ b/src/libcore/atomic.rs
@@ -72,7 +72,7 @@
 
 use self::Ordering::*;
 
-use kinds::Sync;
+use markers::Sync;
 
 use intrinsics;
 use cell::UnsafeCell;
diff --git a/src/libcore/borrow.rs b/src/libcore/borrow.rs
index 2c08b976355..c4adf724b2f 100644
--- a/src/libcore/borrow.rs
+++ b/src/libcore/borrow.rs
@@ -47,7 +47,7 @@
 use clone::Clone;
 use cmp::{Eq, Ord, Ordering, PartialEq, PartialOrd};
 use fmt;
-use kinds::Sized;
+use markers::Sized;
 use ops::Deref;
 use option::Option;
 use self::Cow::*;
diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs
index fd18d6ac3f3..ae590b1de06 100644
--- a/src/libcore/cell.rs
+++ b/src/libcore/cell.rs
@@ -161,7 +161,7 @@ use clone::Clone;
 use cmp::PartialEq;
 use default::Default;
 use fmt;
-use kinds::{Copy, Send};
+use markers::{Copy, Send};
 use ops::{Deref, DerefMut, Drop};
 use option::Option;
 use option::Option::{None, Some};
@@ -520,11 +520,11 @@ impl<'b, T> DerefMut for RefMut<'b, T> {
 ///
 /// ```rust
 /// use std::cell::UnsafeCell;
-/// use std::kinds::marker;
+/// use std::markers;
 ///
 /// struct NotThreadSafe<T> {
 ///     value: UnsafeCell<T>,
-///     marker: marker::NoSync
+///     marker: markers::NoSync
 /// }
 /// ```
 ///
diff --git a/src/libcore/clone.rs b/src/libcore/clone.rs
index 17991659f97..78a5848f34d 100644
--- a/src/libcore/clone.rs
+++ b/src/libcore/clone.rs
@@ -21,7 +21,7 @@
 
 #![stable]
 
-use kinds::Sized;
+use markers::Sized;
 
 /// A common trait for cloning an object.
 #[stable]
diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs
index af5e98ed303..01f1073a5d3 100644
--- a/src/libcore/cmp.rs
+++ b/src/libcore/cmp.rs
@@ -43,7 +43,7 @@
 
 use self::Ordering::*;
 
-use kinds::Sized;
+use markers::Sized;
 use option::Option::{self, Some, None};
 
 /// Trait for equality comparisons which are [partial equivalence relations](
@@ -316,7 +316,7 @@ pub fn partial_max<T: PartialOrd>(v1: T, v2: T) -> Option<T> {
 mod impls {
     use cmp::{PartialOrd, Ord, PartialEq, Eq, Ordering};
     use cmp::Ordering::{Less, Greater, Equal};
-    use kinds::Sized;
+    use markers::Sized;
     use option::Option;
     use option::Option::{Some, None};
 
diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs
index 951f5c29f00..ed01cf64769 100644
--- a/src/libcore/fmt/mod.rs
+++ b/src/libcore/fmt/mod.rs
@@ -15,7 +15,7 @@
 use any;
 use cell::{Cell, Ref, RefMut};
 use iter::{Iterator, IteratorExt, range};
-use kinds::{Copy, Sized};
+use markers::{Copy, Sized};
 use mem;
 use option::Option;
 use option::Option::{Some, None};
diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index e5753f6cc2e..ac5804c910d 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -67,7 +67,7 @@ use num::{ToPrimitive, Int};
 use ops::{Add, Deref, FnMut};
 use option::Option;
 use option::Option::{Some, None};
-use std::kinds::Sized;
+use std::markers::Sized;
 use uint;
 
 /// An interface for dealing with "external iterators". These types of iterators
diff --git a/src/libcore/kinds.rs b/src/libcore/kinds.rs
deleted file mode 100644
index 5d69938fccf..00000000000
--- a/src/libcore/kinds.rs
+++ /dev/null
@@ -1,298 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Primitive traits representing basic 'kinds' of types
-//!
-//! Rust types can be classified in various useful ways according to
-//! intrinsic properties of the type. These classifications, often called
-//! 'kinds', are represented as traits.
-//!
-//! They cannot be implemented by user code, but are instead implemented
-//! by the compiler automatically for the types to which they apply.
-
-/// Types able to be transferred across task boundaries.
-#[lang="send"]
-pub unsafe trait Send : 'static {
-    // empty.
-}
-
-/// Types with a constant size known at compile-time.
-#[lang="sized"]
-pub trait Sized {
-    // Empty.
-}
-
-/// Types that can be copied by simply copying bits (i.e. `memcpy`).
-#[lang="copy"]
-pub trait Copy {
-    // Empty.
-}
-
-/// Types that can be safely shared between tasks when aliased.
-///
-/// The precise definition is: a type `T` is `Sync` if `&T` is
-/// thread-safe. In other words, there is no possibility of data races
-/// when passing `&T` references between tasks.
-///
-/// As one would expect, primitive types like `u8` and `f64` are all
-/// `Sync`, and so are simple aggregate types containing them (like
-/// tuples, structs and enums). More instances of basic `Sync` types
-/// include "immutable" types like `&T` and those with simple
-/// inherited mutability, such as `Box<T>`, `Vec<T>` and most other
-/// collection types. (Generic parameters need to be `Sync` for their
-/// container to be `Sync`.)
-///
-/// A somewhat surprising consequence of the definition is `&mut T` is
-/// `Sync` (if `T` is `Sync`) even though it seems that it might
-/// provide unsynchronised mutation. The trick is a mutable reference
-/// stored in an aliasable reference (that is, `& &mut T`) becomes
-/// read-only, as if it were a `& &T`, hence there is no risk of a data
-/// race.
-///
-/// Types that are not `Sync` are those that have "interior
-/// mutability" in a non-thread-safe way, such as `Cell` and `RefCell`
-/// in `std::cell`. These types allow for mutation of their contents
-/// even when in an immutable, aliasable slot, e.g. the contents of
-/// `&Cell<T>` can be `.set`, and do not ensure data races are
-/// impossible, hence they cannot be `Sync`. A higher level example
-/// of a non-`Sync` type is the reference counted pointer
-/// `std::rc::Rc`, because any reference `&Rc<T>` can clone a new
-/// reference, which modifies the reference counts in a non-atomic
-/// way.
-///
-/// For cases when one does need thread-safe interior mutability,
-/// types like the atomics in `std::sync` and `Mutex` & `RWLock` in
-/// the `sync` crate do ensure that any mutation cannot cause data
-/// races.  Hence these types are `Sync`.
-///
-/// Users writing their own types with interior mutability (or anything
-/// else that is not thread-safe) should use the `NoSync` marker type
-/// (from `std::kinds::marker`) to ensure that the compiler doesn't
-/// consider the user-defined type to be `Sync`.  Any types with
-/// interior mutability must also use the `std::cell::UnsafeCell` wrapper
-/// around the value(s) which can be mutated when behind a `&`
-/// reference; not doing this is undefined behaviour (for example,
-/// `transmute`-ing from `&T` to `&mut T` is illegal).
-#[lang="sync"]
-pub unsafe trait Sync {
-    // Empty
-}
-
-/// Marker types are special types that are used with unsafe code to
-/// inform the compiler of special constraints. Marker types should
-/// only be needed when you are creating an abstraction that is
-/// implemented using unsafe code. In that case, you may want to embed
-/// some of the marker types below into your type.
-pub mod marker {
-    use super::{Copy,Sized};
-    use clone::Clone;
-
-    /// A marker type whose type parameter `T` is considered to be
-    /// covariant with respect to the type itself. This is (typically)
-    /// used to indicate that an instance of the type `T` is being stored
-    /// into memory and read from, even though that may not be apparent.
-    ///
-    /// For more information about variance, refer to this Wikipedia
-    /// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
-    ///
-    /// *Note:* It is very unusual to have to add a covariant constraint.
-    /// If you are not sure, you probably want to use `InvariantType`.
-    ///
-    /// # Example
-    ///
-    /// Given a struct `S` that includes a type parameter `T`
-    /// but does not actually *reference* that type parameter:
-    ///
-    /// ```ignore
-    /// use std::mem;
-    ///
-    /// struct S<T> { x: *() }
-    /// fn get<T>(s: &S<T>) -> T {
-    ///    unsafe {
-    ///        let x: *T = mem::transmute(s.x);
-    ///        *x
-    ///    }
-    /// }
-    /// ```
-    ///
-    /// The type system would currently infer that the value of
-    /// the type parameter `T` is irrelevant, and hence a `S<int>` is
-    /// a subtype of `S<Box<int>>` (or, for that matter, `S<U>` for
-    /// any `U`). But this is incorrect because `get()` converts the
-    /// `*()` into a `*T` and reads from it. Therefore, we should include the
-    /// a marker field `CovariantType<T>` to inform the type checker that
-    /// `S<T>` is a subtype of `S<U>` if `T` is a subtype of `U`
-    /// (for example, `S<&'static int>` is a subtype of `S<&'a int>`
-    /// for some lifetime `'a`, but not the other way around).
-    #[lang="covariant_type"]
-    #[derive(PartialEq, Eq, PartialOrd, Ord)]
-    pub struct CovariantType<T: ?Sized>;
-
-    impl<T: ?Sized> Copy for CovariantType<T> {}
-    impl<T: ?Sized> Clone for CovariantType<T> {
-        fn clone(&self) -> CovariantType<T> { *self }
-    }
-
-    /// A marker type whose type parameter `T` is considered to be
-    /// contravariant with respect to the type itself. This is (typically)
-    /// used to indicate that an instance of the type `T` will be consumed
-    /// (but not read from), even though that may not be apparent.
-    ///
-    /// For more information about variance, refer to this Wikipedia
-    /// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
-    ///
-    /// *Note:* It is very unusual to have to add a contravariant constraint.
-    /// If you are not sure, you probably want to use `InvariantType`.
-    ///
-    /// # Example
-    ///
-    /// Given a struct `S` that includes a type parameter `T`
-    /// but does not actually *reference* that type parameter:
-    ///
-    /// ```
-    /// use std::mem;
-    ///
-    /// struct S<T> { x: *const () }
-    /// fn get<T>(s: &S<T>, v: T) {
-    ///    unsafe {
-    ///        let x: fn(T) = mem::transmute(s.x);
-    ///        x(v)
-    ///    }
-    /// }
-    /// ```
-    ///
-    /// The type system would currently infer that the value of
-    /// the type parameter `T` is irrelevant, and hence a `S<int>` is
-    /// a subtype of `S<Box<int>>` (or, for that matter, `S<U>` for
-    /// any `U`). But this is incorrect because `get()` converts the
-    /// `*()` into a `fn(T)` and then passes a value of type `T` to it.
-    ///
-    /// Supplying a `ContravariantType` marker would correct the
-    /// problem, because it would mark `S` so that `S<T>` is only a
-    /// subtype of `S<U>` if `U` is a subtype of `T`; given that the
-    /// function requires arguments of type `T`, it must also accept
-    /// arguments of type `U`, hence such a conversion is safe.
-    #[lang="contravariant_type"]
-    #[derive(PartialEq, Eq, PartialOrd, Ord)]
-    pub struct ContravariantType<T: ?Sized>;
-
-    impl<T: ?Sized> Copy for ContravariantType<T> {}
-    impl<T: ?Sized> Clone for ContravariantType<T> {
-        fn clone(&self) -> ContravariantType<T> { *self }
-    }
-
-    /// A marker type whose type parameter `T` is considered to be
-    /// invariant with respect to the type itself. This is (typically)
-    /// used to indicate that instances of the type `T` may be read or
-    /// written, even though that may not be apparent.
-    ///
-    /// For more information about variance, refer to this Wikipedia
-    /// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
-    ///
-    /// # Example
-    ///
-    /// The Cell type is an example which uses unsafe code to achieve
-    /// "interior" mutability:
-    ///
-    /// ```
-    /// pub struct Cell<T> { value: T }
-    /// # fn main() {}
-    /// ```
-    ///
-    /// The type system would infer that `value` is only read here and
-    /// never written, but in fact `Cell` uses unsafe code to achieve
-    /// interior mutability.
-    #[lang="invariant_type"]
-    #[derive(PartialEq, Eq, PartialOrd, Ord)]
-    pub struct InvariantType<T: ?Sized>;
-
-    impl<T: ?Sized> Copy for InvariantType<T> {}
-    impl<T: ?Sized> Clone for InvariantType<T> {
-        fn clone(&self) -> InvariantType<T> { *self }
-    }
-
-    /// As `CovariantType`, but for lifetime parameters. Using
-    /// `CovariantLifetime<'a>` indicates that it is ok to substitute
-    /// a *longer* lifetime for `'a` than the one you originally
-    /// started with (e.g., you could convert any lifetime `'foo` to
-    /// `'static`). You almost certainly want `ContravariantLifetime`
-    /// instead, or possibly `InvariantLifetime`. The only case where
-    /// it would be appropriate is that you have a (type-casted, and
-    /// hence hidden from the type system) function pointer with a
-    /// signature like `fn(&'a T)` (and no other uses of `'a`). In
-    /// this case, it is ok to substitute a larger lifetime for `'a`
-    /// (e.g., `fn(&'static T)`), because the function is only
-    /// becoming more selective in terms of what it accepts as
-    /// argument.
-    ///
-    /// For more information about variance, refer to this Wikipedia
-    /// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
-    #[lang="covariant_lifetime"]
-    #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-    pub struct CovariantLifetime<'a>;
-
-    /// As `ContravariantType`, but for lifetime parameters. Using
-    /// `ContravariantLifetime<'a>` indicates that it is ok to
-    /// substitute a *shorter* lifetime for `'a` than the one you
-    /// originally started with (e.g., you could convert `'static` to
-    /// any lifetime `'foo`). This is appropriate for cases where you
-    /// have an unsafe pointer that is actually a pointer into some
-    /// memory with lifetime `'a`, and thus you want to limit the
-    /// lifetime of your data structure to `'a`. An example of where
-    /// this is used is the iterator for vectors.
-    ///
-    /// For more information about variance, refer to this Wikipedia
-    /// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
-    #[lang="contravariant_lifetime"]
-    #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-    pub struct ContravariantLifetime<'a>;
-
-    /// As `InvariantType`, but for lifetime parameters. Using
-    /// `InvariantLifetime<'a>` indicates that it is not ok to
-    /// substitute any other lifetime for `'a` besides its original
-    /// value. This is appropriate for cases where you have an unsafe
-    /// pointer that is actually a pointer into memory with lifetime `'a`,
-    /// and this pointer is itself stored in an inherently mutable
-    /// location (such as a `Cell`).
-    #[lang="invariant_lifetime"]
-    #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-    pub struct InvariantLifetime<'a>;
-
-    /// A type which is considered "not sendable", meaning that it cannot
-    /// be safely sent between tasks, even if it is owned. This is
-    /// typically embedded in other types, such as `Gc`, to ensure that
-    /// their instances remain thread-local.
-    #[lang="no_send_bound"]
-    #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-    pub struct NoSend;
-
-    /// A type which is considered "not POD", meaning that it is not
-    /// implicitly copyable. This is typically embedded in other types to
-    /// ensure that they are never copied, even if they lack a destructor.
-    #[lang="no_copy_bound"]
-    #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
-    #[allow(missing_copy_implementations)]
-    pub struct NoCopy;
-
-    /// A type which is considered "not sync", meaning that
-    /// its contents are not threadsafe, hence they cannot be
-    /// shared between tasks.
-    #[lang="no_sync_bound"]
-    #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-    pub struct NoSync;
-
-    /// A type which is considered managed by the GC. This is typically
-    /// embedded in other types.
-    #[lang="managed_bound"]
-    #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
-    #[allow(missing_copy_implementations)]
-    pub struct Managed;
-}
-
diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs
index aff0065c527..c06dc056d20 100644
--- a/src/libcore/lib.rs
+++ b/src/libcore/lib.rs
@@ -111,7 +111,7 @@ pub mod ptr;
 
 /* Core language traits */
 
-pub mod kinds;
+pub mod markers;
 pub mod ops;
 pub mod cmp;
 pub mod clone;
@@ -150,7 +150,9 @@ mod core {
 mod std {
     pub use clone;
     pub use cmp;
-    pub use kinds;
+    #[cfg(stage0)]
+    pub use markers as kinds;
+    pub use markers;
     pub use option;
     pub use fmt;
     pub use hash;
diff --git a/src/libcore/markers.rs b/src/libcore/markers.rs
new file mode 100644
index 00000000000..0663ceb68e6
--- /dev/null
+++ b/src/libcore/markers.rs
@@ -0,0 +1,299 @@
+// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Primitive traits and marker types representing basic 'kinds' of types.
+//!
+//! Rust types can be classified in various useful ways according to
+//! intrinsic properties of the type. These classifications, often called
+//! 'kinds', are represented as traits.
+//!
+//! They cannot be implemented by user code, but are instead implemented
+//! by the compiler automatically for the types to which they apply.
+//!
+//! Marker types are special types that are used with unsafe code to
+//! inform the compiler of special constraints. Marker types should
+//! only be needed when you are creating an abstraction that is
+//! implemented using unsafe code. In that case, you may want to embed
+//! some of the marker types below into your type.
+
+
+
+use clone::Clone;
+
+
+/// Types able to be transferred across task boundaries.
+#[lang="send"]
+pub unsafe trait Send: 'static {
+    // empty.
+}
+
+/// Types with a constant size known at compile-time.
+#[lang="sized"]
+pub trait Sized {
+    // Empty.
+}
+
+/// Types that can be copied by simply copying bits (i.e. `memcpy`).
+#[lang="copy"]
+pub trait Copy {
+    // Empty.
+}
+
+/// Types that can be safely shared between tasks when aliased.
+///
+/// The precise definition is: a type `T` is `Sync` if `&T` is
+/// thread-safe. In other words, there is no possibility of data races
+/// when passing `&T` references between tasks.
+///
+/// As one would expect, primitive types like `u8` and `f64` are all
+/// `Sync`, and so are simple aggregate types containing them (like
+/// tuples, structs and enums). More instances of basic `Sync` types
+/// include "immutable" types like `&T` and those with simple
+/// inherited mutability, such as `Box<T>`, `Vec<T>` and most other
+/// collection types. (Generic parameters need to be `Sync` for their
+/// container to be `Sync`.)
+///
+/// A somewhat surprising consequence of the definition is `&mut T` is
+/// `Sync` (if `T` is `Sync`) even though it seems that it might
+/// provide unsynchronised mutation. The trick is a mutable reference
+/// stored in an aliasable reference (that is, `& &mut T`) becomes
+/// read-only, as if it were a `& &T`, hence there is no risk of a data
+/// race.
+///
+/// Types that are not `Sync` are those that have "interior
+/// mutability" in a non-thread-safe way, such as `Cell` and `RefCell`
+/// in `std::cell`. These types allow for mutation of their contents
+/// even when in an immutable, aliasable slot, e.g. the contents of
+/// `&Cell<T>` can be `.set`, and do not ensure data races are
+/// impossible, hence they cannot be `Sync`. A higher level example
+/// of a non-`Sync` type is the reference counted pointer
+/// `std::rc::Rc`, because any reference `&Rc<T>` can clone a new
+/// reference, which modifies the reference counts in a non-atomic
+/// way.
+///
+/// For cases when one does need thread-safe interior mutability,
+/// types like the atomics in `std::sync` and `Mutex` & `RWLock` in
+/// the `sync` crate do ensure that any mutation cannot cause data
+/// races.  Hence these types are `Sync`.
+///
+/// Users writing their own types with interior mutability (or anything
+/// else that is not thread-safe) should use the `NoSync` marker type
+/// (from `std::markers`) to ensure that the compiler doesn't
+/// consider the user-defined type to be `Sync`.  Any types with
+/// interior mutability must also use the `std::cell::UnsafeCell` wrapper
+/// around the value(s) which can be mutated when behind a `&`
+/// reference; not doing this is undefined behaviour (for example,
+/// `transmute`-ing from `&T` to `&mut T` is illegal).
+#[lang="sync"]
+pub unsafe trait Sync {
+    // Empty
+}
+
+
+/// A marker type whose type parameter `T` is considered to be
+/// covariant with respect to the type itself. This is (typically)
+/// used to indicate that an instance of the type `T` is being stored
+/// into memory and read from, even though that may not be apparent.
+///
+/// For more information about variance, refer to this Wikipedia
+/// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
+///
+/// *Note:* It is very unusual to have to add a covariant constraint.
+/// If you are not sure, you probably want to use `InvariantType`.
+///
+/// # Example
+///
+/// Given a struct `S` that includes a type parameter `T`
+/// but does not actually *reference* that type parameter:
+///
+/// ```ignore
+/// use std::mem;
+///
+/// struct S<T> { x: *() }
+/// fn get<T>(s: &S<T>) -> T {
+///    unsafe {
+///        let x: *T = mem::transmute(s.x);
+///        *x
+///    }
+/// }
+/// ```
+///
+/// The type system would currently infer that the value of
+/// the type parameter `T` is irrelevant, and hence a `S<int>` is
+/// a subtype of `S<Box<int>>` (or, for that matter, `S<U>` for
+/// any `U`). But this is incorrect because `get()` converts the
+/// `*()` into a `*T` and reads from it. Therefore, we should include the
+/// a marker field `CovariantType<T>` to inform the type checker that
+/// `S<T>` is a subtype of `S<U>` if `T` is a subtype of `U`
+/// (for example, `S<&'static int>` is a subtype of `S<&'a int>`
+/// for some lifetime `'a`, but not the other way around).
+#[lang="covariant_type"]
+#[derive(PartialEq, Eq, PartialOrd, Ord)]
+pub struct CovariantType<Sized? T>;
+
+impl<Sized? T> Copy for CovariantType<T> {}
+impl<Sized? T> Clone for CovariantType<T> {
+    fn clone(&self) -> CovariantType<T> { *self }
+}
+
+/// A marker type whose type parameter `T` is considered to be
+/// contravariant with respect to the type itself. This is (typically)
+/// used to indicate that an instance of the type `T` will be consumed
+/// (but not read from), even though that may not be apparent.
+///
+/// For more information about variance, refer to this Wikipedia
+/// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
+///
+/// *Note:* It is very unusual to have to add a contravariant constraint.
+/// If you are not sure, you probably want to use `InvariantType`.
+///
+/// # Example
+///
+/// Given a struct `S` that includes a type parameter `T`
+/// but does not actually *reference* that type parameter:
+///
+/// ```
+/// use std::mem;
+///
+/// struct S<T> { x: *const () }
+/// fn get<T>(s: &S<T>, v: T) {
+///    unsafe {
+///        let x: fn(T) = mem::transmute(s.x);
+///        x(v)
+///    }
+/// }
+/// ```
+///
+/// The type system would currently infer that the value of
+/// the type parameter `T` is irrelevant, and hence a `S<int>` is
+/// a subtype of `S<Box<int>>` (or, for that matter, `S<U>` for
+/// any `U`). But this is incorrect because `get()` converts the
+/// `*()` into a `fn(T)` and then passes a value of type `T` to it.
+///
+/// Supplying a `ContravariantType` marker would correct the
+/// problem, because it would mark `S` so that `S<T>` is only a
+/// subtype of `S<U>` if `U` is a subtype of `T`; given that the
+/// function requires arguments of type `T`, it must also accept
+/// arguments of type `U`, hence such a conversion is safe.
+#[lang="contravariant_type"]
+#[derive(PartialEq, Eq, PartialOrd, Ord)]
+pub struct ContravariantType<T: ?Sized>;
+
+impl<T: ?Sized> Copy for ContravariantType<T> {}
+impl<T: ?Sized> Clone for ContravariantType<T> {
+    fn clone(&self) -> ContravariantType<T> { *self }
+}
+
+/// A marker type whose type parameter `T` is considered to be
+/// invariant with respect to the type itself. This is (typically)
+/// used to indicate that instances of the type `T` may be read or
+/// written, even though that may not be apparent.
+///
+/// For more information about variance, refer to this Wikipedia
+/// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
+///
+/// # Example
+///
+/// The Cell type is an example which uses unsafe code to achieve
+/// "interior" mutability:
+///
+/// ```
+/// pub struct Cell<T> { value: T }
+/// # fn main() {}
+/// ```
+///
+/// The type system would infer that `value` is only read here and
+/// never written, but in fact `Cell` uses unsafe code to achieve
+/// interior mutability.
+#[lang="invariant_type"]
+#[derive(PartialEq, Eq, PartialOrd, Ord)]
+pub struct InvariantType<T: ?Sized>;
+
+impl<T: ?Sized> Copy for InvariantType<T> {}
+impl<T: ?Sized> Clone for InvariantType<T> {
+    fn clone(&self) -> InvariantType<T> { *self }
+}
+
+/// As `CovariantType`, but for lifetime parameters. Using
+/// `CovariantLifetime<'a>` indicates that it is ok to substitute
+/// a *longer* lifetime for `'a` than the one you originally
+/// started with (e.g., you could convert any lifetime `'foo` to
+/// `'static`). You almost certainly want `ContravariantLifetime`
+/// instead, or possibly `InvariantLifetime`. The only case where
+/// it would be appropriate is that you have a (type-casted, and
+/// hence hidden from the type system) function pointer with a
+/// signature like `fn(&'a T)` (and no other uses of `'a`). In
+/// this case, it is ok to substitute a larger lifetime for `'a`
+/// (e.g., `fn(&'static T)`), because the function is only
+/// becoming more selective in terms of what it accepts as
+/// argument.
+///
+/// For more information about variance, refer to this Wikipedia
+/// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
+#[lang="covariant_lifetime"]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct CovariantLifetime<'a>;
+
+/// As `ContravariantType`, but for lifetime parameters. Using
+/// `ContravariantLifetime<'a>` indicates that it is ok to
+/// substitute a *shorter* lifetime for `'a` than the one you
+/// originally started with (e.g., you could convert `'static` to
+/// any lifetime `'foo`). This is appropriate for cases where you
+/// have an unsafe pointer that is actually a pointer into some
+/// memory with lifetime `'a`, and thus you want to limit the
+/// lifetime of your data structure to `'a`. An example of where
+/// this is used is the iterator for vectors.
+///
+/// For more information about variance, refer to this Wikipedia
+/// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
+#[lang="contravariant_lifetime"]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct ContravariantLifetime<'a>;
+
+/// As `InvariantType`, but for lifetime parameters. Using
+/// `InvariantLifetime<'a>` indicates that it is not ok to
+/// substitute any other lifetime for `'a` besides its original
+/// value. This is appropriate for cases where you have an unsafe
+/// pointer that is actually a pointer into memory with lifetime `'a`,
+/// and this pointer is itself stored in an inherently mutable
+/// location (such as a `Cell`).
+#[lang="invariant_lifetime"]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct InvariantLifetime<'a>;
+
+/// A type which is considered "not sendable", meaning that it cannot
+/// be safely sent between tasks, even if it is owned. This is
+/// typically embedded in other types, such as `Gc`, to ensure that
+/// their instances remain thread-local.
+#[lang="no_send_bound"]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct NoSend;
+
+/// A type which is considered "not POD", meaning that it is not
+/// implicitly copyable. This is typically embedded in other types to
+/// ensure that they are never copied, even if they lack a destructor.
+#[lang="no_copy_bound"]
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
+#[allow(missing_copy_implementations)]
+pub struct NoCopy;
+
+/// A type which is considered "not sync", meaning that
+/// its contents are not threadsafe, hence they cannot be
+/// shared between tasks.
+#[lang="no_sync_bound"]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct NoSync;
+
+/// A type which is considered managed by the GC. This is typically
+/// embedded in other types.
+#[lang="managed_bound"]
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
+#[allow(missing_copy_implementations)]
+pub struct Managed;
diff --git a/src/libcore/mem.rs b/src/libcore/mem.rs
index c6056916121..24cb649ce55 100644
--- a/src/libcore/mem.rs
+++ b/src/libcore/mem.rs
@@ -15,7 +15,7 @@
 
 #![stable]
 
-use kinds::Sized;
+use markers::Sized;
 use intrinsics;
 use ptr;
 
diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs
index 192d6063f6b..25833741024 100644
--- a/src/libcore/num/mod.rs
+++ b/src/libcore/num/mod.rs
@@ -21,7 +21,7 @@ use cmp::{PartialEq, Eq};
 use cmp::{PartialOrd, Ord};
 use intrinsics;
 use iter::IteratorExt;
-use kinds::Copy;
+use markers::Copy;
 use mem::size_of;
 use ops::{Add, Sub, Mul, Div, Rem, Neg};
 use ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr};
@@ -992,7 +992,7 @@ impl_to_primitive_float! { f64 }
 
 /// A generic trait for converting a number to a value.
 #[experimental = "trait is likely to be removed"]
-pub trait FromPrimitive : ::kinds::Sized {
+pub trait FromPrimitive : ::markers::Sized {
     /// Convert an `int` to return an optional value of this type. If the
     /// value cannot be represented by this value, the `None` is returned.
     #[inline]
diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs
index 97d94e73bb3..287a725a33c 100644
--- a/src/libcore/ops.rs
+++ b/src/libcore/ops.rs
@@ -63,7 +63,7 @@
 
 use clone::Clone;
 use iter::{Step, Iterator,DoubleEndedIterator,ExactSizeIterator};
-use kinds::Sized;
+use markers::Sized;
 use option::Option::{self, Some, None};
 
 /// The `Drop` trait is used to run some code when a value goes out of scope. This
diff --git a/src/libcore/prelude.rs b/src/libcore/prelude.rs
index e88cb73c8a9..558e451ee8c 100644
--- a/src/libcore/prelude.rs
+++ b/src/libcore/prelude.rs
@@ -29,7 +29,7 @@
 //! ```
 
 // Reexported core operators
-pub use kinds::{Copy, Send, Sized, Sync};
+pub use markers::{Copy, Send, Sized, Sync};
 pub use ops::{Drop, Fn, FnMut, FnOnce};
 
 // Reexported functions
diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs
index 0b77f3456b2..40c7d60a205 100644
--- a/src/libcore/ptr.rs
+++ b/src/libcore/ptr.rs
@@ -92,7 +92,7 @@ use mem;
 use clone::Clone;
 use intrinsics;
 use option::Option::{self, Some, None};
-use kinds::{Send, Sized, Sync};
+use markers::{Send, Sized, Sync};
 
 use cmp::{PartialEq, Eq, Ord, PartialOrd};
 use cmp::Ordering::{self, Less, Equal, Greater};
diff --git a/src/libcore/raw.rs b/src/libcore/raw.rs
index 5ef6f6b2623..57f1706dc43 100644
--- a/src/libcore/raw.rs
+++ b/src/libcore/raw.rs
@@ -18,7 +18,7 @@
 //!
 //! Their definition should always match the ABI defined in `rustc::back::abi`.
 
-use kinds::Copy;
+use markers::Copy;
 use mem;
 
 /// The representation of a Rust slice
diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs
index 093ed0b242f..e4a15d38535 100644
--- a/src/libcore/slice.rs
+++ b/src/libcore/slice.rs
@@ -41,7 +41,7 @@ use cmp::Ordering::{Less, Equal, Greater};
 use cmp;
 use default::Default;
 use iter::*;
-use kinds::Copy;
+use markers::Copy;
 use num::Int;
 use ops::{FnMut, self};
 use option::Option;
@@ -52,7 +52,7 @@ use ptr;
 use ptr::PtrExt;
 use mem;
 use mem::size_of;
-use kinds::{Sized, marker};
+use markers::{Sized, self};
 use raw::Repr;
 // Avoid conflicts with *both* the Slice trait (buggy) and the `slice::raw` module.
 use raw::Slice as RawSlice;
@@ -169,11 +169,11 @@ impl<T> SliceExt for [T] {
             if mem::size_of::<T>() == 0 {
                 Iter {ptr: p,
                       end: (p as uint + self.len()) as *const T,
-                      marker: marker::ContravariantLifetime::<'a>}
+                      marker: markers::ContravariantLifetime::<'a>}
             } else {
                 Iter {ptr: p,
                       end: p.offset(self.len() as int),
-                      marker: marker::ContravariantLifetime::<'a>}
+                      marker: markers::ContravariantLifetime::<'a>}
             }
         }
     }
@@ -322,11 +322,11 @@ impl<T> SliceExt for [T] {
             if mem::size_of::<T>() == 0 {
                 IterMut {ptr: p,
                          end: (p as uint + self.len()) as *mut T,
-                         marker: marker::ContravariantLifetime::<'a>}
+                         marker: markers::ContravariantLifetime::<'a>}
             } else {
                 IterMut {ptr: p,
                          end: p.offset(self.len() as int),
-                         marker: marker::ContravariantLifetime::<'a>}
+                         marker: markers::ContravariantLifetime::<'a>}
             }
         }
     }
@@ -734,7 +734,7 @@ macro_rules! make_slice {
 pub struct Iter<'a, T: 'a> {
     ptr: *const T,
     end: *const T,
-    marker: marker::ContravariantLifetime<'a>
+    marker: markers::ContravariantLifetime<'a>
 }
 
 #[experimental]
@@ -809,7 +809,7 @@ impl<'a, T> RandomAccessIterator for Iter<'a, T> {
 pub struct IterMut<'a, T: 'a> {
     ptr: *mut T,
     end: *mut T,
-    marker: marker::ContravariantLifetime<'a>,
+    marker: markers::ContravariantLifetime<'a>,
 }
 
 #[experimental]
diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs
index a39787b8207..f1f3cabb66b 100644
--- a/src/libcore/str/mod.rs
+++ b/src/libcore/str/mod.rs
@@ -23,7 +23,7 @@ use default::Default;
 use iter::range;
 use iter::ExactSizeIterator;
 use iter::{Map, Iterator, IteratorExt, DoubleEndedIterator};
-use kinds::Sized;
+use markers::Sized;
 use mem;
 use num::Int;
 use ops::{Fn, FnMut};
diff --git a/src/libcore/ty.rs b/src/libcore/ty.rs
index f8e03662b00..9de3cf30dc9 100644
--- a/src/libcore/ty.rs
+++ b/src/libcore/ty.rs
@@ -10,4 +10,4 @@
 
 //! Types dealing with unsafe actions.
 
-use kinds::marker;
+use markers;
diff --git a/src/libcoretest/hash/mod.rs b/src/libcoretest/hash/mod.rs
index a4bafe754ff..3af38f9035d 100644
--- a/src/libcoretest/hash/mod.rs
+++ b/src/libcoretest/hash/mod.rs
@@ -7,7 +7,7 @@
 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
-use core::kinds::Sized;
+use core::markers::Sized;
 use std::mem;
 
 use core::slice::SliceExt;
diff --git a/src/libcoretest/num/mod.rs b/src/libcoretest/num/mod.rs
index f86c85f8216..57e0737e909 100644
--- a/src/libcoretest/num/mod.rs
+++ b/src/libcoretest/num/mod.rs
@@ -12,7 +12,7 @@ use core::cmp::PartialEq;
 use core::fmt::Show;
 use core::num::{NumCast, cast};
 use core::ops::{Add, Sub, Mul, Div, Rem};
-use core::kinds::Copy;
+use core::markers::Copy;
 
 #[cfg_attr(stage0, macro_escape)]
 #[cfg_attr(not(stage0), macro_use)]
diff --git a/src/libcoretest/option.rs b/src/libcoretest/option.rs
index 4a459992098..5588fbce26a 100644
--- a/src/libcoretest/option.rs
+++ b/src/libcoretest/option.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use core::option::*;
-use core::kinds::marker;
+use core::markers;
 use core::mem;
 use core::clone::Clone;
 
@@ -82,7 +82,7 @@ fn test_option_dance() {
 
 #[test] #[should_fail]
 fn test_option_too_much_dance() {
-    let mut y = Some(marker::NoCopy);
+    let mut y = Some(markers::NoCopy);
     let _y2 = y.take().unwrap();
     let _y3 = y.take().unwrap();
 }
diff --git a/src/liblibc/lib.rs b/src/liblibc/lib.rs
index e3f02146a75..4255114243c 100644
--- a/src/liblibc/lib.rs
+++ b/src/liblibc/lib.rs
@@ -5081,5 +5081,7 @@ pub fn issue_14344_workaround() {} // FIXME #14344 force linkage to happen corre
 #[doc(hidden)]
 #[cfg(not(test))]
 mod std {
-    pub use core::kinds;
+    #[cfg(stage0)]
+    pub use core::markers as kinds;
+    pub use core::markers;
 }
diff --git a/src/librand/lib.rs b/src/librand/lib.rs
index c4dd08f9917..9e900fcb3db 100644
--- a/src/librand/lib.rs
+++ b/src/librand/lib.rs
@@ -516,7 +516,9 @@ pub struct Closed01<F>(pub F);
 mod std {
     pub use core::{option, fmt}; // panic!()
     pub use core::clone; // derive Clone
-    pub use core::kinds;
+    #[cfg(stage0)]
+    pub use core::markers as kinds;
+    pub use core::markers;
 }
 
 #[cfg(test)]
diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs
index df2a4e4c253..780e3da4684 100644
--- a/src/librustc/middle/expr_use_visitor.rs
+++ b/src/librustc/middle/expr_use_visitor.rs
@@ -29,7 +29,7 @@ use middle::ty::{MethodOrigin, MethodParam, MethodTypeParam};
 use middle::ty::{MethodStatic, MethodStaticUnboxedClosure};
 use util::ppaux::Repr;
 
-use std::kinds;
+use std::markers;
 use syntax::{ast, ast_util};
 use syntax::ptr::P;
 use syntax::codemap::Span;
@@ -135,7 +135,7 @@ enum TrackMatchMode<T> {
     Conflicting,
 }
 
-impl<T> kinds::Copy for TrackMatchMode<T> {}
+impl<T> markers::Copy for TrackMatchMode<T> {}
 
 impl<T> TrackMatchMode<T> {
     // Builds up the whole match mode for a pattern from its constituent
diff --git a/src/librustc/middle/infer/unify.rs b/src/librustc/middle/infer/unify.rs
index 73da9644593..b73142b4051 100644
--- a/src/librustc/middle/infer/unify.rs
+++ b/src/librustc/middle/infer/unify.rs
@@ -10,7 +10,7 @@
 
 pub use self::VarValue::*;
 
-use std::kinds::marker;
+use std::markers;
 
 use middle::ty::{expected_found, IntVarValue};
 use middle::ty::{self, Ty};
@@ -78,7 +78,7 @@ pub struct UnificationTable<K,V> {
 /// made during the snapshot may either be *committed* or *rolled back*.
 pub struct Snapshot<K> {
     // Link snapshot to the key type `K` of the table.
-    marker: marker::CovariantType<K>,
+    marker: markers::CovariantType<K>,
     snapshot: sv::Snapshot,
 }
 
@@ -108,7 +108,7 @@ impl<'tcx, V:PartialEq+Clone+Repr<'tcx>, K:UnifyKey<'tcx, V>> UnificationTable<K
     /// Starts a new snapshot. Each snapshot must be either
     /// rolled back or committed in a "LIFO" (stack) order.
     pub fn snapshot(&mut self) -> Snapshot<K> {
-        Snapshot { marker: marker::CovariantType::<K>,
+        Snapshot { marker: markers::CovariantType::<K>,
                    snapshot: self.values.start_snapshot() }
     }
 
diff --git a/src/librustc_typeck/variance.rs b/src/librustc_typeck/variance.rs
index e58c2275fcd..62c46c435bc 100644
--- a/src/librustc_typeck/variance.rs
+++ b/src/librustc_typeck/variance.rs
@@ -402,8 +402,8 @@ impl<'a, 'tcx, 'v> Visitor<'v> for TermsContext<'a, 'tcx> {
 struct ConstraintContext<'a, 'tcx: 'a> {
     terms_cx: TermsContext<'a, 'tcx>,
 
-    // These are the def-id of the std::kinds::marker::InvariantType,
-    // std::kinds::marker::InvariantLifetime, and so on. The arrays
+    // These are the def-id of the std::markers::InvariantType,
+    // std::markers::InvariantLifetime, and so on. The arrays
     // are indexed by the `ParamKind` (type, lifetime, self). Note
     // that there are no marker types for self, so the entries for
     // self are always None.
diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs
index a3fc38c34e8..ce9857f8243 100644
--- a/src/libstd/collections/hash/map.rs
+++ b/src/libstd/collections/hash/map.rs
@@ -21,7 +21,7 @@ use default::Default;
 use fmt::{self, Show};
 use hash::{Hash, Hasher, RandomSipHasher};
 use iter::{self, Iterator, IteratorExt, FromIterator, Extend, Map};
-use kinds::Sized;
+use markers::Sized;
 use mem::{self, replace};
 use num::{Int, UnsignedInt};
 use ops::{Deref, FnMut, Index, IndexMut};
diff --git a/src/libstd/collections/hash/set.rs b/src/libstd/collections/hash/set.rs
index 211bfe2c10e..d67581a12b3 100644
--- a/src/libstd/collections/hash/set.rs
+++ b/src/libstd/collections/hash/set.rs
@@ -13,7 +13,7 @@
 use borrow::BorrowFrom;
 use clone::Clone;
 use cmp::{Eq, PartialEq};
-use core::kinds::Sized;
+use core::markers::Sized;
 use default::Default;
 use fmt::Show;
 use fmt;
diff --git a/src/libstd/collections/hash/table.rs b/src/libstd/collections/hash/table.rs
index 1eb4408eedc..cdfde1958c6 100644
--- a/src/libstd/collections/hash/table.rs
+++ b/src/libstd/collections/hash/table.rs
@@ -16,7 +16,7 @@ use clone::Clone;
 use cmp;
 use hash::{Hash, Hasher};
 use iter::{Iterator, count};
-use kinds::{Copy, Sized, marker};
+use markers::{Copy, Sized, self};
 use mem::{min_align_of, size_of};
 use mem;
 use num::{Int, UnsignedInt};
@@ -72,7 +72,7 @@ pub struct RawTable<K, V> {
     hashes:   Unique<u64>,
     // Because K/V do not appear directly in any of the types in the struct,
     // inform rustc that in fact instances of K and V are reachable from here.
-    marker:   marker::CovariantType<(K,V)>,
+    marker:   markers::CovariantType<(K,V)>,
 }
 
 struct RawBucket<K, V> {
@@ -562,7 +562,7 @@ impl<K, V> RawTable<K, V> {
                 size: 0,
                 capacity: 0,
                 hashes: Unique::null(),
-                marker: marker::CovariantType,
+                marker: markers::CovariantType,
             };
         }
         // No need for `checked_mul` before a more restrictive check performed
@@ -601,7 +601,7 @@ impl<K, V> RawTable<K, V> {
             capacity: capacity,
             size:     0,
             hashes:   Unique(hashes),
-            marker:   marker::CovariantType,
+            marker:   markers::CovariantType,
         }
     }
 
@@ -651,7 +651,7 @@ impl<K, V> RawTable<K, V> {
             hashes_end: unsafe {
                 self.hashes.0.offset(self.capacity as int)
             },
-            marker: marker::ContravariantLifetime,
+            marker: markers::ContravariantLifetime,
         }
     }
 
@@ -676,7 +676,7 @@ impl<K, V> RawTable<K, V> {
             iter: RawBuckets {
                 raw: raw,
                 hashes_end: hashes_end,
-                marker: marker::ContravariantLifetime,
+                marker: markers::ContravariantLifetime,
             },
             table: self,
         }
@@ -689,7 +689,7 @@ impl<K, V> RawTable<K, V> {
             iter: RawBuckets {
                 raw: raw,
                 hashes_end: hashes_end,
-                marker: marker::ContravariantLifetime::<'static>,
+                marker: markers::ContravariantLifetime::<'static>,
             },
             table: self,
         }
@@ -703,7 +703,7 @@ impl<K, V> RawTable<K, V> {
             raw: raw_bucket.offset(self.capacity as int),
             hashes_end: raw_bucket.hash,
             elems_left: self.size,
-            marker:     marker::ContravariantLifetime,
+            marker:     markers::ContravariantLifetime,
         }
     }
 }
@@ -713,7 +713,7 @@ impl<K, V> RawTable<K, V> {
 struct RawBuckets<'a, K, V> {
     raw: RawBucket<K, V>,
     hashes_end: *mut u64,
-    marker: marker::ContravariantLifetime<'a>,
+    marker: markers::ContravariantLifetime<'a>,
 }
 
 // FIXME(#19839) Remove in favor of `#[derive(Clone)]`
@@ -722,7 +722,7 @@ impl<'a, K, V> Clone for RawBuckets<'a, K, V> {
         RawBuckets {
             raw: self.raw,
             hashes_end: self.hashes_end,
-            marker: marker::ContravariantLifetime,
+            marker: markers::ContravariantLifetime,
         }
     }
 }
@@ -754,7 +754,7 @@ struct RevMoveBuckets<'a, K, V> {
     raw: RawBucket<K, V>,
     hashes_end: *mut u64,
     elems_left: uint,
-    marker: marker::ContravariantLifetime<'a>,
+    marker: markers::ContravariantLifetime<'a>,
 }
 
 impl<'a, K, V> Iterator for RevMoveBuckets<'a, K, V> {
diff --git a/src/libstd/hash.rs b/src/libstd/hash.rs
index ac2b01e995e..34facdc7de6 100644
--- a/src/libstd/hash.rs
+++ b/src/libstd/hash.rs
@@ -63,7 +63,7 @@
 
 pub use core::hash::{Hash, Hasher, Writer, hash, sip};
 
-use core::kinds::Sized;
+use core::markers::Sized;
 use default::Default;
 use rand::Rng;
 use rand;
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 5bef473db99..deae56d8a30 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -232,7 +232,7 @@ use error::{FromError, Error};
 use fmt;
 use int;
 use iter::{Iterator, IteratorExt};
-use kinds::Sized;
+use markers::Sized;
 use mem::transmute;
 use ops::FnOnce;
 use option::Option;
diff --git a/src/libstd/io/stdio.rs b/src/libstd/io/stdio.rs
index f571bed3ba2..43d37543e16 100644
--- a/src/libstd/io/stdio.rs
+++ b/src/libstd/io/stdio.rs
@@ -34,7 +34,7 @@ use failure::LOCAL_STDERR;
 use fmt;
 use io::{Reader, Writer, IoResult, IoError, OtherIoError, Buffer,
          standard_error, EndOfFile, LineBufferedWriter, BufferedReader};
-use kinds::{Sync, Send};
+use markers::{Sync, Send};
 use libc;
 use mem;
 use option::Option;
diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
index b9f226c5aca..b258c13f12e 100644
--- a/src/libstd/lib.rs
+++ b/src/libstd/lib.rs
@@ -18,7 +18,7 @@
 //!
 //! The [`ptr`](ptr/index.html) and [`mem`](mem/index.html)
 //! modules deal with unsafe pointers and memory manipulation.
-//! [`kinds`](kinds/index.html) defines the special built-in traits,
+//! [`markers`](markers/index.html) defines the special built-in traits,
 //! and [`raw`](raw/index.html) the runtime representation of Rust types.
 //! These are some of the lowest-level building blocks in Rust.
 //!
@@ -151,7 +151,7 @@ extern crate libc;
 
 // Make std testable by not duplicating lang items. See #2912
 #[cfg(test)] extern crate "std" as realstd;
-#[cfg(test)] pub use realstd::kinds;
+#[cfg(test)] pub use realstd::markers;
 #[cfg(test)] pub use realstd::ops;
 #[cfg(test)] pub use realstd::cmp;
 #[cfg(test)] pub use realstd::boxed;
@@ -168,7 +168,8 @@ pub use core::default;
 pub use core::finally;
 pub use core::intrinsics;
 pub use core::iter;
-#[cfg(not(test))] pub use core::kinds;
+#[cfg(stage0)] #[cfg(not(test))] pub use core::markers as kinds;
+#[cfg(not(test))] pub use core::markers;
 pub use core::mem;
 #[cfg(not(test))] pub use core::ops;
 pub use core::ptr;
@@ -311,7 +312,9 @@ mod std {
     pub use vec; // used for vec![]
     pub use cell; // used for tls!
     pub use thread_local; // used for thread_local!
-    pub use kinds; // used for tls!
+    #[cfg(stage0)]
+    pub use markers as kinds;
+    pub use markers;  // used for tls!
     pub use ops; // used for bitflags!
 
     // The test runner calls ::std::os::args() but really wants realstd
diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs
index e3402984ae5..cd78489cb85 100644
--- a/src/libstd/num/mod.rs
+++ b/src/libstd/num/mod.rs
@@ -19,7 +19,7 @@
 #[cfg(test)] use fmt::Show;
 use ops::{Add, Sub, Mul, Div, Rem, Neg};
 
-use kinds::Copy;
+use markers::Copy;
 use clone::Clone;
 use cmp::{PartialOrd, PartialEq};
 
diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index 300ceec4b45..0e41d608086 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -37,7 +37,7 @@ use error::{FromError, Error};
 use fmt;
 use io::{IoResult, IoError};
 use iter::{Iterator, IteratorExt};
-use kinds::Copy;
+use markers::Copy;
 use libc::{c_void, c_int, c_char};
 use libc;
 use boxed::Box;
diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs
index b020164158c..e263761acd1 100644
--- a/src/libstd/path/mod.rs
+++ b/src/libstd/path/mod.rs
@@ -61,7 +61,7 @@
 
 #![experimental]
 
-use core::kinds::Sized;
+use core::markers::Sized;
 use ffi::CString;
 use clone::Clone;
 use fmt;
diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs
index d9981ace030..03811364d30 100644
--- a/src/libstd/path/posix.rs
+++ b/src/libstd/path/posix.rs
@@ -16,7 +16,7 @@ use hash;
 use io::Writer;
 use iter::{AdditiveIterator, Extend};
 use iter::{Iterator, IteratorExt, Map};
-use kinds::Sized;
+use markers::Sized;
 use option::Option::{self, Some, None};
 use slice::{AsSlice, Split, SliceExt, SliceConcatExt};
 use str::{self, FromStr, StrExt};
diff --git a/src/libstd/prelude/v1.rs b/src/libstd/prelude/v1.rs
index 9e9a483e1a5..bf8d2a3d63b 100644
--- a/src/libstd/prelude/v1.rs
+++ b/src/libstd/prelude/v1.rs
@@ -13,7 +13,7 @@
 #![stable]
 
 // Reexported core operators
-#[stable] #[doc(no_inline)] pub use kinds::{Copy, Send, Sized, Sync};
+#[stable] #[doc(no_inline)] pub use markers::{Copy, Send, Sized, Sync};
 #[stable] #[doc(no_inline)] pub use ops::{Drop, Fn, FnMut, FnOnce};
 
 // Reexported functions
diff --git a/src/libstd/rand/os.rs b/src/libstd/rand/os.rs
index a79a6e35ebc..512bd2a3d6e 100644
--- a/src/libstd/rand/os.rs
+++ b/src/libstd/rand/os.rs
@@ -185,7 +185,7 @@ mod imp {
     extern crate libc;
 
     use io::{IoResult};
-    use kinds::Sync;
+    use markers::Sync;
     use mem;
     use os;
     use rand::Rng;
diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs
index e556888a470..036bb7b637b 100644
--- a/src/libstd/rt/mod.rs
+++ b/src/libstd/rt/mod.rs
@@ -23,7 +23,7 @@
 
 #![allow(dead_code)]
 
-use kinds::Send;
+use markers::Send;
 use ops::FnOnce;
 use sys;
 use thunk::Thunk;
diff --git a/src/libstd/sync/mpsc/blocking.rs b/src/libstd/sync/mpsc/blocking.rs
index faff5f09f81..af6aa803f99 100644
--- a/src/libstd/sync/mpsc/blocking.rs
+++ b/src/libstd/sync/mpsc/blocking.rs
@@ -13,8 +13,8 @@
 use thread::Thread;
 use sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT, Ordering};
 use sync::Arc;
-use kinds::{Sync, Send};
-use kinds::marker::{NoSend, NoSync};
+use markers::{Sync, Send};
+use markers::{NoSend, NoSync};
 use mem;
 use clone::Clone;
 
diff --git a/src/libstd/sync/mpsc/mod.rs b/src/libstd/sync/mpsc/mod.rs
index 7c18b8a43fa..4d18d9e6e9d 100644
--- a/src/libstd/sync/mpsc/mod.rs
+++ b/src/libstd/sync/mpsc/mod.rs
@@ -319,7 +319,7 @@ use prelude::v1::*;
 
 use sync::Arc;
 use fmt;
-use kinds::marker;
+use markers;
 use mem;
 use cell::UnsafeCell;
 
@@ -373,7 +373,7 @@ unsafe impl<T:Send> Send for Sender<T> { }
 pub struct SyncSender<T> {
     inner: Arc<RacyCell<sync::Packet<T>>>,
     // can't share in an arc
-    _marker: marker::NoSync,
+    _marker: markers::NoSync,
 }
 
 /// An error returned from the `send` function on channels.
@@ -678,7 +678,7 @@ impl<T: Send> Drop for Sender<T> {
 
 impl<T: Send> SyncSender<T> {
     fn new(inner: Arc<RacyCell<sync::Packet<T>>>) -> SyncSender<T> {
-        SyncSender { inner: inner, _marker: marker::NoSync }
+        SyncSender { inner: inner, _marker: markers::NoSync }
     }
 
     /// Sends a value on this synchronous channel.
diff --git a/src/libstd/sync/mpsc/select.rs b/src/libstd/sync/mpsc/select.rs
index 16adbf5aa4f..ca7120b5ead 100644
--- a/src/libstd/sync/mpsc/select.rs
+++ b/src/libstd/sync/mpsc/select.rs
@@ -57,7 +57,7 @@
 use core::prelude::*;
 
 use core::cell::Cell;
-use core::kinds::marker;
+use core::markers;
 use core::mem;
 use core::uint;
 
@@ -70,7 +70,7 @@ pub struct Select {
     head: *mut Handle<'static, ()>,
     tail: *mut Handle<'static, ()>,
     next_id: Cell<uint>,
-    marker1: marker::NoSend,
+    marker1: markers::NoSend,
 }
 
 /// A handle to a receiver which is currently a member of a `Select` set of
@@ -115,7 +115,7 @@ impl Select {
     /// rather much easier through the `select!` macro.
     pub fn new() -> Select {
         Select {
-            marker1: marker::NoSend,
+            marker1: markers::NoSend,
             head: 0 as *mut Handle<'static, ()>,
             tail: 0 as *mut Handle<'static, ()>,
             next_id: Cell::new(1),
diff --git a/src/libstd/sync/mutex.rs b/src/libstd/sync/mutex.rs
index 6b3dd89f33b..bb5a6337646 100644
--- a/src/libstd/sync/mutex.rs
+++ b/src/libstd/sync/mutex.rs
@@ -11,7 +11,7 @@
 use prelude::v1::*;
 
 use cell::UnsafeCell;
-use kinds::marker;
+use markers;
 use ops::{Deref, DerefMut};
 use sync::poison::{self, TryLockError, TryLockResult, LockResult};
 use sys_common::mutex as sys;
@@ -166,7 +166,7 @@ pub struct MutexGuard<'a, T: 'a> {
     __lock: &'a StaticMutex,
     __data: &'a UnsafeCell<T>,
     __poison: poison::Guard,
-    __marker: marker::NoSend,
+    __marker: markers::NoSend,
 }
 
 /// Static initialization of a mutex. This constant can be used to initialize
@@ -286,7 +286,7 @@ impl<'mutex, T> MutexGuard<'mutex, T> {
                 __lock: lock,
                 __data: data,
                 __poison: guard,
-                __marker: marker::NoSend,
+                __marker: markers::NoSend,
             }
         })
     }
diff --git a/src/libstd/sync/once.rs b/src/libstd/sync/once.rs
index aa2d957a3eb..11a5cad2c25 100644
--- a/src/libstd/sync/once.rs
+++ b/src/libstd/sync/once.rs
@@ -14,7 +14,7 @@
 //! example use case would be for initializing an FFI library.
 
 use int;
-use kinds::Sync;
+use markers::Sync;
 use mem::drop;
 use ops::FnOnce;
 use sync::atomic::{AtomicInt, Ordering, ATOMIC_INT_INIT};
diff --git a/src/libstd/sync/rwlock.rs b/src/libstd/sync/rwlock.rs
index 4afd5bb63f4..f40c0cc0c0e 100644
--- a/src/libstd/sync/rwlock.rs
+++ b/src/libstd/sync/rwlock.rs
@@ -11,7 +11,7 @@
 use prelude::v1::*;
 
 use cell::UnsafeCell;
-use kinds::marker;
+use markers;
 use ops::{Deref, DerefMut};
 use sync::poison::{self, LockResult, TryLockError, TryLockResult};
 use sys_common::rwlock as sys;
@@ -113,7 +113,7 @@ pub const RW_LOCK_INIT: StaticRwLock = StaticRwLock {
 pub struct RwLockReadGuard<'a, T: 'a> {
     __lock: &'a StaticRwLock,
     __data: &'a UnsafeCell<T>,
-    __marker: marker::NoSend,
+    __marker: markers::NoSend,
 }
 
 /// RAII structure used to release the exclusive write access of a lock when
@@ -124,7 +124,7 @@ pub struct RwLockWriteGuard<'a, T: 'a> {
     __lock: &'a StaticRwLock,
     __data: &'a UnsafeCell<T>,
     __poison: poison::Guard,
-    __marker: marker::NoSend,
+    __marker: markers::NoSend,
 }
 
 impl<T: Send + Sync> RwLock<T> {
@@ -309,7 +309,7 @@ impl<'rwlock, T> RwLockReadGuard<'rwlock, T> {
             RwLockReadGuard {
                 __lock: lock,
                 __data: data,
-                __marker: marker::NoSend,
+                __marker: markers::NoSend,
             }
         })
     }
@@ -322,7 +322,7 @@ impl<'rwlock, T> RwLockWriteGuard<'rwlock, T> {
                 __lock: lock,
                 __data: data,
                 __poison: guard,
-                __marker: marker::NoSend,
+                __marker: markers::NoSend,
             }
         })
     }
diff --git a/src/libstd/sys/common/mutex.rs b/src/libstd/sys/common/mutex.rs
index 567c26956ef..b86e6ce254a 100644
--- a/src/libstd/sys/common/mutex.rs
+++ b/src/libstd/sys/common/mutex.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use kinds::Sync;
+use markers::Sync;
 use sys::mutex as imp;
 
 /// An OS-based mutual exclusion lock.
diff --git a/src/libstd/sys/unix/c.rs b/src/libstd/sys/unix/c.rs
index ca419d1c7f4..968347bbfbc 100644
--- a/src/libstd/sys/unix/c.rs
+++ b/src/libstd/sys/unix/c.rs
@@ -165,8 +165,8 @@ mod signal {
         sa_restorer: *mut libc::c_void,
     }
 
-    unsafe impl ::kinds::Send for sigaction { }
-    unsafe impl ::kinds::Sync for sigaction { }
+    unsafe impl ::markers::Send for sigaction { }
+    unsafe impl ::markers::Sync for sigaction { }
 
     #[repr(C)]
     #[cfg(target_word_size = "32")]
@@ -217,8 +217,8 @@ mod signal {
         sa_resv: [libc::c_int; 1],
     }
 
-    unsafe impl ::kinds::Send for sigaction { }
-    unsafe impl ::kinds::Sync for sigaction { }
+    unsafe impl ::markers::Send for sigaction { }
+    unsafe impl ::markers::Sync for sigaction { }
 
     #[repr(C)]
     pub struct sigset_t {
diff --git a/src/libstd/sys/unix/mutex.rs b/src/libstd/sys/unix/mutex.rs
index 81f8659d6ae..8da25c7880d 100644
--- a/src/libstd/sys/unix/mutex.rs
+++ b/src/libstd/sys/unix/mutex.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use cell::UnsafeCell;
-use kinds::Sync;
+use markers::Sync;
 use sys::sync as ffi;
 use sys_common::mutex;
 
diff --git a/src/libstd/thread.rs b/src/libstd/thread.rs
index cc82d38ae2a..630087e2291 100644
--- a/src/libstd/thread.rs
+++ b/src/libstd/thread.rs
@@ -128,7 +128,7 @@ use any::Any;
 use boxed::Box;
 use cell::UnsafeCell;
 use clone::Clone;
-use kinds::{Send, Sync};
+use markers::{Send, Sync};
 use ops::{Drop, FnOnce};
 use option::Option::{self, Some, None};
 use result::Result::{Err, Ok};
diff --git a/src/libstd/thread_local/mod.rs b/src/libstd/thread_local/mod.rs
index e0cbaa8ca50..bf01b578b1f 100644
--- a/src/libstd/thread_local/mod.rs
+++ b/src/libstd/thread_local/mod.rs
@@ -346,7 +346,7 @@ mod imp {
         pub dtor_running: UnsafeCell<bool>, // should be Cell
     }
 
-    unsafe impl<T> ::kinds::Sync for Key<T> { }
+    unsafe impl<T> ::markers::Sync for Key<T> { }
 
     #[doc(hidden)]
     impl<T> Key<T> {
@@ -472,7 +472,7 @@ mod imp {
         pub os: OsStaticKey,
     }
 
-    unsafe impl<T> ::kinds::Sync for Key<T> { }
+    unsafe impl<T> ::markers::Sync for Key<T> { }
 
     struct Value<T: 'static> {
         key: &'static Key<T>,
diff --git a/src/libstd/thread_local/scoped.rs b/src/libstd/thread_local/scoped.rs
index 714b71d5dbd..a643d2cb8ee 100644
--- a/src/libstd/thread_local/scoped.rs
+++ b/src/libstd/thread_local/scoped.rs
@@ -108,7 +108,7 @@ macro_rules! __scoped_thread_local_inner {
         const _INIT: __Key<$t> = __Key {
             inner: ::std::thread_local::scoped::__impl::KeyInner {
                 inner: ::std::thread_local::scoped::__impl::OS_INIT,
-                marker: ::std::kinds::marker::InvariantType,
+                marker: ::std::markers::InvariantType,
             }
         };
 
@@ -211,7 +211,7 @@ mod imp {
     #[doc(hidden)]
     pub struct KeyInner<T> { pub inner: UnsafeCell<*mut T> }
 
-    unsafe impl<T> ::kinds::Sync for KeyInner<T> { }
+    unsafe impl<T> ::markers::Sync for KeyInner<T> { }
 
     #[doc(hidden)]
     impl<T> KeyInner<T> {
@@ -224,16 +224,16 @@ mod imp {
 
 #[cfg(any(windows, target_os = "android", target_os = "ios", target_arch = "aarch64"))]
 mod imp {
-    use kinds::marker;
+    use markers;
     use sys_common::thread_local::StaticKey as OsStaticKey;
 
     #[doc(hidden)]
     pub struct KeyInner<T> {
         pub inner: OsStaticKey,
-        pub marker: marker::InvariantType<T>,
+        pub marker: markers::InvariantType<T>,
     }
 
-    unsafe impl<T> ::kinds::Sync for KeyInner<T> { }
+    unsafe impl<T> ::markers::Sync for KeyInner<T> { }
 
     #[doc(hidden)]
     impl<T> KeyInner<T> {
diff --git a/src/libstd/thunk.rs b/src/libstd/thunk.rs
index 067926042f1..ec9dd86f941 100644
--- a/src/libstd/thunk.rs
+++ b/src/libstd/thunk.rs
@@ -12,7 +12,7 @@
 #![allow(missing_docs)]
 
 use alloc::boxed::Box;
-use core::kinds::Send;
+use core::markers::Send;
 use core::ops::FnOnce;
 
 pub struct Thunk<A=(),R=()> {
diff --git a/src/libsyntax/ext/deriving/bounds.rs b/src/libsyntax/ext/deriving/bounds.rs
index cf29bb048d6..50c91c13343 100644
--- a/src/libsyntax/ext/deriving/bounds.rs
+++ b/src/libsyntax/ext/deriving/bounds.rs
@@ -47,7 +47,7 @@ pub fn expand_deriving_bound<F>(cx: &mut ExtCtxt,
     let trait_def = TraitDef {
         span: span,
         attributes: Vec::new(),
-        path: Path::new(vec!("std", "kinds", name)),
+        path: Path::new(vec!("std", "markers", name)),
         additional_bounds: Vec::new(),
         generics: LifetimeBounds::empty(),
         methods: vec!()
diff --git a/src/libunicode/tables.rs b/src/libunicode/tables.rs
index c755ea93184..094d45a10d1 100644
--- a/src/libunicode/tables.rs
+++ b/src/libunicode/tables.rs
@@ -7801,7 +7801,7 @@ pub mod charwidth {
 }
 
 pub mod grapheme {
-    use core::kinds::Copy;
+    use core::markers::Copy;
     use core::slice::SliceExt;
     pub use self::GraphemeCat::*;
     use core::result::Result::{Ok, Err};
diff --git a/src/test/compile-fail/associated-types-unsized.rs b/src/test/compile-fail/associated-types-unsized.rs
index db39eafc191..28483abda3c 100644
--- a/src/test/compile-fail/associated-types-unsized.rs
+++ b/src/test/compile-fail/associated-types-unsized.rs
@@ -14,7 +14,7 @@ trait Get {
 }
 
 fn foo<T:Get>(t: T) {
-    let x = t.get(); //~ ERROR the trait `core::kinds::Sized` is not implemented
+    let x = t.get(); //~ ERROR the trait `core::markers::Sized` is not implemented
 }
 
 fn main() {
diff --git a/src/test/compile-fail/bad-method-typaram-kind.rs b/src/test/compile-fail/bad-method-typaram-kind.rs
index cf07dc02b96..33907dc4c46 100644
--- a/src/test/compile-fail/bad-method-typaram-kind.rs
+++ b/src/test/compile-fail/bad-method-typaram-kind.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn foo<T:'static>() {
-    1u.bar::<T>(); //~ ERROR `core::kinds::Send` is not implemented
+    1u.bar::<T>(); //~ ERROR `core::markers::Send` is not implemented
 }
 
 trait bar {
diff --git a/src/test/compile-fail/bad-sized.rs b/src/test/compile-fail/bad-sized.rs
index 4e0ad8088be..6e8fcba8c8a 100644
--- a/src/test/compile-fail/bad-sized.rs
+++ b/src/test/compile-fail/bad-sized.rs
@@ -16,8 +16,8 @@ trait Trait {}
 
 pub fn main() {
     let x: Vec<Trait + Sized> = Vec::new();
-    //~^ ERROR the trait `core::kinds::Sized` is not implemented
-    //~^^ ERROR the trait `core::kinds::Sized` is not implemented
+    //~^ ERROR the trait `core::markers::Sized` is not implemented
+    //~^^ ERROR the trait `core::markers::Sized` is not implemented
     let x: Vec<Box<RefCell<Trait + Sized>>> = Vec::new();
-    //~^ ERROR the trait `core::kinds::Sized` is not implemented
+    //~^ ERROR the trait `core::markers::Sized` is not implemented
 }
diff --git a/src/test/compile-fail/borrowck-move-out-of-static-item.rs b/src/test/compile-fail/borrowck-move-out-of-static-item.rs
index ea36c76ea40..310da28dd49 100644
--- a/src/test/compile-fail/borrowck-move-out-of-static-item.rs
+++ b/src/test/compile-fail/borrowck-move-out-of-static-item.rs
@@ -10,14 +10,14 @@
 
 // Ensure that moves out of static items is forbidden
 
-use std::kinds::marker;
+use std::markers;
 
 struct Foo {
     foo: int,
-    nocopy: marker::NoCopy
+    nocopy: markers::NoCopy
 }
 
-static BAR: Foo = Foo{foo: 5, nocopy: marker::NoCopy};
+static BAR: Foo = Foo{foo: 5, nocopy: markers::NoCopy};
 
 
 fn test(f: Foo) {
diff --git a/src/test/compile-fail/borrowck-struct-update-with-dtor.rs b/src/test/compile-fail/borrowck-struct-update-with-dtor.rs
index 23cd4d80724..36d430ddeaa 100644
--- a/src/test/compile-fail/borrowck-struct-update-with-dtor.rs
+++ b/src/test/compile-fail/borrowck-struct-update-with-dtor.rs
@@ -12,7 +12,7 @@
 // move, when the struct implements Drop.
 
 // NoCopy
-use std::kinds::marker::NoCopy as NP;
+use std::markers::NoCopy as NP;
 
 
 struct S { a: int, np: NP }
diff --git a/src/test/compile-fail/builtin-superkinds-double-superkind.rs b/src/test/compile-fail/builtin-superkinds-double-superkind.rs
index f3b9c395e45..03c1aa2a05d 100644
--- a/src/test/compile-fail/builtin-superkinds-double-superkind.rs
+++ b/src/test/compile-fail/builtin-superkinds-double-superkind.rs
@@ -13,9 +13,9 @@
 
 trait Foo : Send+Sync { }
 
-impl <T: Sync+'static> Foo for (T,) { } //~ ERROR the trait `core::kinds::Send` is not implemented
+impl <T: Sync+'static> Foo for (T,) { } //~ ERROR the trait `core::markers::Send` is not implemented
 
-impl <T: Send> Foo for (T,T) { } //~ ERROR the trait `core::kinds::Sync` is not implemented
+impl <T: Send> Foo for (T,T) { } //~ ERROR the trait `core::markers::Sync` is not implemented
 
 impl <T: Send+Sync> Foo for (T,T,T) { } // (ok)
 
diff --git a/src/test/compile-fail/builtin-superkinds-in-metadata.rs b/src/test/compile-fail/builtin-superkinds-in-metadata.rs
index 76835c9955f..1fa663640d8 100644
--- a/src/test/compile-fail/builtin-superkinds-in-metadata.rs
+++ b/src/test/compile-fail/builtin-superkinds-in-metadata.rs
@@ -22,6 +22,6 @@ struct X<T>(T);
 impl <T:Sync> RequiresShare for X<T> { }
 
 impl <T:Sync+'static> RequiresRequiresShareAndSend for X<T> { }
-//~^ ERROR the trait `core::kinds::Send` is not implemented
+//~^ ERROR the trait `core::markers::Send` is not implemented
 
 fn main() { }
diff --git a/src/test/compile-fail/builtin-superkinds-typaram-not-send.rs b/src/test/compile-fail/builtin-superkinds-typaram-not-send.rs
index e77177f7f6d..2c295768e7a 100644
--- a/src/test/compile-fail/builtin-superkinds-typaram-not-send.rs
+++ b/src/test/compile-fail/builtin-superkinds-typaram-not-send.rs
@@ -12,6 +12,6 @@
 
 trait Foo : Send { }
 
-impl <T: Sync+'static> Foo for T { } //~ ERROR the trait `core::kinds::Send` is not implemented
+impl <T: Sync+'static> Foo for T { } //~ ERROR the trait `core::markers::Send` is not implemented
 
 fn main() { }
diff --git a/src/test/compile-fail/check-static-values-constraints.rs b/src/test/compile-fail/check-static-values-constraints.rs
index 54dccebe699..8b7d2457d3c 100644
--- a/src/test/compile-fail/check-static-values-constraints.rs
+++ b/src/test/compile-fail/check-static-values-constraints.rs
@@ -10,7 +10,7 @@
 
 // Verifies all possible restrictions for statics values.
 
-use std::kinds::marker;
+use std::markers;
 
 struct WithDtor;
 
diff --git a/src/test/compile-fail/comm-not-freeze-receiver.rs b/src/test/compile-fail/comm-not-freeze-receiver.rs
index 2e535b39509..5dce6ba8133 100644
--- a/src/test/compile-fail/comm-not-freeze-receiver.rs
+++ b/src/test/compile-fail/comm-not-freeze-receiver.rs
@@ -13,5 +13,5 @@ use std::sync::mpsc::Receiver;
 fn test<T: Sync>() {}
 
 fn main() {
-    test::<Receiver<int>>();   //~ ERROR: `core::kinds::Sync` is not implemented
+    test::<Receiver<int>>();   //~ ERROR: `core::markers::Sync` is not implemented
 }
diff --git a/src/test/compile-fail/comm-not-freeze.rs b/src/test/compile-fail/comm-not-freeze.rs
index 1b1c43e4793..0f34ccf4a52 100644
--- a/src/test/compile-fail/comm-not-freeze.rs
+++ b/src/test/compile-fail/comm-not-freeze.rs
@@ -13,5 +13,5 @@ use std::sync::mpsc::Sender;
 fn test<T: Sync>() {}
 
 fn main() {
-    test::<Sender<int>>();     //~ ERROR: `core::kinds::Sync` is not implemented
+    test::<Sender<int>>();     //~ ERROR: `core::markers::Sync` is not implemented
 }
diff --git a/src/test/compile-fail/dst-bad-assign-2.rs b/src/test/compile-fail/dst-bad-assign-2.rs
index 5e360b6ab9b..b9c06c60a5d 100644
--- a/src/test/compile-fail/dst-bad-assign-2.rs
+++ b/src/test/compile-fail/dst-bad-assign-2.rs
@@ -43,5 +43,5 @@ pub fn main() {
     let f5: &mut Fat<ToBar> = &mut Fat { f1: 5, f2: "some str", ptr: Bar1 {f :42} };
     let z: Box<ToBar> = box Bar1 {f: 36};
     f5.ptr = *z;
-    //~^ ERROR the trait `core::kinds::Sized` is not implemented
+    //~^ ERROR the trait `core::markers::Sized` is not implemented
 }
diff --git a/src/test/compile-fail/dst-bad-assign.rs b/src/test/compile-fail/dst-bad-assign.rs
index cc709be9900..2516d987455 100644
--- a/src/test/compile-fail/dst-bad-assign.rs
+++ b/src/test/compile-fail/dst-bad-assign.rs
@@ -43,5 +43,5 @@ pub fn main() {
     let f5: &mut Fat<ToBar> = &mut Fat { f1: 5, f2: "some str", ptr: Bar1 {f :42} };
     let z: Box<ToBar> = box Bar1 {f: 36};
     f5.ptr = Bar1 {f: 36}; //~ ERROR mismatched types: expected `ToBar`, found `Bar1`
-    //~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `ToBar`
+    //~^ ERROR the trait `core::markers::Sized` is not implemented for the type `ToBar`
 }
diff --git a/src/test/compile-fail/dst-bad-deep.rs b/src/test/compile-fail/dst-bad-deep.rs
index b169824cb3a..ed2ccc9d9cc 100644
--- a/src/test/compile-fail/dst-bad-deep.rs
+++ b/src/test/compile-fail/dst-bad-deep.rs
@@ -21,5 +21,5 @@ pub fn main() {
     let f: Fat<[int; 3]> = Fat { ptr: [5i, 6, 7] };
     let g: &Fat<[int]> = &f;
     let h: &Fat<Fat<[int]>> = &Fat { ptr: *g };
-    //~^ ERROR the trait `core::kinds::Sized` is not implemented
+    //~^ ERROR the trait `core::markers::Sized` is not implemented
 }
diff --git a/src/test/compile-fail/dst-object-from-unsized-type.rs b/src/test/compile-fail/dst-object-from-unsized-type.rs
index 3c75b5b6edd..b28952d2b33 100644
--- a/src/test/compile-fail/dst-object-from-unsized-type.rs
+++ b/src/test/compile-fail/dst-object-from-unsized-type.rs
@@ -15,22 +15,22 @@ impl Foo for str {}
 
 fn test1<T: ?Sized + Foo>(t: &T) {
     let u: &Foo = t;
-    //~^ ERROR `core::kinds::Sized` is not implemented for the type `T`
+    //~^ ERROR `core::markers::Sized` is not implemented for the type `T`
 }
 
 fn test2<T: ?Sized + Foo>(t: &T) {
     let v: &Foo = t as &Foo;
-    //~^ ERROR `core::kinds::Sized` is not implemented for the type `T`
+    //~^ ERROR `core::markers::Sized` is not implemented for the type `T`
 }
 
 fn test3() {
     let _: &[&Foo] = &["hi"];
-    //~^ ERROR `core::kinds::Sized` is not implemented for the type `str`
+    //~^ ERROR `core::markers::Sized` is not implemented for the type `str`
 }
 
 fn test4() {
     let _: &Foo = "hi" as &Foo;
-    //~^ ERROR `core::kinds::Sized` is not implemented for the type `str`
+    //~^ ERROR `core::markers::Sized` is not implemented for the type `str`
 }
 
 fn main() { }
diff --git a/src/test/compile-fail/dst-sized-trait-param.rs b/src/test/compile-fail/dst-sized-trait-param.rs
index ea5becbf229..af0b780b3b7 100644
--- a/src/test/compile-fail/dst-sized-trait-param.rs
+++ b/src/test/compile-fail/dst-sized-trait-param.rs
@@ -15,9 +15,9 @@
 trait Foo<T> : Sized { fn take(self, x: &T) { } } // Note: T is sized
 
 impl Foo<[int]> for uint { }
-//~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `[int]`
+//~^ ERROR the trait `core::markers::Sized` is not implemented for the type `[int]`
 
 impl Foo<int> for [uint] { }
-//~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `[uint]`
+//~^ ERROR the trait `core::markers::Sized` is not implemented for the type `[uint]`
 
 pub fn main() { }
diff --git a/src/test/compile-fail/error-should-say-copy-not-pod.rs b/src/test/compile-fail/error-should-say-copy-not-pod.rs
index 3d25c7ee772..581a06db745 100644
--- a/src/test/compile-fail/error-should-say-copy-not-pod.rs
+++ b/src/test/compile-fail/error-should-say-copy-not-pod.rs
@@ -13,5 +13,5 @@
 fn check_bound<T:Copy>(_: T) {}
 
 fn main() {
-    check_bound("nocopy".to_string()); //~ ERROR the trait `core::kinds::Copy` is not implemented
+    check_bound("nocopy".to_string()); //~ ERROR the trait `core::markers::Copy` is not implemented
 }
diff --git a/src/test/compile-fail/issue-14366.rs b/src/test/compile-fail/issue-14366.rs
index d03885ca713..d9b8c4db031 100644
--- a/src/test/compile-fail/issue-14366.rs
+++ b/src/test/compile-fail/issue-14366.rs
@@ -10,5 +10,5 @@
 
 fn main() {
     let _x = "test" as &::std::any::Any;
-//~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `str`
+//~^ ERROR the trait `core::markers::Sized` is not implemented for the type `str`
 }
diff --git a/src/test/compile-fail/issue-15756.rs b/src/test/compile-fail/issue-15756.rs
index 5be3b960ec6..5e305313fcf 100644
--- a/src/test/compile-fail/issue-15756.rs
+++ b/src/test/compile-fail/issue-15756.rs
@@ -15,7 +15,7 @@ fn dft_iter<'a, T>(arg1: Chunks<'a,T>, arg2: ChunksMut<'a,T>)
 {
     for
     &something
-//~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `[T]`
+//~^ ERROR the trait `core::markers::Sized` is not implemented for the type `[T]`
     in arg2
     {
     }
diff --git a/src/test/compile-fail/issue-16538.rs b/src/test/compile-fail/issue-16538.rs
index 0e022834bac..505a59b484d 100644
--- a/src/test/compile-fail/issue-16538.rs
+++ b/src/test/compile-fail/issue-16538.rs
@@ -20,6 +20,6 @@ mod Y {
 
 static foo: *const Y::X = Y::foo(Y::x as *const Y::X);
 //~^ ERROR cannot refer to other statics by value
-//~| ERROR: the trait `core::kinds::Sync` is not implemented for the type
+//~| ERROR: the trait `core::markers::Sync` is not implemented for the type
 
 fn main() {}
diff --git a/src/test/compile-fail/issue-17718-static-move.rs b/src/test/compile-fail/issue-17718-static-move.rs
index c57df9a3af4..730344f5763 100644
--- a/src/test/compile-fail/issue-17718-static-move.rs
+++ b/src/test/compile-fail/issue-17718-static-move.rs
@@ -8,10 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::kinds::marker;
+use std::markers;
 
-struct Foo { nc: marker::NoCopy }
-const INIT: Foo = Foo { nc: marker::NoCopy };
+struct Foo { nc: markers::NoCopy }
+const INIT: Foo = Foo { nc: markers::NoCopy };
 static FOO: Foo = INIT;
 
 fn main() {
diff --git a/src/test/compile-fail/issue-17718-static-sync.rs b/src/test/compile-fail/issue-17718-static-sync.rs
index 63a40e2374b..da343cc81ac 100644
--- a/src/test/compile-fail/issue-17718-static-sync.rs
+++ b/src/test/compile-fail/issue-17718-static-sync.rs
@@ -8,12 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::kinds::marker;
+use std::markers;
 
-struct Foo { marker: marker::NoSync }
+struct Foo { marker: markers::NoSync }
 
 static FOO: uint = 3;
-static BAR: Foo = Foo { marker: marker::NoSync };
-//~^ ERROR: the trait `core::kinds::Sync` is not implemented
+static BAR: Foo = Foo { marker: markers::NoSync };
+//~^ ERROR: the trait `core::markers::Sync` is not implemented
 
 fn main() {}
diff --git a/src/test/compile-fail/issue-18107.rs b/src/test/compile-fail/issue-18107.rs
index 6cebf7f9da1..a17b2ee0c68 100644
--- a/src/test/compile-fail/issue-18107.rs
+++ b/src/test/compile-fail/issue-18107.rs
@@ -14,7 +14,7 @@ pub trait AbstractRenderer {}
 
 fn _create_render(_: &()) ->
     AbstractRenderer
-//~^ ERROR: the trait `core::kinds::Sized` is not implemented
+//~^ ERROR: the trait `core::markers::Sized` is not implemented
 {
     match 0u {
         _ => unimplemented!()
diff --git a/src/test/compile-fail/issue-19883.rs b/src/test/compile-fail/issue-19883.rs
index 70fe6b9b6a8..b9fbc37828f 100644
--- a/src/test/compile-fail/issue-19883.rs
+++ b/src/test/compile-fail/issue-19883.rs
@@ -18,13 +18,13 @@ trait To {
     // This is a typo, the return type should be `<Dst as From<Self>>::Output`
     fn to<Dst: From<Self>>(
         self
-        //~^ error: the trait `core::kinds::Sized` is not implemented
+        //~^ error: the trait `core::markers::Sized` is not implemented
     ) ->
         <Dst as From<Self>>::Dst
-        //~^ error: the trait `core::kinds::Sized` is not implemented
+        //~^ error: the trait `core::markers::Sized` is not implemented
     {
         From::from(
-            //~^ error: the trait `core::kinds::Sized` is not implemented
+            //~^ error: the trait `core::markers::Sized` is not implemented
             self
         )
     }
diff --git a/src/test/compile-fail/issue-20005.rs b/src/test/compile-fail/issue-20005.rs
index b52f2b1b138..8076df39db9 100644
--- a/src/test/compile-fail/issue-20005.rs
+++ b/src/test/compile-fail/issue-20005.rs
@@ -16,9 +16,9 @@ trait From<Src> {
 
 trait To {
     fn to<Dst>(
-        self //~ error: the trait `core::kinds::Sized` is not implemented
+        self //~ error: the trait `core::markers::Sized` is not implemented
     ) -> <Dst as From<Self>>::Result where Dst: From<Self> {
-        From::from( //~ error: the trait `core::kinds::Sized` is not implemented
+        From::from( //~ error: the trait `core::markers::Sized` is not implemented
             self
         )
     }
diff --git a/src/test/compile-fail/issue-3907-2.rs b/src/test/compile-fail/issue-3907-2.rs
index 981abf6cc23..da60fee65c6 100644
--- a/src/test/compile-fail/issue-3907-2.rs
+++ b/src/test/compile-fail/issue-3907-2.rs
@@ -17,6 +17,6 @@ struct S {
     name: int
 }
 
-fn bar(_x: Foo) {} //~ ERROR the trait `core::kinds::Sized` is not implemented
+fn bar(_x: Foo) {} //~ ERROR the trait `core::markers::Sized` is not implemented
 
 fn main() {}
diff --git a/src/test/compile-fail/issue-5035-2.rs b/src/test/compile-fail/issue-5035-2.rs
index d0830ff8e4d..05073927beb 100644
--- a/src/test/compile-fail/issue-5035-2.rs
+++ b/src/test/compile-fail/issue-5035-2.rs
@@ -11,6 +11,6 @@
 trait I {}
 type K = I+'static;
 
-fn foo(_x: K) {} //~ ERROR: the trait `core::kinds::Sized` is not implemented
+fn foo(_x: K) {} //~ ERROR: the trait `core::markers::Sized` is not implemented
 
 fn main() {}
diff --git a/src/test/compile-fail/issue-5543.rs b/src/test/compile-fail/issue-5543.rs
index f970cdb1b83..6981c4451ca 100644
--- a/src/test/compile-fail/issue-5543.rs
+++ b/src/test/compile-fail/issue-5543.rs
@@ -14,5 +14,5 @@ impl Foo for u8 {}
 fn main() {
     let r: Box<Foo> = box 5;
     let _m: Box<Foo> = r as Box<Foo>;
-    //~^ ERROR `core::kinds::Sized` is not implemented for the type `Foo`
+    //~^ ERROR `core::markers::Sized` is not implemented for the type `Foo`
 }
diff --git a/src/test/compile-fail/issue-5883.rs b/src/test/compile-fail/issue-5883.rs
index e6ac30139c3..2f601a8ba58 100644
--- a/src/test/compile-fail/issue-5883.rs
+++ b/src/test/compile-fail/issue-5883.rs
@@ -15,8 +15,8 @@ struct Struct {
 }
 
 fn new_struct(r: A+'static)
-    -> Struct { //~^  ERROR the trait `core::kinds::Sized` is not implemented
-    //~^ ERROR the trait `core::kinds::Sized` is not implemented
+    -> Struct { //~^  ERROR the trait `core::markers::Sized` is not implemented
+    //~^ ERROR the trait `core::markers::Sized` is not implemented
     Struct { r: r }
 }
 
diff --git a/src/test/compile-fail/issue-7013.rs b/src/test/compile-fail/issue-7013.rs
index a8a699d62d5..30a59c52faa 100644
--- a/src/test/compile-fail/issue-7013.rs
+++ b/src/test/compile-fail/issue-7013.rs
@@ -32,6 +32,6 @@ struct A {
 
 fn main() {
     let a = A {v: box B{v: None} as Box<Foo+Send>};
-    //~^ ERROR the trait `core::kinds::Send` is not implemented
-    //~^^ ERROR the trait `core::kinds::Send` is not implemented
+    //~^ ERROR the trait `core::markers::Send` is not implemented
+    //~^^ ERROR the trait `core::markers::Send` is not implemented
 }
diff --git a/src/test/compile-fail/issue-7364.rs b/src/test/compile-fail/issue-7364.rs
index 77836143f27..c4217029a93 100644
--- a/src/test/compile-fail/issue-7364.rs
+++ b/src/test/compile-fail/issue-7364.rs
@@ -14,7 +14,7 @@ use std::cell::RefCell;
 // Regresion test for issue 7364
 static boxed: Box<RefCell<int>> = box RefCell::new(0);
 //~^ ERROR statics are not allowed to have custom pointers
-//~| ERROR: the trait `core::kinds::Sync` is not implemented for the type
-//~| ERROR: the trait `core::kinds::Sync` is not implemented for the type
+//~| ERROR: the trait `core::markers::Sync` is not implemented for the type
+//~| ERROR: the trait `core::markers::Sync` is not implemented for the type
 
 fn main() { }
diff --git a/src/test/compile-fail/kindck-copy.rs b/src/test/compile-fail/kindck-copy.rs
index b5725249812..583fbedfcbc 100644
--- a/src/test/compile-fail/kindck-copy.rs
+++ b/src/test/compile-fail/kindck-copy.rs
@@ -36,14 +36,14 @@ fn test<'a,T,U:Copy>(_: &'a int) {
     assert_copy::<&'a [int]>();
 
     // ...unless they are mutable
-    assert_copy::<&'static mut int>(); //~ ERROR `core::kinds::Copy` is not implemented
-    assert_copy::<&'a mut int>();  //~ ERROR `core::kinds::Copy` is not implemented
+    assert_copy::<&'static mut int>(); //~ ERROR `core::markers::Copy` is not implemented
+    assert_copy::<&'a mut int>();  //~ ERROR `core::markers::Copy` is not implemented
 
     // ~ pointers are not ok
-    assert_copy::<Box<int>>();   //~ ERROR `core::kinds::Copy` is not implemented
-    assert_copy::<String>();   //~ ERROR `core::kinds::Copy` is not implemented
-    assert_copy::<Vec<int> >(); //~ ERROR `core::kinds::Copy` is not implemented
-    assert_copy::<Box<&'a mut int>>(); //~ ERROR `core::kinds::Copy` is not implemented
+    assert_copy::<Box<int>>();   //~ ERROR `core::markers::Copy` is not implemented
+    assert_copy::<String>();   //~ ERROR `core::markers::Copy` is not implemented
+    assert_copy::<Vec<int> >(); //~ ERROR `core::markers::Copy` is not implemented
+    assert_copy::<Box<&'a mut int>>(); //~ ERROR `core::markers::Copy` is not implemented
 
     // borrowed object types are generally ok
     assert_copy::<&'a Dummy>();
@@ -51,11 +51,11 @@ fn test<'a,T,U:Copy>(_: &'a int) {
     assert_copy::<&'static (Dummy+Copy)>();
 
     // owned object types are not ok
-    assert_copy::<Box<Dummy>>(); //~ ERROR `core::kinds::Copy` is not implemented
-    assert_copy::<Box<Dummy+Copy>>(); //~ ERROR `core::kinds::Copy` is not implemented
+    assert_copy::<Box<Dummy>>(); //~ ERROR `core::markers::Copy` is not implemented
+    assert_copy::<Box<Dummy+Copy>>(); //~ ERROR `core::markers::Copy` is not implemented
 
     // mutable object types are not ok
-    assert_copy::<&'a mut (Dummy+Copy)>();  //~ ERROR `core::kinds::Copy` is not implemented
+    assert_copy::<&'a mut (Dummy+Copy)>();  //~ ERROR `core::markers::Copy` is not implemented
 
     // unsafe ptrs are ok
     assert_copy::<*const int>();
@@ -73,10 +73,10 @@ fn test<'a,T,U:Copy>(_: &'a int) {
     assert_copy::<MyStruct>();
 
     // structs containing non-POD are not ok
-    assert_copy::<MyNoncopyStruct>(); //~ ERROR `core::kinds::Copy` is not implemented
+    assert_copy::<MyNoncopyStruct>(); //~ ERROR `core::markers::Copy` is not implemented
 
     // ref counted types are not ok
-    assert_copy::<Rc<int>>();   //~ ERROR `core::kinds::Copy` is not implemented
+    assert_copy::<Rc<int>>();   //~ ERROR `core::markers::Copy` is not implemented
 }
 
 pub fn main() {
diff --git a/src/test/compile-fail/kindck-impl-type-params-2.rs b/src/test/compile-fail/kindck-impl-type-params-2.rs
index 6b25289567b..2ec22ceb63f 100644
--- a/src/test/compile-fail/kindck-impl-type-params-2.rs
+++ b/src/test/compile-fail/kindck-impl-type-params-2.rs
@@ -19,5 +19,5 @@ fn take_param<T:Foo>(foo: &T) { }
 fn main() {
     let x = box 3i;
     take_param(&x);
-    //~^ ERROR the trait `core::kinds::Copy` is not implemented
+    //~^ ERROR the trait `core::markers::Copy` is not implemented
 }
diff --git a/src/test/compile-fail/kindck-impl-type-params.rs b/src/test/compile-fail/kindck-impl-type-params.rs
index 57ee4cf7cc3..ad62fd98560 100644
--- a/src/test/compile-fail/kindck-impl-type-params.rs
+++ b/src/test/compile-fail/kindck-impl-type-params.rs
@@ -20,15 +20,15 @@ impl<T: Send + Copy> Gettable<T> for S<T> {}
 fn f<T>(val: T) {
     let t: S<T> = S;
     let a = &t as &Gettable<T>;
-    //~^ ERROR the trait `core::kinds::Send` is not implemented
-    //~^^ ERROR the trait `core::kinds::Copy` is not implemented
+    //~^ ERROR the trait `core::markers::Send` is not implemented
+    //~^^ ERROR the trait `core::markers::Copy` is not implemented
 }
 
 fn g<T>(val: T) {
     let t: S<T> = S;
     let a: &Gettable<T> = &t;
-    //~^ ERROR the trait `core::kinds::Send` is not implemented
-    //~^^ ERROR the trait `core::kinds::Copy` is not implemented
+    //~^ ERROR the trait `core::markers::Send` is not implemented
+    //~^^ ERROR the trait `core::markers::Copy` is not implemented
 }
 
 fn foo<'a>() {
@@ -40,13 +40,13 @@ fn foo<'a>() {
 fn foo2<'a>() {
     let t: Box<S<String>> = box S;
     let a = t as Box<Gettable<String>>;
-    //~^ ERROR the trait `core::kinds::Copy` is not implemented
+    //~^ ERROR the trait `core::markers::Copy` is not implemented
 }
 
 fn foo3<'a>() {
     let t: Box<S<String>> = box S;
     let a: Box<Gettable<String>> = t;
-    //~^ ERROR the trait `core::kinds::Copy` is not implemented
+    //~^ ERROR the trait `core::markers::Copy` is not implemented
 }
 
 fn main() { }
diff --git a/src/test/compile-fail/kindck-inherited-copy-bound.rs b/src/test/compile-fail/kindck-inherited-copy-bound.rs
index d66fd0d77d6..238f495187c 100644
--- a/src/test/compile-fail/kindck-inherited-copy-bound.rs
+++ b/src/test/compile-fail/kindck-inherited-copy-bound.rs
@@ -22,13 +22,13 @@ fn take_param<T:Foo>(foo: &T) { }
 
 fn a() {
     let x = box 3i;
-    take_param(&x); //~ ERROR `core::kinds::Copy` is not implemented
+    take_param(&x); //~ ERROR `core::markers::Copy` is not implemented
 }
 
 fn b() {
     let x = box 3i;
     let y = &x;
-    let z = &x as &Foo; //~ ERROR `core::kinds::Copy` is not implemented
+    let z = &x as &Foo; //~ ERROR `core::markers::Copy` is not implemented
 }
 
 fn main() { }
diff --git a/src/test/compile-fail/kindck-nonsendable-1.rs b/src/test/compile-fail/kindck-nonsendable-1.rs
index fdd8584a8bb..b46f91413a4 100644
--- a/src/test/compile-fail/kindck-nonsendable-1.rs
+++ b/src/test/compile-fail/kindck-nonsendable-1.rs
@@ -18,7 +18,7 @@ fn bar<F:FnOnce() + Send>(_: F) { }
 fn main() {
     let x = Rc::new(3u);
     bar(move|| foo(x));
-    //~^ ERROR `core::kinds::Send` is not implemented
-    //~^^ ERROR `core::kinds::Send` is not implemented
+    //~^ ERROR `core::markers::Send` is not implemented
+    //~^^ ERROR `core::markers::Send` is not implemented
 }
 
diff --git a/src/test/compile-fail/kindck-send-object.rs b/src/test/compile-fail/kindck-send-object.rs
index c300096caf1..1235a0a1228 100644
--- a/src/test/compile-fail/kindck-send-object.rs
+++ b/src/test/compile-fail/kindck-send-object.rs
@@ -20,11 +20,11 @@ trait Message : Send { }
 
 fn object_ref_with_static_bound_not_ok() {
     assert_send::<&'static (Dummy+'static)>();
-    //~^ ERROR the trait `core::kinds::Send` is not implemented
+    //~^ ERROR the trait `core::markers::Send` is not implemented
 }
 
 fn box_object_with_no_bound_not_ok<'a>() {
-    assert_send::<Box<Dummy>>(); //~ ERROR the trait `core::kinds::Send` is not implemented
+    assert_send::<Box<Dummy>>(); //~ ERROR the trait `core::markers::Send` is not implemented
 }
 
 fn object_with_send_bound_ok() {
diff --git a/src/test/compile-fail/kindck-send-object1.rs b/src/test/compile-fail/kindck-send-object1.rs
index d83a8031c45..4f1a95859ae 100644
--- a/src/test/compile-fail/kindck-send-object1.rs
+++ b/src/test/compile-fail/kindck-send-object1.rs
@@ -18,7 +18,7 @@ trait Dummy { }
 // careful with object types, who knows what they close over...
 fn test51<'a>() {
     assert_send::<&'a Dummy>();
-    //~^ ERROR the trait `core::kinds::Send` is not implemented
+    //~^ ERROR the trait `core::markers::Send` is not implemented
 }
 fn test52<'a>() {
     assert_send::<&'a (Dummy+Send)>();
@@ -37,7 +37,7 @@ fn test61() {
 // them not ok
 fn test_71<'a>() {
     assert_send::<Box<Dummy+'a>>();
-    //~^ ERROR the trait `core::kinds::Send` is not implemented
+    //~^ ERROR the trait `core::markers::Send` is not implemented
 }
 
 fn main() { }
diff --git a/src/test/compile-fail/kindck-send-object2.rs b/src/test/compile-fail/kindck-send-object2.rs
index ea8c2628306..06b8cf20258 100644
--- a/src/test/compile-fail/kindck-send-object2.rs
+++ b/src/test/compile-fail/kindck-send-object2.rs
@@ -14,11 +14,11 @@ fn assert_send<T:Send>() { }
 trait Dummy { }
 
 fn test50() {
-    assert_send::<&'static Dummy>(); //~ ERROR the trait `core::kinds::Send` is not implemented
+    assert_send::<&'static Dummy>(); //~ ERROR the trait `core::markers::Send` is not implemented
 }
 
 fn test53() {
-    assert_send::<Box<Dummy>>(); //~ ERROR the trait `core::kinds::Send` is not implemented
+    assert_send::<Box<Dummy>>(); //~ ERROR the trait `core::markers::Send` is not implemented
 }
 
 // ...unless they are properly bounded
diff --git a/src/test/compile-fail/kindck-send-unsafe.rs b/src/test/compile-fail/kindck-send-unsafe.rs
index 4e1641025d5..0a2f4cbce85 100644
--- a/src/test/compile-fail/kindck-send-unsafe.rs
+++ b/src/test/compile-fail/kindck-send-unsafe.rs
@@ -14,7 +14,7 @@ fn assert_send<T:Send>() { }
 
 fn test71<'a>() {
     assert_send::<*mut &'a int>();
-    //~^ ERROR the trait `core::kinds::Send` is not implemented for the type
+    //~^ ERROR the trait `core::markers::Send` is not implemented for the type
 }
 
 fn main() {
diff --git a/src/test/compile-fail/lint-dead-code-4.rs b/src/test/compile-fail/lint-dead-code-4.rs
index 0d5b562e04c..3bdc44ec363 100644
--- a/src/test/compile-fail/lint-dead-code-4.rs
+++ b/src/test/compile-fail/lint-dead-code-4.rs
@@ -19,7 +19,7 @@ use std::num::Int;
 struct Foo {
     x: uint,
     b: bool, //~ ERROR: struct field is never used
-    marker: std::kinds::marker::NoCopy
+    marker: std::markers::NoCopy
 }
 
 fn field_read(f: Foo) -> uint {
@@ -59,7 +59,7 @@ fn field_match_in_let(f: Bar) -> bool {
 }
 
 fn main() {
-    field_read(Foo { x: 1, b: false, marker: std::kinds::marker::NoCopy });
+    field_read(Foo { x: 1, b: false, marker: std::markers::NoCopy });
     field_match_in_patterns(XYZ::Z);
     field_match_in_let(Bar { x: 42u, b: true, _guard: () });
     let _ = Baz { x: 0 };
diff --git a/src/test/compile-fail/marker-no-copy.rs b/src/test/compile-fail/marker-no-copy.rs
index d620c13cc25..e329cdc32d3 100644
--- a/src/test/compile-fail/marker-no-copy.rs
+++ b/src/test/compile-fail/marker-no-copy.rs
@@ -8,11 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::kinds::marker;
+use std::markers;
 
 fn foo<P:Copy>(p: P) { }
 
 fn main()
 {
-    foo(marker::NoCopy); //~ ERROR the trait `core::kinds::Copy` is not implemented
+    foo(markers::NoCopy); //~ ERROR the trait `core::markers::Copy` is not implemented
 }
diff --git a/src/test/compile-fail/marker-no-send.rs b/src/test/compile-fail/marker-no-send.rs
index 813e2548398..dcbe63a417d 100644
--- a/src/test/compile-fail/marker-no-send.rs
+++ b/src/test/compile-fail/marker-no-send.rs
@@ -8,11 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::kinds::marker;
+use std::markers;
 
 fn foo<P:Send>(p: P) { }
 
 fn main()
 {
-    foo(marker::NoSend); //~ ERROR the trait `core::kinds::Send` is not implemented
+    foo(markers::NoSend); //~ ERROR the trait `core::markers::Send` is not implemented
 }
diff --git a/src/test/compile-fail/marker-no-share.rs b/src/test/compile-fail/marker-no-share.rs
index 735e61fa139..77d5fc23a35 100644
--- a/src/test/compile-fail/marker-no-share.rs
+++ b/src/test/compile-fail/marker-no-share.rs
@@ -8,11 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::kinds::marker;
+use std::markers;
 
 fn foo<P: Sync>(p: P) { }
 
 fn main()
 {
-    foo(marker::NoSync); //~ ERROR the trait `core::kinds::Sync` is not implemented
+    foo(markers::NoSync); //~ ERROR the trait `core::markers::Sync` is not implemented
 }
diff --git a/src/test/compile-fail/mut-not-freeze.rs b/src/test/compile-fail/mut-not-freeze.rs
index 95ebb8bd882..711763c20c6 100644
--- a/src/test/compile-fail/mut-not-freeze.rs
+++ b/src/test/compile-fail/mut-not-freeze.rs
@@ -15,6 +15,6 @@ fn f<T: Sync>(_: T) {}
 fn main() {
     let x = RefCell::new(0i);
     f(x);
-    //~^ ERROR `core::kinds::Sync` is not implemented
-    //~^^ ERROR `core::kinds::Sync` is not implemented
+    //~^ ERROR `core::markers::Sync` is not implemented
+    //~^^ ERROR `core::markers::Sync` is not implemented
 }
diff --git a/src/test/compile-fail/mutable-enum-indirect.rs b/src/test/compile-fail/mutable-enum-indirect.rs
index af9c5256040..01c977dc62c 100644
--- a/src/test/compile-fail/mutable-enum-indirect.rs
+++ b/src/test/compile-fail/mutable-enum-indirect.rs
@@ -11,13 +11,13 @@
 // Tests that an `&` pointer to something inherently mutable is itself
 // to be considered mutable.
 
-use std::kinds::marker;
+use std::markers;
 
-enum Foo { A(marker::NoSync) }
+enum Foo { A(markers::NoSync) }
 
 fn bar<T: Sync>(_: T) {}
 
 fn main() {
-    let x = Foo::A(marker::NoSync);
-    bar(&x); //~ ERROR the trait `core::kinds::Sync` is not implemented
+    let x = Foo::A(markers::NoSync);
+    bar(&x); //~ ERROR the trait `core::markers::Sync` is not implemented
 }
diff --git a/src/test/compile-fail/no-send-res-ports.rs b/src/test/compile-fail/no-send-res-ports.rs
index 9e56b27a05b..66082d46549 100644
--- a/src/test/compile-fail/no-send-res-ports.rs
+++ b/src/test/compile-fail/no-send-res-ports.rs
@@ -36,8 +36,8 @@ fn main() {
     let x = foo(Port(Rc::new(())));
 
     Thread::spawn(move|| {
-        //~^ ERROR `core::kinds::Send` is not implemented
-        //~^^ ERROR `core::kinds::Send` is not implemented
+        //~^ ERROR `core::markers::Send` is not implemented
+        //~^^ ERROR `core::markers::Send` is not implemented
         let y = x;
         println!("{}", y);
     });
diff --git a/src/test/compile-fail/no_send-enum.rs b/src/test/compile-fail/no_send-enum.rs
index 8b409cfe89d..2a0ffd93208 100644
--- a/src/test/compile-fail/no_send-enum.rs
+++ b/src/test/compile-fail/no_send-enum.rs
@@ -8,16 +8,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::kinds::marker;
+use std::markers;
 
 enum Foo {
-    A(marker::NoSend)
+    A(markers::NoSend)
 }
 
 fn bar<T: Send>(_: T) {}
 
 fn main() {
-    let x = Foo::A(marker::NoSend);
+    let x = Foo::A(markers::NoSend);
     bar(x);
-    //~^ ERROR `core::kinds::Send` is not implemented
+    //~^ ERROR `core::markers::Send` is not implemented
 }
diff --git a/src/test/compile-fail/no_send-rc.rs b/src/test/compile-fail/no_send-rc.rs
index 004921b1db0..e604fd9f838 100644
--- a/src/test/compile-fail/no_send-rc.rs
+++ b/src/test/compile-fail/no_send-rc.rs
@@ -15,6 +15,6 @@ fn bar<T: Send>(_: T) {}
 fn main() {
     let x = Rc::new(5i);
     bar(x);
-    //~^ ERROR `core::kinds::Send` is not implemented
-    //~^^ ERROR `core::kinds::Send` is not implemented
+    //~^ ERROR `core::markers::Send` is not implemented
+    //~^^ ERROR `core::markers::Send` is not implemented
 }
diff --git a/src/test/compile-fail/no_send-struct.rs b/src/test/compile-fail/no_send-struct.rs
index 6e84578e92e..7e2f7c55bd2 100644
--- a/src/test/compile-fail/no_send-struct.rs
+++ b/src/test/compile-fail/no_send-struct.rs
@@ -8,17 +8,17 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::kinds::marker;
+use std::markers;
 
 struct Foo {
     a: int,
-    ns: marker::NoSend
+    ns: markers::NoSend
 }
 
 fn bar<T: Send>(_: T) {}
 
 fn main() {
-    let x = Foo { a: 5, ns: marker::NoSend };
+    let x = Foo { a: 5, ns: markers::NoSend };
     bar(x);
-    //~^ ERROR the trait `core::kinds::Send` is not implemented
+    //~^ ERROR the trait `core::markers::Send` is not implemented
 }
diff --git a/src/test/compile-fail/no_share-enum.rs b/src/test/compile-fail/no_share-enum.rs
index cb8ecd7259b..aeaa56c35a8 100644
--- a/src/test/compile-fail/no_share-enum.rs
+++ b/src/test/compile-fail/no_share-enum.rs
@@ -8,14 +8,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::kinds::marker;
+use std::markers;
 
-enum Foo { A(marker::NoSync) }
+enum Foo { A(markers::NoSync) }
 
 fn bar<T: Sync>(_: T) {}
 
 fn main() {
-    let x = Foo::A(marker::NoSync);
+    let x = Foo::A(markers::NoSync);
     bar(x);
-    //~^ ERROR the trait `core::kinds::Sync` is not implemented
+    //~^ ERROR the trait `core::markers::Sync` is not implemented
 }
diff --git a/src/test/compile-fail/no_share-rc.rs b/src/test/compile-fail/no_share-rc.rs
index ac3b456def5..66e8571527d 100644
--- a/src/test/compile-fail/no_share-rc.rs
+++ b/src/test/compile-fail/no_share-rc.rs
@@ -16,6 +16,6 @@ fn bar<T: Sync>(_: T) {}
 fn main() {
     let x = Rc::new(RefCell::new(5i));
     bar(x);
-    //~^ ERROR the trait `core::kinds::Sync` is not implemented
-    //~^^ ERROR the trait `core::kinds::Sync` is not implemented
+    //~^ ERROR the trait `core::markers::Sync` is not implemented
+    //~^^ ERROR the trait `core::markers::Sync` is not implemented
 }
diff --git a/src/test/compile-fail/no_share-struct.rs b/src/test/compile-fail/no_share-struct.rs
index 1379a9f7382..ee6a29d3176 100644
--- a/src/test/compile-fail/no_share-struct.rs
+++ b/src/test/compile-fail/no_share-struct.rs
@@ -8,14 +8,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::kinds::marker;
+use std::markers;
 
-struct Foo { a: int, m: marker::NoSync }
+struct Foo { a: int, m: markers::NoSync }
 
 fn bar<T: Sync>(_: T) {}
 
 fn main() {
-    let x = Foo { a: 5, m: marker::NoSync };
+    let x = Foo { a: 5, m: markers::NoSync };
     bar(x);
-    //~^ ERROR the trait `core::kinds::Sync` is not implemented
+    //~^ ERROR the trait `core::markers::Sync` is not implemented
 }
diff --git a/src/test/compile-fail/opt-out-copy-bad.rs b/src/test/compile-fail/opt-out-copy-bad.rs
index 4aae8fa87da..f949e89fcac 100644
--- a/src/test/compile-fail/opt-out-copy-bad.rs
+++ b/src/test/compile-fail/opt-out-copy-bad.rs
@@ -30,7 +30,7 @@ impl Copy for IWantToCopyThis {}
 
 enum CantCopyThisEither {
     A,
-    B(::std::kinds::marker::NoCopy),
+    B(::std::markers::NoCopy),
 }
 
 enum IWantToCopyThisToo {
diff --git a/src/test/compile-fail/range-1.rs b/src/test/compile-fail/range-1.rs
index 4af748661fd..b05117a7185 100644
--- a/src/test/compile-fail/range-1.rs
+++ b/src/test/compile-fail/range-1.rs
@@ -23,5 +23,5 @@ pub fn main() {
     // Unsized type.
     let arr: &[_] = &[1u, 2, 3];
     let range = (*arr)..;
-    //~^ ERROR the trait `core::kinds::Sized` is not implemented
+    //~^ ERROR the trait `core::markers::Sized` is not implemented
 }
diff --git a/src/test/compile-fail/regions-infer-contravariance-due-to-decl.rs b/src/test/compile-fail/regions-infer-contravariance-due-to-decl.rs
index 4dd028b7884..d8bad0f9103 100644
--- a/src/test/compile-fail/regions-infer-contravariance-due-to-decl.rs
+++ b/src/test/compile-fail/regions-infer-contravariance-due-to-decl.rs
@@ -14,13 +14,13 @@
 // Note: see variance-regions-*.rs for the tests that check that the
 // variance inference works in the first place.
 
-use std::kinds::marker;
+use std::markers;
 
 // This is contravariant with respect to 'a, meaning that
 // Contravariant<'foo> <: Contravariant<'static> because
 // 'foo <= 'static
 struct Contravariant<'a> {
-    marker: marker::ContravariantLifetime<'a>
+    marker: markers::ContravariantLifetime<'a>
 }
 
 fn use_<'short,'long>(c: Contravariant<'short>,
diff --git a/src/test/compile-fail/regions-infer-covariance-due-to-decl.rs b/src/test/compile-fail/regions-infer-covariance-due-to-decl.rs
index 93c06aecd30..58c1f0c4721 100644
--- a/src/test/compile-fail/regions-infer-covariance-due-to-decl.rs
+++ b/src/test/compile-fail/regions-infer-covariance-due-to-decl.rs
@@ -14,10 +14,10 @@
 // Note: see variance-regions-*.rs for the tests that check that the
 // variance inference works in the first place.
 
-use std::kinds::marker;
+use std::markers;
 
 struct Covariant<'a> {
-    marker: marker::CovariantLifetime<'a>
+    marker: markers::CovariantLifetime<'a>
 }
 
 fn use_<'short,'long>(c: Covariant<'long>,
diff --git a/src/test/compile-fail/regions-infer-invariance-due-to-decl.rs b/src/test/compile-fail/regions-infer-invariance-due-to-decl.rs
index ad5ad143b15..d3d6aa06cdb 100644
--- a/src/test/compile-fail/regions-infer-invariance-due-to-decl.rs
+++ b/src/test/compile-fail/regions-infer-invariance-due-to-decl.rs
@@ -8,10 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::kinds::marker;
+use std::markers;
 
 struct invariant<'a> {
-    marker: marker::InvariantLifetime<'a>
+    marker: markers::InvariantLifetime<'a>
 }
 
 fn to_same_lifetime<'r>(bi: invariant<'r>) {
diff --git a/src/test/compile-fail/repeat-to-run-dtor-twice.rs b/src/test/compile-fail/repeat-to-run-dtor-twice.rs
index d3126cf44d1..d8a183c0e46 100644
--- a/src/test/compile-fail/repeat-to-run-dtor-twice.rs
+++ b/src/test/compile-fail/repeat-to-run-dtor-twice.rs
@@ -25,5 +25,5 @@ impl Drop for Foo {
 fn main() {
     let a = Foo { x: 3 };
     let _ = [ a; 5 ];
-    //~^ ERROR the trait `core::kinds::Copy` is not implemented for the type `Foo`
+    //~^ ERROR the trait `core::markers::Copy` is not implemented for the type `Foo`
 }
diff --git a/src/test/compile-fail/static-items-cant-move.rs b/src/test/compile-fail/static-items-cant-move.rs
index 28e73f74ff3..e0f241f87a7 100644
--- a/src/test/compile-fail/static-items-cant-move.rs
+++ b/src/test/compile-fail/static-items-cant-move.rs
@@ -10,14 +10,14 @@
 
 // Verifies that static items can't be moved
 
-use std::kinds::marker;
+use std::markers;
 
 struct Foo {
     foo: int,
-    nocopy: marker::NoCopy
+    nocopy: markers::NoCopy
 }
 
-static BAR: Foo = Foo{foo: 5, nocopy: marker::NoCopy};
+static BAR: Foo = Foo{foo: 5, nocopy: markers::NoCopy};
 
 
 fn test(f: Foo) {
diff --git a/src/test/compile-fail/syntax-trait-polarity-feature-gate.rs b/src/test/compile-fail/syntax-trait-polarity-feature-gate.rs
index e6dc712137f..186f5f91eee 100644
--- a/src/test/compile-fail/syntax-trait-polarity-feature-gate.rs
+++ b/src/test/compile-fail/syntax-trait-polarity-feature-gate.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::kinds::Send;
+use std::markers::Send;
 
 struct TestType;
 
diff --git a/src/test/compile-fail/syntax-trait-polarity.rs b/src/test/compile-fail/syntax-trait-polarity.rs
index 3c84bc26298..bdfadcad2bf 100644
--- a/src/test/compile-fail/syntax-trait-polarity.rs
+++ b/src/test/compile-fail/syntax-trait-polarity.rs
@@ -10,7 +10,7 @@
 
 #![feature(optin_builtin_traits)]
 
-use std::kinds::Send;
+use std::markers::Send;
 
 struct TestType;
 
diff --git a/src/test/compile-fail/task-rng-isnt-sendable.rs b/src/test/compile-fail/task-rng-isnt-sendable.rs
index f673c3b7978..5bc96cae0bb 100644
--- a/src/test/compile-fail/task-rng-isnt-sendable.rs
+++ b/src/test/compile-fail/task-rng-isnt-sendable.rs
@@ -16,6 +16,6 @@ fn test_send<S: Send>() {}
 
 pub fn main() {
     test_send::<rand::ThreadRng>();
-    //~^ ERROR `core::kinds::Send` is not implemented
-    //~^^ ERROR `core::kinds::Send` is not implemented
+    //~^ ERROR `core::markers::Send` is not implemented
+    //~^^ ERROR `core::markers::Send` is not implemented
 }
diff --git a/src/test/compile-fail/trait-bounds-not-on-bare-trait.rs b/src/test/compile-fail/trait-bounds-not-on-bare-trait.rs
index 85a2761172d..f569bed126d 100644
--- a/src/test/compile-fail/trait-bounds-not-on-bare-trait.rs
+++ b/src/test/compile-fail/trait-bounds-not-on-bare-trait.rs
@@ -14,7 +14,7 @@ trait Foo {
 // This should emit the less confusing error, not the more confusing one.
 
 fn foo(_x: Foo + Send) {
-    //~^ERROR the trait `core::kinds::Sized` is not implemented
+    //~^ERROR the trait `core::markers::Sized` is not implemented
 }
 
 fn main() { }
diff --git a/src/test/compile-fail/typeck-unsafe-always-share.rs b/src/test/compile-fail/typeck-unsafe-always-share.rs
index a7911eb791e..d3199ff982e 100644
--- a/src/test/compile-fail/typeck-unsafe-always-share.rs
+++ b/src/test/compile-fail/typeck-unsafe-always-share.rs
@@ -13,14 +13,14 @@
 // ignore-tidy-linelength
 
 use std::cell::UnsafeCell;
-use std::kinds::marker;
+use std::markers;
 
 struct MySync<T> {
     u: UnsafeCell<T>
 }
 
 struct NoSync {
-    m: marker::NoSync
+    m: markers::NoSync
 }
 
 fn test<T: Sync>(s: T){
@@ -30,17 +30,17 @@ fn test<T: Sync>(s: T){
 fn main() {
     let us = UnsafeCell::new(MySync{u: UnsafeCell::new(0i)});
     test(us);
-    //~^ ERROR `core::kinds::Sync` is not implemented
+    //~^ ERROR `core::markers::Sync` is not implemented
 
-    let uns = UnsafeCell::new(NoSync{m: marker::NoSync});
+    let uns = UnsafeCell::new(NoSync{m: markers::NoSync});
     test(uns);
-    //~^ ERROR `core::kinds::Sync` is not implemented
+    //~^ ERROR `core::markers::Sync` is not implemented
 
     let ms = MySync{u: uns};
     test(ms);
-    //~^ ERROR `core::kinds::Sync` is not implemented
+    //~^ ERROR `core::markers::Sync` is not implemented
 
-    let ns = NoSync{m: marker::NoSync};
+    let ns = NoSync{m: markers::NoSync};
     test(ns);
-    //~^ ERROR `core::kinds::Sync` is not implemented
+    //~^ ERROR `core::markers::Sync` is not implemented
 }
diff --git a/src/test/compile-fail/unboxed-closure-sugar-region.rs b/src/test/compile-fail/unboxed-closure-sugar-region.rs
index 5ace9e115ec..ee7d2cc168c 100644
--- a/src/test/compile-fail/unboxed-closure-sugar-region.rs
+++ b/src/test/compile-fail/unboxed-closure-sugar-region.rs
@@ -15,7 +15,7 @@
 #![feature(unboxed_closures)]
 #![allow(dead_code)]
 
-use std::kinds::marker;
+use std::markers;
 
 trait Foo<'a,T,U> {
     fn dummy(&'a self) -> &'a (T,U);
diff --git a/src/test/compile-fail/unique-unique-kind.rs b/src/test/compile-fail/unique-unique-kind.rs
index 48d5028f435..98d8b2d36cd 100644
--- a/src/test/compile-fail/unique-unique-kind.rs
+++ b/src/test/compile-fail/unique-unique-kind.rs
@@ -17,6 +17,6 @@ fn f<T:Send>(_i: T) {
 fn main() {
     let i = box Rc::new(100i);
     f(i);
-    //~^ ERROR `core::kinds::Send` is not implemented
-    //~^^ ERROR `core::kinds::Send` is not implemented
+    //~^ ERROR `core::markers::Send` is not implemented
+    //~^^ ERROR `core::markers::Send` is not implemented
 }
diff --git a/src/test/compile-fail/unsendable-class.rs b/src/test/compile-fail/unsendable-class.rs
index 993df8e59f3..6398623e75b 100644
--- a/src/test/compile-fail/unsendable-class.rs
+++ b/src/test/compile-fail/unsendable-class.rs
@@ -30,7 +30,7 @@ fn foo(i:int, j: Rc<String>) -> foo {
 fn main() {
   let cat = "kitty".to_string();
   let (tx, _) = channel();
-  //~^ ERROR `core::kinds::Send` is not implemented
-  //~^^ ERROR `core::kinds::Send` is not implemented
+  //~^ ERROR `core::markers::Send` is not implemented
+  //~^^ ERROR `core::markers::Send` is not implemented
   tx.send(foo(42, Rc::new(cat)));
 }
diff --git a/src/test/compile-fail/unsized-bare-typaram.rs b/src/test/compile-fail/unsized-bare-typaram.rs
index 2de490e018b..b6078cd3af4 100644
--- a/src/test/compile-fail/unsized-bare-typaram.rs
+++ b/src/test/compile-fail/unsized-bare-typaram.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 fn bar<T: Sized>() { }
-fn foo<T: ?Sized>() { bar::<T>() } //~ ERROR the trait `core::kinds::Sized` is not implemented
+fn foo<T: ?Sized>() { bar::<T>() } //~ ERROR the trait `core::markers::Sized` is not implemented
 fn main() { }
diff --git a/src/test/compile-fail/unsized-enum.rs b/src/test/compile-fail/unsized-enum.rs
index aea236c9268..a78ffb13408 100644
--- a/src/test/compile-fail/unsized-enum.rs
+++ b/src/test/compile-fail/unsized-enum.rs
@@ -15,14 +15,14 @@ fn not_sized<T: ?Sized>() { }
 enum Foo<U> { FooSome(U), FooNone }
 fn foo1<T>() { not_sized::<Foo<T>>() } // Hunky dory.
 fn foo2<T: ?Sized>() { not_sized::<Foo<T>>() }
-//~^ ERROR the trait `core::kinds::Sized` is not implemented
+//~^ ERROR the trait `core::markers::Sized` is not implemented
 //
 // Not OK: `T` is not sized.
 
 enum Bar<U: ?Sized> { BarSome(U), BarNone }
 fn bar1<T: ?Sized>() { not_sized::<Bar<T>>() }
 fn bar2<T: ?Sized>() { is_sized::<Bar<T>>() }
-//~^ ERROR the trait `core::kinds::Sized` is not implemented
+//~^ ERROR the trait `core::markers::Sized` is not implemented
 //
 // Not OK: `Bar<T>` is not sized, but it should be.
 
diff --git a/src/test/compile-fail/unsized-struct.rs b/src/test/compile-fail/unsized-struct.rs
index 89c71103697..c6812679155 100644
--- a/src/test/compile-fail/unsized-struct.rs
+++ b/src/test/compile-fail/unsized-struct.rs
@@ -15,14 +15,14 @@ fn not_sized<T: ?Sized>() { }
 struct Foo<T> { data: T }
 fn foo1<T>() { not_sized::<Foo<T>>() } // Hunky dory.
 fn foo2<T: ?Sized>() { not_sized::<Foo<T>>() }
-//~^ ERROR the trait `core::kinds::Sized` is not implemented
+//~^ ERROR the trait `core::markers::Sized` is not implemented
 //
 // Not OK: `T` is not sized.
 
 struct Bar<T: ?Sized> { data: T }
 fn bar1<T: ?Sized>() { not_sized::<Bar<T>>() }
 fn bar2<T: ?Sized>() { is_sized::<Bar<T>>() }
-//~^ ERROR the trait `core::kinds::Sized` is not implemented
+//~^ ERROR the trait `core::markers::Sized` is not implemented
 //
 // Not OK: `Bar<T>` is not sized, but it should be.
 
diff --git a/src/test/compile-fail/unsized-trait-impl-trait-arg.rs b/src/test/compile-fail/unsized-trait-impl-trait-arg.rs
index 7ae74fc2600..9a29775f7c9 100644
--- a/src/test/compile-fail/unsized-trait-impl-trait-arg.rs
+++ b/src/test/compile-fail/unsized-trait-impl-trait-arg.rs
@@ -15,7 +15,7 @@ trait T2<Z> {
 }
 struct S4<Y: ?Sized>;
 impl<X: ?Sized> T2<X> for S4<X> {
-    //~^ ERROR `core::kinds::Sized` is not implemented for the type `X`
+    //~^ ERROR `core::markers::Sized` is not implemented for the type `X`
 }
 
 fn main() { }
diff --git a/src/test/compile-fail/unsized3.rs b/src/test/compile-fail/unsized3.rs
index 9b7d10b0d0f..7e4a1d13557 100644
--- a/src/test/compile-fail/unsized3.rs
+++ b/src/test/compile-fail/unsized3.rs
@@ -14,7 +14,7 @@
 // Unbounded.
 fn f1<X: ?Sized>(x: &X) {
     f2::<X>(x);
-    //~^ ERROR the trait `core::kinds::Sized` is not implemented
+    //~^ ERROR the trait `core::markers::Sized` is not implemented
 }
 fn f2<X>(x: &X) {
 }
@@ -23,7 +23,7 @@ fn f2<X>(x: &X) {
 trait T {}
 fn f3<X: ?Sized + T>(x: &X) {
     f4::<X>(x);
-    //~^ ERROR the trait `core::kinds::Sized` is not implemented
+    //~^ ERROR the trait `core::markers::Sized` is not implemented
 }
 fn f4<X: T>(x: &X) {
 }
@@ -37,7 +37,7 @@ fn f5<Y>(x: &Y) {}
 fn f6<X: ?Sized>(x: &X) {}
 fn f7<X: ?Sized>(x1: &E<X>, x2: &E<X>) {
     f5(x1);
-    //~^ ERROR the trait `core::kinds::Sized` is not implemented
+    //~^ ERROR the trait `core::markers::Sized` is not implemented
     f6(x2); // ok
 }
 
@@ -49,19 +49,19 @@ struct S<X: ?Sized> {
 
 fn f8<X: ?Sized>(x1: &S<X>, x2: &S<X>) {
     f5(x1);
-    //~^ ERROR the trait `core::kinds::Sized` is not implemented
+    //~^ ERROR the trait `core::markers::Sized` is not implemented
     f6(x2); // ok
 }
 
 // Test some tuples.
 fn f9<X: ?Sized>(x1: Box<S<X>>, x2: Box<E<X>>) {
     f5(&(*x1, 34i));
-    //~^ ERROR the trait `core::kinds::Sized` is not implemented
+    //~^ ERROR the trait `core::markers::Sized` is not implemented
 }
 
 fn f10<X: ?Sized>(x1: Box<S<X>>, x2: Box<E<X>>) {
     f5(&(32i, *x2));
-    //~^ ERROR the trait `core::kinds::Sized` is not implemented
+    //~^ ERROR the trait `core::markers::Sized` is not implemented
 }
 
 pub fn main() {
diff --git a/src/test/compile-fail/unsized5.rs b/src/test/compile-fail/unsized5.rs
index f7477d746fa..a714b7d9238 100644
--- a/src/test/compile-fail/unsized5.rs
+++ b/src/test/compile-fail/unsized5.rs
@@ -8,30 +8,30 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// Test `Sized?` types not allowed in fields (except the last one).
+// Test `?Sized` types not allowed in fields (except the last one).
 
 struct S1<X: ?Sized> {
-    f1: X, //~ ERROR `core::kinds::Sized` is not implemented
+    f1: X, //~ ERROR `core::markers::Sized` is not implemented
     f2: int,
 }
 struct S2<X: ?Sized> {
     f: int,
-    g: X, //~ ERROR `core::kinds::Sized` is not implemented
+    g: X, //~ ERROR `core::markers::Sized` is not implemented
     h: int,
 }
 struct S3 {
-    f: str, //~ ERROR `core::kinds::Sized` is not implemented
+    f: str, //~ ERROR `core::markers::Sized` is not implemented
     g: [uint]
 }
 struct S4 {
-    f: str, //~ ERROR `core::kinds::Sized` is not implemented
+    f: str, //~ ERROR `core::markers::Sized` is not implemented
     g: uint
 }
 enum E<X: ?Sized> {
-    V1(X, int), //~ERROR `core::kinds::Sized` is not implemented
+    V1(X, int), //~ERROR `core::markers::Sized` is not implemented
 }
 enum F<X: ?Sized> {
-    V2{f1: X, f: int}, //~ERROR `core::kinds::Sized` is not implemented
+    V2{f1: X, f: int}, //~ERROR `core::markers::Sized` is not implemented
 }
 
 pub fn main() {
diff --git a/src/test/compile-fail/unsized6.rs b/src/test/compile-fail/unsized6.rs
index b4f0a4912cf..d3b03493fdc 100644
--- a/src/test/compile-fail/unsized6.rs
+++ b/src/test/compile-fail/unsized6.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// Test `Sized?` local variables.
+// Test `?Sized` local variables.
 
 
 trait T {}
@@ -16,27 +16,27 @@ trait T {}
 fn f1<X: ?Sized>(x: &X) {
     let _: X; // <-- this is OK, no bindings created, no initializer.
     let _: (int, (X, int)); // same
-    let y: X; //~ERROR the trait `core::kinds::Sized` is not implemented
-    let y: (int, (X, int)); //~ERROR the trait `core::kinds::Sized` is not implemented
+    let y: X; //~ERROR the trait `core::markers::Sized` is not implemented
+    let y: (int, (X, int)); //~ERROR the trait `core::markers::Sized` is not implemented
 }
 fn f2<X: ?Sized + T>(x: &X) {
-    let y: X; //~ERROR the trait `core::kinds::Sized` is not implemented
-    let y: (int, (X, int)); //~ERROR the trait `core::kinds::Sized` is not implemented
+    let y: X; //~ERROR the trait `core::markers::Sized` is not implemented
+    let y: (int, (X, int)); //~ERROR the trait `core::markers::Sized` is not implemented
 }
 
 fn f3<X: ?Sized>(x1: Box<X>, x2: Box<X>, x3: Box<X>) {
-    let y: X = *x1; //~ERROR the trait `core::kinds::Sized` is not implemented
-    let y = *x2; //~ERROR the trait `core::kinds::Sized` is not implemented
-    let (y, z) = (*x3, 4i); //~ERROR the trait `core::kinds::Sized` is not implemented
+    let y: X = *x1; //~ERROR the trait `core::markers::Sized` is not implemented
+    let y = *x2; //~ERROR the trait `core::markers::Sized` is not implemented
+    let (y, z) = (*x3, 4i); //~ERROR the trait `core::markers::Sized` is not implemented
 }
-fn f4<X: ?Sized + T>(x1: Box<X>, x2: Box<X>, x3: Box<X>) {
-    let y: X = *x1;         //~ERROR the trait `core::kinds::Sized` is not implemented
-    let y = *x2;            //~ERROR the trait `core::kinds::Sized` is not implemented
-    let (y, z) = (*x3, 4i); //~ERROR the trait `core::kinds::Sized` is not implemented
+fn f4<X: ?Sized: T>(x1: Box<X>, x2: Box<X>, x3: Box<X>) {
+    let y: X = *x1;         //~ERROR the trait `core::markers::Sized` is not implemented
+    let y = *x2;            //~ERROR the trait `core::markers::Sized` is not implemented
+    let (y, z) = (*x3, 4i); //~ERROR the trait `core::markers::Sized` is not implemented
 }
 
-fn g1<X: ?Sized>(x: X) {} //~ERROR the trait `core::kinds::Sized` is not implemented
-fn g2<X: ?Sized + T>(x: X) {} //~ERROR the trait `core::kinds::Sized` is not implemented
+fn g1<X: ?Sized>(x: X) {} //~ERROR the trait `core::markers::Sized` is not implemented
+fn g2<X: ?Sized + T>(x: X) {} //~ERROR the trait `core::markers::Sized` is not implemented
 
 pub fn main() {
 }
diff --git a/src/test/compile-fail/unsized7.rs b/src/test/compile-fail/unsized7.rs
index 8a54771112f..32daa2a246e 100644
--- a/src/test/compile-fail/unsized7.rs
+++ b/src/test/compile-fail/unsized7.rs
@@ -18,7 +18,7 @@ trait T1<Z: T> {
 }
 struct S3<Y: ?Sized>;
 impl<X: ?Sized + T> T1<X> for S3<X> {
-    //~^ ERROR `core::kinds::Sized` is not implemented for the type `X`
+    //~^ ERROR `core::markers::Sized` is not implemented for the type `X`
 }
 
 fn main() { }
diff --git a/src/test/compile-fail/where-clause-constraints-are-local-for-inherent-impl.rs b/src/test/compile-fail/where-clause-constraints-are-local-for-inherent-impl.rs
index 8d72e260a18..c584c30448f 100644
--- a/src/test/compile-fail/where-clause-constraints-are-local-for-inherent-impl.rs
+++ b/src/test/compile-fail/where-clause-constraints-are-local-for-inherent-impl.rs
@@ -21,7 +21,7 @@ impl<T> Foo<T> {
 
     fn fails_copy(self) {
         require_copy(self.x);
-        //~^ ERROR the trait `core::kinds::Copy` is not implemented for the type `T`
+        //~^ ERROR the trait `core::markers::Copy` is not implemented for the type `T`
     }
 }
 
diff --git a/src/test/compile-fail/where-clause-constraints-are-local-for-trait-impl.rs b/src/test/compile-fail/where-clause-constraints-are-local-for-trait-impl.rs
index 096b53a1ea6..45df3af08d4 100644
--- a/src/test/compile-fail/where-clause-constraints-are-local-for-trait-impl.rs
+++ b/src/test/compile-fail/where-clause-constraints-are-local-for-trait-impl.rs
@@ -26,7 +26,7 @@ impl<T> Foo<T> for Bar<T> {
 
     fn fails_copy(self) {
         require_copy(self.x);
-        //~^ ERROR the trait `core::kinds::Copy` is not implemented for the type `T`
+        //~^ ERROR the trait `core::markers::Copy` is not implemented for the type `T`
     }
 }
 
diff --git a/src/test/run-pass/associated-types-impl-redirect.rs b/src/test/run-pass/associated-types-impl-redirect.rs
index 388a2d73447..d18d6ffd7d0 100644
--- a/src/test/run-pass/associated-types-impl-redirect.rs
+++ b/src/test/run-pass/associated-types-impl-redirect.rs
@@ -19,7 +19,7 @@
 #![feature(lang_items, unboxed_closures)]
 #![no_implicit_prelude]
 
-use std::kinds::Sized;
+use std::markers::Sized;
 use std::option::Option::{None, Some, self};
 
 trait Iterator {
diff --git a/src/test/run-pass/associated-types-where-clause-impl-ambiguity.rs b/src/test/run-pass/associated-types-where-clause-impl-ambiguity.rs
index abbe250b627..4ebf071cbc1 100644
--- a/src/test/run-pass/associated-types-where-clause-impl-ambiguity.rs
+++ b/src/test/run-pass/associated-types-where-clause-impl-ambiguity.rs
@@ -19,7 +19,7 @@
 #![feature(lang_items, unboxed_closures)]
 #![no_implicit_prelude]
 
-use std::kinds::Sized;
+use std::markers::Sized;
 use std::option::Option::{None, Some, self};
 
 trait Iterator {
diff --git a/src/test/run-pass/const-block.rs b/src/test/run-pass/const-block.rs
index 35783ea5899..9ec68264076 100644
--- a/src/test/run-pass/const-block.rs
+++ b/src/test/run-pass/const-block.rs
@@ -11,7 +11,7 @@
 #![allow(dead_code)]
 #![allow(unused_unsafe)]
 
-use std::kinds::Sync;
+use std::markers::Sync;
 
 struct Foo {
     a: uint,
diff --git a/src/test/run-pass/fsu-moves-and-copies.rs b/src/test/run-pass/fsu-moves-and-copies.rs
index 14843b30e1c..5ce8eb64318 100644
--- a/src/test/run-pass/fsu-moves-and-copies.rs
+++ b/src/test/run-pass/fsu-moves-and-copies.rs
@@ -11,7 +11,7 @@
 // Issue 4691: Ensure that functional-struct-updates operates
 // correctly and moves rather than copy when appropriate.
 
-use std::kinds::marker::NoCopy as NP;
+use std::markers::NoCopy as NP;
 
 struct ncint { np: NP, v: int }
 fn ncint(v: int) -> ncint { ncint { np: NP, v: v } }
diff --git a/src/test/run-pass/hrtb-opt-in-copy.rs b/src/test/run-pass/hrtb-opt-in-copy.rs
index 0616a7b21b5..e364cb0c9a2 100644
--- a/src/test/run-pass/hrtb-opt-in-copy.rs
+++ b/src/test/run-pass/hrtb-opt-in-copy.rs
@@ -18,7 +18,7 @@
 
 #![allow(dead_code)]
 
-use std::kinds::marker;
+use std::markers;
 
 #[derive(Copy)]
 struct Foo<T> { x: T }
@@ -26,7 +26,7 @@ struct Foo<T> { x: T }
 type Ty<'tcx> = &'tcx TyS<'tcx>;
 
 enum TyS<'tcx> {
-    Boop(marker::InvariantLifetime<'tcx>)
+    Boop(markers::InvariantLifetime<'tcx>)
 }
 
 enum Bar<'tcx> {
diff --git a/src/test/run-pass/issue-17718-static-unsafe-interior.rs b/src/test/run-pass/issue-17718-static-unsafe-interior.rs
index 0851f0e367b..ac9a70379f8 100644
--- a/src/test/run-pass/issue-17718-static-unsafe-interior.rs
+++ b/src/test/run-pass/issue-17718-static-unsafe-interior.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::kinds::marker;
+use std::markers;
 use std::cell::UnsafeCell;
 
 struct MyUnsafePack<T>(UnsafeCell<T>);
diff --git a/src/test/run-pass/issue-2718.rs b/src/test/run-pass/issue-2718.rs
index f4146063409..435b1699883 100644
--- a/src/test/run-pass/issue-2718.rs
+++ b/src/test/run-pass/issue-2718.rs
@@ -23,7 +23,7 @@ pub mod pipes {
     use std::mem::{replace, swap};
     use std::mem;
     use std::thread::Thread;
-    use std::kinds::Send;
+    use std::markers::Send;
 
     pub struct Stuff<T> {
         state: state,
diff --git a/src/test/run-pass/method-recursive-blanket-impl.rs b/src/test/run-pass/method-recursive-blanket-impl.rs
index e81244d4bea..279f05ea1c9 100644
--- a/src/test/run-pass/method-recursive-blanket-impl.rs
+++ b/src/test/run-pass/method-recursive-blanket-impl.rs
@@ -13,7 +13,7 @@
 // know not to stop at the blanket, we have to recursively evaluate
 // the `T:Foo` bound.
 
-use std::kinds::Sized;
+use std::markers::Sized;
 
 // Note: this must be generic for the problem to show up
 trait Foo<A> {
diff --git a/src/test/run-pass/regions-infer-bivariance.rs b/src/test/run-pass/regions-infer-bivariance.rs
index 8b9d6af1017..a750b3f4b4e 100644
--- a/src/test/run-pass/regions-infer-bivariance.rs
+++ b/src/test/run-pass/regions-infer-bivariance.rs
@@ -11,7 +11,7 @@
 // Test that a type whose lifetime parameters is never used is
 // inferred to be bivariant.
 
-use std::kinds::marker;
+use std::markers;
 
 struct Bivariant<'a>;
 
diff --git a/src/test/run-pass/syntax-trait-polarity.rs b/src/test/run-pass/syntax-trait-polarity.rs
index 021cfedf06f..244e084e65b 100644
--- a/src/test/run-pass/syntax-trait-polarity.rs
+++ b/src/test/run-pass/syntax-trait-polarity.rs
@@ -10,7 +10,7 @@
 
 #![feature(optin_builtin_traits)]
 
-use std::kinds::Send;
+use std::markers::Send;
 
 struct TestType;