// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(core)]
-
-use std::marker::MarkerTrait;
-
-pub trait Foo : MarkerTrait {
+pub trait Foo {
fn bar();
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(core)]
-
-trait Foo : ::std::marker::MarkerTrait {}
+trait Foo {}
pub mod bar {
use std::marker;
- pub trait Bar: marker::MarkerTrait + 'static {}
+ pub trait Bar: 'static {}
impl Bar for .. {}
//! (#14132).
#![crate_name = "a"]
-#![feature(core)]
-
-use std::marker::MarkerTrait;
macro_rules! three {
() => { 3 }
}
-pub trait U : MarkerTrait {}
-pub trait V : MarkerTrait {}
+pub trait U {}
+pub trait V {}
impl U for () {}
impl V for () {}
//! (#14132).
#![crate_name = "a"]
-#![feature(core)]
-
-use std::marker::MarkerTrait;
macro_rules! three {
() => { 3 }
}
-pub trait U : MarkerTrait {}
-pub trait V : MarkerTrait {}
+pub trait U {}
+pub trait V {}
impl U for () {}
impl V for () {}
//! (#14132).
#![crate_name = "a"]
-#![feature(core)]
-
-use std::marker::MarkerTrait;
macro_rules! three {
() => { 3 }
}
-pub trait U : MarkerTrait {}
-pub trait V : MarkerTrait {}
+pub trait U {}
+pub trait V {}
impl U for () {}
impl V for () {}
//! (#14132).
#![crate_name = "a"]
-#![feature(core)]
-
-use std::marker::MarkerTrait;
macro_rules! three {
() => { 3 }
}
-pub trait U : MarkerTrait {}
-pub trait V : MarkerTrait {}
+pub trait U {}
+pub trait V {}
impl U for () {}
impl V for () {}
//! (#14132).
#![crate_name = "a"]
-#![feature(core)]
-
-use std::marker::MarkerTrait;
macro_rules! three {
() => { 3 }
}
-pub trait U : MarkerTrait {}
-pub trait V : MarkerTrait {}
+pub trait U {}
+pub trait V {}
impl U for () {}
impl V for () {}
//! (#14132).
#![crate_name = "a"]
-#![feature(core)]
-
-use std::marker::MarkerTrait;
macro_rules! three {
() => { 3 }
}
-pub trait U : MarkerTrait {}
-pub trait V : MarkerTrait {}
+pub trait U {}
+pub trait V {}
impl U for () {}
impl V for () {}
#![crate_name = "a"]
#![feature(core)]
-use std::marker::MarkerTrait;
-
macro_rules! three {
() => { 3 }
}
-pub trait U : MarkerTrait {}
-pub trait V : MarkerTrait {}
+pub trait U {}
+pub trait V {}
impl U for () {}
impl V for () {}
//! (#14132).
#![crate_name = "a"]
-#![feature(core)]
-
-use std::marker::MarkerTrait;
macro_rules! three {
() => { 3 }
}
-pub trait U : MarkerTrait {}
-pub trait V : MarkerTrait {}
+pub trait U {}
+pub trait V {}
impl U for () {}
impl V for () {}
//! (#14132).
#![crate_name = "a"]
-#![feature(core)]
-
-use std::marker::MarkerTrait;
macro_rules! three {
() => { 3 }
}
-pub trait U : MarkerTrait {}
-pub trait V : MarkerTrait {}
+pub trait U {}
+pub trait V {}
impl U for () {}
impl V for () {}
//! (#14132).
#![crate_name = "a"]
-#![feature(core)]
-
-use std::marker::MarkerTrait;
macro_rules! three {
() => { 3 }
}
-pub trait U : MarkerTrait {}
-pub trait V : MarkerTrait {}
+pub trait U {}
+pub trait V {}
impl U for () {}
impl V for () {}
//! (#14132).
#![crate_name = "a"]
-#![feature(core)]
-
-use std::marker::MarkerTrait;
macro_rules! three {
() => { 3 }
}
-pub trait U : MarkerTrait {}
-pub trait V : MarkerTrait {}
+pub trait U {}
+pub trait V {}
impl U for () {}
impl V for () {}
//! (#14132).
#![crate_name = "a"]
-#![feature(core)]
-
-use std::marker::MarkerTrait;
macro_rules! three {
() => { 3 }
}
-pub trait U : MarkerTrait {}
-pub trait V : MarkerTrait {}
+pub trait U {}
+pub trait V {}
impl U for () {}
impl V for () {}
//! (#14132).
#![crate_name = "a"]
-#![feature(core)]
-
-use std::marker::MarkerTrait;
macro_rules! three {
() => { 3 }
}
-pub trait U : MarkerTrait {}
-pub trait V : MarkerTrait {}
+pub trait U {}
+pub trait V {}
impl U for () {}
impl V for () {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(core)]
-
-pub trait Foo : ::std::marker::MarkerTrait {
+pub trait Foo {
}
impl Foo for isize {
#![feature(optin_builtin_traits, core)]
#![crate_type = "rlib"]
-use std::marker::MarkerTrait;
-
-pub trait DefaultedTrait : MarkerTrait { }
+pub trait DefaultedTrait { }
impl DefaultedTrait for .. { }
pub struct Something<T> { t: T }
// Check that an associated type cannot be bound in an expression path.
-trait Foo : ::std::marker::MarkerTrait {
+trait Foo {
type A;
fn bar() -> isize;
}
// Test that we do not ICE when an impl is missing an associated type (and that we report
// a useful error, of course).
-trait Trait : ::std::marker::MarkerTrait {
+trait Trait {
type Type;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-trait Foo : ::std::marker::MarkerTrait {
+trait Foo {
type X;
type Y;
}
// which checks that the trait interface itself is not considered an
// error as long as all impls satisfy the constraint.
-trait Get : ::std::marker::MarkerTrait {
+trait Get {
type Value;
}
// which checks that the trait interface itself is not considered an
// error as long as all impls satisfy the constraint.
-trait Get : ::std::marker::MarkerTrait {
+trait Get {
type Value;
}
// Check that an associated type cannot be bound in an expression path.
-trait Foo : ::std::marker::MarkerTrait {
+trait Foo {
type A;
fn bar() -> isize;
}
use std::cell::RefCell;
-trait Trait : ::std::marker::MarkerTrait {}
+trait Trait {}
pub fn main() {
let x: Vec<Trait + Sized> = Vec::new();
use std::fmt::Debug;
use std::default::Default;
-use std::marker::MarkerTrait;
// Test that two blanket impls conflict (at least without negative
// bounds). After all, some other crate could implement Even or Odd
fn get(&self) -> usize;
}
-trait Even : MarkerTrait { }
+trait Even { }
-trait Odd : MarkerTrait { }
+trait Odd { }
impl Even for isize { }
fn get(&self) -> usize;
}
-trait Even : ::std::marker::MarkerTrait { }
+trait Even {}
-trait Odd : ::std::marker::MarkerTrait { }
+trait Odd {}
impl<T:Even> MyTrait for T { //~ ERROR E0119
fn get(&self) -> usize { 0 }
#![feature(optin_builtin_traits)]
-trait MyTrait : ::std::marker::MarkerTrait {}
+trait MyTrait {}
struct TestType<T>(::std::marker::PhantomData<T>);
#![feature(optin_builtin_traits)]
-use std::marker::MarkerTrait;
-
-trait MyTrait: MarkerTrait {}
+trait MyTrait {}
impl MyTrait for .. {}
impl MyTrait for .. {}
//~^ ERROR conflicting implementations for trait `MyTrait`
-trait MySafeTrait: MarkerTrait {}
+trait MySafeTrait {}
unsafe impl MySafeTrait for .. {}
//~^ ERROR implementing the trait `MySafeTrait` is not unsafe
-unsafe trait MyUnsafeTrait: MarkerTrait {}
+unsafe trait MyUnsafeTrait {}
impl MyUnsafeTrait for .. {}
//~^ ERROR the trait `MyUnsafeTrait` requires an `unsafe impl` declaration
extern crate coherence_copy_like_lib as lib;
-use std::marker::MarkerTrait;
-
struct MyType { x: i32 }
-trait MyTrait : MarkerTrait { }
+trait MyTrait { }
impl<T: lib::MyCopy> MyTrait for T { } //~ ERROR E0119
extern crate coherence_copy_like_lib as lib;
-use std::marker::MarkerTrait;
-
struct MyType { x: i32 }
-trait MyTrait : MarkerTrait { }
+trait MyTrait { }
impl<T: lib::MyCopy> MyTrait for T { } //~ ERROR E0119
// `MyStruct` is not declared fundamental, therefore this would
extern crate coherence_copy_like_lib as lib;
-use std::marker::MarkerTrait;
-
struct MyType { x: i32 }
-trait MyTrait : MarkerTrait { }
+trait MyTrait { }
impl<T: lib::MyCopy> MyTrait for T { } //~ ERROR E0119
// Tuples are not fundamental, therefore this would require that
}
struct Foo;
-trait Bar : ::std::marker::MarkerTrait {}
+trait Bar {}
impl Bar for Foo {}
pub fn main() {
// Test implicit coercions involving DSTs and raw pointers.
-use std::marker::MarkerTrait;
-
struct S;
-trait T : MarkerTrait {}
+trait T {}
impl T for S {}
struct Foo<T: ?Sized> {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::num::SignedInt;
-
fn main() {
- let _f = 10.abs; //~ ERROR attempted to take value of method
+ let _f = 10i32.abs; //~ ERROR attempted to take value of method
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::marker::MarkerTrait;
-
-trait Node : MarkerTrait {
+trait Node {
fn zomg();
}
// except according to those terms.
use std::fmt::Debug;
-use std::marker::MarkerTrait;
-trait Str : MarkerTrait {}
+trait Str {}
trait Something {
fn yay<T: Debug>(_: Option<Self>, thing: &[T]);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::marker::MarkerTrait;
-
-trait ListItem<'a> : MarkerTrait {
+trait ListItem<'a> {
fn list_name() -> &'a str;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::marker::MarkerTrait;
-
-pub trait AbstractRenderer : MarkerTrait {}
+pub trait AbstractRenderer {}
fn _create_render(_: &()) ->
AbstractRenderer
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(unboxed_closures)]
-
use std::any::Any;
use std::any::TypeId;
-use std::marker::MarkerTrait;
-pub trait Pt : MarkerTrait {}
-pub trait Rt : MarkerTrait {}
+pub trait Pt {}
+pub trait Rt {}
trait Private<P: Pt, R: Rt> {
fn call(&self, p: P, r: R);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::marker::MarkerTrait;
-
fn add_state(op: <isize as HasState>::State) {
//~^ ERROR the trait `HasState` is not implemented for the type `isize`
}
-trait HasState : MarkerTrait {
+trait HasState {
type State;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::marker::MarkerTrait;
-
-trait Foo : MarkerTrait {
+trait Foo {
type Item;
}
// cause compiler to loop. Note that no instances
// of such a type could ever be constructed.
-use std::marker::MarkerTrait;
-
struct t(Box<t>); //~ ERROR this type cannot be instantiated
-trait to_str_2 : MarkerTrait {
+trait to_str_2 {
fn my_to_string() -> String;
}
// away.
use std::cell::RefCell;
-use std::marker::MarkerTrait;
use std::ops::{Shl, Shr};
-pub trait Subscriber : MarkerTrait {
+pub trait Subscriber {
type Input;
}
#![feature(optin_builtin_traits)]
-use std::marker::MarkerTrait;
-
-unsafe trait Trait: MarkerTrait {
+unsafe trait Trait {
//~^ error: traits with default impls (`e.g. unsafe impl Trait for ..`) must have no methods or associated items
type Output;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::num::ToPrimitive;
+pub trait ToPrimitive {
+ fn to_int(&self) -> isize { 0 }
+}
+
+impl ToPrimitive for i32 {}
+impl ToPrimitive for isize {}
trait Add {
fn to_int(&self) -> isize;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::marker::MarkerTrait;
-
-trait I : MarkerTrait {}
+trait I {}
type K = I+'static;
fn foo(_x: K) {} //~ ERROR: the trait `core::marker::Sized` is not implemented
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::marker::MarkerTrait;
-
-trait A : MarkerTrait {}
+trait A {}
struct Struct {
r: A+'static
Struct { r: r }
}
-trait Curve : MarkerTrait {}
+trait Curve {}
enum E {X(Curve+'static)}
fn main() {}
// Test the mechanism for warning about possible missing `self` declarations.
-use std::marker::MarkerTrait;
-
trait CtxtFn {
fn f8(self, usize) -> usize;
fn f9(usize) -> usize; //~ NOTE candidate
}
-trait OtherTrait : MarkerTrait {
+trait OtherTrait {
fn f9(usize) -> usize; //~ NOTE candidate
}
// declaration to match against, so we wind up prisizeing it as a
// candidate. This seems not unreasonable -- perhaps the user meant to
// implement it, after all.
-trait UnusedTrait : MarkerTrait {
+trait UnusedTrait {
fn f9(usize) -> usize; //~ NOTE candidate
}
}
}
-trait ManyImplTrait : MarkerTrait {
+trait ManyImplTrait {
fn is_str() -> bool { //~ NOTE candidate
false
}
// Test which of the builtin types are considered POD.
-use std::marker::MarkerTrait;
use std::rc::Rc;
fn assert_copy<T:Copy>() { }
-trait Dummy : MarkerTrait { }
+trait Dummy { }
#[derive(Copy, Clone)]
struct MyStruct {
#![feature(box_syntax)]
-use std::marker::MarkerTrait;
-
-trait Foo : MarkerTrait {
+trait Foo {
}
impl<T:Copy> Foo for T {
// in this file all test the "kind" violates detected during kindck.
// See all `regions-bounded-by-send.rs`
-use std::marker::MarkerTrait;
-
fn assert_send<T:Send>() { }
-trait Dummy : MarkerTrait { }
+trait Dummy { }
trait Message : Send { }
// careful with object types, who knows what they close over...
// is broken into two parts because some errors occur in distinct
// phases in the compiler. See kindck-send-object2.rs as well!
-use std::marker::MarkerTrait;
-
fn assert_send<T:Send+'static>() { }
-trait Dummy : MarkerTrait { }
+trait Dummy { }
// careful with object types, who knows what they close over...
fn test51<'a>() {
// Continue kindck-send-object1.rs.
-use std::marker::MarkerTrait;
-
fn assert_send<T:Send>() { }
-trait Dummy : MarkerTrait { }
+trait Dummy { }
fn test50() {
assert_send::<&'static Dummy>(); //~ ERROR the trait `core::marker::Sync` is not implemented
fn bar(&self) -> Private<isize> { panic!() }
}
-pub trait ParamTrait<T> : marker::MarkerTrait {
+pub trait ParamTrait<T> {
fn foo() -> T;
}
// Test that an object type `Box<Foo>` is not considered to implement the
// trait `Foo`. Issue #5087.
-use std::marker::MarkerTrait;
-
-trait Foo : MarkerTrait {}
+trait Foo {}
fn take_foo<F:Foo>(f: F) {}
fn take_object(f: Box<Foo>) { take_foo(f); }
//~^ ERROR the trait `Foo` is not implemented
// Check that we correctly prevent users from making trait objects
// from traits with static methods.
-trait Foo : ::std::marker::MarkerTrait {
+trait Foo {
fn foo();
}
#![feature(optin_builtin_traits)]
-use std::marker::{MarkerTrait, PhantomData};
+use std::marker::{PhantomData};
-unsafe trait Zen: MarkerTrait {}
+unsafe trait Zen {}
unsafe impl Zen for .. {}
// public type, private value
pub mod foo1 {
- use std::marker::MarkerTrait;
-
- pub trait Bar : MarkerTrait {
+ pub trait Bar {
}
pub struct Baz;
// private type, public value
pub mod foo2 {
- trait Bar : ::std::marker::MarkerTrait {
+ trait Bar {
}
pub struct Baz;
// neither public
pub mod foo3 {
- trait Bar : ::std::marker::MarkerTrait {
+ trait Bar {
}
pub struct Baz;
// Test that attempts to implicitly coerce a value into an
// object respect the lifetime bound on the object type.
-trait Foo : ::std::marker::MarkerTrait {}
+trait Foo {}
impl<'a> Foo for &'a [u8] {}
// FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
// FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
-use std::marker::MarkerTrait;
-
-trait X : MarkerTrait {}
+trait X {}
trait Iter {
type Item: X;
#![feature(box_syntax)]
-use std::marker::MarkerTrait;
-
-trait Foo : MarkerTrait { }
+trait Foo { }
impl<'a> Foo for &'a isize { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-trait TraitNotAStruct : ::std::marker::MarkerTrait { }
+trait TraitNotAStruct {}
fn main() {
TraitNotAStruct{ value: 0 };
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::marker::MarkerTrait;
-
-trait Trait : MarkerTrait {}
+trait Trait {}
struct Foo<T:Trait> {
x: T,
// Tests for "default" bounds inferred for traits with no bounds list.
-use std::marker::MarkerTrait;
-
-trait Foo : MarkerTrait {}
+trait Foo {}
fn a(_x: Box<Foo+Send>) {
}
// trait impl is only applied to a trait object, not concrete types which implement
// the trait.
-use std::marker::MarkerTrait;
-
-trait T : MarkerTrait {}
+trait T {}
impl<'a> T+'a {
fn foo(&self) {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::num::Int;
+use std::ops::Add;
-trait BrokenAdd: Int {
+trait BrokenAdd: Copy + Add<Output=Self> {
fn broken_add<T>(&self, rhs: T) -> Self {
*self + rhs //~ ERROR mismatched types
//~| expected `Self`
}
}
-impl<T: Int> BrokenAdd for T {}
+impl<T: Copy + Add<Output=T>> BrokenAdd for T {}
pub fn main() {
let foo: u8 = 0;
#![feature(optin_builtin_traits)]
-use std::marker::MarkerTrait;
-
-trait MyTrait: MarkerTrait {}
+trait MyTrait {}
impl MyTrait for .. {}
#![feature(optin_builtin_traits)]
-use std::marker::MarkerTrait;
-
-trait MyTrait: MarkerTrait {}
+trait MyTrait {}
impl MyTrait for .. {}
impl<T> !MyTrait for *mut T {}
#![feature(optin_builtin_traits)]
-use std::marker::MarkerTrait;
-
-trait MyTrait: MarkerTrait {}
+trait MyTrait {}
impl MyTrait for .. {}
-unsafe trait MyUnsafeTrait: MarkerTrait {}
+unsafe trait MyUnsafeTrait {}
unsafe impl MyUnsafeTrait for .. {}
#![feature(optin_builtin_traits)]
-use std::marker::MarkerTrait;
-
-trait Defaulted : MarkerTrait { }
+trait Defaulted { }
impl Defaulted for .. { }
impl<'a,T:Signed> Defaulted for &'a T { }
impl<'a,T:Signed> Defaulted for &'a mut T { }
fn is_defaulted<T:Defaulted>() { }
-trait Signed : MarkerTrait { }
+trait Signed { }
impl Signed for i32 { }
fn main() {
#![feature(optin_builtin_traits)]
-use std::marker::MarkerTrait;
-
trait MyTrait : 'static {}
impl MyTrait for .. {}
#![feature(optin_builtin_traits)]
-use std::marker::MarkerTrait;
-
-trait NotImplemented: MarkerTrait { }
+trait NotImplemented { }
trait MyTrait : NotImplemented {}
#![feature(optin_builtin_traits)]
-use std::marker::MarkerTrait;
+trait NotImplemented { }
-trait NotImplemented: MarkerTrait { }
-
-trait MyTrait: MarkerTrait
+trait MyTrait
where Option<Self> : NotImplemented
{}
// Test `?Sized` local variables.
-use std::marker;
-
-trait T : marker::MarkerTrait { }
+trait T {}
fn f1<X: ?Sized>(x: &X) {
let _: X; // <-- this is OK, no bindings created, no initializer.
// Test sized-ness checking in substitution in impls.
-use std::marker::MarkerTrait;
-
-trait T : MarkerTrait {}
+trait T {}
// I would like these to fail eventually.
// impl - bounded
use sub::sub2;
use sub::sub2::nested_struct as sub_struct;
use std::num::One;
-use std::num::cast;
-use std::num::{from_int,from_i8,from_i32};
use std::mem::size_of;
// import tests
fn foo(x: &One) {}
- let _: Option<u8> = from_i32(45);
let x = 42;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
-#![feature(core)]
-
-use std::marker::MarkerTrait;
-
-trait Foo : MarkerTrait {
+trait Foo {
type T;
}
// pretty-expanded FIXME #23616
-#![feature(core)]
-
-use std::marker::MarkerTrait;
-
impl X for f64 { type Y = isize; }
-trait X : MarkerTrait { type Y; }
+trait X { type Y; }
fn main() {}
#![feature(core)]
-use std::marker::MarkerTrait;
use std::slice;
-trait Bound : MarkerTrait {}
+trait Bound {}
impl<'a> Bound for &'a i32 {}
// pretty-expanded FIXME #23616
-#![feature(core)]
#![allow(dead_code)]
-use std::marker::MarkerTrait;
-
-pub trait Integral : MarkerTrait {
+pub trait Integral {
type Opposite;
}
// `Item` originates in a where-clause, not the declaration of
// `T`. Issue #20300.
-
-#![feature(core)]
-
-use std::marker::{MarkerTrait, PhantomData};
+use std::marker::{PhantomData};
use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT};
use std::sync::atomic::Ordering::SeqCst;
static COUNTER: AtomicUsize = ATOMIC_USIZE_INIT;
// Preamble.
-trait Trait : MarkerTrait { type Item; }
+trait Trait { type Item; }
struct Struct;
impl Trait for Struct {
type Item = u32;
macro_rules! assert_approx_eq {
($a:expr, $b:expr) => ({
- use std::num::Float;
let (a, b) = (&$a, &$b);
assert!((*a - *b).abs() < 1.0e-6,
"{} is not approximately equal to {}", *a, *b);
Quux(u32),
}
-#[derive(FromPrimitive)]
enum Baz { A=0, B=5, }
fn main() {
+++ /dev/null
-// Copyright 2013-2014 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.
-
-#![feature(core)]
-
-use std::num::FromPrimitive;
-use std::isize;
-
-#[derive(PartialEq, FromPrimitive, Debug)]
-enum A {
- Foo = isize::MAX,
- Bar = 1,
- Baz = 3,
- Qux,
-}
-
-pub fn main() {
- let x: Option<A> = FromPrimitive::from_int(isize::MAX);
- assert_eq!(x, Some(A::Foo));
-
- let x: Option<A> = FromPrimitive::from_int(1);
- assert_eq!(x, Some(A::Bar));
-
- let x: Option<A> = FromPrimitive::from_int(3);
- assert_eq!(x, Some(A::Baz));
-
- let x: Option<A> = FromPrimitive::from_int(4);
- assert_eq!(x, Some(A::Qux));
-
- let x: Option<A> = FromPrimitive::from_int(5);
- assert_eq!(x, None);
-}
// pretty-expanded FIXME #23616
-use std::num::Int;
+use std::ops::Add;
-fn wsucc<T:Int>(n: T) -> T { n + { return n } }
+fn wsucc<T:Add<Output=T> + Copy>(n: T) -> T { n + { return n } }
pub fn main() { }
+++ /dev/null
-// Copyright 2014 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.
-
-
-#![feature(std_misc)]
-
-use std::num::strconv::ExponentFormat::{ExpBin, ExpDec};
-use std::num::strconv::SignificantDigits::DigMax;
-use std::num::strconv::SignFormat::{SignAll, SignNeg};
-use std::num::strconv::float_to_str_common as to_string;
-
-macro_rules! t {
- ($a:expr, $b:expr) => { { let (r, _) = $a; assert_eq!(r, $b.to_string()); } }
-}
-
-pub fn main() {
- // Basic usage
- t!(to_string(1.2345678e-5f64, 10, true, SignNeg, DigMax(6), ExpDec, false),
- "1.234568e-5");
-
- // Hexadecimal output
- t!(to_string(7.281738281250e+01f64, 16, true, SignAll, DigMax(6), ExpBin, false),
- "+1.2345p+6");
- t!(to_string(-1.777768135071e-02f64, 16, true, SignAll, DigMax(6), ExpBin, false),
- "-1.2345p-6");
-
- // Some denormals
- t!(to_string(4.9406564584124654e-324f64, 10, true, SignNeg, DigMax(6), ExpBin, false),
- "1p-1074");
- t!(to_string(2.2250738585072009e-308f64, 10, true, SignNeg, DigMax(6), ExpBin, false),
- "1p-1022");
-}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
-#![feature(core)]
-
-use std::marker::MarkerTrait;
-
-trait A : MarkerTrait {
+trait A {
extern "fastcall" fn test1(i: i32);
extern fn test2(i: i32);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
-#![feature(std_misc)]
-
-use std::num::Float;
+use std::f64;
pub fn main() {
- let nan: f64 = Float::nan();
+ let nan: f64 = f64::NAN;
assert!((nan).is_nan());
- let inf: f64 = Float::infinity();
- let neg_inf: f64 = Float::neg_infinity();
+ let inf: f64 = f64::INFINITY;
+ let neg_inf: f64 = -f64::INFINITY;
assert_eq!(-inf, neg_inf);
assert!( nan != nan);
macro_rules! assert_approx_eq {
($a:expr, $b:expr) => ({
- use std::num::Float;
let (a, b) = (&$a, &$b);
assert!((*a - *b).abs() < 1.0e-6,
"{} is not approximately equal to {}", *a, *b);
#![feature(collections)]
-extern crate collections;
-
use std::collections::BitVec;
-use std::num::Float;
fn main() {
// Generate sieve of Eratosthenes for n up to 1e6
// pretty-expanded FIXME #23616
-#![feature(core)]
-
-use std::marker::MarkerTrait;
-
-trait Foo : MarkerTrait {
+trait Foo {
fn quux(u8) {}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(zero_one)]
-#![feature(core)]
-
-use std::num::Int;
+use std::num::Zero;
use std::thread;
-// Avoid using constants, which would trigger compile-time errors.
-fn min_val<T: Int>() -> T { Int::min_value() }
-fn zero<T: Int>() -> T { Int::zero() }
-
fn main() {
- assert!(thread::spawn(move|| { min_val::<isize>() / -1; }).join().is_err());
- assert!(thread::spawn(move|| { min_val::<i8>() / -1; }).join().is_err());
- assert!(thread::spawn(move|| { min_val::<i16>() / -1; }).join().is_err());
- assert!(thread::spawn(move|| { min_val::<i32>() / -1; }).join().is_err());
- assert!(thread::spawn(move|| { min_val::<i64>() / -1; }).join().is_err());
- assert!(thread::spawn(move|| { 1isize / zero::<isize>(); }).join().is_err());
- assert!(thread::spawn(move|| { 1i8 / zero::<i8>(); }).join().is_err());
- assert!(thread::spawn(move|| { 1i16 / zero::<i16>(); }).join().is_err());
- assert!(thread::spawn(move|| { 1i32 / zero::<i32>(); }).join().is_err());
- assert!(thread::spawn(move|| { 1i64 / zero::<i64>(); }).join().is_err());
- assert!(thread::spawn(move|| { min_val::<isize>() % -1; }).join().is_err());
- assert!(thread::spawn(move|| { min_val::<i8>() % -1; }).join().is_err());
- assert!(thread::spawn(move|| { min_val::<i16>() % -1; }).join().is_err());
- assert!(thread::spawn(move|| { min_val::<i32>() % -1; }).join().is_err());
- assert!(thread::spawn(move|| { min_val::<i64>() % -1; }).join().is_err());
- assert!(thread::spawn(move|| { 1isize % zero::<isize>(); }).join().is_err());
- assert!(thread::spawn(move|| { 1i8 % zero::<i8>(); }).join().is_err());
- assert!(thread::spawn(move|| { 1i16 % zero::<i16>(); }).join().is_err());
- assert!(thread::spawn(move|| { 1i32 % zero::<i32>(); }).join().is_err());
- assert!(thread::spawn(move|| { 1i64 % zero::<i64>(); }).join().is_err());
+ assert!(thread::spawn(move|| { isize::min_value() / -1; }).join().is_err());
+ assert!(thread::spawn(move|| { i8::min_value() / -1; }).join().is_err());
+ assert!(thread::spawn(move|| { i16::min_value() / -1; }).join().is_err());
+ assert!(thread::spawn(move|| { i32::min_value() / -1; }).join().is_err());
+ assert!(thread::spawn(move|| { i64::min_value() / -1; }).join().is_err());
+ assert!(thread::spawn(move|| { 1isize / isize::zero(); }).join().is_err());
+ assert!(thread::spawn(move|| { 1i8 / i8::zero(); }).join().is_err());
+ assert!(thread::spawn(move|| { 1i16 / i16::zero(); }).join().is_err());
+ assert!(thread::spawn(move|| { 1i32 / i32::zero(); }).join().is_err());
+ assert!(thread::spawn(move|| { 1i64 / i64::zero(); }).join().is_err());
+ assert!(thread::spawn(move|| { isize::min_value() % -1; }).join().is_err());
+ assert!(thread::spawn(move|| { i8::min_value() % -1; }).join().is_err());
+ assert!(thread::spawn(move|| { i16::min_value() % -1; }).join().is_err());
+ assert!(thread::spawn(move|| { i32::min_value() % -1; }).join().is_err());
+ assert!(thread::spawn(move|| { i64::min_value() % -1; }).join().is_err());
+ assert!(thread::spawn(move|| { 1isize % isize::zero(); }).join().is_err());
+ assert!(thread::spawn(move|| { 1i8 % i8::zero(); }).join().is_err());
+ assert!(thread::spawn(move|| { 1i16 % i16::zero(); }).join().is_err());
+ assert!(thread::spawn(move|| { 1i32 % i32::zero(); }).join().is_err());
+ assert!(thread::spawn(move|| { 1i64 % i64::zero(); }).join().is_err());
}
// pretty-expanded FIXME #23616
-#![feature(core)]
-
-use std::marker::MarkerTrait;
-
-trait Serializer : MarkerTrait {
+trait Serializer {
}
trait Serializable {
// necessary. Testing the methods of the impls is done within the source
// file for each numeric type.
-
-#![feature(core)]
-
use std::ops::Add;
-use std::num::ToPrimitive;
pub fn main() {
// ints
assert_eq!(15_u16.add(6u16), 21_u16);
assert_eq!(15_u32.add(6u32), 21_u32);
assert_eq!(15_u64.add(6u64), 21_u64);
-
-// floats
- // num
- assert_eq!(10_f32.to_i32().unwrap(), 10);
- assert_eq!(10_f64.to_i32().unwrap(), 10);
}
use std::cell::RefCell;
use std::rc::Rc;
-use std::num::ToPrimitive;
#[derive(PartialEq, Debug)]
struct Point {
pub fn main() {
let box_5: Box<_> = box 5_usize;
- assert_eq!(Rc::new(5_usize).to_uint(), Some(5));
- // FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
- assert_eq!((Box::new(&Box::new(&Rc::new(Box::new(Box::new(&box_5)))))).to_uint(), Some(5));
let point = Rc::new(Point {x: 2, y: 4});
assert_eq!(point.x, 2);
assert_eq!(point.y, 4);
// pretty-expanded FIXME #23616
-#![feature(optin_builtin_traits, core)]
-
-use std::marker::{MarkerTrait, Send};
+#![feature(optin_builtin_traits)]
struct TestType;
impl TestType {}
-trait TestTrait : MarkerTrait {}
+trait TestTrait {}
impl !Send for TestType {}
// pretty-expanded FIXME #23616
-#![feature(core)]
-
-trait Foo : ::std::marker::MarkerTrait {
+trait Foo {
}
fn b(_x: Box<Foo+Send>) {
#![feature(core)]
-trait U : ::std::marker::MarkerTrait {}
+trait U {}
trait T<X: U> { fn get(self) -> X; }
-trait S2<Y: U> : ::std::marker::MarkerTrait {
+trait S2<Y: U> {
fn m(x: Box<T<Y>+'static>) {}
}
// pretty-expanded FIXME #23616
-#![feature(core)]
-
trait I { fn i(&self) -> Self; }
-trait A<T:I> : ::std::marker::MarkerTrait {
+trait A<T:I> {
fn id(x:T) -> T { x.i() }
}
trait J<T> { fn j(&self) -> T; }
-trait B<T:J<T>> : ::std::marker::MarkerTrait {
+trait B<T:J<T>> {
fn id(x:T) -> T { x.j() }
}
-trait C : ::std::marker::MarkerTrait {
+trait C {
fn id<T:J<T>>(x:T) -> T { x.j() }
}
// pretty-expanded FIXME #23616
-#![feature(core)]
-
-use std::cmp::{PartialEq, PartialOrd};
-use std::num::NumCast;
-
-pub trait NumExt: NumCast + PartialEq + PartialOrd {}
+pub trait NumExt: PartialEq + PartialOrd {}
pub trait FloatExt: NumExt {}
-fn greater_than_one<T: NumExt>(n: &T) -> bool { *n > NumCast::from(1).unwrap() }
-fn greater_than_one_float<T: FloatExt>(n: &T) -> bool { *n > NumCast::from(1).unwrap() }
+fn greater_than_one<T: NumExt>(n: &T) -> bool { loop {} }
+fn greater_than_one_float<T: FloatExt>(n: &T) -> bool { loop {} }
pub fn main() {}
#![feature(core)]
use std::cmp::PartialOrd;
-use std::num::NumCast;
+
+pub trait NumCast {
+ fn from(i: i32) -> Option<Self>;
+}
pub trait Num {
fn from_int(i: isize) -> Self;
// pretty-expanded FIXME #23616
-#![feature(core)]
-
-use std::cmp::PartialOrd;
-use std::num::NumCast;
+pub trait NumCast {
+ fn from(i: i32) -> Option<Self>;
+}
pub trait NumExt: NumCast + PartialOrd { }
// A more complex example of numeric extensions
-#![feature(core)]
-
-use std::cmp::{PartialEq, PartialOrd};
-use std::num::NumCast;
-
-pub trait TypeExt : ::std::marker::MarkerTrait { }
+pub trait TypeExt {}
impl TypeExt for u8 {}
impl TypeExt for u16 {}
impl TypeExt for f64 {}
-pub trait NumExt: TypeExt + PartialEq + PartialOrd + NumCast {}
+pub trait NumExt: TypeExt + PartialEq + PartialOrd {}
impl NumExt for u8 {}
impl NumExt for u16 {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(core)]
-
-use std::cmp::{PartialEq, PartialOrd};
-use std::num::NumCast;
+pub trait NumCast {
+ fn from(i: i32) -> Option<Self>;
+}
pub trait NumExt: PartialEq + PartialOrd + NumCast {}
impl NumExt for f32 {}
+impl NumCast for f32 {
+ fn from(i: i32) -> Option<f32> { Some(i as f32) }
+}
fn num_eq_one<T: NumExt>(n: T) {
println!("{}", n == NumCast::from(1).unwrap())
// pretty-expanded FIXME #23616
-#![feature(core)]
-
-use std::cmp::PartialEq;
-use std::num::NumCast;
+pub trait NumCast {
+ fn from(i: i32) -> Option<Self>;
+}
pub trait NumExt: PartialEq + NumCast {}
impl NumExt for f32 {}
impl NumExt for isize {}
+impl NumCast for f32 {
+ fn from(i: i32) -> Option<f32> { Some(i as f32) }
+}
+impl NumCast for isize {
+ fn from(i: i32) -> Option<isize> { Some(i as isize) }
+}
+
fn num_eq_one<T:NumExt>() -> T {
NumCast::from(1).unwrap()
}
// Test for issue #4183: use of Self in supertraits.
-
-use std::num::Float as StdFloat;
-
pub static FUZZY_EPSILON: f64 = 0.1;
pub trait FuzzyEq<Eps> {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+pub trait MyEq {}
-#![feature(core)]
-
-pub trait MyEq : ::std::marker::MarkerTrait { }
-
-pub trait MyNum : ::std::marker::MarkerTrait {
+pub trait MyNum {
fn from_int(isize) -> Self;
}
// pretty-expanded FIXME #23616
-#![feature(unboxed_closures, core)]
+pub trait ToPrimitive {
+ fn to_int(&self) {}
+}
-use std::num::ToPrimitive;
+impl ToPrimitive for isize {}
+impl ToPrimitive for i32 {}
+impl ToPrimitive for usize {}
fn doit<T,F>(val: T, f: &F)
where F : Fn(T)
{
- f.call((val,))
+ f(val)
}
pub fn main() {
// pretty-expanded FIXME #23616
-#![feature(unboxed_closures, core)]
+pub trait ToPrimitive {
+ fn to_int(&self) {}
+}
-use std::num::ToPrimitive;
+impl ToPrimitive for isize {}
+impl ToPrimitive for i32 {}
+impl ToPrimitive for usize {}
-fn doit<T>(val: T, f: &Fn(T)) { f.call((val,)) }
+fn doit<T>(val: T, f: &Fn(T)) { f(val) }
pub fn main() {
doit(0, &|x /*: isize*/ | { x.to_int(); });
// pretty-expanded FIXME #23616
-#![feature(unboxed_closures, core)]
+pub trait ToPrimitive {
+ fn to_int(&self) {}
+}
-use std::num::ToPrimitive;
+impl ToPrimitive for isize {}
+impl ToPrimitive for i32 {}
+impl ToPrimitive for usize {}
fn doit<T,F>(val: T, f: &F)
where F : Fn(&T)
{
- f.call((&val,))
+ f(&val)
}
pub fn main() {
#![feature(non_ascii_idents)]
-use std::num::Float;
-
pub fn main() {
let ε = 0.00001f64;
let Π = 3.14f64;
projects / rust.git / commitdiff