diff --git a/src/libextra/extra.rs b/src/libextra/extra.rs index 90434cf0d4912..c6fc41e683161 100644 --- a/src/libextra/extra.rs +++ b/src/libextra/extra.rs @@ -118,6 +118,8 @@ pub mod extra { pub use std::clone; pub use std::condition; pub use std::cmp; + // NOTE: Remove import after next snapshot + #[cfg(stage0)] pub use std::sys; pub use std::unstable; pub use std::str; diff --git a/src/libstd/rt/borrowck.rs b/src/libstd/rt/borrowck.rs index 7fcd674009d88..bd528cbe61f06 100644 --- a/src/libstd/rt/borrowck.rs +++ b/src/libstd/rt/borrowck.rs @@ -65,7 +65,7 @@ unsafe fn fail_borrowed(box: *mut raw::Box<()>, file: *c_char, line: size_t) -> None => { // not recording borrows let msg = "borrowed"; do msg.with_c_str |msg_p| { - task::begin_unwind(msg_p, file, line); + task::begin_unwind_raw(msg_p, file, line); } } Some(borrow_list) => { // recording borrows @@ -81,7 +81,7 @@ unsafe fn fail_borrowed(box: *mut raw::Box<()>, file: *c_char, line: size_t) -> } } do msg.with_c_str |msg_p| { - task::begin_unwind(msg_p, file, line) + task::begin_unwind_raw(msg_p, file, line) } } } @@ -180,7 +180,7 @@ pub unsafe fn unrecord_borrow(a: *u8, old_ref_count: uint, if br.box != a || br.file != file || br.line != line { let err = format!("wrong borrow found, br={:?}", br); do err.with_c_str |msg_p| { - task::begin_unwind(msg_p, file, line) + task::begin_unwind_raw(msg_p, file, line) } } borrow_list diff --git a/src/libstd/rt/kill.rs b/src/libstd/rt/kill.rs index edf6ffb820b31..949421db9fc80 100644 --- a/src/libstd/rt/kill.rs +++ b/src/libstd/rt/kill.rs @@ -155,7 +155,7 @@ use cell::Cell; use option::{Option, Some, None}; use prelude::*; use rt::task::Task; -use rt::task::UnwindReasonLinked; +use rt::task::UnwindMessageLinked; use rt::task::{UnwindResult, Failure}; use task::spawn::Taskgroup; use to_bytes::IterBytes; @@ -597,7 +597,7 @@ impl Death { } if !success { - result = Cell::new(Failure(UnwindReasonLinked)); + result = Cell::new(Failure(UnwindMessageLinked)); } } on_exit(result.take()); diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs index 516a795a1adf1..b56dd0809dfd1 100644 --- a/src/libstd/rt/task.rs +++ b/src/libstd/rt/task.rs @@ -95,8 +95,8 @@ pub enum UnwindResult { /// The task is ending successfully Success, - /// The Task is failing with reason `UnwindReason` - Failure(UnwindReason), + /// The Task is failing with reason `UnwindMessage` + Failure(UnwindMessage), } impl UnwindResult { @@ -121,20 +121,25 @@ impl UnwindResult { /// Represents the cause of a task failure #[deriving(ToStr)] -pub enum UnwindReason { - /// Failed with a string message - UnwindReasonStr(SendStr), +pub enum UnwindMessage { + // FIXME: #9913 - This variant is not neccessary once Any works properly + /// Failed with a static string message + UnwindMessageStrStatic(&'static str), + + // FIXME: #9913 - This variant is not neccessary once Any works properly + /// Failed with a owned string message + UnwindMessageStrOwned(~str), /// Failed with an `~Any` - UnwindReasonAny(~Any), + UnwindMessageAny(~Any), /// Failed because of linked failure - UnwindReasonLinked + UnwindMessageLinked } pub struct Unwinder { unwinding: bool, - cause: Option + cause: Option } impl Unwinder { @@ -527,7 +532,7 @@ impl Unwinder { } } - pub fn begin_unwind(&mut self, cause: UnwindReason) -> ! { + pub fn begin_unwind(&mut self, cause: UnwindMessage) -> ! { #[fixed_stack_segment]; #[inline(never)]; self.unwinding = true; @@ -622,7 +627,7 @@ pub extern "C" fn rust_stack_exhausted() { /// This is the entry point of unwinding for things like lang items and such. /// The arguments are normally generated by the compiler, and need to /// have static lifetimes. -pub fn begin_unwind(msg: *c_char, file: *c_char, line: size_t) -> ! { +pub fn begin_unwind_raw(msg: *c_char, file: *c_char, line: size_t) -> ! { use c_str::CString; use cast::transmute; @@ -638,11 +643,33 @@ pub fn begin_unwind(msg: *c_char, file: *c_char, line: size_t) -> ! { let msg = static_char_ptr(msg); let file = static_char_ptr(file); - begin_unwind_reason(UnwindReasonStr(msg.into_send_str()), file, line as uint) + begin_unwind(msg, file, line as uint) } /// This is the entry point of unwinding for fail!() and assert!(). -pub fn begin_unwind_reason(reason: UnwindReason, file: &'static str, line: uint) -> ! { +pub fn begin_unwind(msg: M, file: &'static str, line: uint) -> ! { + // Wrap the fail message in a `Any` box for uniform representation. + let any = ~msg as ~Any; + + // FIXME: #9913 - This can be changed to be internal to begin_unwind_internal + // once Any works properly. + // As a workaround, string types need to be special cased right now + // because `Any` does not support dynamically querying whether the + // type implements a trait yet, so without requiring that every `Any` + // also implements `ToStr` there is no way to get a failure message + // out of it again during unwinding. + let msg = if any.is::<&'static str>() { + UnwindMessageStrStatic(*any.move::<&'static str>().unwrap()) + } else if any.is::<~str>() { + UnwindMessageStrOwned(*any.move::<~str>().unwrap()) + } else { + UnwindMessageAny(any) + }; + + begin_unwind_internal(msg, file, line) +} + +fn begin_unwind_internal(msg: UnwindMessage, file: &'static str, line: uint) -> ! { use rt::in_green_task_context; use rt::task::Task; use rt::local::Local; @@ -656,15 +683,16 @@ pub fn begin_unwind_reason(reason: UnwindReason, file: &'static str, line: uint) let task: *mut Task; { - let msg = match reason { - UnwindReasonStr(ref s) => s.as_slice(), - UnwindReasonAny(_) => "~Any", - UnwindReasonLinked => "linked failure", + let msg_s = match msg { + UnwindMessageAny(_) => "~Any", + UnwindMessageLinked => "linked failure", + UnwindMessageStrOwned(ref s) => s.as_slice(), + UnwindMessageStrStatic(ref s) => s.as_slice(), }; if !in_green_task_context() { rterrln!("failed in non-task context at '{}', {}:{}", - msg, file, line); + msg_s, file, line); intrinsics::abort(); } @@ -679,19 +707,20 @@ pub fn begin_unwind_reason(reason: UnwindReason, file: &'static str, line: uint) // due to mismanagment of its own kill flag, so calling our own // logger in its current state is a bit of a problem. - rterrln!("task '{}' failed at '{}', {}:{}", n, msg, file, line); + rterrln!("task '{}' failed at '{}', {}:{}", n, msg_s, file, line); if (*task).unwinder.unwinding { rtabort!("unwinding again"); } } - (*task).unwinder.begin_unwind(reason); + (*task).unwinder.begin_unwind(msg); } } #[cfg(test)] mod test { + use super::*; use rt::test::*; #[test] @@ -804,4 +833,8 @@ mod test { a.next = Some(b); } } + + #[test] + #[should_fail] + fn test_begin_unwind() { begin_unwind("cause", file!(), line!()) } } diff --git a/src/libstd/std.rs b/src/libstd/std.rs index 3a96cfb11718d..df6c47a8492be 100644 --- a/src/libstd/std.rs +++ b/src/libstd/std.rs @@ -184,6 +184,8 @@ pub mod os; pub mod path; pub mod rand; pub mod run; +// NOTE: Remove module after next snapshot +#[cfg(stage0)] pub mod sys; pub mod cast; pub mod fmt; @@ -226,7 +228,10 @@ mod std { pub use logging; pub use option; pub use os; + pub use rt; pub use str; + // NOTE: Remove import after next snapshot + #[cfg(stage0)] pub use sys; pub use to_bytes; pub use to_str; diff --git a/src/libstd/sys.rs b/src/libstd/sys.rs index b35b25aeb6f72..4216f91b60263 100644 --- a/src/libstd/sys.rs +++ b/src/libstd/sys.rs @@ -10,99 +10,20 @@ //! Misc low level stuff +// NOTE: Remove this module after an snapshot + #[allow(missing_doc)]; use any::Any; use kinds::Send; -use rt::task::{UnwindReasonStr, UnwindReasonAny}; use rt::task; -use send_str::{SendStr, IntoSendStr}; -/// Trait for initiating task failure with a sendable cause. pub trait FailWithCause { - /// Fail the current task with `cause`. fn fail_with(cause: Self, file: &'static str, line: uint) -> !; } -impl FailWithCause for ~str { - fn fail_with(cause: ~str, file: &'static str, line: uint) -> ! { - task::begin_unwind_reason(UnwindReasonStr(cause.into_send_str()), file, line) - } -} - -impl FailWithCause for &'static str { - fn fail_with(cause: &'static str, file: &'static str, line: uint) -> ! { - task::begin_unwind_reason(UnwindReasonStr(cause.into_send_str()), file, line) - } -} - -impl FailWithCause for SendStr { - fn fail_with(cause: SendStr, file: &'static str, line: uint) -> ! { - task::begin_unwind_reason(UnwindReasonStr(cause), file, line) - } -} - -impl FailWithCause for ~Any { - fn fail_with(cause: ~Any, file: &'static str, line: uint) -> ! { - task::begin_unwind_reason(UnwindReasonAny(cause), file, line) - } -} - -impl FailWithCause for ~T { - fn fail_with(cause: ~T, file: &'static str, line: uint) -> ! { - task::begin_unwind_reason(UnwindReasonAny(cause as ~Any), file, line) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - use any::Any; - use cast; - use send_str::IntoSendStr; - - #[test] - fn synthesize_closure() { - use unstable::raw::Closure; - unsafe { - let x = 10; - let f: &fn(int) -> int = |y| x + y; - - assert_eq!(f(20), 30); - - let original_closure: Closure = cast::transmute(f); - - let actual_function_pointer = original_closure.code; - let environment = original_closure.env; - - let new_closure = Closure { - code: actual_function_pointer, - env: environment - }; - - let new_f: &fn(int) -> int = cast::transmute(new_closure); - assert_eq!(new_f(20), 30); - } +impl FailWithCause for T { + fn fail_with(msg: T, file: &'static str, line: uint) -> ! { + task::begin_unwind(msg, file, line) } - - #[test] - #[should_fail] - fn fail_static() { FailWithCause::fail_with("cause", file!(), line!()) } - - #[test] - #[should_fail] - fn fail_owned() { FailWithCause::fail_with(~"cause", file!(), line!()) } - - #[test] - #[should_fail] - fn fail_send() { FailWithCause::fail_with("cause".into_send_str(), file!(), line!()) } - - #[test] - #[should_fail] - fn fail_any() { FailWithCause::fail_with(~612_u16 as ~Any, file!(), line!()) } - - #[test] - #[should_fail] - fn fail_any_wrap() { FailWithCause::fail_with(~413_u16, file!(), line!()) } } diff --git a/src/libstd/task/mod.rs b/src/libstd/task/mod.rs index 023ba6f7108a2..cdb70f00dfe57 100644 --- a/src/libstd/task/mod.rs +++ b/src/libstd/task/mod.rs @@ -60,7 +60,8 @@ use comm::{stream, Chan, GenericChan, GenericPort, Port, Peekable}; use result::{Result, Ok, Err}; use rt::in_green_task_context; use rt::local::Local; -use rt::task::{UnwindReasonAny, UnwindReasonLinked, UnwindReasonStr}; +use rt::task::{UnwindMessageAny, UnwindMessageLinked}; +use rt::task::{UnwindMessageStrStatic, UnwindMessageStrOwned}; use rt::task::{UnwindResult, Success, Failure}; use send_str::{SendStr, IntoSendStr}; use unstable::finally::Finally; @@ -93,9 +94,10 @@ pub struct LinkedFailure; fn wrap_as_any(res: UnwindResult) -> TaskResult { match res { Success => Ok(()), - Failure(UnwindReasonStr(s)) => Err(~s as ~Any), - Failure(UnwindReasonAny(a)) => Err(a), - Failure(UnwindReasonLinked) => Err(~LinkedFailure as ~Any) + Failure(UnwindMessageAny(a)) => Err(a), + Failure(UnwindMessageLinked) => Err(~LinkedFailure as ~Any), + Failure(UnwindMessageStrOwned(s)) => Err(~s as ~Any), + Failure(UnwindMessageStrStatic(s)) => Err(~s as ~Any), } } @@ -1425,38 +1427,52 @@ fn test_indestructible() { } #[test] -fn test_try_fail_cause_static_str() { +fn test_try_fail_message_static_str() { match do try { fail!("static string"); } { - Err(ref e) if e.is::() => {} - Err(_) | Ok(()) => fail!() + Err(e) => { + type T = &'static str; + assert!(e.is::()); + assert_eq!(*e.move::().unwrap(), "static string"); + } + Ok(()) => fail!() } } #[test] -fn test_try_fail_cause_owned_str() { +fn test_try_fail_message_owned_str() { match do try { fail!(~"owned string"); } { - Err(ref e) if e.is::() => {} - Err(_) | Ok(()) => fail!() + Err(e) => { + type T = ~str; + assert!(e.is::()); + assert_eq!(*e.move::().unwrap(), ~"owned string"); + } + Ok(()) => fail!() } } #[test] -fn test_try_fail_cause_any() { +fn test_try_fail_message_any() { match do try { fail!(~413u16 as ~Any); } { - Err(ref e) if e.is::() => {} - Err(_) | Ok(()) => fail!() + Err(e) => { + type T = ~Any; + assert!(e.is::()); + let any = e.move::().unwrap(); + assert!(any.is::()); + assert_eq!(*any.move::().unwrap(), 413u16); + } + Ok(()) => fail!() } } #[ignore(reason = "linked failure")] #[test] -fn test_try_fail_cause_linked() { +fn test_try_fail_message_linked() { match do try { do spawn { fail!() @@ -1468,11 +1484,11 @@ fn test_try_fail_cause_linked() { } #[test] -fn test_try_fail_cause_any_wrapped() { +fn test_try_fail_message_unit_struct() { struct Juju; match do try { - fail!(~Juju) + fail!(Juju) } { Err(ref e) if e.is::() => {} Err(_) | Ok(()) => fail!() diff --git a/src/libstd/task/spawn.rs b/src/libstd/task/spawn.rs index a08bf8f3147b8..4a98e396bbccd 100644 --- a/src/libstd/task/spawn.rs +++ b/src/libstd/task/spawn.rs @@ -83,12 +83,11 @@ use local_data; use rt::local::Local; use rt::sched::{Scheduler, Shutdown, TaskFromFriend}; use rt::task::{Task, Sched}; -use rt::task::{UnwindReasonLinked, UnwindReasonStr}; +use rt::task::{UnwindMessageLinked, UnwindMessageStrStatic}; use rt::task::{UnwindResult, Success, Failure}; use rt::thread::Thread; use rt::work_queue::WorkQueue; use rt::{in_green_task_context, new_event_loop, KillHandle}; -use send_str::IntoSendStr; use task::SingleThreaded; use task::TaskOpts; use task::unkillable; @@ -325,7 +324,7 @@ impl Drop for Taskgroup { do RuntimeGlue::with_task_handle_and_failing |me, failing| { if failing { for x in self.notifier.mut_iter() { - x.task_result = Some(Failure(UnwindReasonLinked)); + x.task_result = Some(Failure(UnwindMessageLinked)); } // Take everybody down with us. After this point, every // other task in the group will see 'tg' as none, which @@ -380,7 +379,7 @@ impl AutoNotify { notify_chan: chan, // Un-set above when taskgroup successfully made. - task_result: Some(Failure(UnwindReasonStr("AutoNotify::new()".into_send_str()))) + task_result: Some(Failure(UnwindMessageStrStatic("AutoNotify::new()"))) } } } diff --git a/src/libstd/unstable/lang.rs b/src/libstd/unstable/lang.rs index 89126bf9c9c88..092e9b6d348bc 100644 --- a/src/libstd/unstable/lang.rs +++ b/src/libstd/unstable/lang.rs @@ -19,7 +19,7 @@ use rt::borrowck; #[cold] #[lang="fail_"] pub fn fail_(expr: *c_char, file: *c_char, line: size_t) -> ! { - task::begin_unwind(expr, file, line); + task::begin_unwind_raw(expr, file, line); } #[cold] diff --git a/src/libstd/unstable/raw.rs b/src/libstd/unstable/raw.rs index 46e80f9f4e8b7..d784c1d38c60f 100644 --- a/src/libstd/unstable/raw.rs +++ b/src/libstd/unstable/raw.rs @@ -62,3 +62,33 @@ impl Repr<*Box> for @str {} // sure would be nice to have this // impl Repr<*Vec> for ~[T] {} + +#[cfg(test)] +mod tests { + use super::*; + + use cast; + + #[test] + fn synthesize_closure() { + unsafe { + let x = 10; + let f: &fn(int) -> int = |y| x + y; + + assert_eq!(f(20), 30); + + let original_closure: Closure = cast::transmute(f); + + let actual_function_pointer = original_closure.code; + let environment = original_closure.env; + + let new_closure = Closure { + code: actual_function_pointer, + env: environment + }; + + let new_f: &fn(int) -> int = cast::transmute(new_closure); + assert_eq!(new_f(20), 30); + } + } +} diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index 273ce180a5f1d..76d9f755d3c9f 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -604,9 +604,9 @@ impl AstBuilder for @ExtCtxt { span, ~[ self.ident_of("std"), - self.ident_of("sys"), - self.ident_of("FailWithCause"), - self.ident_of("fail_with"), + self.ident_of("rt"), + self.ident_of("task"), + self.ident_of("begin_unwind"), ], ~[ self.expr_str(span, msg), diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 575f8bc6278c7..052b177d4d8d3 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -763,8 +763,7 @@ pub fn new_span(cx: @ExtCtxt, sp: Span) -> Span { // syntax elements. pub fn std_macros() -> @str { - return -@"mod __std_macros { +@r#"mod __std_macros { #[macro_escape]; #[doc(hidden)]; @@ -789,31 +788,30 @@ pub fn std_macros() -> @str { macro_rules! fail( () => ( - fail!(\"explicit failure\") + fail!("explicit failure") ); - ($fmt:expr) => ( - ::std::sys::FailWithCause::fail_with($fmt, file!(), line!()) + ($msg:expr) => ( + ::std::rt::task::begin_unwind($msg, file!(), line!()) ); ($fmt:expr, $($arg:tt)*) => ( - ::std::sys::FailWithCause::fail_with(format!($fmt, $($arg)*), file!(), line!()) + ::std::rt::task::begin_unwind(format!($fmt, $($arg)*), file!(), line!()) ) ) macro_rules! assert( ($cond:expr) => { if !$cond { - ::std::sys::FailWithCause::fail_with( - \"assertion failed: \" + stringify!($cond), file!(), line!()) + fail!("assertion failed: {:s}", stringify!($cond)) } }; ($cond:expr, $msg:expr) => { if !$cond { - ::std::sys::FailWithCause::fail_with($msg, file!(), line!()) + fail!($msg) } }; ($cond:expr, $( $arg:expr ),+) => { if !$cond { - ::std::sys::FailWithCause::fail_with(format!( $($arg),+ ), file!(), line!()) + fail!( $($arg),+ ) } } ) @@ -826,9 +824,8 @@ pub fn std_macros() -> @str { // check both directions of equality.... if !((*given_val == *expected_val) && (*expected_val == *given_val)) { - fail!(\"assertion failed: `(left == right) && (right == \ - left)` (left: `{:?}`, right: `{:?}`)\", - *given_val, *expected_val); + fail!("assertion failed: `(left == right) && (right == left)` \ + (left: `{:?}`, right: `{:?}`)", *given_val, *expected_val) } } ) @@ -846,7 +843,7 @@ pub fn std_macros() -> @str { given_val.approx_eq(&expected_val) && expected_val.approx_eq(&given_val) ) { - fail!(\"left: {:?} does not approximately equal right: {:?}\", + fail!("left: {:?} does not approximately equal right: {:?}", given_val, expected_val); } } @@ -863,42 +860,37 @@ pub fn std_macros() -> @str { given_val.approx_eq_eps(&expected_val, &epsilon_val) && expected_val.approx_eq_eps(&given_val, &epsilon_val) ) { - fail!(\"left: {:?} does not approximately equal right: \ - {:?} with epsilon: {:?}\", + fail!("left: {:?} does not approximately equal right: \ + {:?} with epsilon: {:?}", given_val, expected_val, epsilon_val); } } ) ) - // FIXME(#6266): change the /* to /** when attributes are supported on macros - // (Though even then—is it going to work according to the clear intent here?) - /* - A utility macro for indicating unreachable code. It will fail if - executed. This is occasionally useful to put after loops that never - terminate normally, but instead directly return from a function. - - # Example - - ```rust - fn choose_weighted_item(v: &[Item]) -> Item { - assert!(!v.is_empty()); - let mut so_far = 0u; - for v.each |item| { - so_far += item.weight; - if so_far > 100 { - return item; - } - } - // The above loop always returns, so we must hint to the - // type checker that it isn't possible to get down here - unreachable!(); - } - ``` - - */ + /// A utility macro for indicating unreachable code. It will fail if + /// executed. This is occasionally useful to put after loops that never + /// terminate normally, but instead directly return from a function. + /// + /// # Example + /// + /// ```rust + /// fn choose_weighted_item(v: &[Item]) -> Item { + /// assert!(!v.is_empty()); + /// let mut so_far = 0u; + /// for item in v.iter() { + /// so_far += item.weight; + /// if so_far > 100 { + /// return item; + /// } + /// } + /// // The above loop always returns, so we must hint to the + /// // type checker that it isn't possible to get down here + /// unreachable!(); + /// } + /// ``` macro_rules! unreachable (() => ( - fail!(\"internal error: entered unreachable code\"); + fail!("internal error: entered unreachable code"); )) macro_rules! condition ( @@ -968,18 +960,18 @@ pub fn std_macros() -> @str { ) ) - // externfn! declares a wrapper for an external function. - // It is intended to be used like: - // - // externfn!(#[nolink] - // fn memcmp(cx: *u8, ct: *u8, n: u32) -> u32) - // - // Due to limitations in the macro parser, this pattern must be - // implemented with 4 distinct patterns (with attrs / without - // attrs CROSS with args / without ARGS). - // - // Also, this macro grammar allows for any number of return types - // because I couldn't figure out the syntax to specify at most one. + /// externfn! declares a wrapper for an external function. + /// It is intended to be used like: + /// + /// externfn!(#[nolink] + /// fn memcmp(cx: *u8, ct: *u8, n: u32) -> u32) + /// + /// Due to limitations in the macro parser, this pattern must be + /// implemented with 4 distinct patterns (with attrs / without + /// attrs CROSS with args / without ARGS). + /// + /// Also, this macro grammar allows for any number of return types + /// because I couldn't figure out the syntax to specify at most one. macro_rules! externfn( (fn $name:ident () $(-> $ret_ty:ty),*) => ( pub unsafe fn $name() $(-> $ret_ty),* { @@ -1045,7 +1037,7 @@ pub fn std_macros() -> @str { ) ) -}"; +}"# } struct Injector { diff --git a/src/test/compile-fail/fail-expr.rs b/src/test/compile-fail/fail-expr.rs deleted file mode 100644 index 98270bdc58383..0000000000000 --- a/src/test/compile-fail/fail-expr.rs +++ /dev/null @@ -1,13 +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 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -// error-pattern:failed to find an implementation of trait std::sys::FailWithCause for int - -fn main() { fail!(5); } diff --git a/src/test/compile-fail/fail-type-err.rs b/src/test/compile-fail/fail-type-err.rs deleted file mode 100644 index b6755249bcf98..0000000000000 --- a/src/test/compile-fail/fail-type-err.rs +++ /dev/null @@ -1,12 +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 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -// error-pattern:failed to find an implementation of trait std::sys::FailWithCause for ~[int] -fn main() { fail!(~[0i]); } diff --git a/src/test/run-fail/fail-macro-send_str.rs b/src/test/run-fail/fail-macro-send_str.rs deleted file mode 100644 index 2047fde150b9a..0000000000000 --- a/src/test/run-fail/fail-macro-send_str.rs +++ /dev/null @@ -1,15 +0,0 @@ -// Copyright 2013 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. - -// error-pattern:failed at 'test-fail-send-str' - -fn main() { - fail!("test-fail-send-str".into_send_str()); -} diff --git a/src/test/run-pass/unit-like-struct-drop-run.rs b/src/test/run-pass/unit-like-struct-drop-run.rs index 8d4680436a423..5707406de146c 100644 --- a/src/test/run-pass/unit-like-struct-drop-run.rs +++ b/src/test/run-pass/unit-like-struct-drop-run.rs @@ -25,6 +25,6 @@ pub fn main() { let _b = Foo; }; - let s = x.unwrap_err().move::().unwrap(); + let s = x.unwrap_err().move::<&'static str>().unwrap(); assert_eq!(s.as_slice(), "This failure should happen."); }