From 698f8c2f01ea549d77d7dc3338a12e04c11057b9 Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Wed, 17 Apr 2024 14:02:58 +0200
Subject: Adding upstream version 1.64.0+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 .../ui/rust-2018/edition-lint-infer-outlives.fixed | 795 +++++++++++++++++++++
 1 file changed, 795 insertions(+)
 create mode 100644 src/test/ui/rust-2018/edition-lint-infer-outlives.fixed

(limited to 'src/test/ui/rust-2018/edition-lint-infer-outlives.fixed')

diff --git a/src/test/ui/rust-2018/edition-lint-infer-outlives.fixed b/src/test/ui/rust-2018/edition-lint-infer-outlives.fixed
new file mode 100644
index 000000000..13645244d
--- /dev/null
+++ b/src/test/ui/rust-2018/edition-lint-infer-outlives.fixed
@@ -0,0 +1,795 @@
+// run-rustfix
+
+#![allow(unused)]
+#![deny(explicit_outlives_requirements)]
+
+// Programmatically generated examples!
+//
+// Exercise outlives bounds for each of the following parameter/position
+// combinations—
+//
+// • one generic parameter (T) bound inline
+// • one parameter (T) with a where clause
+// • two parameters (T and U), both bound inline
+// • two parameters (T and U), one bound inline, one with a where clause
+// • two parameters (T and U), both with where clauses
+//
+// —and for every permutation of 1 or 2 lifetimes to outlive and 0 or 1 trait
+// bounds distributed among said parameters (subject to no where clause being
+// empty and the struct having at least one lifetime).
+//
+// —and for each of tuple structs, enums and unions.
+
+mod structs {
+    use std::fmt::Debug;
+
+    struct TeeOutlivesAy<'a, T> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a T
+    }
+
+    struct TeeOutlivesAyIsDebug<'a, T: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a T
+    }
+
+    struct TeeIsDebugOutlivesAy<'a, T: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a T
+    }
+
+    struct TeeOutlivesAyBee<'a, 'b, T> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T
+    }
+
+    struct TeeOutlivesAyBeeIsDebug<'a, 'b, T: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T
+    }
+
+    struct TeeIsDebugOutlivesAyBee<'a, 'b, T: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T
+    }
+
+    struct TeeWhereOutlivesAy<'a, T> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a T
+    }
+
+    struct TeeWhereOutlivesAyIsDebug<'a, T> where T: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a T
+    }
+
+    struct TeeWhereIsDebugOutlivesAy<'a, T> where T: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a T
+    }
+
+    struct TeeWhereOutlivesAyBee<'a, 'b, T> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T
+    }
+
+    struct TeeWhereOutlivesAyBeeIsDebug<'a, 'b, T> where T: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T
+    }
+
+    struct TeeWhereIsDebugOutlivesAyBee<'a, 'b, T> where T: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T
+    }
+
+    struct TeeYooOutlivesAy<'a, T, U> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: T,
+        yoo: &'a U
+    }
+
+    struct TeeYooOutlivesAyIsDebug<'a, T, U: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: T,
+        yoo: &'a U
+    }
+
+    struct TeeYooIsDebugOutlivesAy<'a, T, U: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: T,
+        yoo: &'a U
+    }
+
+    struct TeeOutlivesAyYooIsDebug<'a, T, U: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a T,
+        yoo: U
+    }
+
+    struct TeeYooOutlivesAyBee<'a, 'b, T, U> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: T,
+        yoo: &'a &'b U
+    }
+
+    struct TeeYooOutlivesAyBeeIsDebug<'a, 'b, T, U: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: T,
+        yoo: &'a &'b U
+    }
+
+    struct TeeYooIsDebugOutlivesAyBee<'a, 'b, T, U: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: T,
+        yoo: &'a &'b U
+    }
+
+    struct TeeOutlivesAyBeeYooIsDebug<'a, 'b, T, U: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T,
+        yoo: U
+    }
+
+    struct TeeYooWhereOutlivesAy<'a, T, U> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: T,
+        yoo: &'a U
+    }
+
+    struct TeeYooWhereOutlivesAyIsDebug<'a, T, U> where U: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: T,
+        yoo: &'a U
+    }
+
+    struct TeeYooWhereIsDebugOutlivesAy<'a, T, U> where U: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: T,
+        yoo: &'a U
+    }
+
+    struct TeeOutlivesAyYooWhereIsDebug<'a, T, U> where U: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a T,
+        yoo: U
+    }
+
+    struct TeeYooWhereOutlivesAyBee<'a, 'b, T, U> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: T,
+        yoo: &'a &'b U
+    }
+
+    struct TeeYooWhereOutlivesAyBeeIsDebug<'a, 'b, T, U> where U: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: T,
+        yoo: &'a &'b U
+    }
+
+    struct TeeYooWhereIsDebugOutlivesAyBee<'a, 'b, T, U> where U: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: T,
+        yoo: &'a &'b U
+    }
+
+    struct TeeOutlivesAyBeeYooWhereIsDebug<'a, 'b, T, U> where U: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T,
+        yoo: U
+    }
+
+    struct TeeWhereOutlivesAyYooWhereIsDebug<'a, T, U> where U: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a T,
+        yoo: U
+    }
+
+    struct TeeWhereOutlivesAyBeeYooWhereIsDebug<'a, 'b, T, U> where U: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T,
+        yoo: U
+    }
+
+    struct BeeOutlivesAy<'a, 'b> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b (),
+    }
+
+    struct BeeWhereOutlivesAy<'a, 'b> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b (),
+    }
+
+    struct BeeOutlivesAyTee<'a, 'b, T> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T,
+    }
+
+    struct BeeWhereOutlivesAyTee<'a, 'b, T> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T,
+    }
+
+    struct BeeWhereOutlivesAyTeeWhereBee<'a, 'b, T> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T,
+    }
+
+    struct BeeWhereOutlivesAyTeeWhereAyBee<'a, 'b, T> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T,
+    }
+
+    struct BeeOutlivesAyTeeDebug<'a, 'b, T: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T,
+    }
+
+    struct BeeWhereOutlivesAyTeeWhereDebug<'a, 'b, T> where T: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T,
+    }
+}
+
+mod tuple_structs {
+    use std::fmt::Debug;
+
+    struct TeeOutlivesAy<'a, T>(&'a T);
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeOutlivesAyIsDebug<'a, T: Debug>(&'a T);
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeIsDebugOutlivesAy<'a, T: Debug>(&'a T);
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeOutlivesAyBee<'a, 'b, T>(&'a &'b T);
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeOutlivesAyBeeIsDebug<'a, 'b, T: Debug>(&'a &'b T);
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeIsDebugOutlivesAyBee<'a, 'b, T: Debug>(&'a &'b T);
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeWhereOutlivesAy<'a, T>(&'a T) ;
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeWhereOutlivesAyIsDebug<'a, T>(&'a T) where T: Debug;
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeWhereIsDebugOutlivesAy<'a, T>(&'a T) where T: Debug;
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeWhereOutlivesAyBee<'a, 'b, T>(&'a &'b T) ;
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeWhereOutlivesAyBeeIsDebug<'a, 'b, T>(&'a &'b T) where T: Debug;
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeWhereIsDebugOutlivesAyBee<'a, 'b, T>(&'a &'b T) where T: Debug;
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeYooOutlivesAy<'a, T, U>(T, &'a U);
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeYooOutlivesAyIsDebug<'a, T, U: Debug>(T, &'a U);
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeYooIsDebugOutlivesAy<'a, T, U: Debug>(T, &'a U);
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeOutlivesAyYooIsDebug<'a, T, U: Debug>(&'a T, U);
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeYooOutlivesAyBee<'a, 'b, T, U>(T, &'a &'b U);
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeYooOutlivesAyBeeIsDebug<'a, 'b, T, U: Debug>(T, &'a &'b U);
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeYooIsDebugOutlivesAyBee<'a, 'b, T, U: Debug>(T, &'a &'b U);
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeOutlivesAyBeeYooIsDebug<'a, 'b, T, U: Debug>(&'a &'b T, U);
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeYooWhereOutlivesAy<'a, T, U>(T, &'a U) ;
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeYooWhereOutlivesAyIsDebug<'a, T, U>(T, &'a U) where U: Debug;
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeYooWhereIsDebugOutlivesAy<'a, T, U>(T, &'a U) where U: Debug;
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeOutlivesAyYooWhereIsDebug<'a, T, U>(&'a T, U) where U: Debug;
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeYooWhereOutlivesAyBee<'a, 'b, T, U>(T, &'a &'b U) ;
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeYooWhereOutlivesAyBeeIsDebug<'a, 'b, T, U>(T, &'a &'b U) where U: Debug;
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeYooWhereIsDebugOutlivesAyBee<'a, 'b, T, U>(T, &'a &'b U) where U: Debug;
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeOutlivesAyBeeYooWhereIsDebug<'a, 'b, T, U>(&'a &'b T, U) where U: Debug;
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeWhereOutlivesAyYooWhereIsDebug<'a, T, U>(&'a T, U) where U: Debug;
+    //~^ ERROR outlives requirements can be inferred
+
+    struct TeeWhereAyBeeYooWhereIsDebug<'a, 'b, T, U>(&'a &'b T, U) where U: Debug;
+    //~^ ERROR outlives requirements can be inferred
+
+    struct BeeOutlivesAy<'a, 'b>(&'a &'b ());
+    //~^ ERROR outlives requirements can be inferred
+
+    struct BeeWhereOutlivesAy<'a, 'b>(&'a &'b ()) ;
+    //~^ ERROR outlives requirements can be inferred
+
+    struct BeeOutlivesAyTee<'a, 'b, T>(&'a &'b T);
+    //~^ ERROR outlives requirements can be inferred
+
+    struct BeeWhereOutlivesAyTee<'a, 'b, T>(&'a &'b T) ;
+    //~^ ERROR outlives requirements can be inferred
+
+    struct BeeWhereOutlivesAyTeeWhereBee<'a, 'b, T>(&'a &'b T) ;
+    //~^ ERROR outlives requirements can be inferred
+
+    struct BeeWhereOutlivesAyTeeWhereAyBee<'a, 'b, T>(&'a &'b T) ;
+    //~^ ERROR outlives requirements can be inferred
+
+    struct BeeOutlivesAyTeeDebug<'a, 'b, T: Debug>(&'a &'b T);
+    //~^ ERROR outlives requirements can be inferred
+
+    struct BeeWhereOutlivesAyTeeWhereDebug<'a, 'b, T>(&'a &'b T) where T: Debug;
+    //~^ ERROR outlives requirements can be inferred
+}
+
+mod enums {
+    use std::fmt::Debug;
+
+    enum TeeOutlivesAy<'a, T> {
+        //~^ ERROR outlives requirements can be inferred
+        V { tee: &'a T },
+    }
+
+    enum TeeOutlivesAyIsDebug<'a, T: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        V(&'a T),
+    }
+
+    enum TeeIsDebugOutlivesAy<'a, T: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        V { tee: &'a T },
+        W,
+    }
+
+    enum TeeOutlivesAyBee<'a, 'b, T> {
+        //~^ ERROR outlives requirements can be inferred
+        V(&'a &'b T),
+        W,
+    }
+
+    enum TeeOutlivesAyBeeIsDebug<'a, 'b, T: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        V { tee: &'a &'b T },
+    }
+
+    enum TeeIsDebugOutlivesAyBee<'a, 'b, T: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        V(&'a &'b T),
+    }
+
+    enum TeeWhereOutlivesAy<'a, T> {
+        //~^ ERROR outlives requirements can be inferred
+        V { tee: &'a T },
+        W,
+    }
+
+    enum TeeWhereOutlivesAyIsDebug<'a, T> where T: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        V(&'a T),
+        W,
+    }
+
+    enum TeeWhereIsDebugOutlivesAy<'a, T> where T: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        V { tee: &'a T },
+    }
+
+    enum TeeWhereOutlivesAyBee<'a, 'b, T> {
+        //~^ ERROR outlives requirements can be inferred
+        V(&'a &'b T),
+    }
+
+    enum TeeWhereOutlivesAyBeeIsDebug<'a, 'b, T> where T: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        V { tee: &'a &'b T },
+        W,
+    }
+
+    enum TeeWhereIsDebugOutlivesAyBee<'a, 'b, T> where T: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        V(&'a &'b T),
+        W,
+    }
+
+    enum TeeYooOutlivesAy<'a, T, U> {
+        //~^ ERROR outlives requirements can be inferred
+        V { tee: T },
+        W(&'a U),
+    }
+
+    enum TeeYooOutlivesAyIsDebug<'a, T, U: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        V { tee: T, yoo: &'a U },
+        W,
+    }
+
+    enum TeeYooIsDebugOutlivesAy<'a, T, U: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        V(T, &'a U),
+        W,
+    }
+
+    enum TeeOutlivesAyYooIsDebug<'a, T, U: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        V { tee: &'a T },
+        W(U),
+    }
+
+    enum TeeYooOutlivesAyBee<'a, 'b, T, U> {
+        //~^ ERROR outlives requirements can be inferred
+        V { tee: T, yoo: &'a &'b U },
+        W,
+    }
+
+    enum TeeYooOutlivesAyBeeIsDebug<'a, 'b, T, U: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        V(T, &'a &'b U),
+        W,
+    }
+
+    enum TeeYooIsDebugOutlivesAyBee<'a, 'b, T, U: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        V { tee: T, yoo: &'a &'b U },
+        W,
+    }
+
+    enum TeeOutlivesAyBeeYooIsDebug<'a, 'b, T, U: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        V(&'a &'b T, U),
+        W,
+    }
+
+    enum TeeYooWhereOutlivesAy<'a, T, U> {
+        //~^ ERROR outlives requirements can be inferred
+        V { tee: T },
+        W(&'a U),
+    }
+
+    enum TeeYooWhereOutlivesAyIsDebug<'a, T, U> where U: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        V { tee: T, yoo: &'a U },
+        W,
+    }
+
+    enum TeeYooWhereIsDebugOutlivesAy<'a, T, U> where U: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        V(T, &'a U),
+        W,
+    }
+
+    enum TeeOutlivesAyYooWhereIsDebug<'a, T, U> where U: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        V { tee: &'a T },
+        W(U),
+    }
+
+    enum TeeYooWhereOutlivesAyBee<'a, 'b, T, U> {
+        //~^ ERROR outlives requirements can be inferred
+        V { tee: T, yoo: &'a &'b U },
+        W,
+    }
+
+    enum TeeYooWhereOutlivesAyBeeIsDebug<'a, 'b, T, U> where U: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        V(T, &'a &'b U),
+        W,
+    }
+
+    enum TeeYooWhereIsDebugOutlivesAyBee<'a, 'b, T, U> where U: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        V { tee: T },
+        W(&'a &'b U),
+    }
+
+    enum TeeOutlivesAyBeeYooWhereIsDebug<'a, 'b, T, U> where U: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        V { tee: &'a &'b T, yoo: U },
+        W,
+    }
+
+    enum TeeWhereOutlivesAyYooWhereIsDebug<'a, T, U> where U: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        V(&'a T, U),
+        W,
+    }
+
+    enum TeeWhereOutlivesAyBeeYooWhereIsDebug<'a, 'b, T, U> where U: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        V { tee: &'a &'b T },
+        W(U),
+    }
+
+    enum BeeOutlivesAy<'a, 'b> {
+        //~^ ERROR outlives requirements can be inferred
+        V { tee: &'a &'b () },
+    }
+
+    enum BeeWhereOutlivesAy<'a, 'b> {
+        //~^ ERROR outlives requirements can be inferred
+        V(&'a &'b ()),
+    }
+
+    enum BeeOutlivesAyTee<'a, 'b, T> {
+        //~^ ERROR outlives requirements can be inferred
+        V { tee: &'a &'b T },
+        W,
+    }
+
+    enum BeeWhereOutlivesAyTee<'a, 'b, T> {
+        //~^ ERROR outlives requirements can be inferred
+        V(&'a &'b T),
+        W,
+    }
+
+    enum BeeWhereOutlivesAyTeeWhereBee<'a, 'b, T> {
+        //~^ ERROR outlives requirements can be inferred
+        V(&'a &'b T),
+    }
+
+    enum BeeWhereOutlivesAyTeeWhereAyBee<'a, 'b, T> {
+        //~^ ERROR outlives requirements can be inferred
+        V(&'a &'b T),
+        W,
+    }
+
+    enum BeeOutlivesAyTeeDebug<'a, 'b, T: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        V { tee: &'a &'b T },
+    }
+
+    enum BeeWhereOutlivesAyTeeWhereDebug<'a, 'b, T> where T: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        V(&'a &'b T),
+    }
+}
+
+mod unions {
+    use std::fmt::Debug;
+
+    union TeeOutlivesAy<'a, T> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a T
+    }
+
+    union TeeOutlivesAyIsDebug<'a, T: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a T
+    }
+
+    union TeeIsDebugOutlivesAy<'a, T: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a T
+    }
+
+    union TeeOutlivesAyBee<'a, 'b, T> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T
+    }
+
+    union TeeOutlivesAyBeeIsDebug<'a, 'b, T: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T
+    }
+
+    union TeeIsDebugOutlivesAyBee<'a, 'b, T: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T
+    }
+
+    union TeeWhereOutlivesAy<'a, T> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a T
+    }
+
+    union TeeWhereOutlivesAyIsDebug<'a, T> where T: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a T
+    }
+
+    union TeeWhereIsDebugOutlivesAy<'a, T> where T: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a T
+    }
+
+    union TeeWhereOutlivesAyBee<'a, 'b, T> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T
+    }
+
+    union TeeWhereOutlivesAyBeeIsDebug<'a, 'b, T> where T: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T
+    }
+
+    union TeeWhereIsDebugOutlivesAyBee<'a, 'b, T> where T: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T
+    }
+
+    union TeeYooOutlivesAy<'a, T, U> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: *const T,
+        yoo: &'a U
+    }
+
+    union TeeYooOutlivesAyIsDebug<'a, T, U: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: *const T,
+        yoo: &'a U
+    }
+
+    union TeeYooIsDebugOutlivesAy<'a, T, U: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: *const T,
+        yoo: &'a U
+    }
+
+    union TeeOutlivesAyYooIsDebug<'a, T, U: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a T,
+        yoo: *const U
+    }
+
+    union TeeYooOutlivesAyBee<'a, 'b, T, U> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: *const T,
+        yoo: &'a &'b U
+    }
+
+    union TeeYooOutlivesAyBeeIsDebug<'a, 'b, T, U: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: *const T,
+        yoo: &'a &'b U
+    }
+
+    union TeeYooIsDebugOutlivesAyBee<'a, 'b, T, U: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: *const T,
+        yoo: &'a &'b U
+    }
+
+    union TeeOutlivesAyBeeYooIsDebug<'a, 'b, T, U: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T,
+        yoo: *const U
+    }
+
+    union TeeYooWhereOutlivesAy<'a, T, U> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: *const T,
+        yoo: &'a U
+    }
+
+    union TeeYooWhereOutlivesAyIsDebug<'a, T, U> where U: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: *const T,
+        yoo: &'a U
+    }
+
+    union TeeYooWhereIsDebugOutlivesAy<'a, T, U> where U: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: *const T,
+        yoo: &'a U
+    }
+
+    union TeeOutlivesAyYooWhereIsDebug<'a, T, U> where U: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a T,
+        yoo: *const U
+    }
+
+    union TeeYooWhereOutlivesAyBee<'a, 'b, T, U> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: *const T,
+        yoo: &'a &'b U
+    }
+
+    union TeeYooWhereOutlivesAyBeeIsDebug<'a, 'b, T, U> where U: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: *const T,
+        yoo: &'a &'b U
+    }
+
+    union TeeYooWhereIsDebugOutlivesAyBee<'a, 'b, T, U> where U: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: *const T,
+        yoo: &'a &'b U
+    }
+
+    union TeeOutlivesAyBeeYooWhereIsDebug<'a, 'b, T, U> where U: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T,
+        yoo: *const U
+    }
+
+    union TeeWhereOutlivesAyYooWhereIsDebug<'a, T, U> where U: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a T,
+        yoo: *const U
+    }
+
+    union TeeWhereOutlivesAyBeeYooWhereIsDebug<'a, 'b, T, U> where U: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T,
+        yoo: *const U
+    }
+
+    union BeeOutlivesAy<'a, 'b> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b (),
+    }
+
+    union BeeWhereOutlivesAy<'a, 'b> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b (),
+    }
+
+    union BeeOutlivesAyTee<'a, 'b, T> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T,
+    }
+
+    union BeeWhereOutlivesAyTee<'a, 'b, T> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T,
+    }
+
+    union BeeWhereOutlivesAyTeeWhereBee<'a, 'b, T> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T,
+    }
+
+    union BeeWhereOutlivesAyTeeWhereAyBee<'a, 'b, T> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T,
+    }
+
+    union BeeOutlivesAyTeeDebug<'a, 'b, T: Debug> {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T,
+    }
+
+    union BeeWhereOutlivesAyTeeWhereDebug<'a, 'b, T> where T: Debug {
+        //~^ ERROR outlives requirements can be inferred
+        tee: &'a &'b T,
+    }
+}
+
+
+// But outlives inference for 'static lifetimes is under a separate
+// feature-gate for now
+// (https://github.com/rust-lang/rust/issues/44493#issuecomment-407846046).
+struct StaticRef<T: 'static> {
+    field: &'static T
+}
+
+
+fn main() {}
-- 
cgit v1.2.3