cleaned up some tests

Author: Kivooeo

tests/ui/defaults-well-formedness.rs

@@ -2,4 +2,4 @@
 //@ compile-flags:-Zforce-unstable-if-unmarked
 
 #[deprecated] // should work even with -Zforce-unstable-if-unmarked
-fn main() { }
+fn main() {}

tests/ui/deprecation-in-force-unstable.rs renamed to tests/ui/deprecation/deprecated_main_function.rs

@@ -0,0 +1,23 @@
+//! Regression test for `#[derive(Debug)]` on enums with uninhabited variants.
+//!
+//! Ensures there are no special warnings about uninhabited types when deriving
+//! Debug on an enum with uninhabited variants, only standard unused warnings.
+//!
+//! Issue: https://github.com/rust-lang/rust/issues/38885
+
+//@ check-pass
+//@ compile-flags: -Wunused
+
+#[derive(Debug)]
+enum Void {}
+
+#[derive(Debug)]
+enum Foo {
+    Bar(#[allow(dead_code)] u8),
+    Void(Void), //~ WARN variant `Void` is never constructed
+}
+
+fn main() {
+    let x = Foo::Bar(42);
+    println!("{:?}", x);
+}

tests/ui/deref-rc.rs

@@ -1,5 +1,5 @@
 warning: variant `Void` is never constructed
-  --> $DIR/derive-uninhabited-enum-38885.rs:13:5
+  --> $DIR/derive-debug-uninhabited-enum.rs:17:5
    |
 LL | enum Foo {
    |      --- variant in this enum

tests/ui/deref.rs

@@ -0,0 +1,50 @@
+//! Test for well-formedness checking of default type parameters.
+//!
+//! Regression Test for: https://github.com/rust-lang/rust/issues/49344
+
+//@ run-pass
+
+#![allow(dead_code)]
+
+trait Trait<T> {}
+struct Foo<U, V = i32>(U, V)
+where
+    U: Trait<V>;
+
+trait Marker {}
+struct TwoParams<T, U>(T, U);
+impl Marker for TwoParams<i32, i32> {}
+
+// Clauses with more than 1 param are not checked.
+struct IndividuallyBogus<T = i32, U = i32>(TwoParams<T, U>)
+where
+    TwoParams<T, U>: Marker;
+
+struct BogusTogether<T = u32, U = i32>(T, U)
+where
+    TwoParams<T, U>: Marker;
+
+// Clauses with non-defaulted params are not checked.
+struct NonDefaultedInClause<T, U = i32>(TwoParams<T, U>)
+where
+    TwoParams<T, U>: Marker;
+
+struct DefaultedLhs<U, V = i32>(U, V)
+where
+    V: Trait<U>;
+
+// Dependent defaults are not checked.
+struct Dependent<T, U = T>(T, U)
+where
+    U: Copy;
+
+trait SelfBound<T: Copy = Self> {}
+
+// Not even for well-formedness.
+struct WellFormedProjection<A, T = <A as Iterator>::Item>(A, T);
+
+// Issue #49344, predicates with lifetimes should not be checked.
+trait Scope<'a> {}
+struct Request<'a, S: Scope<'a> = i32>(S, &'a ());
+
+fn main() {}

tests/ui/derive-uninhabited-enum-38885.rs

@@ -0,0 +1,22 @@
+//@ run-pass
+
+#![allow(warnings)]
+
+//! Tests type inference fallback to `!` (never type) in `Option` context.
+//!
+//! Regression test for issues:
+//! - https://github.com/rust-lang/rust/issues/39808
+//! - https://github.com/rust-lang/rust/issues/39984
+//!
+//! Here the type of `c` is `Option<?T>`, where `?T` is unconstrained.
+//! Because there is data-flow from the `{ return; }` block, which
+//! diverges and hence has type `!`, into `c`, we will default `?T` to
+//! `!`, and hence this code compiles rather than failing and requiring
+//! a type annotation.
+
+fn main() {
+    let c: Option<!> = Some({
+        return;
+    });
+    c.unwrap();
+}

tests/ui/derives/derive-debug-uninhabited-enum.rs

@@ -0,0 +1,29 @@
+//! Regression test for destructuring trait references (`&dyn T`/`Box<dyn T>`).
+//! Checks cases where number of `&`/`Box` patterns (n) matches/doesn't match references (m).
+//!
+//! Issue: https://github.com/rust-lang/rust/issues/15031
+
+#![feature(box_patterns)]
+
+trait T {
+    fn foo(&self) {}
+}
+
+impl T for isize {}
+
+fn main() {
+    // Valid cases: n < m (can dereference)
+    let &x = &(&1isize as &dyn T);
+    let &x = &&(&1isize as &dyn T);
+    let &&x = &&(&1isize as &dyn T);
+
+    // Error cases: n == m (cannot dereference trait object)
+    let &x = &1isize as &dyn T; //~ ERROR type `&dyn T` cannot be dereferenced
+    let &&x = &(&1isize as &dyn T); //~ ERROR type `&dyn T` cannot be dereferenced
+    let box x = Box::new(1isize) as Box<dyn T>; //~ ERROR type `Box<dyn T>` cannot be dereferenced
+
+    // Error cases: n > m (type mismatch)
+    let &&x = &1isize as &dyn T; //~ ERROR mismatched types
+    let &&&x = &(&1isize as &dyn T); //~ ERROR mismatched types
+    let box box x = Box::new(1isize) as Box<dyn T>; //~ ERROR mismatched types
+}

tests/ui/derive-uninhabited-enum-38885.stderr renamed to tests/ui/derives/derive-debug-uninhabited-enum.stderr

@@ -1,23 +1,23 @@
 error[E0033]: type `&dyn T` cannot be dereferenced
-  --> $DIR/destructure-trait-ref.rs:28:9
+  --> $DIR/trait-object-destructure.rs:21:9
    |
 LL |     let &x = &1isize as &dyn T;
    |         ^^ type `&dyn T` cannot be dereferenced
 
 error[E0033]: type `&dyn T` cannot be dereferenced
-  --> $DIR/destructure-trait-ref.rs:29:10
+  --> $DIR/trait-object-destructure.rs:22:10
    |
 LL |     let &&x = &(&1isize as &dyn T);
    |          ^^ type `&dyn T` cannot be dereferenced
 
 error[E0033]: type `Box<dyn T>` cannot be dereferenced
-  --> $DIR/destructure-trait-ref.rs:30:9
+  --> $DIR/trait-object-destructure.rs:23:9
    |
 LL |     let box x = Box::new(1isize) as Box<dyn T>;
    |         ^^^^^ type `Box<dyn T>` cannot be dereferenced
 
 error[E0308]: mismatched types
-  --> $DIR/destructure-trait-ref.rs:34:10
+  --> $DIR/trait-object-destructure.rs:26:10
    |
 LL |     let &&x = &1isize as &dyn T;
    |          ^^   ----------------- this expression has type `&dyn T`
@@ -33,7 +33,7 @@ LL +     let &x = &1isize as &dyn T;
    |
 
 error[E0308]: mismatched types
-  --> $DIR/destructure-trait-ref.rs:38:11
+  --> $DIR/trait-object-destructure.rs:27:11
    |
 LL |     let &&&x = &(&1isize as &dyn T);
    |           ^^   -------------------- this expression has type `&&dyn T`
@@ -49,7 +49,7 @@ LL +     let &&x = &(&1isize as &dyn T);
    |
 
 error[E0308]: mismatched types
-  --> $DIR/destructure-trait-ref.rs:42:13
+  --> $DIR/trait-object-destructure.rs:28:13
    |
 LL |     let box box x = Box::new(1isize) as Box<dyn T>;
    |             ^^^^^   ------------------------------ this expression has type `Box<dyn T>`

tests/ui/destructure-trait-ref.rs

@@ -0,0 +1,19 @@
+//! Test type inference in method chains with diverging fallback.
+//! Verifies that closure type in `unwrap_or_else` is properly inferred
+//! when chained with other combinators and contains a diverging path.
+
+//@ run-pass
+
+fn produce<T>() -> Result<&'static str, T> {
+    Ok("22")
+}
+
+fn main() {
+    // The closure's error type `T` must unify with `ParseIntError`,
+    // while the success type must be `usize` (from parse())
+    let x: usize = produce()
+        .and_then(|x| x.parse::<usize>()) // Explicit turbofish for clarity
+        .unwrap_or_else(|_| panic!()); // Diverging fallback
+
+    assert_eq!(x, 22);
+}