diff options
19 files changed, 168 insertions, 108 deletions
diff --git a/tests/ui/allocator/allocator-reallocate-overflow.rs b/tests/ui/allocator/alloc-shrink-oob-read.rs index 43810a469df..b9edfca3b7b 100644 --- a/tests/ui/allocator/allocator-reallocate-overflow.rs +++ b/tests/ui/allocator/alloc-shrink-oob-read.rs @@ -1,13 +1,13 @@ +//! Sanity check for out-of-bounds read caused by copying the entire original buffer on shrink. +//! +//! Regression test for: <https://github.com/rust-lang/rust/issues/16687> + //@ run-pass -// alloc::heap::reallocate test. -// -// Ideally this would be revised to use no_std, but for now it serves -// well enough to reproduce (and illustrate) the bug from #16687. #![feature(allocator_api)] #![feature(slice_ptr_get)] -use std::alloc::{handle_alloc_error, Allocator, Global, Layout}; +use std::alloc::{Allocator, Global, Layout, handle_alloc_error}; use std::ptr::{self, NonNull}; fn main() { diff --git a/tests/ui/auto-traits/auto-trait-phantom-data-bounds.rs b/tests/ui/auto-traits/auto-trait-phantom-data-bounds.rs index 0172ca335c3..6d1c4c87fad 100644 --- a/tests/ui/auto-traits/auto-trait-phantom-data-bounds.rs +++ b/tests/ui/auto-traits/auto-trait-phantom-data-bounds.rs @@ -1,9 +1,9 @@ -// Ensure that auto trait checks `T` when it encounters a `PhantomData<T>` field, instead of -// checking the `PhantomData<T>` type itself (which almost always implements an auto trait). +//! Ensure that auto trait checks `T` when it encounters a `PhantomData<T>` field, instead of +//! checking the `PhantomData<T>` type itself (which almost always implements an auto trait). #![feature(auto_traits)] -use std::marker::{PhantomData}; +use std::marker::PhantomData; unsafe auto trait Zen {} diff --git a/tests/ui/auto-traits/auto-trait-phantom-data-bounds.stderr b/tests/ui/auto-traits/auto-trait-phantom-data-bounds.stderr index ffd4c3a0e1a..56c2e8ff257 100644 --- a/tests/ui/auto-traits/auto-trait-phantom-data-bounds.stderr +++ b/tests/ui/auto-traits/auto-trait-phantom-data-bounds.stderr @@ -1,5 +1,5 @@ error[E0277]: `T` cannot be shared between threads safely - --> $DIR/phantom-auto-trait.rs:21:12 + --> $DIR/auto-trait-phantom-data-bounds.rs:21:12 | LL | is_zen(x) | ------ ^ `T` cannot be shared between threads safely @@ -7,19 +7,19 @@ LL | is_zen(x) | required by a bound introduced by this call | note: required for `&T` to implement `Zen` - --> $DIR/phantom-auto-trait.rs:10:24 + --> $DIR/auto-trait-phantom-data-bounds.rs:10:24 | LL | unsafe impl<'a, T: 'a> Zen for &'a T where T: Sync {} | ^^^ ^^^^^ ---- unsatisfied trait bound introduced here note: required because it appears within the type `PhantomData<&T>` --> $SRC_DIR/core/src/marker.rs:LL:COL note: required because it appears within the type `Guard<'_, T>` - --> $DIR/phantom-auto-trait.rs:12:8 + --> $DIR/auto-trait-phantom-data-bounds.rs:12:8 | LL | struct Guard<'a, T: 'a> { | ^^^^^ note: required by a bound in `is_zen` - --> $DIR/phantom-auto-trait.rs:18:14 + --> $DIR/auto-trait-phantom-data-bounds.rs:18:14 | LL | fn is_zen<T: Zen>(_: T) {} | ^^^ required by this bound in `is_zen` @@ -29,7 +29,7 @@ LL | fn not_sync<T: std::marker::Sync>(x: Guard<T>) { | +++++++++++++++++++ error[E0277]: `T` cannot be shared between threads safely - --> $DIR/phantom-auto-trait.rs:26:12 + --> $DIR/auto-trait-phantom-data-bounds.rs:26:12 | LL | is_zen(x) | ------ ^ `T` cannot be shared between threads safely @@ -37,24 +37,24 @@ LL | is_zen(x) | required by a bound introduced by this call | note: required for `&T` to implement `Zen` - --> $DIR/phantom-auto-trait.rs:10:24 + --> $DIR/auto-trait-phantom-data-bounds.rs:10:24 | LL | unsafe impl<'a, T: 'a> Zen for &'a T where T: Sync {} | ^^^ ^^^^^ ---- unsatisfied trait bound introduced here note: required because it appears within the type `PhantomData<&T>` --> $SRC_DIR/core/src/marker.rs:LL:COL note: required because it appears within the type `Guard<'_, T>` - --> $DIR/phantom-auto-trait.rs:12:8 + --> $DIR/auto-trait-phantom-data-bounds.rs:12:8 | LL | struct Guard<'a, T: 'a> { | ^^^^^ note: required because it appears within the type `Nested<Guard<'_, T>>` - --> $DIR/phantom-auto-trait.rs:16:8 + --> $DIR/auto-trait-phantom-data-bounds.rs:16:8 | LL | struct Nested<T>(T); | ^^^^^^ note: required by a bound in `is_zen` - --> $DIR/phantom-auto-trait.rs:18:14 + --> $DIR/auto-trait-phantom-data-bounds.rs:18:14 | LL | fn is_zen<T: Zen>(_: T) {} | ^^^ required by this bound in `is_zen` diff --git a/tests/ui/binop/binop-evaluation-order-primitive.rs b/tests/ui/binop/binop-evaluation-order-primitive.rs index d988e2ed14f..33266d1c047 100644 --- a/tests/ui/binop/binop-evaluation-order-primitive.rs +++ b/tests/ui/binop/binop-evaluation-order-primitive.rs @@ -1,6 +1,15 @@ +//! Test evaluation order in binary operations with primitive types. + //@ run-pass fn main() { let x = Box::new(0); - assert_eq!(0, *x + { drop(x); let _ = Box::new(main); 0 }); + assert_eq!( + 0, + *x + { + drop(x); + let _ = Box::new(main); + 0 + } + ); } diff --git a/tests/ui/coercion/basic-ptr-coercions.rs b/tests/ui/coercion/basic-ptr-coercions.rs index 8cc4120328e..4229d1fb274 100644 --- a/tests/ui/coercion/basic-ptr-coercions.rs +++ b/tests/ui/coercion/basic-ptr-coercions.rs @@ -1,29 +1,24 @@ -//@ run-pass - -#![allow(unused_variables)] -// Test coercions between pointers which don't do anything fancy like unsizing. +//! Tests basic pointer coercions +//@ run-pass pub fn main() { // &mut -> & let x: &mut isize = &mut 42; - let x: &isize = x; - - let x: &isize = &mut 42; + let _x: &isize = x; + let _x: &isize = &mut 42; // & -> *const let x: &isize = &42; - let x: *const isize = x; - - let x: *const isize = &42; + let _x: *const isize = x; + let _x: *const isize = &42; // &mut -> *const let x: &mut isize = &mut 42; - let x: *const isize = x; - - let x: *const isize = &mut 42; + let _x: *const isize = x; + let _x: *const isize = &mut 42; // *mut -> *const - let x: *mut isize = &mut 42; - let x: *const isize = x; + let _x: *mut isize = &mut 42; + let _x: *const isize = x; } diff --git a/tests/ui/coercion/ptr-mutability-errors.rs b/tests/ui/coercion/ptr-mutability-errors.rs index 2549bd6f134..391eaf0b913 100644 --- a/tests/ui/coercion/ptr-mutability-errors.rs +++ b/tests/ui/coercion/ptr-mutability-errors.rs @@ -1,5 +1,4 @@ -// Test coercions between pointers which don't do anything fancy like unsizing. -// These are testing that we don't lose mutability when converting to raw pointers. +//! Tests that pointer coercions preserving mutability are enforced: //@ dont-require-annotations: NOTE diff --git a/tests/ui/coercion/ptr-mutability-errors.stderr b/tests/ui/coercion/ptr-mutability-errors.stderr index 8de41d2c382..b4ded821c79 100644 --- a/tests/ui/coercion/ptr-mutability-errors.stderr +++ b/tests/ui/coercion/ptr-mutability-errors.stderr @@ -1,5 +1,5 @@ error[E0308]: mismatched types - --> $DIR/ptr-coercion.rs:9:25 + --> $DIR/ptr-mutability-errors.rs:8:25 | LL | let x: *mut isize = x; | ---------- ^ types differ in mutability @@ -10,7 +10,7 @@ LL | let x: *mut isize = x; found raw pointer `*const isize` error[E0308]: mismatched types - --> $DIR/ptr-coercion.rs:15:25 + --> $DIR/ptr-mutability-errors.rs:14:25 | LL | let x: *mut isize = &42; | ---------- ^^^ types differ in mutability @@ -21,7 +21,7 @@ LL | let x: *mut isize = &42; found reference `&isize` error[E0308]: mismatched types - --> $DIR/ptr-coercion.rs:21:25 + --> $DIR/ptr-mutability-errors.rs:20:25 | LL | let x: *mut isize = x; | ---------- ^ types differ in mutability diff --git a/tests/ui/io-checks/stdout-stderr-separation.rs b/tests/ui/io-checks/stdout-stderr-separation.rs index 4b356e2fe61..1bb3f16d3a1 100644 --- a/tests/ui/io-checks/stdout-stderr-separation.rs +++ b/tests/ui/io-checks/stdout-stderr-separation.rs @@ -1,3 +1,6 @@ +//! Test that print!/println! output to stdout and eprint!/eprintln! +//! output to stderr correctly. + //@ run-pass //@ needs-subprocess diff --git a/tests/ui/mismatched_types/closure-parameter-type-inference-mismatch.rs b/tests/ui/mismatched_types/closure-parameter-type-inference-mismatch.rs index d5f43df9d85..1cd41114bbd 100644 --- a/tests/ui/mismatched_types/closure-parameter-type-inference-mismatch.rs +++ b/tests/ui/mismatched_types/closure-parameter-type-inference-mismatch.rs @@ -1,13 +1,25 @@ +//! Test closure parameter type inference and type mismatch errors. +//! +//! Related to <https://github.com/rust-lang/rust/issues/2093>. + //@ dont-require-annotations: NOTE -fn let_in<T, F>(x: T, f: F) where F: FnOnce(T) {} +fn let_in<T, F>(x: T, f: F) +where + F: FnOnce(T), +{ +} fn main() { - let_in(3u32, |i| { assert!(i == 3i32); }); - //~^ ERROR mismatched types - //~| NOTE expected `u32`, found `i32` + let_in(3u32, |i| { + assert!(i == 3i32); + //~^ ERROR mismatched types + //~| NOTE expected `u32`, found `i32` + }); - let_in(3i32, |i| { assert!(i == 3u32); }); - //~^ ERROR mismatched types - //~| NOTE expected `i32`, found `u32` + let_in(3i32, |i| { + assert!(i == 3u32); + //~^ ERROR mismatched types + //~| NOTE expected `i32`, found `u32` + }); } diff --git a/tests/ui/mismatched_types/closure-parameter-type-inference-mismatch.stderr b/tests/ui/mismatched_types/closure-parameter-type-inference-mismatch.stderr index a6d673e61c6..c75e90ce4ef 100644 --- a/tests/ui/mismatched_types/closure-parameter-type-inference-mismatch.stderr +++ b/tests/ui/mismatched_types/closure-parameter-type-inference-mismatch.stderr @@ -1,29 +1,29 @@ error[E0308]: mismatched types - --> $DIR/pptypedef.rs:6:37 + --> $DIR/closure-parameter-type-inference-mismatch.rs:15:22 | -LL | let_in(3u32, |i| { assert!(i == 3i32); }); - | - ^^^^ expected `u32`, found `i32` - | | - | expected because this is `u32` +LL | assert!(i == 3i32); + | - ^^^^ expected `u32`, found `i32` + | | + | expected because this is `u32` | help: change the type of the numeric literal from `i32` to `u32` | -LL - let_in(3u32, |i| { assert!(i == 3i32); }); -LL + let_in(3u32, |i| { assert!(i == 3u32); }); +LL - assert!(i == 3i32); +LL + assert!(i == 3u32); | error[E0308]: mismatched types - --> $DIR/pptypedef.rs:10:37 + --> $DIR/closure-parameter-type-inference-mismatch.rs:21:22 | -LL | let_in(3i32, |i| { assert!(i == 3u32); }); - | - ^^^^ expected `i32`, found `u32` - | | - | expected because this is `i32` +LL | assert!(i == 3u32); + | - ^^^^ expected `i32`, found `u32` + | | + | expected because this is `i32` | help: change the type of the numeric literal from `u32` to `i32` | -LL - let_in(3i32, |i| { assert!(i == 3u32); }); -LL + let_in(3i32, |i| { assert!(i == 3i32); }); +LL - assert!(i == 3u32); +LL + assert!(i == 3i32); | error: aborting due to 2 previous errors diff --git a/tests/ui/mismatched_types/type-error-diagnostic-in-complex-return.rs b/tests/ui/mismatched_types/type-error-diagnostic-in-complex-return.rs index 50f1fe873cb..6711d303eb3 100644 --- a/tests/ui/mismatched_types/type-error-diagnostic-in-complex-return.rs +++ b/tests/ui/mismatched_types/type-error-diagnostic-in-complex-return.rs @@ -1,4 +1,8 @@ -fn unrelated() -> Result<(), std::string::ParseError> { // #57664 +//! Regression test for <https://github.com/rust-lang/rust/issues/57664>. +//! Checks that compiler doesn't get confused by `?` operator and complex +//! return types when reporting type mismatches. + +fn unrelated() -> Result<(), std::string::ParseError> { let x = 0; match x { diff --git a/tests/ui/mismatched_types/type-error-diagnostic-in-complex-return.stderr b/tests/ui/mismatched_types/type-error-diagnostic-in-complex-return.stderr index 34aaea5b70b..38392fe99d6 100644 --- a/tests/ui/mismatched_types/type-error-diagnostic-in-complex-return.stderr +++ b/tests/ui/mismatched_types/type-error-diagnostic-in-complex-return.stderr @@ -1,5 +1,5 @@ error[E0308]: mismatched types - --> $DIR/point-to-type-err-cause-on-impl-trait-return-2.rs:9:41 + --> $DIR/type-error-diagnostic-in-complex-return.rs:13:41 | LL | let value: &bool = unsafe { &42 }; | ^^^ expected `&bool`, found `&{integer}` diff --git a/tests/ui/parser/doc-comment-in-generic.rs b/tests/ui/parser/doc-comment-in-generic.rs index 84abe875910..2596496763b 100644 --- a/tests/ui/parser/doc-comment-in-generic.rs +++ b/tests/ui/parser/doc-comment-in-generic.rs @@ -1,9 +1,13 @@ +//! Tests correct parsing of doc comments on generic parameters in traits. +//! Checks that compiler doesn't panic when processing this. + //@ check-pass -// Check that it doesn't panic when `Input` gets its visibility checked. #![crate_type = "lib"] pub trait Layer< - /// Hello. + /// Documentation for generic parameter. Input, -> {} +> +{ +} diff --git a/tests/ui/parser/raw/raw-string-literals.rs b/tests/ui/parser/raw/raw-string-literals.rs index 23018403295..2272f268b36 100644 --- a/tests/ui/parser/raw/raw-string-literals.rs +++ b/tests/ui/parser/raw/raw-string-literals.rs Binary files differdiff --git a/tests/ui/pattern/move-ref-patterns/pattern-ref-bindings-reassignment.rs b/tests/ui/pattern/move-ref-patterns/pattern-ref-bindings-reassignment.rs index d6d41e959d9..42b0b9ac44d 100644 --- a/tests/ui/pattern/move-ref-patterns/pattern-ref-bindings-reassignment.rs +++ b/tests/ui/pattern/move-ref-patterns/pattern-ref-bindings-reassignment.rs @@ -1,16 +1,24 @@ -// Tests how we behave when the user attempts to mutate an immutable -// binding that was introduced by either `ref` or `ref mut` -// patterns. -// -// Such bindings cannot be made mutable via the mere addition of the -// `mut` keyword, and thus we want to check that the compiler does not -// suggest doing so. +//! Tests how we behave when the user attempts to mutate an immutable +//! binding that was introduced by either `ref` or `ref mut` +//! patterns. +//! +//! Such bindings cannot be made mutable via the mere addition of the +//! `mut` keyword, and thus we want to check that the compiler does not +//! suggest doing so. fn main() { let (mut one_two, mut three_four) = ((1, 2), (3, 4)); + + // Bind via pattern: + // - `a` as immutable reference (`ref`) + // - `b` as mutable reference (`ref mut`) let &mut (ref a, ref mut b) = &mut one_two; + + // Attempt to reassign immutable `ref`-bound variable a = &three_four.0; - //~^ ERROR cannot assign twice to immutable variable `a` [E0384] + //~^ ERROR cannot assign twice to immutable variable `a` + + // Attempt to reassign mutable `ref mut`-bound variable b = &mut three_four.1; - //~^ ERROR cannot assign twice to immutable variable `b` [E0384] + //~^ ERROR cannot assign twice to immutable variable `b` } diff --git a/tests/ui/pattern/move-ref-patterns/pattern-ref-bindings-reassignment.stderr b/tests/ui/pattern/move-ref-patterns/pattern-ref-bindings-reassignment.stderr index e623578e025..e04eb1dd25c 100644 --- a/tests/ui/pattern/move-ref-patterns/pattern-ref-bindings-reassignment.stderr +++ b/tests/ui/pattern/move-ref-patterns/pattern-ref-bindings-reassignment.stderr @@ -1,13 +1,14 @@ error[E0384]: cannot assign twice to immutable variable `a` - --> $DIR/reassign-ref-mut.rs:12:5 + --> $DIR/pattern-ref-bindings-reassignment.rs:18:5 | LL | let &mut (ref a, ref mut b) = &mut one_two; | ----- first assignment to `a` +... LL | a = &three_four.0; | ^^^^^^^^^^^^^^^^^ cannot assign twice to immutable variable error[E0384]: cannot assign twice to immutable variable `b` - --> $DIR/reassign-ref-mut.rs:14:5 + --> $DIR/pattern-ref-bindings-reassignment.rs:22:5 | LL | let &mut (ref a, ref mut b) = &mut one_two; | --------- first assignment to `b` diff --git a/tests/ui/print-request/print-calling-conventions.rs b/tests/ui/print-request/print-calling-conventions.rs index 302ed088142..cefaa0d9b6f 100644 --- a/tests/ui/print-request/print-calling-conventions.rs +++ b/tests/ui/print-request/print-calling-conventions.rs @@ -1,2 +1,4 @@ +//! Test that `--print calling-conventions` outputs all supported calling conventions. + //@ compile-flags: --print calling-conventions //@ build-pass diff --git a/tests/ui/std/fs-nul-byte-paths.rs b/tests/ui/std/fs-nul-byte-paths.rs index 5c37980127d..79012362347 100644 --- a/tests/ui/std/fs-nul-byte-paths.rs +++ b/tests/ui/std/fs-nul-byte-paths.rs @@ -1,18 +1,22 @@ -//@ run-pass +//! Test that `std::fs` functions properly reject paths containing NUL bytes. +//@ run-pass #![allow(deprecated)] //@ ignore-wasm32 no cwd //@ ignore-sgx no files -use std::fs; -use std::io; +use std::{fs, io}; fn assert_invalid_input<T>(on: &str, result: io::Result<T>) { fn inner(on: &str, result: io::Result<()>) { match result { Ok(()) => panic!("{} didn't return an error on a path with NUL", on), - Err(e) => assert!(e.kind() == io::ErrorKind::InvalidInput, - "{} returned a strange {:?} on a path with NUL", on, e.kind()), + Err(e) => assert!( + e.kind() == io::ErrorKind::InvalidInput, + "{} returned a strange {:?} on a path with NUL", + on, + e.kind() + ), } } inner(on, result.map(drop)) @@ -43,6 +47,8 @@ fn main() { assert_invalid_input("remove_dir", fs::remove_dir("\0")); assert_invalid_input("remove_dir_all", fs::remove_dir_all("\0")); assert_invalid_input("read_dir", fs::read_dir("\0")); - assert_invalid_input("set_permissions", - fs::set_permissions("\0", fs::metadata(".").unwrap().permissions())); + assert_invalid_input( + "set_permissions", + fs::set_permissions("\0", fs::metadata(".").unwrap().permissions()), + ); } diff --git a/tests/ui/typeck/nested-generic-traits-performance.rs b/tests/ui/typeck/nested-generic-traits-performance.rs index 29c278171a6..e029228c1b2 100644 --- a/tests/ui/typeck/nested-generic-traits-performance.rs +++ b/tests/ui/typeck/nested-generic-traits-performance.rs @@ -1,65 +1,82 @@ +//! Test that deeply nested generic traits with complex bounds +//! don't cause excessive memory usage during type checking. +//! +//! Regression test for <https://github.com/rust-lang/rust/issues/31849>. + //@ run-pass -// Regression test for #31849: the problem here was actually a performance -// cliff, but I'm adding the test for reference. pub trait Upcast<T> { fn upcast(self) -> T; } -impl<S1, S2, T1, T2> Upcast<(T1, T2)> for (S1,S2) - where S1: Upcast<T1>, - S2: Upcast<T2>, +impl<S1, S2, T1, T2> Upcast<(T1, T2)> for (S1, S2) +where + S1: Upcast<T1>, + S2: Upcast<T2>, { - fn upcast(self) -> (T1, T2) { (self.0.upcast(), self.1.upcast()) } + fn upcast(self) -> (T1, T2) { + (self.0.upcast(), self.1.upcast()) + } } -impl Upcast<()> for () -{ - fn upcast(self) -> () { () } +impl Upcast<()> for () { + fn upcast(self) -> () { + () + } } pub trait ToStatic { type Static: 'static; - fn to_static(self) -> Self::Static where Self: Sized; + fn to_static(self) -> Self::Static + where + Self: Sized; } impl<T, U> ToStatic for (T, U) - where T: ToStatic, - U: ToStatic +where + T: ToStatic, + U: ToStatic, { type Static = (T::Static, U::Static); - fn to_static(self) -> Self::Static { (self.0.to_static(), self.1.to_static()) } + fn to_static(self) -> Self::Static { + (self.0.to_static(), self.1.to_static()) + } } -impl ToStatic for () -{ +impl ToStatic for () { type Static = (); - fn to_static(self) -> () { () } + fn to_static(self) -> () { + () + } } - trait Factory { type Output; fn build(&self) -> Self::Output; } -impl<S,T> Factory for (S, T) - where S: Factory, - T: Factory, - S::Output: ToStatic, - <S::Output as ToStatic>::Static: Upcast<S::Output>, +impl<S, T> Factory for (S, T) +where + S: Factory, + T: Factory, + S::Output: ToStatic, + <S::Output as ToStatic>::Static: Upcast<S::Output>, { type Output = (S::Output, T::Output); - fn build(&self) -> Self::Output { (self.0.build().to_static().upcast(), self.1.build()) } + fn build(&self) -> Self::Output { + (self.0.build().to_static().upcast(), self.1.build()) + } } impl Factory for () { type Output = (); - fn build(&self) -> Self::Output { () } + fn build(&self) -> Self::Output { + () + } } fn main() { - // More parens, more time. - let it = ((((((((((),()),()),()),()),()),()),()),()),()); + // Deeply nested tuple to trigger the original performance issue + let it = ((((((((((), ()), ()), ()), ()), ()), ()), ()), ()), ()); it.build(); } |