rust/tests/ui/panics/panic-task-name-none.rs

// run-fail
// error-pattern:thread '<unnamed>' panicked at 'test'
// ignore-emscripten Needs threads

use std::thread;

fn main() {
    let r: Result<(), _> = thread::spawn(move || {
                               panic!("test");
                           })
                               .join();
    assert!(r.is_ok());
}
Move tests from `test/run-fail` to UI 2020-04-16 01:50:32 -05:00			`// run-fail`
Revise std::thread API to join by default This commit is part of a series that introduces a `std::thread` API to replace `std::task`. In the new API, `spawn` returns a `JoinGuard`, which by default will join the spawned thread when dropped. It can also be used to join explicitly at any time, returning the thread's result. Alternatively, the spawned thread can be explicitly detached (so no join takes place). As part of this change, Rust processes now terminate when the main thread exits, even if other detached threads are still running, moving Rust closer to standard threading models. This new behavior may break code that was relying on the previously implicit join-all. In addition to the above, the new thread API also offers some built-in support for building blocking abstractions in user space; see the module doc for details. Closes #18000 [breaking-change] 2014-12-14 02:05:32 -06:00			`// error-pattern:thread '<unnamed>' panicked at 'test'`
Adding ignore-emscripten to failing tests. 2016-09-05 19:00:09 -05:00			`// ignore-emscripten Needs threads`
Make a task name use a `SendStr`, allowing for either static or owned strings 2013-10-05 14:01:58 -05:00
Fallout from stabilization 2015-02-17 17:10:25 -06:00			`use std::thread;`
Remove linked failure from the runtime The reasons for doing this are: * The model on which linked failure is based is inherently complex * The implementation is also very complex, and there are few remaining who fully understand the implementation * There are existing race conditions in the core context switching function of the scheduler, and possibly others. * It's unclear whether this model of linked failure maps well to a 1:1 threading model Linked failure is often a desired aspect of tasks, but we would like to take a much more conservative approach in re-implementing linked failure if at all. Closes #8674 Closes #8318 Closes #8863 2013-11-21 18:55:40 -06:00
Make a task name use a `SendStr`, allowing for either static or owned strings 2013-10-05 14:01:58 -05:00			`fn main() {`
run rustfmt on test/run-fail folder 2016-05-26 21:39:36 -05:00			`let r: Result<(), _> = thread::spawn(move \|\| {`
			`panic!("test");`
			`})`
			`.join();`
librustc: Match trait self types exactly. This can break code that looked like: impl Foo for Box<Any> { fn f(&self) { ... } } let x: Box<Any + Send> = ...; x.f(); Change such code to: impl Foo for Box<Any> { fn f(&self) { ... } } let x: Box<Any> = ...; x.f(); That is, upcast before calling methods. This is a conservative solution to #5781. A more proper treatment (see the xfail'd `trait-contravariant-self.rs`) would take variance into account. This change fixes the soundness hole. Some library changes had to be made to make this work. In particular, `Box<Any>` is no longer showable, and only `Box<Any+Send>` is showable. Eventually, this restriction can be lifted; for now, it does not prove too onerous, because `Any` is only used for propagating the result of task failure. This patch also adds a test for the variance inference work in #12828, which accidentally landed as part of DST. Closes #5781. [breaking-change] 2014-06-25 20:18:13 -05:00			`assert!(r.is_ok());`
Make a task name use a `SendStr`, allowing for either static or owned strings 2013-10-05 14:01:58 -05:00			`}`