rust/tests/ui/builtin-superkinds/builtin-superkinds-capabilities-transitive.rs

// run-pass
// Tests "transitivity" of super-builtin-kinds on traits. Here, if
// we have a Foo, we know we have a Bar, and if we have a Bar, we
// know we have a Send. So if we have a Foo we should know we have
// a Send. Basically this just makes sure rustc is using
// each_bound_trait_and_supertraits in type_contents correctly.


use std::sync::mpsc::{channel, Sender};

trait Bar : Send { }
trait Foo : Bar { }

impl <T: Send> Foo for T { }
impl <T: Send> Bar for T { }

fn foo<T: Foo + 'static>(val: T, chan: Sender<T>) {
    chan.send(val).unwrap();
}

pub fn main() {
    let (tx, rx) = channel();
    foo(31337, tx);
    assert_eq!(rx.recv().unwrap(), 31337);
}
tests: Add missing run-pass annotations 2019-07-26 21:54:25 +00:00			`// run-pass`
Fixup style of test cases for #7083 2013-08-19 21:15:25 +00:00			`// Tests "transitivity" of super-builtin-kinds on traits. Here, if`
			`// we have a Foo, we know we have a Bar, and if we have a Bar, we`
			`// know we have a Send. So if we have a Foo we should know we have`
			`// a Send. Basically this just makes sure rustc is using`
			`// each_bound_trait_and_supertraits in type_contents correctly.`

rustdoc: Replace no-pretty-expanded with pretty-expanded Now that features must be declared expanded source often does not compile. This adds 'pretty-expanded' to a bunch of test cases that still work. 2015-03-22 20:13:15 +00:00
std: Second pass stabilization for `comm` This commit is a second pass stabilization for the `std::comm` module, performing the following actions: * The entire `std::comm` module was moved under `std::sync::mpsc`. This movement reflects that channels are just yet another synchronization primitive, and they don't necessarily deserve a special place outside of the other concurrency primitives that the standard library offers. * The `send` and `recv` methods have all been removed. * The `send_opt` and `recv_opt` methods have been renamed to `send` and `recv`. This means that all send/receive operations return a `Result` now indicating whether the operation was successful or not. * The error type of `send` is now a `SendError` to implement a custom error message and allow for `unwrap()`. The error type contains an `into_inner` method to extract the value. * The error type of `recv` is now `RecvError` for the same reasons as `send`. * The `TryRecvError` and `TrySendError` types have had public reexports removed of their variants and the variant names have been tweaked with enum namespacing rules. * The `Messages` iterator is renamed to `Iter` This functionality is now all `#[stable]`: * `Sender` * `SyncSender` * `Receiver` * `std::sync::mpsc` * `channel` * `sync_channel` * `Iter` * `Sender::send` * `Sender::clone` * `SyncSender::send` * `SyncSender::try_send` * `SyncSender::clone` * `Receiver::recv` * `Receiver::try_recv` * `Receiver::iter` * `SendError` * `RecvError` * `TrySendError::{mod, Full, Disconnected}` * `TryRecvError::{mod, Empty, Disconnected}` * `SendError::into_inner` * `TrySendError::into_inner` This is a breaking change due to the modification of where this module is located, as well as the changing of the semantics of `send` and `recv`. Most programs just need to rename imports of `std::comm` to `std::sync::mpsc` and add calls to `unwrap` after a send or a receive operation. [breaking-change] 2014-12-23 19:53:35 +00:00			`use std::sync::mpsc::{channel, Sender};`
std: Stabilize the prelude module This commit is an implementation of [RFC 503][rfc] which is a stabilization story for the prelude. Most of the RFC was directly applied, removing reexports. Some reexports are kept around, however: * `range` remains until range syntax has landed to reduce churn. * `Path` and `GenericPath` remain until path reform lands. This is done to prevent many imports of `GenericPath` which will soon be removed. * All `io` traits remain until I/O reform lands so imports can be rewritten all at once to `std::io::prelude::*`. This is a breaking change because many prelude reexports have been removed, and the RFC can be consulted for the exact list of removed reexports, as well as to find the locations of where to import them. [rfc]: https://github.com/rust-lang/rfcs/blob/master/text/0503-prelude-stabilization.md [breaking-change] Closes #20068 2014-12-22 17:04:23 +00:00
Add tests for super-builtin-kind capabilities (#7083) 2013-08-19 20:54:58 +00:00			`trait Bar : Send { }`
			`trait Foo : Bar { }`

			`impl <T: Send> Foo for T { }`
			`impl <T: Send> Bar for T { }`

Update tests for the Send - 'static change. 2015-02-17 12:48:32 +00:00			`fn foo<T: Foo + 'static>(val: T, chan: Sender<T>) {`
std: Second pass stabilization for `comm` This commit is a second pass stabilization for the `std::comm` module, performing the following actions: * The entire `std::comm` module was moved under `std::sync::mpsc`. This movement reflects that channels are just yet another synchronization primitive, and they don't necessarily deserve a special place outside of the other concurrency primitives that the standard library offers. * The `send` and `recv` methods have all been removed. * The `send_opt` and `recv_opt` methods have been renamed to `send` and `recv`. This means that all send/receive operations return a `Result` now indicating whether the operation was successful or not. * The error type of `send` is now a `SendError` to implement a custom error message and allow for `unwrap()`. The error type contains an `into_inner` method to extract the value. * The error type of `recv` is now `RecvError` for the same reasons as `send`. * The `TryRecvError` and `TrySendError` types have had public reexports removed of their variants and the variant names have been tweaked with enum namespacing rules. * The `Messages` iterator is renamed to `Iter` This functionality is now all `#[stable]`: * `Sender` * `SyncSender` * `Receiver` * `std::sync::mpsc` * `channel` * `sync_channel` * `Iter` * `Sender::send` * `Sender::clone` * `SyncSender::send` * `SyncSender::try_send` * `SyncSender::clone` * `Receiver::recv` * `Receiver::try_recv` * `Receiver::iter` * `SendError` * `RecvError` * `TrySendError::{mod, Full, Disconnected}` * `TryRecvError::{mod, Empty, Disconnected}` * `SendError::into_inner` * `TrySendError::into_inner` This is a breaking change due to the modification of where this module is located, as well as the changing of the semantics of `send` and `recv`. Most programs just need to rename imports of `std::comm` to `std::sync::mpsc` and add calls to `unwrap` after a send or a receive operation. [breaking-change] 2014-12-23 19:53:35 +00:00			`chan.send(val).unwrap();`
Add tests for super-builtin-kind capabilities (#7083) 2013-08-19 20:54:58 +00:00			`}`

Fix run-pass tests to have 'pub fn main' This is required by the check-fast target because each test is slurped up into a submodule. 2013-09-25 07:43:37 +00:00			`pub fn main() {`
std: Rename Chan/Port types and constructor * Chan<T> => Sender<T> * Port<T> => Receiver<T> * Chan::new() => channel() * constructor returns (Sender, Receiver) instead of (Receiver, Sender) * local variables named `port` renamed to `rx` * local variables named `chan` renamed to `tx` Closes #11765 2014-03-09 21:58:32 +00:00			`let (tx, rx) = channel();`
Remove all `i` suffixes 2015-01-25 21:05:03 +00:00			`foo(31337, tx);`
Use `assert_eq!` instead of `assert!` in tests 2015-06-07 18:00:38 +00:00			`assert_eq!(rx.recv().unwrap(), 31337);`
Add tests for super-builtin-kind capabilities (#7083) 2013-08-19 20:54:58 +00:00			`}`