bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

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

Browse source 
[breaking-change]
This commit is contained in:
Nick Cameron 2015-01-06 14:03:46 +13:00
parent 6539cb417f
commit 503709708c
154 changed files with 635 additions and 623 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/doc/guide-unsafe.md
View file

@ -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

2
src/liballoc/arc.rs
View file

@ -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;

2
src/liballoc/boxed.rs
View file

@ -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;

24
src/liballoc/rc.rs
View file

@ -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 }
}
}

10
src/libcollections/btree/map.rs
View file

@ -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)

6
src/libcollections/lib.rs
View file

@ -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;

6
src/libcollections/ring_buf.rs
View file

@ -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]

2
src/libcollections/slice.rs
View file

@ -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};

2
src/libcollections/vec.rs
View file

@ -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};

2
src/libcore/array.rs
View file

@ -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;

2
src/libcore/atomic.rs
View file

@ -72,7 +72,7 @@
use self::Ordering::*;
use kinds::Sync;
use markers::Sync;
use intrinsics;
use cell::UnsafeCell;

2
src/libcore/borrow.rs
View file

@ -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::*;

6
src/libcore/cell.rs
View file

@ -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
/// }
/// ```
///

2
src/libcore/clone.rs
View file

@ -21,7 +21,7 @@
#![stable]
use kinds::Sized;
use markers::Sized;
/// A common trait for cloning an object.
#[stable]

4
src/libcore/cmp.rs
View file

@ -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};

2
src/libcore/fmt/mod.rs
View file

@ -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};

2
src/libcore/iter.rs
View file

@ -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

298
src/libcore/kinds.rs
View file

@ -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;
}

6
src/libcore/lib.rs
View file

@ -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;

299
src/libcore/markers.rs Normal file
View file

@ -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;

2
src/libcore/mem.rs
View file

@ -15,7 +15,7 @@
#![stable]
use kinds::Sized;
use markers::Sized;
use intrinsics;
use ptr;

4
src/libcore/num/mod.rs
View file

@ -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]

2
src/libcore/ops.rs
View file

@ -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

2
src/libcore/prelude.rs
View file

@ -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

2
src/libcore/ptr.rs
View file

@ -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};

2
src/libcore/raw.rs
View file

@ -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

16
src/libcore/slice.rs
View file

@ -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]

2
src/libcore/str/mod.rs
View file

@ -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};

2
src/libcore/ty.rs
View file

@ -10,4 +10,4 @@
//! Types dealing with unsafe actions.
use kinds::marker;
use markers;

2
src/libcoretest/hash/mod.rs
View file

@ -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;

2
src/libcoretest/num/mod.rs
View file

@ -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)]

4
src/libcoretest/option.rs
View file

@ -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();
}

4
src/liblibc/lib.rs
View file

@ -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;
}

4
src/librand/lib.rs
View file

@ -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)]

4
src/librustc/middle/expr_use_visitor.rs
View file

@ -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

6
src/librustc/middle/infer/unify.rs
View file

@ -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() }
}

4
src/librustc_typeck/variance.rs
View file

@ -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.

2
src/libstd/collections/hash/map.rs
View file

@ -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};

2
src/libstd/collections/hash/set.rs
View file

@ -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;

22
src/libstd/collections/hash/table.rs
View file

@ -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> {

2
src/libstd/hash.rs
View file

@ -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;

2
src/libstd/io/mod.rs
View file

@ -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;

2
src/libstd/io/stdio.rs
View file

@ -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;

11
src/libstd/lib.rs
View file

@ -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

2
src/libstd/num/mod.rs
View file

@ -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};

2
src/libstd/os.rs
View file

@ -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;

2
src/libstd/path/mod.rs
View file

@ -61,7 +61,7 @@
#![experimental]
use core::kinds::Sized;
use core::markers::Sized;
use ffi::CString;
use clone::Clone;
use fmt;

2
src/libstd/path/posix.rs
View file

@ -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};

2
src/libstd/prelude/v1.rs
View file

@ -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

2
src/libstd/rand/os.rs
View file

@ -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;

2
src/libstd/rt/mod.rs
View file

@ -23,7 +23,7 @@
#![allow(dead_code)]
use kinds::Send;
use markers::Send;
use ops::FnOnce;
use sys;
use thunk::Thunk;

