diff --git a/src/test/compile-fail/issue-11382.rs b/src/test/compile-fail/issue-11382.rs new file mode 100644 index 0000000000000..44f6cd7719d1d --- /dev/null +++ b/src/test/compile-fail/issue-11382.rs @@ -0,0 +1,16 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +fn main() { +panic!( + 1.2 +//~^ ERROR cannot determine the type of this number; add a suffix to specify the type explicitly +); +} diff --git a/src/test/compile-fail/issue-11771.rs b/src/test/compile-fail/issue-11771.rs new file mode 100644 index 0000000000000..7ce23e1f6ac79 --- /dev/null +++ b/src/test/compile-fail/issue-11771.rs @@ -0,0 +1,21 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +fn main() { + let x = (); + 1 + + x //~ ERROR mismatched types: expected `_`, found `()` (expected integral variable, found ()) + ; + + let x: () = (); + 1 + + x //~ ERROR mismatched types: expected `_`, found `()` (expected integral variable, found ()) + ; +} diff --git a/src/test/compile-fail/issue-13058.rs b/src/test/compile-fail/issue-13058.rs new file mode 100644 index 0000000000000..5203c91237be8 --- /dev/null +++ b/src/test/compile-fail/issue-13058.rs @@ -0,0 +1,39 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use std::iter::{Range,range}; + +trait Itble<'r, T, I: Iterator> { fn iter(&'r self) -> I; } + +impl<'r> Itble<'r, uint, Range> for (uint, uint) { + fn iter(&'r self) -> Range { + let &(min, max) = self; + range(min, max) + } +} + +fn check<'r, I: Iterator, T: Itble<'r, uint, I>>(cont: &T) -> bool +//~^ HELP as shown: fn check<'r, I: Iterator, T: Itble<'r, uint, I>>(cont: &'r T) -> bool +{ + let cont_iter = cont.iter(); +//~^ ERROR cannot infer an appropriate lifetime for autoref due to conflicting requirements + let result = cont_iter.fold(Some(0u16), |state, val| { + state.map_or(None, |mask| { + let bit = 1 << val; + if mask & bit == 0 {Some(mask|bit)} else {None} + }) + }); + result.is_some() +} + +fn main() { + check((3u, 5u)); +//~^ ERROR mismatched types: expected `&_`, found `(uint, uint)` (expected &-ptr, found tuple) +} diff --git a/src/test/compile-fail/issue-2718-a.rs b/src/test/compile-fail/issue-2718-a.rs index 41bdab0941e6f..3ba8dd4fefef0 100644 --- a/src/test/compile-fail/issue-2718-a.rs +++ b/src/test/compile-fail/issue-2718-a.rs @@ -8,18 +8,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// ignore-test - pub struct send_packet { - p: T + p: T } - mod pingpong { use send_packet; pub type ping = send_packet; pub struct pong(send_packet); - //~^ ERROR illegal recursive enum type; wrap the inner value in a box to make it representable + //~^ ERROR illegal recursive struct type; wrap the inner value in a box to make it representable } fn main() {} diff --git a/src/test/run-pass/issue-10396.rs b/src/test/run-pass/issue-10396.rs new file mode 100644 index 0000000000000..ce04f188e341f --- /dev/null +++ b/src/test/run-pass/issue-10396.rs @@ -0,0 +1,22 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#[deriving(Show)] +enum Foo<'s> { + V(&'s str) +} + +fn f(arr: &[&Foo]) { + for &f in arr.iter() { + println!("{}", f); + } +} + +fn main() {} diff --git a/src/test/run-pass/issue-10501.rs b/src/test/run-pass/issue-10501.rs new file mode 100644 index 0000000000000..78f125398edcb --- /dev/null +++ b/src/test/run-pass/issue-10501.rs @@ -0,0 +1,14 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +pub type Foo = fn(&int) -> (); +#[deriving(Clone)] +enum Baz { Bar(Foo) } +fn main() {} diff --git a/src/test/run-pass/issue-12741.rs b/src/test/run-pass/issue-12741.rs new file mode 100644 index 0000000000000..e41613b4ae305 --- /dev/null +++ b/src/test/run-pass/issue-12741.rs @@ -0,0 +1,35 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#[deriving(Clone)] +pub struct Foo { + f: fn(char, |char| -> char) -> char +} + +impl Foo { + fn bar(&self) -> char { + ((*self).f)('a', |c: char| c) + } +} + +fn bla(c: char, cb: |char| -> char) -> char { + cb(c) +} + +pub fn make_foo() -> Foo { + Foo { + f: bla + } +} + +fn main() { + let a = make_foo(); + assert_eq!(a.bar(), 'a'); +} diff --git a/src/test/run-pass/issue-15063.rs b/src/test/run-pass/issue-15063.rs new file mode 100644 index 0000000000000..0b7eb41d2aac1 --- /dev/null +++ b/src/test/run-pass/issue-15063.rs @@ -0,0 +1,19 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +enum Two { A, B} +impl Drop for Two { + fn drop(&mut self) { + println!("Dropping!"); + } +} +fn main() { + let k = A; +} diff --git a/src/test/run-pass/issue-15734.rs b/src/test/run-pass/issue-15734.rs new file mode 100644 index 0000000000000..ea5bd550d53da --- /dev/null +++ b/src/test/run-pass/issue-15734.rs @@ -0,0 +1,56 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +struct Mat { data: Vec, cols: uint, } + +impl Mat { + fn new(data: Vec, cols: uint) -> Mat { + Mat { data: data, cols: cols } + } + fn row<'a>(&'a self, row: uint) -> Row<&'a Mat> { + Row { mat: self, row: row, } + } +} + +impl Index<(uint, uint), T> for Mat { + fn index<'a>(&'a self, &(row, col): &(uint, uint)) -> &'a T { + &self.data[row * self.cols + col] + } +} + +impl<'a, T> Index<(uint, uint), T> for &'a Mat { + fn index<'b>(&'b self, index: &(uint, uint)) -> &'b T { + (*self).index(index) + } +} + +struct Row { mat: M, row: uint, } + +impl> Index for Row { + fn index<'a>(&'a self, col: &uint) -> &'a T { + &self.mat[(self.row, *col)] + } +} + +fn main() { + let m = Mat::new(vec!(1u, 2, 3, 4, 5, 6), 3); + let r = m.row(1); + + assert!(r.index(&2) == &6); + assert!(r[2] == 6); + assert!(r[2u] == 6u); + assert!(6 == r[2]); + + let e = r[2]; + assert!(e == 6); + + let e: uint = r[2]; + assert!(e == 6); +} diff --git a/src/test/run-pass/issue-16774.rs b/src/test/run-pass/issue-16774.rs new file mode 100644 index 0000000000000..f996f9309c135 --- /dev/null +++ b/src/test/run-pass/issue-16774.rs @@ -0,0 +1,50 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![feature(overloaded_calls, unboxed_closures)] + +struct X(Box); + +static mut DESTRUCTOR_RAN: bool = false; + +impl Drop for X { + fn drop(&mut self) { + unsafe { + assert!(!DESTRUCTOR_RAN); + DESTRUCTOR_RAN = true; + } + } +} + +impl Deref for X { + fn deref(&self) -> &int { + let &X(box ref x) = self; + x + } +} + +impl DerefMut for X { + fn deref_mut(&mut self) -> &mut int { + let &X(box ref mut x) = self; + x + } +} + +fn main() { + { + let mut test = X(box 5i); + { + let mut change = |&mut:| { *test = 10 }; + change(); + } + assert_eq!(*test, 10); + } + assert!(unsafe { DESTRUCTOR_RAN }); +} diff --git a/src/test/run-pass/issue-18110.rs b/src/test/run-pass/issue-18110.rs new file mode 100644 index 0000000000000..3d6b23c8805fc --- /dev/null +++ b/src/test/run-pass/issue-18110.rs @@ -0,0 +1,13 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +fn main() { + ({return},); +} diff --git a/src/test/run-pass/issue-7268.rs b/src/test/run-pass/issue-7268.rs new file mode 100644 index 0000000000000..8aa9592731230 --- /dev/null +++ b/src/test/run-pass/issue-7268.rs @@ -0,0 +1,16 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +fn foo(_: T) {} + +fn bar(x: &'static T) { + foo(x); +} +fn main() {}