rust/tests/ui/threads-sendsync/task-spawn-barefn.rs

//@ run-fail
//@ error-pattern:Ensure that the child thread runs by panicking
//@ needs-threads

use std::thread;

fn main() {
    // the purpose of this test is to make sure that thread::spawn()
    // works when provided with a bare function:
    let r = thread::spawn(startfn).join();
    if r.is_err() {
        panic!()
    }
}

fn startfn() {
    assert!("Ensure that the child thread runs by panicking".is_empty());
}
Move tests from `test/run-fail` to UI 2020-04-16 06:50:32 +00:00			`//@ run-fail`
Squeeze the last bits of `task`s in documentation in favor of `thread` An automated script was run against the `.rs` and `.md` files, subsituting every occurrence of `task` with `thread`. In the `.rs` files, only the texts in the comment blocks were affected. 2015-05-08 15:12:29 +00:00			`//@ error-pattern:Ensure that the child thread runs by panicking`
compiletest: Add a `//@ needs-threads` directive This commit is extracted from #122036 and adds a new directive to the `compiletest` test runner, `//@ needs-threads`. This is intended to capture the need that a target must implement threading to execute a specific test, typically one that uses `std::thread`. This is primarily done for WebAssembly targets which currently do not have threads by default. This enables transitioning a lot of `//@ ignore-wasm*`-style ignores into a more self-documenting `//@ needs-threads` directive. Additionally the `wasm32-wasi-preview1-threads` target, for example, does actually have threads, but isn't tested in CI at this time. This change enables running these tests for that target, but not other wasm targets. 2024-03-06 20:19:20 +00:00			`//@ needs-threads`
make spawned fn copy mode so that bare fns can be used 2012-01-08 19:19:44 +00:00
Fallout from stabilization 2015-02-17 23:10:25 +00:00			`use std::thread;`
librustc: Stop reexporting the standard modules from prelude. 2013-05-25 02:35:29 +00:00
make spawned fn copy mode so that bare fns can be used 2012-01-08 19:19:44 +00:00			`fn main() {`
Squeeze the last bits of `task`s in documentation in favor of `thread` An automated script was run against the `.rs` and `.md` files, subsituting every occurrence of `task` with `thread`. In the `.rs` files, only the texts in the comment blocks were affected. 2015-05-08 15:12:29 +00:00			`// the purpose of this test is to make sure that thread::spawn()`
make spawned fn copy mode so that bare fns can be used 2012-01-08 19:19:44 +00:00			`// works when provided with a bare function:`
Fallout from stabilization 2015-02-17 23:10:25 +00:00			`let r = thread::spawn(startfn).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-26 01:18:13 +00:00			`if r.is_err() {`
Rename fail! to panic! https://github.com/rust-lang/rfcs/pull/221 The current terminology of "task failure" often causes problems when writing or speaking about code. You often want to talk about the possibility of an operation that returns a Result "failing", but cannot because of the ambiguity with task failure. Instead, you have to speak of "the failing case" or "when the operation does not succeed" or other circumlocutions. Likewise, we use a "Failure" header in rustdoc to describe when operations may fail the task, but it would often be helpful to separate out a section describing the "Err-producing" case. We have been steadily moving away from task failure and toward Result as an error-handling mechanism, so we should optimize our terminology accordingly: Result-producing functions should be easy to describe. To update your code, rename any call to `fail!` to `panic!` instead. Assuming you have not created your own macro named `panic!`, this will work on UNIX based systems: grep -lZR 'fail!' . \| xargs -0 -l sed -i -e 's/fail!/panic!/g' You can of course also do this by hand. [breaking-change] 2014-10-09 19:17:22 +00:00			`panic!()`
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-26 01:18:13 +00:00			`}`
make spawned fn copy mode so that bare fns can be used 2012-01-08 19:19:44 +00:00			`}`

			`fn startfn() {`
Fix the tests broken by replacing `task` with `thread` 2015-05-08 17:14:51 +00:00			`assert!("Ensure that the child thread runs by panicking".is_empty());`
make spawned fn copy mode so that bare fns can be used 2012-01-08 19:19:44 +00:00			`}`