4
src/libstd/sync/mpsc/blocking.rs
View file

@ -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;

6
src/libstd/sync/mpsc/mod.rs
View file

@ -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.

6
src/libstd/sync/mpsc/select.rs
View file

@ -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),

6
src/libstd/sync/mutex.rs
View file

@ -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,
}
})
}

2
src/libstd/sync/once.rs
View file

@ -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};

10
src/libstd/sync/rwlock.rs
View file

@ -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,
}
})
}

2
src/libstd/sys/common/mutex.rs
View file

@ -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.

8
src/libstd/sys/unix/c.rs
View file

@ -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 {

2
src/libstd/sys/unix/mutex.rs
View file

@ -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;

2
src/libstd/thread.rs
View file

@ -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};

4
src/libstd/thread_local/mod.rs
View file

@ -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>,

10
src/libstd/thread_local/scoped.rs
View file

@ -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> {

2
src/libstd/thunk.rs
View file

@ -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=()> {

2
src/libsyntax/ext/deriving/bounds.rs
View file

@ -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!()

2
src/libunicode/tables.rs
View file

@ -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};

2
src/test/compile-fail/associated-types-unsized.rs
View file

@ -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() {

2
src/test/compile-fail/bad-method-typaram-kind.rs
View file

@ -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 {

6
src/test/compile-fail/bad-sized.rs
View file

@ -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
}

6
src/test/compile-fail/borrowck-move-out-of-static-item.rs
View file

@ -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) {

2
src/test/compile-fail/borrowck-struct-update-with-dtor.rs
View file

@ -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 }

4
src/test/compile-fail/builtin-superkinds-double-superkind.rs
View file

@ -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)

2
src/test/compile-fail/builtin-superkinds-in-metadata.rs
View file

@ -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() { }

2
src/test/compile-fail/builtin-superkinds-typaram-not-send.rs
View file

@ -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() { }

2
src/test/compile-fail/check-static-values-constraints.rs
View file

@ -10,7 +10,7 @@
// Verifies all possible restrictions for statics values.
use std::kinds::marker;
use std::markers;
struct WithDtor;

2
src/test/compile-fail/comm-not-freeze-receiver.rs
View file

@ -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
}

2
src/test/compile-fail/comm-not-freeze.rs
View file

@ -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
}

2
src/test/compile-fail/dst-bad-assign-2.rs
View file

@ -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
}

2
src/test/compile-fail/dst-bad-assign.rs
View file

@ -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`
}

2
src/test/compile-fail/dst-bad-deep.rs
View file

@ -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
}

8
src/test/compile-fail/dst-object-from-unsized-type.rs
View file

@ -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() { }

4
src/test/compile-fail/dst-sized-trait-param.rs
View file

@ -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() { }

2
src/test/compile-fail/error-should-say-copy-not-pod.rs
View file

@ -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
}

2
src/test/compile-fail/issue-14366.rs
View file

@ -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`
}

2
src/test/compile-fail/issue-15756.rs
View file

@ -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
{
}

2
src/test/compile-fail/issue-16538.rs
View file

@ -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() {}

6
src/test/compile-fail/issue-17718-static-move.rs
View file

@ -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() {

8
src/test/compile-fail/issue-17718-static-sync.rs
View file

@ -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() {}

2
src/test/compile-fail/issue-18107.rs
View file

@ -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!()

6
src/test/compile-fail/issue-19883.rs
View file

@ -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
)
}

4
src/test/compile-fail/issue-20005.rs
View file

@ -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
)
}

2
src/test/compile-fail/issue-3907-2.rs
View file

@ -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() {}

2
src/test/compile-fail/issue-5035-2.rs
View file

@ -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() {}

2
src/test/compile-fail/issue-5543.rs
View file

@ -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`
}

4
src/test/compile-fail/issue-5883.rs
View file

@ -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 }
}

4
src/test/compile-fail/issue-7013.rs
View file

@ -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
}

4
src/test/compile-fail/issue-7364.rs
View file

@ -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() { }

22
src/test/compile-fail/kindck-copy.rs
View file

@ -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() {

2
src/test/compile-fail/kindck-impl-type-params-2.rs
View file

@ -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
}

12
src/test/compile-fail/kindck-impl-type-params.rs
View file

@ -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() { }

Some files were not shown because too many files have changed in this diff Show more