rollup merge of #20607: nrc/kinds
Conflicts: src/libcore/array.rs src/libcore/cell.rs src/libcore/prelude.rs src/libstd/path/posix.rs src/libstd/prelude/v1.rs src/test/compile-fail/dst-sized-trait-param.rs
This commit is contained in:
Alex Crichton
commit
771fe9026a
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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::marker::{Sync, Send};
|
||||
use core::mem::{min_align_of, size_of, drop};
|
||||
use core::mem;
|
||||
use core::nonzero::NonZero;
|
||||
|
|
|
|||
|
|
@ -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::marker::Sized;
|
||||
use core::mem;
|
||||
use core::option::Option;
|
||||
use core::ptr::Unique;
|
||||
|
|
|
|||
|
|
@ -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::marker;
|
||||
use core::mem::{transmute, min_align_of, size_of, forget};
|
||||
use core::nonzero::NonZero;
|
||||
use core::ops::{Deref, Drop};
|
||||
|
|
|
|||
|
|
@ -480,7 +480,7 @@ enum Continuation<A, B> {
|
|||
/// boilerplate gets cut out.
|
||||
mod stack {
|
||||
use core::prelude::*;
|
||||
use core::kinds::marker;
|
||||
use core::marker;
|
||||
use core::mem;
|
||||
use core::ops::{Deref, DerefMut};
|
||||
use super::BTreeMap;
|
||||
|
|
|
|||
|
|
@ -99,7 +99,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::marker as kinds;
|
||||
pub use core::marker; // deriving(Copy)
|
||||
pub use core::hash; // deriving(Hash)
|
||||
}
|
||||
|
||||
|
|
@ -114,7 +116,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::marker::{Copy, Send, Sized, Sync};
|
||||
pub use core::mem::drop;
|
||||
pub use core::ops::{Drop, Fn, FnMut, FnOnce};
|
||||
pub use core::option::Option;
|
||||
|
|
|
|||
|
|
@ -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::marker;
|
||||
use core::mem;
|
||||
use core::num::{Int, UnsignedInt};
|
||||
use core::ops::{Index, IndexMut};
|
||||
|
|
|
|||
|
|
@ -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::marker::Sized;
|
||||
use core::mem::size_of;
|
||||
use core::mem;
|
||||
use core::ops::{FnMut, FullRange, Index, IndexMut};
|
||||
|
|
|
|||
|
|
@ -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::marker::{ContravariantLifetime, InvariantType};
|
||||
use core::mem;
|
||||
use core::nonzero::NonZero;
|
||||
use core::num::{Int, UnsignedInt};
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@
|
|||
use clone::Clone;
|
||||
use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
|
||||
use fmt;
|
||||
use kinds::Copy;
|
||||
use marker::Copy;
|
||||
use ops::{Deref, FullRange, Index};
|
||||
use option::Option;
|
||||
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@
|
|||
|
||||
use self::Ordering::*;
|
||||
|
||||
use kinds::Sync;
|
||||
use marker::Sync;
|
||||
|
||||
use intrinsics;
|
||||
use cell::UnsafeCell;
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@
|
|||
use clone::Clone;
|
||||
use cmp::{Eq, Ord, Ordering, PartialEq, PartialOrd};
|
||||
use fmt;
|
||||
use kinds::Sized;
|
||||
use marker::Sized;
|
||||
use ops::Deref;
|
||||
use option::Option;
|
||||
use self::Cow::*;
|
||||
|
|
|
|||
|
|
@ -160,7 +160,7 @@
|
|||
use clone::Clone;
|
||||
use cmp::PartialEq;
|
||||
use default::Default;
|
||||
use kinds::{Copy, Send};
|
||||
use marker::{Copy, Send};
|
||||
use ops::{Deref, DerefMut, Drop};
|
||||
use option::Option;
|
||||
use option::Option::{None, Some};
|
||||
|
|
@ -509,7 +509,7 @@ impl<'b, T> DerefMut for RefMut<'b, T> {
|
|||
///
|
||||
/// ```rust
|
||||
/// use std::cell::UnsafeCell;
|
||||
/// use std::kinds::marker;
|
||||
/// use std::marker;
|
||||
///
|
||||
/// struct NotThreadSafe<T> {
|
||||
/// value: UnsafeCell<T>,
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@
|
|||
|
||||
#![stable]
|
||||
|
||||
use kinds::Sized;
|
||||
use marker::Sized;
|
||||
|
||||
/// A common trait for cloning an object.
|
||||
#[stable]
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@
|
|||
|
||||
use self::Ordering::*;
|
||||
|
||||
use kinds::Sized;
|
||||
use marker::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 marker::Sized;
|
||||
use option::Option;
|
||||
use option::Option::{Some, None};
|
||||
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ use any;
|
|||
use cell::{Cell, RefCell, Ref, RefMut};
|
||||
use char::CharExt;
|
||||
use iter::{Iterator, IteratorExt, range};
|
||||
use kinds::{Copy, Sized};
|
||||
use marker::{Copy, Sized};
|
||||
use mem;
|
||||
use option::Option;
|
||||
use option::Option::{Some, None};
|
||||
|
|
|
|||
|
|
@ -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::marker::Sized;
|
||||
use uint;
|
||||
|
||||
/// An interface for dealing with "external iterators". These types of iterators
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
@ -107,7 +107,7 @@ pub mod ptr;
|
|||
|
||||
/* Core language traits */
|
||||
|
||||
pub mod kinds;
|
||||
pub mod marker;
|
||||
pub mod ops;
|
||||
pub mod cmp;
|
||||
pub mod clone;
|
||||
|
|
@ -146,7 +146,9 @@ mod core {
|
|||
mod std {
|
||||
pub use clone;
|
||||
pub use cmp;
|
||||
pub use kinds;
|
||||
#[cfg(stage0)]
|
||||
pub use marker as kinds;
|
||||
pub use marker;
|
||||
pub use option;
|
||||
pub use fmt;
|
||||
pub use hash;
|
||||
|
|
|
|||
|
|
@ -0,0 +1,314 @@
|
|||
// 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.
|
||||
|
||||
#![stable]
|
||||
|
||||
use clone::Clone;
|
||||
|
||||
/// Types able to be transferred across task boundaries.
|
||||
#[unstable = "will be overhauled with new lifetime rules; see RFC 458"]
|
||||
#[lang="send"]
|
||||
pub unsafe trait Send: 'static {
|
||||
// empty.
|
||||
}
|
||||
|
||||
/// Types with a constant size known at compile-time.
|
||||
#[stable]
|
||||
#[lang="sized"]
|
||||
pub trait Sized {
|
||||
// Empty.
|
||||
}
|
||||
|
||||
/// Types that can be copied by simply copying bits (i.e. `memcpy`).
|
||||
#[stable]
|
||||
#[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::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).
|
||||
#[unstable = "will be overhauled with new lifetime rules; see RFC 458"]
|
||||
#[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).
|
||||
#[unstable = "likely to change with new variance strategy"]
|
||||
#[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.
|
||||
#[unstable = "likely to change with new variance strategy"]
|
||||
#[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.
|
||||
#[unstable = "likely to change with new variance strategy"]
|
||||
#[lang="invariant_type"]
|
||||
#[derive(PartialEq, Eq, PartialOrd, Ord)]
|
||||
pub struct InvariantType<T: ?Sized>;
|
||||
|
||||
#[unstable = "likely to change with new variance strategy"]
|
||||
impl<T: ?Sized> Copy for InvariantType<T> {}
|
||||
#[unstable = "likely to change with new variance strategy"]
|
||||
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>.
|
||||
#[unstable = "likely to change with new variance strategy"]
|
||||
#[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>.
|
||||
#[unstable = "likely to change with new variance strategy"]
|
||||
#[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`).
|
||||
#[unstable = "likely to change with new variance strategy"]
|
||||
#[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.
|
||||
#[unstable = "likely to change with new variance strategy"]
|
||||
#[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.
|
||||
#[unstable = "likely to change with new variance strategy"]
|
||||
#[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.
|
||||
#[unstable = "likely to change with new variance strategy"]
|
||||
#[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.
|
||||
#[unstable = "likely to change with new variance strategy"]
|
||||
#[lang="managed_bound"]
|
||||
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
|
||||
#[allow(missing_copy_implementations)]
|
||||
pub struct Managed;
|
||||
|
|
@ -15,7 +15,7 @@
|
|||
|
||||
#![stable]
|
||||
|
||||
use kinds::Sized;
|
||||
use marker::Sized;
|
||||
use intrinsics;
|
||||
use ptr;
|
||||
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ use cmp::{PartialEq, Eq};
|
|||
use cmp::{PartialOrd, Ord};
|
||||
use intrinsics;
|
||||
use iter::IteratorExt;
|
||||
use kinds::Copy;
|
||||
use marker::Copy;
|
||||
use mem::size_of;
|
||||
use ops::{Add, Sub, Mul, Div, Rem, Neg};
|
||||
use ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr, Index};
|
||||
|
|
@ -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 : ::marker::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]
|
||||
|
|
|
|||
|
|
@ -63,7 +63,7 @@
|
|||
|
||||
use clone::Clone;
|
||||
use iter::{Step, Iterator,DoubleEndedIterator,ExactSizeIterator};
|
||||
use kinds::Sized;
|
||||
use marker::Sized;
|
||||
use option::Option::{self, Some, None};
|
||||
|
||||
/// The `Drop` trait is used to run some code when a value goes out of scope. This
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@
|
|||
//! ```
|
||||
|
||||
// Reexported core operators
|
||||
pub use kinds::{Copy, Send, Sized, Sync};
|
||||
pub use marker::{Copy, Send, Sized, Sync};
|
||||
pub use ops::{Drop, Fn, FnMut, FnOnce, FullRange};
|
||||
|
||||
// Reexported functions
|
||||
|
|
|
|||
|
|
@ -92,7 +92,7 @@ use mem;
|
|||
use clone::Clone;
|
||||
use intrinsics;
|
||||
use option::Option::{self, Some, None};
|
||||
use kinds::{Send, Sized, Sync};
|
||||
use marker::{Send, Sized, Sync};
|
||||
|
||||
use cmp::{PartialEq, Eq, Ord, PartialOrd};
|
||||
use cmp::Ordering::{self, Less, Equal, Greater};
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@
|
|||
//!
|
||||
//! Their definition should always match the ABI defined in `rustc::back::abi`.
|
||||
|
||||
use kinds::Copy;
|
||||
use marker::Copy;
|
||||
use mem;
|
||||
|
||||
/// The representation of a Rust slice
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ use cmp::Ordering::{Less, Equal, Greater};
|
|||
use cmp;
|
||||
use default::Default;
|
||||
use iter::*;
|
||||
use kinds::Copy;
|
||||
use marker::Copy;
|
||||
use num::Int;
|
||||
use ops::{FnMut, self, Index};
|
||||
use option::Option;
|
||||
|
|
@ -52,7 +52,7 @@ use ptr;
|
|||
use ptr::PtrExt;
|
||||
use mem;
|
||||
use mem::size_of;
|
||||
use kinds::{Sized, marker};
|
||||
use marker::{Sized, self};
|
||||
use raw::Repr;
|
||||
// Avoid conflicts with *both* the Slice trait (buggy) and the `slice::raw` module.
|
||||
use raw::Slice as RawSlice;
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ use default::Default;
|
|||
use iter::range;
|
||||
use iter::ExactSizeIterator;
|
||||
use iter::{Map, Iterator, IteratorExt, DoubleEndedIterator};
|
||||
use kinds::Sized;
|
||||
use marker::Sized;
|
||||
use mem;
|
||||
use num::Int;
|
||||
use ops::{Fn, FnMut, Index};
|
||||
|
|
|
|||
|
|
@ -10,4 +10,4 @@
|
|||
|
||||
//! Types dealing with unsafe actions.
|
||||
|
||||
use kinds::marker;
|
||||
use marker;
|
||||
|
|
|
|||
|
|
@ -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::marker::Sized;
|
||||
use std::mem;
|
||||
|
||||
use core::slice::SliceExt;
|
||||
|
|
|
|||
|
|
@ -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::marker::Copy;
|
||||
|
||||
#[macro_use]
|
||||
mod int_macros;
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@
|
|||
// except according to those terms.
|
||||
|
||||
use core::option::*;
|
||||
use core::kinds::marker;
|
||||
use core::marker;
|
||||
use core::mem;
|
||||
use core::clone::Clone;
|
||||
|
||||
|
|
|
|||
|
|
@ -5080,5 +5080,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::marker as kinds;
|
||||
pub use core::marker;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -495,7 +495,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::marker as kinds;
|
||||
pub use core::marker;
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@ use middle::ty::{MethodOrigin, MethodParam, MethodTypeParam};
|
|||
use middle::ty::{MethodStatic, MethodStaticUnboxedClosure};
|
||||
use util::ppaux::Repr;
|
||||
|
||||
use std::kinds;
|
||||
use std::marker;
|
||||
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> marker::Copy for TrackMatchMode<T> {}
|
||||
|
||||
impl<T> TrackMatchMode<T> {
|
||||
// Builds up the whole match mode for a pattern from its constituent
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@
|
|||
|
||||
pub use self::VarValue::*;
|
||||
|
||||
use std::kinds::marker;
|
||||
use std::marker;
|
||||
|
||||
use middle::ty::{expected_found, IntVarValue};
|
||||
use middle::ty::{self, Ty};
|
||||
|
|
|
|||
|
|
@ -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::marker::InvariantType,
|
||||
// std::marker::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.
|
||||
|
|
|
|||
|
|
@ -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 marker::Sized;
|
||||
use mem::{self, replace};
|
||||
use num::{Int, UnsignedInt};
|
||||
use ops::{Deref, FnMut, Index, IndexMut};
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@
|
|||
use borrow::BorrowFrom;
|
||||
use clone::Clone;
|
||||
use cmp::{Eq, PartialEq};
|
||||
use core::kinds::Sized;
|
||||
use core::marker::Sized;
|
||||
use default::Default;
|
||||
use fmt::Show;
|
||||
use fmt;
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ use clone::Clone;
|
|||
use cmp;
|
||||
use hash::{Hash, Hasher};
|
||||
use iter::{Iterator, count};
|
||||
use kinds::{Copy, Sized, marker};
|
||||
use marker::{Copy, Sized, self};
|
||||
use mem::{min_align_of, size_of};
|
||||
use mem;
|
||||
use num::{Int, UnsignedInt};
|
||||
|
|
|
|||
|
|
@ -63,7 +63,7 @@
|
|||
|
||||
pub use core::hash::{Hash, Hasher, Writer, hash, sip};
|
||||
|
||||
use core::kinds::Sized;
|
||||
use core::marker::Sized;
|
||||
use default::Default;
|
||||
use rand::Rng;
|
||||
use rand;
|
||||
|
|
|
|||
|
|
@ -232,7 +232,7 @@ use error::{FromError, Error};
|
|||
use fmt;
|
||||
use int;
|
||||
use iter::{Iterator, IteratorExt};
|
||||
use kinds::Sized;
|
||||
use marker::Sized;
|
||||
use mem::transmute;
|
||||
use ops::{FnOnce, Index};
|
||||
use option::Option;
|
||||
|
|
|
|||
|
|
@ -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 marker::{Sync, Send};
|
||||
use libc;
|
||||
use mem;
|
||||
use option::Option;
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
//!
|
||||
|
|
@ -134,7 +134,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::marker;
|
||||
#[cfg(test)] pub use realstd::ops;
|
||||
#[cfg(test)] pub use realstd::cmp;
|
||||
#[cfg(test)] pub use realstd::boxed;
|
||||
|
|
@ -151,7 +151,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::marker as kinds;
|
||||
#[cfg(not(test))] pub use core::marker;
|
||||
pub use core::mem;
|
||||
#[cfg(not(test))] pub use core::ops;
|
||||
pub use core::ptr;
|
||||
|
|
@ -282,7 +283,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 marker as kinds;
|
||||
pub use marker; // used for tls!
|
||||
pub use ops; // used for bitflags!
|
||||
|
||||
// The test runner calls ::std::os::args() but really wants realstd
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@
|
|||
#[cfg(test)] use fmt::Show;
|
||||
use ops::{Add, Sub, Mul, Div, Rem, Neg};
|
||||
|
||||
use kinds::Copy;
|
||||
use marker::Copy;
|
||||
use clone::Clone;
|
||||
use cmp::{PartialOrd, PartialEq};
|
||||
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ use error::{FromError, Error};
|
|||
use fmt;
|
||||
use io::{IoResult, IoError};
|
||||
use iter::{Iterator, IteratorExt};
|
||||
use kinds::Copy;
|
||||
use marker::Copy;
|
||||
use libc::{c_void, c_int, c_char};
|
||||
use libc;
|
||||
use boxed::Box;
|
||||
|
|
|
|||
|
|
@ -61,7 +61,7 @@
|
|||
|
||||
#![experimental]
|
||||
|
||||
use core::kinds::Sized;
|
||||
use core::marker::Sized;
|
||||
use ffi::CString;
|
||||
use clone::Clone;
|
||||
use fmt;
|
||||
|
|
|
|||
|
|
@ -17,8 +17,8 @@ use hash;
|
|||
use io::Writer;
|
||||
use iter::{AdditiveIterator, Extend};
|
||||
use iter::{Iterator, IteratorExt, Map};
|
||||
use prelude::v1::Index;
|
||||
use kinds::Sized;
|
||||
use ops::Index;
|
||||
use marker::Sized;
|
||||
use option::Option::{self, Some, None};
|
||||
use slice::{AsSlice, Split, SliceExt, SliceConcatExt};
|
||||
use str::{self, FromStr, StrExt};
|
||||
|
|
|
|||
|
|
@ -13,9 +13,8 @@
|
|||
#![stable]
|
||||
|
||||
// Reexported core operators
|
||||
#[stable] #[doc(no_inline)] pub use kinds::{Copy, Send, Sized, Sync};
|
||||
#[stable] #[doc(no_inline)] pub use marker::{Copy, Send, Sized, Sync};
|
||||
#[stable] #[doc(no_inline)] pub use ops::{Drop, Fn, FnMut, FnOnce, FullRange};
|
||||
#[unstable] #[doc(no_inline)] pub use ops::{Index, IndexMut};
|
||||
|
||||
// Reexported functions
|
||||
#[stable] #[doc(no_inline)] pub use mem::drop;
|
||||
|
|
|
|||
|
|
@ -182,7 +182,7 @@ mod imp {
|
|||
extern crate libc;
|
||||
|
||||
use io::{IoResult};
|
||||
use kinds::Sync;
|
||||
use marker::Sync;
|
||||
use mem;
|
||||
use os;
|
||||
use rand::Rng;
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@
|
|||
|
||||
#![allow(dead_code)]
|
||||
|
||||
use kinds::Send;
|
||||
use marker::Send;
|
||||
use ops::FnOnce;
|
||||
use sys;
|
||||
use thunk::Thunk;
|
||||
|
|
|
|||
|
|
@ -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 marker::{Sync, Send};
|
||||
use marker::{NoSend, NoSync};
|
||||
use mem;
|
||||
use clone::Clone;
|
||||
|
||||
|
|
|
|||
|
|
@ -319,7 +319,7 @@ use prelude::v1::*;
|
|||
|
||||
use sync::Arc;
|
||||
use fmt;
|
||||
use kinds::marker;
|
||||
use marker;
|
||||
use mem;
|
||||
use cell::UnsafeCell;
|
||||
|
||||
|
|
|
|||
|
|
@ -57,7 +57,7 @@
|
|||
use core::prelude::*;
|
||||
|
||||
use core::cell::Cell;
|
||||
use core::kinds::marker;
|
||||
use core::marker;
|
||||
use core::mem;
|
||||
use core::uint;
|
||||
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
use prelude::v1::*;
|
||||
|
||||
use cell::UnsafeCell;
|
||||
use kinds::marker;
|
||||
use marker;
|
||||
use ops::{Deref, DerefMut};
|
||||
use sync::poison::{self, TryLockError, TryLockResult, LockResult};
|
||||
use sys_common::mutex as sys;
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@
|
|||
//! example use case would be for initializing an FFI library.
|
||||
|
||||
use int;
|
||||
use kinds::Sync;
|
||||
use marker::Sync;
|
||||
use mem::drop;
|
||||
use ops::FnOnce;
|
||||
use sync::atomic::{AtomicInt, Ordering, ATOMIC_INT_INIT};
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
use prelude::v1::*;
|
||||
|
||||
use cell::UnsafeCell;
|
||||
use kinds::marker;
|
||||
use marker;
|
||||
use ops::{Deref, DerefMut};
|
||||
use sync::poison::{self, LockResult, TryLockError, TryLockResult};
|
||||
use sys_common::rwlock as sys;
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use kinds::Sync;
|
||||
use marker::Sync;
|
||||
use sys::mutex as imp;
|
||||
|
||||
/// An OS-based mutual exclusion lock.
|
||||
|
|
|
|||
|
|
@ -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 ::marker::Send for sigaction { }
|
||||
unsafe impl ::marker::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 ::marker::Send for sigaction { }
|
||||
unsafe impl ::marker::Sync for sigaction { }
|
||||
|
||||
#[repr(C)]
|
||||
pub struct sigset_t {
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@
|
|||
// except according to those terms.
|
||||
|
||||
use cell::UnsafeCell;
|
||||
use kinds::Sync;
|
||||
use marker::Sync;
|
||||
use sys::sync as ffi;
|
||||
use sys_common::mutex;
|
||||
|
||||
|
|
|
|||
|
|
@ -128,7 +128,7 @@ use any::Any;
|
|||
use boxed::Box;
|
||||
use cell::UnsafeCell;
|
||||
use clone::Clone;
|
||||
use kinds::{Send, Sync};
|
||||
use marker::{Send, Sync};
|
||||
use ops::{Drop, FnOnce};
|
||||
use option::Option::{self, Some, None};
|
||||
use result::Result::{Err, Ok};
|
||||
|
|
|
|||
|
|
@ -345,7 +345,7 @@ mod imp {
|
|||
pub dtor_running: UnsafeCell<bool>, // should be Cell
|
||||
}
|
||||
|
||||
unsafe impl<T> ::kinds::Sync for Key<T> { }
|
||||
unsafe impl<T> ::marker::Sync for Key<T> { }
|
||||
|
||||
#[doc(hidden)]
|
||||
impl<T> Key<T> {
|
||||
|
|
@ -471,7 +471,7 @@ mod imp {
|
|||
pub os: OsStaticKey,
|
||||
}
|
||||
|
||||
unsafe impl<T> ::kinds::Sync for Key<T> { }
|
||||
unsafe impl<T> ::marker::Sync for Key<T> { }
|
||||
|
||||
struct Value<T: 'static> {
|
||||
key: &'static Key<T>,
|
||||
|
|
|
|||
|
|
@ -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::marker::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> ::marker::Sync for KeyInner<T> { }
|
||||
|
||||
#[doc(hidden)]
|
||||
impl<T> KeyInner<T> {
|
||||
|
|
@ -224,7 +224,7 @@ mod imp {
|
|||
|
||||
#[cfg(any(windows, target_os = "android", target_os = "ios", target_arch = "aarch64"))]
|
||||
mod imp {
|
||||
use kinds::marker;
|
||||
use marker;
|
||||
use sys_common::thread_local::StaticKey as OsStaticKey;
|
||||
|
||||
#[doc(hidden)]
|
||||
|
|
@ -233,7 +233,7 @@ mod imp {
|
|||
pub marker: marker::InvariantType<T>,
|
||||
}
|
||||
|
||||
unsafe impl<T> ::kinds::Sync for KeyInner<T> { }
|
||||
unsafe impl<T> ::marker::Sync for KeyInner<T> { }
|
||||
|
||||
#[doc(hidden)]
|
||||
impl<T> KeyInner<T> {
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@
|
|||
#![allow(missing_docs)]
|
||||
|
||||
use alloc::boxed::Box;
|
||||
use core::kinds::Send;
|
||||
use core::marker::Send;
|
||||
use core::ops::FnOnce;
|
||||
|
||||
pub struct Thunk<A=(),R=()> {
|
||||
|
|
|
|||
|
|
@ -48,7 +48,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", "marker", name)),
|
||||
additional_bounds: Vec::new(),
|
||||
generics: LifetimeBounds::empty(),
|
||||
methods: vec!()
|
||||
|
|
|
|||
|
|
@ -7801,7 +7801,7 @@ pub mod charwidth {
|
|||
}
|
||||
|
||||
pub mod grapheme {
|
||||
use core::kinds::Copy;
|
||||
use core::marker::Copy;
|
||||
use core::slice::SliceExt;
|
||||
pub use self::GraphemeCat::*;
|
||||
use core::result::Result::{Ok, Err};
|
||||
|
|
|
|||
|
|
@ -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::marker::Sized` is not implemented
|
||||
}
|
||||
|
||||
fn main() {
|
||||
|
|
|
|||
|
|
@ -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::marker::Send` is not implemented
|
||||
}
|
||||
|
||||
trait bar {
|
||||
|
|
|
|||
|
|
@ -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::marker::Sized` is not implemented
|
||||
//~^^ ERROR the trait `core::marker::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::marker::Sized` is not implemented
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@
|
|||
|
||||
// Ensure that moves out of static items is forbidden
|
||||
|
||||
use std::kinds::marker;
|
||||
use std::marker;
|
||||
|
||||
struct Foo {
|
||||
foo: int,
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@
|
|||
// move, when the struct implements Drop.
|
||||
|
||||
// NoCopy
|
||||
use std::kinds::marker::NoCopy as NP;
|
||||
use std::marker::NoCopy as NP;
|
||||
|
||||
|
||||
struct S { a: int, np: NP }
|
||||
|
|
|
|||
|
|
@ -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::marker::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::marker::Sync` is not implemented
|
||||
|
||||
impl <T: Send+Sync> Foo for (T,T,T) { } // (ok)
|
||||
|
||||
|
|
|
|||
|
|
@ -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::marker::Send` is not implemented
|
||||
|
||||
fn main() { }
|
||||
|
|
|
|||
|
|
@ -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::marker::Send` is not implemented
|
||||
|
||||
fn main() { }
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@
|
|||
|
||||
// Verifies all possible restrictions for statics values.
|
||||
|
||||
use std::kinds::marker;
|
||||
use std::marker;
|
||||
|
||||
struct WithDtor;
|
||||
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ struct X<F> where F: FnOnce() + 'static + Send {
|
|||
}
|
||||
|
||||
fn foo<F>(blk: F) -> X<F> where F: FnOnce() + 'static {
|
||||
//~^ ERROR the trait `core::kinds::Send` is not implemented for the type
|
||||
//~^ ERROR the trait `core::marker::Send` is not implemented for the type
|
||||
return X { field: blk };
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ fn give_any<F>(f: F) where F: FnOnce() {
|
|||
|
||||
fn give_owned<F>(f: F) where F: FnOnce() + Send {
|
||||
take_any(f);
|
||||
take_const_owned(f); //~ ERROR the trait `core::kinds::Sync` is not implemented for the type
|
||||
take_const_owned(f); //~ ERROR the trait `core::marker::Sync` is not implemented for the type
|
||||
}
|
||||
|
||||
fn main() {}
|
||||
|
|
|
|||
|
|
@ -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::marker::Sync` is not implemented
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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::marker::Sync` is not implemented
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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::marker::Sized` is not implemented
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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::marker::Sized` is not implemented for the type `ToBar`
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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::marker::Sized` is not implemented
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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::marker::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::marker::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::marker::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::marker::Sized` is not implemented for the type `str`
|
||||
}
|
||||
|
||||
fn main() { }
|
||||
|
|
|
|||
|
|
@ -14,10 +14,10 @@
|
|||
|
||||
trait Foo<T> : Sized { fn take(self, x: &T) { } } // Note: T is sized
|
||||
|
||||
impl Foo<[isize]> for uint { }
|
||||
//~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `[isize]`
|
||||
impl Foo<[isize]> for usize { }
|
||||
//~^ ERROR the trait `core::marker::Sized` is not implemented for the type `[isize]`
|
||||
|
||||
impl Foo<isize> for [usize] { }
|
||||
//~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `[usize]`
|
||||
//~^ ERROR the trait `core::marker::Sized` is not implemented for the type `[usize]`
|
||||
|
||||
pub fn main() { }
|
||||
|
|
|
|||
|
|
@ -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::marker::Copy` is not implemented
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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::marker::Sized` is not implemented for the type `str`
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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::marker::Sized` is not implemented for the type `[T]`
|
||||
in arg2
|
||||
{
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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::marker::Sync` is not implemented for the type
|
||||
|
||||
fn main() {}
|
||||
|
|
|
|||
|
|
@ -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::marker;
|
||||
|
||||
struct Foo { nc: marker::NoCopy }
|
||||
const INIT: Foo = Foo { nc: marker::NoCopy };
|
||||
|
|
|
|||
|
|
@ -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::marker;
|
||||
|
||||
struct Foo { marker: marker::NoSync }
|
||||
|
||||
static FOO: uint = 3;
|
||||
static BAR: Foo = Foo { marker: marker::NoSync };
|
||||
//~^ ERROR: the trait `core::kinds::Sync` is not implemented
|
||||
//~^ ERROR: the trait `core::marker::Sync` is not implemented
|
||||
|
||||
fn main() {}
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ pub trait AbstractRenderer {}
|
|||
|
||||
fn _create_render(_: &()) ->
|
||||
AbstractRenderer
|
||||
//~^ ERROR: the trait `core::kinds::Sized` is not implemented
|
||||
//~^ ERROR: the trait `core::marker::Sized` is not implemented
|
||||
{
|
||||
match 0u {
|
||||
_ => unimplemented!()
|
||||
|
|
|
|||
|
|
@ -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::marker::Sized` is not implemented
|
||||
) ->
|
||||
<Dst as From<Self>>::Dst
|
||||
//~^ error: the trait `core::kinds::Sized` is not implemented
|
||||
//~^ error: the trait `core::marker::Sized` is not implemented
|
||||
{
|
||||
From::from(
|
||||
//~^ error: the trait `core::kinds::Sized` is not implemented
|
||||
//~^ error: the trait `core::marker::Sized` is not implemented
|
||||
self
|
||||
)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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::marker::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::marker::Sized` is not implemented
|
||||
self
|
||||
)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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::marker::Sized` is not implemented
|
||||
|
||||
fn main() {}
|
||||
|
|
|
|||
|
|
@ -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::marker::Sized` is not implemented
|
||||
|
||||
fn main() {}
|
||||
|
|
|
|||
|
|
@ -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::marker::Sized` is not implemented for the type `Foo`
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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::marker::Sized` is not implemented
|
||||
//~^ ERROR the trait `core::marker::Sized` is not implemented
|
||||
Struct { r: r }
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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::marker::Send` is not implemented
|
||||
//~^^ ERROR the trait `core::marker::Send` is not implemented
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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::marker::Sync` is not implemented for the type
|
||||
//~| ERROR: the trait `core::marker::Sync` is not implemented for the type
|
||||
|
||||
fn main() { }
|
||||
|
|
|
|||
|
|
@ -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::marker::Copy` is not implemented
|
||||
assert_copy::<&'a mut int>(); //~ ERROR `core::marker::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::marker::Copy` is not implemented
|
||||
assert_copy::<String>(); //~ ERROR `core::marker::Copy` is not implemented
|
||||
assert_copy::<Vec<int> >(); //~ ERROR `core::marker::Copy` is not implemented
|
||||
assert_copy::<Box<&'a mut int>>(); //~ ERROR `core::marker::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::marker::Copy` is not implemented
|
||||
assert_copy::<Box<Dummy+Copy>>(); //~ ERROR `core::marker::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::marker::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::marker::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::marker::Copy` is not implemented
|
||||
}
|
||||
|
||||
pub fn main() {
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue