OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Auto merge of #74929 - Manishearth:rollup-z2vflrp, r=Manishearth

Browse Source 
Rollup of 10 pull requests

Successful merges:

 - #74742 (Remove links to rejected errata 4406 for RFC 4291)
 - #74819 (Point towards `format_spec`; it is in other direction)
 - #74852 (Explain why inlining default ToString impl)
 - #74869 (Make closures and generators a must use types)
 - #74873 (symbol mangling: use ty::print::Print for consts)
 - #74902 (Remove deprecated unstable `{Box,Rc,Arc}::into_raw_non_null` functions)
 - #74904 (Fix some typos in src/librustdoc/clean/auto_trait.rs)
 - #74910 (fence docs: fix example Mutex)
 - #74912 (Fix broken link in unstable book `plugin`)
 - #74927 (Change the target data layout to specify more values)

Failed merges:

r? @ghost
This commit is contained in:
bors 2020-07-30 00:17:51 +00:00
commit fb0b1237b1
47 changed files with 373 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
library/alloc/src/boxed.rs
View File

@ -143,7 +143,7 @@ use core::ops::{
CoerceUnsized, Deref, DerefMut, DispatchFromDyn, Generator, GeneratorState, Receiver,
};
use core::pin::Pin;
use core::ptr::{self, NonNull, Unique};
use core::ptr::{self, Unique};
use core::task::{Context, Poll};
use crate::alloc::{self, AllocInit, AllocRef, Global};
@ -451,50 +451,6 @@ impl<T: ?Sized> Box<T> {
Box::leak(b) as *mut T
}
/// Consumes the `Box`, returning the wrapped pointer as `NonNull<T>`.
///
/// After calling this function, the caller is responsible for the
/// memory previously managed by the `Box`. In particular, the
/// caller should properly destroy `T` and release the memory. The
/// easiest way to do so is to convert the `NonNull<T>` pointer
/// into a raw pointer and back into a `Box` with the [`Box::from_raw`]
/// function.
///
/// Note: this is an associated function, which means that you have
/// to call it as `Box::into_raw_non_null(b)`
/// instead of `b.into_raw_non_null()`. This
/// is so that there is no conflict with a method on the inner type.
///
/// [`Box::from_raw`]: struct.Box.html#method.from_raw
///
/// # Examples
///
/// ```
/// #![feature(box_into_raw_non_null)]
/// #![allow(deprecated)]
///
/// let x = Box::new(5);
/// let ptr = Box::into_raw_non_null(x);
///
/// // Clean up the memory by converting the NonNull pointer back
/// // into a Box and letting the Box be dropped.
/// let x = unsafe { Box::from_raw(ptr.as_ptr()) };
/// ```
#[unstable(feature = "box_into_raw_non_null", issue = "47336")]
#[rustc_deprecated(
since = "1.44.0",
reason = "use `Box::leak(b).into()` or `NonNull::from(Box::leak(b))` instead"
)]
#[inline]
pub fn into_raw_non_null(b: Box<T>) -> NonNull<T> {
// Box is recognized as a "unique pointer" by Stacked Borrows, but internally it is a
// raw pointer for the type system. Turning it directly into a raw pointer would not be
// recognized as "releasing" the unique pointer to permit aliased raw accesses,
// so all raw pointer methods go through `leak` which creates a (unique)
// mutable reference. Turning *that* to a raw pointer behaves correctly.
Box::leak(b).into()
}
#[unstable(
feature = "ptr_internals",
issue = "none",

2
library/alloc/src/fmt.rs
View File

@ -83,7 +83,7 @@
//! # Formatting Parameters
//!
//! Each argument being formatted can be transformed by a number of formatting
//! parameters (corresponding to `format_spec` in the syntax above). These
//! parameters (corresponding to `format_spec` in [the syntax](#syntax)). These
//! parameters affect the string representation of what's being formatted.
//!
//! ## Width

23
library/alloc/src/rc.rs
View File

@ -645,29 +645,6 @@ impl<T: ?Sized> Rc<T> {
unsafe { Self::from_ptr(rc_ptr) }
}
/// Consumes the `Rc`, returning the wrapped pointer as `NonNull<T>`.
///
/// # Examples
///
/// ```
/// #![feature(rc_into_raw_non_null)]
/// #![allow(deprecated)]
///
/// use std::rc::Rc;
///
/// let x = Rc::new("hello".to_owned());
/// let ptr = Rc::into_raw_non_null(x);
/// let deref = unsafe { ptr.as_ref() };
/// assert_eq!(deref, "hello");
/// ```
#[unstable(feature = "rc_into_raw_non_null", issue = "47336")]
#[rustc_deprecated(since = "1.44.0", reason = "use `Rc::into_raw` instead")]
#[inline]
pub fn into_raw_non_null(this: Self) -> NonNull<T> {
// safe because Rc guarantees its pointer is non-null
unsafe { NonNull::new_unchecked(Rc::into_raw(this) as *mut _) }
}
/// Creates a new [`Weak`][weak] pointer to this allocation.
///
/// [weak]: struct.Weak.html

3
library/alloc/src/string.rs
View File

@ -2196,6 +2196,9 @@ pub trait ToString {
/// since `fmt::Write for String` never returns an error itself.
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: fmt::Display + ?Sized> ToString for T {
// A common guideline is to not inline generic functions. However,
// remove `#[inline]` from this method causes non-negligible regression.
// See <https://github.com/rust-lang/rust/pull/74852> as last attempt try to remove it.
#[inline]
default fn to_string(&self) -> String {
use fmt::Write;

23
library/alloc/src/sync.rs
View File

@ -646,29 +646,6 @@ impl<T: ?Sized> Arc<T> {
}
}
/// Consumes the `Arc`, returning the wrapped pointer as `NonNull<T>`.
///
/// # Examples
///
/// ```
/// #![feature(rc_into_raw_non_null)]
/// #![allow(deprecated)]
///
/// use std::sync::Arc;
///
/// let x = Arc::new("hello".to_owned());
/// let ptr = Arc::into_raw_non_null(x);
/// let deref = unsafe { ptr.as_ref() };
/// assert_eq!(deref, "hello");
/// ```
#[unstable(feature = "rc_into_raw_non_null", issue = "47336")]
#[rustc_deprecated(since = "1.44.0", reason = "use `Arc::into_raw` instead")]
#[inline]
pub fn into_raw_non_null(this: Self) -> NonNull<T> {
// safe because Arc guarantees its pointer is non-null
unsafe { NonNull::new_unchecked(Arc::into_raw(this) as *mut _) }
}
/// Creates a new [`Weak`][weak] pointer to this allocation.
///
/// [weak]: struct.Weak.html

3
library/core/src/sync/atomic.rs
View File

@ -2649,7 +2649,8 @@ unsafe fn atomic_umin<T: Copy>(dst: *mut T, val: T, order: Ordering) -> T {
/// }
///
/// pub fn lock(&self) {
/// while !self.flag.compare_and_swap(false, true, Ordering::Relaxed) {}
/// // Wait until the old value is `false`.
/// while self.flag.compare_and_swap(false, true, Ordering::Relaxed) != false {}
/// // This fence synchronizes-with store in `unlock`.
/// fence(Ordering::Acquire);
/// }

8
library/std/src/net/ip.rs
View File

@ -1265,7 +1265,8 @@ impl Ipv6Addr {
/// # See also
///
/// - [IETF RFC 4291 section 2.5.6]
/// - [RFC 4291 errata 4406]
/// - [RFC 4291 errata 4406] (which has been rejected but provides useful
/// insight)
/// - [`is_unicast_link_local()`]
///
/// [IETF RFC 4291]: https://tools.ietf.org/html/rfc4291
@ -1273,7 +1274,6 @@ impl Ipv6Addr {
/// [`true`]: ../../std/primitive.bool.html
/// [RFC 4291 errata 4406]: https://www.rfc-editor.org/errata/eid4406
/// [`is_unicast_link_local()`]: ../../std/net/struct.Ipv6Addr.html#method.is_unicast_link_local
///
pub fn is_unicast_link_local_strict(&self) -> bool {
(self.segments()[0] & 0xffff) == 0xfe80
&& (self.segments()[1] & 0xffff) == 0
@ -1324,13 +1324,13 @@ impl Ipv6Addr {
/// # See also
///
/// - [IETF RFC 4291 section 2.4]
/// - [RFC 4291 errata 4406]
/// - [RFC 4291 errata 4406] (which has been rejected but provides useful
/// insight)
///
/// [IETF RFC 4291 section 2.4]: https://tools.ietf.org/html/rfc4291#section-2.4
/// [`true`]: ../../std/primitive.bool.html
/// [RFC 4291 errata 4406]: https://www.rfc-editor.org/errata/eid4406
/// [`is_unicast_link_local_strict()`]: ../../std/net/struct.Ipv6Addr.html#method.is_unicast_link_local_strict
///
pub fn is_unicast_link_local(&self) -> bool {
(self.segments()[0] & 0xffc0) == 0xfe80
}

2
src/doc/unstable-book/src/language-features/plugin.md
View File

@ -35,7 +35,7 @@ of a library.
Plugins can extend [Rust's lint
infrastructure](../../reference/attributes/diagnostics.md#lint-check-attributes) with
additional checks for code style, safety, etc. Now let's write a plugin
[`lint_plugin_test.rs`](https://github.com/rust-lang/rust/blob/master/src/test/ui-fulldeps/auxiliary/lint_plugin_test.rs)
[`lint-plugin-test.rs`](https://github.com/rust-lang/rust/blob/master/src/test/ui-fulldeps/auxiliary/lint-plugin-test.rs)
that warns about any item named `lintme`.
```rust,ignore

22
src/librustc_lint/unused.rs
View File

@ -203,6 +203,28 @@ impl<'tcx> LateLintPass<'tcx> for UnusedResults {
// Otherwise, we don't lint, to avoid false positives.
_ => false,
},
ty::Closure(..) => {
cx.struct_span_lint(UNUSED_MUST_USE, span, |lint| {
let mut err = lint.build(&format!(
"unused {}closure{}{} that must be used",
descr_pre, plural_suffix, descr_post,
));
err.note("closures are lazy and do nothing unless called");
err.emit();
});
true
}
ty::Generator(..) => {
cx.struct_span_lint(UNUSED_MUST_USE, span, |lint| {
let mut err = lint.build(&format!(
"unused {}generator{}{} that must be used",
descr_pre, plural_suffix, descr_post,
));
err.note("generators are lazy and do nothing unless resumed");
err.emit();
});
true
}
_ => false,
}
}

4
src/librustc_symbol_mangling/v0.rs
View File

@ -636,9 +636,7 @@ impl Printer<'tcx> for SymbolMangler<'tcx> {
}
GenericArgKind::Const(c) => {
self.push("K");
// FIXME(const_generics) implement `ty::print::Print` on `ty::Const`.
// self = c.print(self)?;
self = self.print_const(c)?;
self = c.print(self)?;
}
}
}

2
src/librustc_target/spec/thumbv4t_none_eabi.rs
View File

@ -29,7 +29,7 @@ pub fn target() -> TargetResult {
* native integers are 32-bit
* All other elements are default
*/
data_layout: "e-S64-p:32:32-i64:64-m:e-n32".to_string(),
data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
linker_flavor: LinkerFlavor::Ld,
options: TargetOptions {
linker: Some("arm-none-eabi-ld".to_string()),

8
src/librustdoc/clean/auto_trait.rs
View File

@ -430,14 +430,14 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
}
// Converts the calculated ParamEnv and lifetime information to a clean::Generics, suitable for
// display on the docs page. Cleaning the Predicates produces sub-optimal WherePredicate's,
// display on the docs page. Cleaning the Predicates produces sub-optimal `WherePredicate`s,
// so we fix them up:
//
// * Multiple bounds for the same type are coalesced into one: e.g., 'T: Copy', 'T: Debug'
// becomes 'T: Copy + Debug'
// * Fn bounds are handled specially - instead of leaving it as 'T: Fn(), <T as Fn::Output> =
// K', we use the dedicated syntax 'T: Fn() -> K'
// * We explcitly add a '?Sized' bound if we didn't find any 'Sized' predicates for a type
// * We explicitly add a '?Sized' bound if we didn't find any 'Sized' predicates for a type
fn param_env_to_generics(
&self,
tcx: TyCtxt<'tcx>,
@ -588,7 +588,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
.args;
match args {
// Convert somethiung like '<T as Iterator::Item> = u8'
// Convert something like '<T as Iterator::Item> = u8'
// to 'T: Iterator<Item=u8>'
GenericArgs::AngleBracketed {
ref mut bindings, ..
@ -712,7 +712,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
// since FxHasher has different behavior for 32-bit and 64-bit platforms.
//
// Obviously, it's extremely undesirable for documentation rendering
// to be depndent on the platform it's run on. Apart from being confusing
// to be dependent on the platform it's run on. Apart from being confusing
// to end users, it makes writing tests much more difficult, as predicates
// can appear in any order in the final result.
//

4
src/test/ui/generator/issue-52398.rs
View File

@ -14,14 +14,14 @@ impl A {
fn main() {
// Test that the MIR local with type &A created for the auto-borrow adjustment
// is caught by typeck
move || {
move || { //~ WARN unused generator that must be used
A.test(yield);
};
// Test that the std::cell::Ref temporary returned from the `borrow` call
// is caught by typeck
let y = RefCell::new(true);
static move || {
static move || { //~ WARN unused generator that must be used
yield *y.borrow();
return "Done";
};

24
src/test/ui/generator/issue-52398.stderr Normal file
View File

@ -0,0 +1,24 @@
warning: unused generator that must be used
--> $DIR/issue-52398.rs:17:5
|
LL | / move || {
LL | | A.test(yield);
LL | | };
| |______^
|
= note: `#[warn(unused_must_use)]` on by default
= note: generators are lazy and do nothing unless resumed
warning: unused generator that must be used
--> $DIR/issue-52398.rs:24:5
|
LL | / static move || {
LL | | yield *y.borrow();
LL | | return "Done";
LL | | };
| |______^
|
= note: generators are lazy and do nothing unless resumed
warning: 2 warnings emitted

2
src/test/ui/generator/issue-57084.rs
View File

@ -19,7 +19,7 @@ where F: Fn() -> ()
fn main() {
let data = &vec![1];
|| {
|| { //~ WARN unused generator that must be used
let _to_pin = with(move || println!("{:p}", data));
loop {
yield

16
src/test/ui/generator/issue-57084.stderr Normal file
View File

@ -0,0 +1,16 @@
warning: unused generator that must be used
--> $DIR/issue-57084.rs:22:5
|
LL | / || {
LL | | let _to_pin = with(move || println!("{:p}", data));
LL | | loop {
LL | | yield
LL | | }
LL | | };
| |______^
|
= note: `#[warn(unused_must_use)]` on by default
= note: generators are lazy and do nothing unless resumed
warning: 1 warning emitted

2
src/test/ui/generator/match-bindings.rs
View File

@ -9,7 +9,7 @@ enum Enum {
}
fn main() {
|| {
|| { //~ WARN unused generator that must be used
loop {
if let true = true {
match Enum::A(String::new()) {

17
src/test/ui/generator/match-bindings.stderr Normal file
View File

@ -0,0 +1,17 @@
warning: unused generator that must be used
--> $DIR/match-bindings.rs:12:5
|
LL | / || {
LL | | loop {
LL | | if let true = true {
LL | | match Enum::A(String::new()) {
... |
LL | | }
LL | | };
| |______^
|
= note: `#[warn(unused_must_use)]` on by default
= note: generators are lazy and do nothing unless resumed
warning: 1 warning emitted

2
src/test/ui/generator/reborrow-mut-upvar.rs
View File

@ -3,7 +3,7 @@
#![feature(generators)]
fn _run(bar: &mut i32) {
|| {
|| { //~ WARN unused generator that must be used
{
let _baz = &*bar;
yield;

17
src/test/ui/generator/reborrow-mut-upvar.stderr Normal file
View File

@ -0,0 +1,17 @@
warning: unused generator that must be used
--> $DIR/reborrow-mut-upvar.rs:6:5
|
LL | / || {
LL | | {
LL | | let _baz = &*bar;
LL | | yield;
... |
LL | | *bar = 2;
LL | | };
| |______^
|
= note: `#[warn(unused_must_use)]` on by default
= note: generators are lazy and do nothing unless resumed
warning: 1 warning emitted

2
src/test/ui/generator/too-live-local-in-immovable-gen.rs
View File

@ -5,7 +5,7 @@
fn main() {
unsafe {
static move || {
static move || { //~ WARN unused generator that must be used
// Tests that the generator transformation finds out that `a` is not live
// during the yield expression. Type checking will also compute liveness
// and it should also find out that `a` is not live.

17
src/test/ui/generator/too-live-local-in-immovable-gen.stderr Normal file
View File

@ -0,0 +1,17 @@
warning: unused generator that must be used
--> $DIR/too-live-local-in-immovable-gen.rs:8:9
|
LL | / static move || {
LL | | // Tests that the generator transformation finds out that `a` is not live
LL | | // during the yield expression. Type checking will also compute liveness
LL | | // and it should also find out that `a` is not live.
... |
LL | | &a;
LL | | };
| |__________^
|
= note: `#[warn(unused_must_use)]` on by default
= note: generators are lazy and do nothing unless resumed
warning: 1 warning emitted

2
src/test/ui/generator/yield-in-args-rev.rs
View File

@ -10,7 +10,7 @@
fn foo(_a: (), _b: &bool) {}
fn bar() {
|| {
|| { //~ WARN unused generator that must be used
let b = true;
foo(yield, &b);
};

14
src/test/ui/generator/yield-in-args-rev.stderr Normal file
View File

@ -0,0 +1,14 @@
warning: unused generator that must be used
--> $DIR/yield-in-args-rev.rs:13:5
|
LL | / || {
LL | | let b = true;
LL | | foo(yield, &b);
LL | | };
| |______^
|
= note: `#[warn(unused_must_use)]` on by default
= note: generators are lazy and do nothing unless resumed
warning: 1 warning emitted

2
src/test/ui/generator/yield-in-box.rs
View File

@ -6,7 +6,7 @@
fn main() {
let x = 0i32;
|| {
|| { //~ WARN unused generator that must be used
let y = 2u32;
{
let _t = box (&x, yield 0, &y);

17
src/test/ui/generator/yield-in-box.stderr Normal file
View File

@ -0,0 +1,17 @@
warning: unused generator that must be used
--> $DIR/yield-in-box.rs:9:5
|
LL | / || {
LL | | let y = 2u32;
LL | | {
LL | | let _t = box (&x, yield 0, &y);
... |
LL | | }
LL | | };
| |______^
|
= note: `#[warn(unused_must_use)]` on by default
= note: generators are lazy and do nothing unless resumed
warning: 1 warning emitted

2
src/test/ui/generator/yield-in-initializer.rs
View File

@ -3,7 +3,7 @@
#![feature(generators)]
fn main() {
static || {
static || { //~ WARN unused generator that must be used
loop {
// Test that `opt` is not live across the yield, even when borrowed in a loop
// See https://github.com/rust-lang/rust/issues/52792

17
src/test/ui/generator/yield-in-initializer.stderr Normal file
View File

@ -0,0 +1,17 @@
warning: unused generator that must be used
--> $DIR/yield-in-initializer.rs:6:5
|
LL | / static || {
LL | | loop {
LL | | // Test that `opt` is not live across the yield, even when borrowed in a loop
LL | | // See https://github.com/rust-lang/rust/issues/52792
... |
LL | | }
LL | | };
| |______^
|
= note: `#[warn(unused_must_use)]` on by default
= note: generators are lazy and do nothing unless resumed
warning: 1 warning emitted

2
src/test/ui/generator/yield-subtype.rs
View File

@ -8,7 +8,7 @@ fn bar<'a>() {
let a: &'static str = "hi";
let b: &'a str = a;
|| {
|| { //~ WARN unused generator that must be used
yield a;
yield b;
};

14
src/test/ui/generator/yield-subtype.stderr Normal file
View File

@ -0,0 +1,14 @@
warning: unused generator that must be used
--> $DIR/yield-subtype.rs:11:5
|
LL | / || {
LL | | yield a;
LL | | yield b;
LL | | };
| |______^
|
= note: `#[warn(unused_must_use)]` on by default
= note: generators are lazy and do nothing unless resumed
warning: 1 warning emitted

2
src/test/ui/issues/issue-1460.rs
View File

@ -3,5 +3,5 @@
// pretty-expanded FIXME #23616
pub fn main() {
{|i: u32| if 1 == i { }};
{|i: u32| if 1 == i { }}; //~ WARN unused closure that must be used
}

11
src/test/ui/issues/issue-1460.stderr Normal file
View File

@ -0,0 +1,11 @@
warning: unused closure that must be used
--> $DIR/issue-1460.rs:6:5
|
LL | {|i: u32| if 1 == i { }};
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: `#[warn(unused_must_use)]` on by default
= note: closures are lazy and do nothing unless called
warning: 1 warning emitted

2
src/test/ui/issues/issue-16256.rs
View File

@ -3,5 +3,5 @@
fn main() {
let mut buf = Vec::new();
|c: u8| buf.push(c);
|c: u8| buf.push(c); //~ WARN unused closure that must be used
}

11
src/test/ui/issues/issue-16256.stderr Normal file
View File

@ -0,0 +1,11 @@
warning: unused closure that must be used
--> $DIR/issue-16256.rs:6:5
|
LL | |c: u8| buf.push(c);
| ^^^^^^^^^^^^^^^^^^^^
|
= note: `#[warn(unused_must_use)]` on by default
= note: closures are lazy and do nothing unless called
warning: 1 warning emitted

18
src/test/ui/liveness/liveness-upvars.rs
View File

@ -27,7 +27,7 @@ pub fn f() {
let mut c = 0;
// Captured by value, but variable is dead on entry.
move || {
let _ = move || {
c = 1; //~ WARN value captured by `c` is never read
println!("{}", c);
};
@ -37,7 +37,7 @@ pub fn f() {
};
// Read and written to, but never actually used.
move || {
let _ = move || {
c += 1; //~ WARN unused variable: `c`
};
let _ = async move {
@ -45,13 +45,13 @@ pub fn f() {
//~| WARN unused variable: `c`
};
move || {
let _ = move || {
println!("{}", c);
// Value is read by closure itself on later invocations.
c += 1;
};
let b = Box::new(42);
move || {
let _ = move || {
println!("{}", c);
// Never read because this is FnOnce closure.
c += 1; //~ WARN value assigned to `c` is never read
@ -67,12 +67,12 @@ pub fn f() {
pub fn nested() {
let mut d = None;
let mut e = None;
|| {
|| {
let _ = || {
let _ = || {
d = Some("d1"); //~ WARN value assigned to `d` is never read
d = Some("d2");
};
move || {
let _ = move || {
e = Some("e1"); //~ WARN value assigned to `e` is never read
//~| WARN unused variable: `e`
e = Some("e2"); //~ WARN value assigned to `e` is never read
@ -81,7 +81,7 @@ pub fn nested() {
}
pub fn g<T: Default>(mut v: T) {
|r| {
let _ = |r| {
if r {
v = T::default(); //~ WARN value assigned to `v` is never read
} else {
@ -92,7 +92,7 @@ pub fn g<T: Default>(mut v: T) {
pub fn h<T: Copy + Default + std::fmt::Debug>() {
let mut z = T::default();
move |b| {
let _ = move |b| {
loop {
if b {
z = T::default(); //~ WARN value assigned to `z` is never read

2
src/test/ui/nll/capture-mut-ref.fixed
View File

@ -8,7 +8,7 @@
pub fn mutable_upvar() {
let x = &mut 0;
//~^ ERROR
move || {
let _ = move || {
*x = 1;
};
}

2
src/test/ui/nll/capture-mut-ref.rs
View File

@ -8,7 +8,7 @@
pub fn mutable_upvar() {
let mut x = &mut 0;
//~^ ERROR
move || {
let _ = move || {
*x = 1;
};
}

2
src/test/ui/nll/issue-48623-generator.rs
View File

@ -12,7 +12,7 @@ impl Drop for WithDrop {
fn reborrow_from_generator(r: &mut ()) {
let d = WithDrop;
move || { d; yield; &mut *r };
move || { d; yield; &mut *r }; //~ WARN unused generator that must be used
}
fn main() {}

11
src/test/ui/nll/issue-48623-generator.stderr Normal file
View File

@ -0,0 +1,11 @@
warning: unused generator that must be used
--> $DIR/issue-48623-generator.rs:15:5
|
LL | move || { d; yield; &mut *r };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: `#[warn(unused_must_use)]` on by default
= note: generators are lazy and do nothing unless resumed
warning: 1 warning emitted

4
src/test/ui/test-attrs/test-runner-hides-buried-main.rs
View File

@ -7,9 +7,9 @@
mod a {
fn b() {
|| {
(|| {
#[main]
fn c() { panic!(); }
};
})();
}
}

1
src/test/ui/unboxed-closures/unboxed-closures-move-mutable.rs
View File

@ -2,6 +2,7 @@
// pretty-expanded FIXME #23616
#![deny(unused_mut)]
#![allow(unused_must_use)]
// Test that mutating a mutable upvar in a capture-by-value unboxed
// closure does not ice (issue #18238) and marks the upvar as used

4
src/test/ui/unboxed-closures/unboxed-closures-move-mutable.stderr
View File

@ -1,5 +1,5 @@
warning: unused variable: `x`
--> $DIR/unboxed-closures-move-mutable.rs:16:17
--> $DIR/unboxed-closures-move-mutable.rs:17:17
|
LL | move || x += 1;
| ^
@ -8,7 +8,7 @@ LL | move || x += 1;
= help: did you mean to capture by reference instead?
warning: unused variable: `x`
--> $DIR/unboxed-closures-move-mutable.rs:20:17
--> $DIR/unboxed-closures-move-mutable.rs:21:17
|
LL | move || x += 1;
| ^

40
src/test/ui/unused/unused-closure.rs Normal file
View File

@ -0,0 +1,40 @@
// Test that closures and generators are "must use" types.
// edition:2018
#![feature(async_closure)]
#![feature(const_in_array_repeat_expressions)]
#![feature(generators)]
#![deny(unused_must_use)]
fn unused() {
|| { //~ ERROR unused closure that must be used
println!("Hello!");
};
async {}; //~ ERROR unused implementer of `std::future::Future` that must be used
|| async {}; //~ ERROR unused closure that must be used
async || {}; //~ ERROR unused closure that must be used
[Box::new([|| {}; 10]); 1]; //~ ERROR unused array of boxed arrays of closures that must be used
[|| { //~ ERROR unused array of generators that must be used
yield 42u32;
}; 42];
vec![|| "a"].pop().unwrap(); //~ ERROR unused closure that must be used
let b = false;
|| true; //~ ERROR unused closure that must be used
println!("{}", b);
}
fn ignored() {
let _ = || {};
let _ = || yield 42;
}
fn main() {
unused();
ignored();
}

75
src/test/ui/unused/unused-closure.stderr Normal file
View File

@ -0,0 +1,75 @@
error: unused closure that must be used
--> $DIR/unused-closure.rs:10:5
|
LL | / || {
LL | | println!("Hello!");
LL | | };
| |______^
|
note: the lint level is defined here
--> $DIR/unused-closure.rs:7:9
|
LL | #![deny(unused_must_use)]
| ^^^^^^^^^^^^^^^
= note: closures are lazy and do nothing unless called
error: unused implementer of `std::future::Future` that must be used
--> $DIR/unused-closure.rs:14:5
|
LL | async {};
| ^^^^^^^^^
|
= note: futures do nothing unless you `.await` or poll them
error: unused closure that must be used
--> $DIR/unused-closure.rs:15:5
|
LL | || async {};
| ^^^^^^^^^^^^
|
= note: closures are lazy and do nothing unless called
error: unused closure that must be used
--> $DIR/unused-closure.rs:16:5
|
LL | async || {};
| ^^^^^^^^^^^^
|
= note: closures are lazy and do nothing unless called
error: unused array of boxed arrays of closures that must be used
--> $DIR/unused-closure.rs:19:5
|
LL | [Box::new([|| {}; 10]); 1];
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: closures are lazy and do nothing unless called
error: unused array of generators that must be used
--> $DIR/unused-closure.rs:21:5
|
LL | / [|| {
LL | | yield 42u32;
LL | | }; 42];
| |___________^
|
= note: generators are lazy and do nothing unless resumed
error: unused closure that must be used
--> $DIR/unused-closure.rs:25:5
|
LL | vec![|| "a"].pop().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: closures are lazy and do nothing unless called
error: unused closure that must be used
--> $DIR/unused-closure.rs:28:9
|
LL | || true;
| ^^^^^^^^
|
= note: closures are lazy and do nothing unless called
error: aborting due to 8 previous errors

2
src/test/ui/unused/unused-mut-warning-captured-var.fixed
View File

@ -5,5 +5,5 @@
fn main() {
let x = 1;
//~^ ERROR: variable does not need to be mutable
move|| { println!("{}", x); };
(move|| { println!("{}", x); })();
}

2
src/test/ui/unused/unused-mut-warning-captured-var.rs
View File

@ -5,5 +5,5 @@
fn main() {
let mut x = 1;
//~^ ERROR: variable does not need to be mutable
move|| { println!("{}", x); };
(move|| { println!("{}", x); })();
}

2
src/test/ui/weird-exprs.rs
View File

@ -5,7 +5,7 @@
#![allow(non_camel_case_types)]
#![allow(dead_code)]
#![allow(unreachable_code)]
#![allow(unused_braces, unused_parens)]
#![allow(unused_braces, unused_must_use, unused_parens)]
#![recursion_limit = "256"]