Auto merge of #53793 - toidiu:ak-stabalize, r=nikomatsakis

stabilize outlives requirements

https://github.com/rust-lang/rust/issues/44493

r? @nikomatsakis

src/doc/unstable-book/src/language-features/infer-outlives-requirements.md

-# `infer_outlives_requirements`
-
-The tracking issue for this feature is: [#44493]
-
-[#44493]: https://github.com/rust-lang/rust/issues/44493
-
-------------------------
-The `infer_outlives_requirements` feature indicates that certain
-outlives requirements can be inferred by the compiler rather than
-stating them explicitly.
-
-For example, currently generic struct definitions that contain
-references, require where-clauses of the form T: 'a. By using
-this feature the outlives predicates will be inferred, although
-they may still be written explicitly.
-
-```rust,ignore (pseudo-Rust)
-struct Foo<'a, T>
-  where T: 'a // <-- currently required
-  {
-      bar: &'a T,
-  }
-```
-
-
-## Examples:
-
-
-```rust,ignore (pseudo-Rust)
-#![feature(infer_outlives_requirements)]
-
-// Implicitly infer T: 'a
-struct Foo<'a, T> {
-    bar: &'a T,
-}
-```
-
-```rust,ignore (pseudo-Rust)
-#![feature(infer_outlives_requirements)]
-
-// Implicitly infer `U: 'b`
-struct Foo<'b, U> {
-    bar: Bar<'b, U>
-}
-
-struct Bar<'a, T> where T: 'a {
-    x: &'a (),
-    y: T,
-}
-```
-
-```rust,ignore (pseudo-Rust)
-#![feature(infer_outlives_requirements)]
-
-// Implicitly infer `b': 'a`
-struct Foo<'a, 'b, T> {
-    x: &'a &'b T
-}
-```
-
-```rust,ignore (pseudo-Rust)
-#![feature(infer_outlives_requirements)]
-
-// Implicitly infer `<T as std::iter::Iterator>::Item : 'a`
-struct Foo<'a, T: Iterator> {
-    bar: &'a T::Item
-```

src/liballoc/lib.rs

@@ -77,7 +77,6 @@
 #![cfg_attr(not(test), feature(fn_traits))]
 #![cfg_attr(not(test), feature(generator_trait))]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![cfg_attr(test, feature(test))]
 
 #![feature(allocator_api)]

src/liballoc_jemalloc/lib.rs

@@ -17,7 +17,6 @@
 #![feature(libc)]
 #![feature(linkage)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(staged_api)]
 #![feature(rustc_attrs)]
 #![cfg_attr(dummy_jemalloc, allow(dead_code, unused_extern_crates))]

src/liballoc_system/lib.rs

@@ -18,7 +18,6 @@
 #![feature(allocator_api)]
 #![feature(core_intrinsics)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(staged_api)]
 #![feature(rustc_attrs)]
 #![cfg_attr(any(unix, target_os = "cloudabi", target_os = "redox"), feature(libc))]

src/libarena/lib.rs

@@ -27,7 +27,6 @@
 #![feature(core_intrinsics)]
 #![feature(dropck_eyepatch)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(raw_vec_internals)]
 #![cfg_attr(test, feature(test))]
 

src/libcore/lib.rs

@@ -92,7 +92,6 @@
 #![feature(link_llvm_intrinsics)]
 #![feature(never_type)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(exhaustive_patterns)]
 #![feature(macro_at_most_once_rep)]
 #![feature(no_core)]

src/libfmt_macros/lib.rs

@@ -21,7 +21,6 @@
        test(attr(deny(warnings))))]
 
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 
 pub use self::Piece::*;
 pub use self::Position::*;

src/libgraphviz/lib.rs

@@ -289,7 +289,6 @@
        test(attr(allow(unused_variables), deny(warnings))))]
 
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(str_escape)]
 
 use self::LabelText::*;

src/libpanic_abort/lib.rs

@@ -25,7 +25,6 @@
 #![feature(core_intrinsics)]
 #![feature(libc)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(panic_runtime)]
 #![feature(staged_api)]
 #![feature(rustc_attrs)]

src/libpanic_unwind/lib.rs

@@ -35,7 +35,6 @@
 #![feature(lang_items)]
 #![feature(libc)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(panic_unwind)]
 #![feature(raw)]
 #![feature(staged_api)]

src/libproc_macro/lib.rs

@@ -28,7 +28,6 @@
        test(attr(allow(dead_code, deprecated, unused_variables, unused_mut))))]
 
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(rustc_private)]
 #![feature(staged_api)]
 #![feature(lang_items)]

src/libprofiler_builtins/lib.rs

@@ -16,5 +16,4 @@
             issue = "0")]
 #![allow(unused_features)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(staged_api)]

src/librustc/diagnostics.rs

@@ -1232,41 +1232,54 @@ fn main() {}
 "##,
 
 E0309: r##"
-Types in type definitions have lifetimes associated with them that represent
-how long the data stored within them is guaranteed to be live. This lifetime
-must be as long as the data needs to be alive, and missing the constraint that
-denotes this will cause this error.
+The type definition contains some field whose type
+requires an outlives annotation. Outlives annotations
+(e.g., `T: 'a`) are used to guarantee that all the data in T is valid
+for at least the lifetime `'a`. This scenario most commonly
+arises when the type contains an associated type reference
+like `<T as SomeTrait<'a>>::Output`, as shown in this example:
 
 ```compile_fail,E0309
-// This won't compile because T is not constrained, meaning the data
-// stored in it is not guaranteed to last as long as the reference
+// This won't compile because the applicable impl of
+// `SomeTrait` (below) requires that `T: 'a`, but the struct does
+// not have a matching where-clause.
 struct Foo<'a, T> {
-    foo: &'a T
+    foo: <T as SomeTrait<'a>>::Output,
 }
-```
 
-This will compile, because it has the constraint on the type parameter:
+trait SomeTrait<'a> {
+    type Output;
+}
 
-```
-struct Foo<'a, T: 'a> {
-    foo: &'a T
+impl<'a, T> SomeTrait<'a> for T
+where
+    T: 'a,
+{
+    type Output = u32;
 }
 ```
 
-To see why this is important, consider the case where `T` is itself a reference
-(e.g., `T = &str`). If we don't include the restriction that `T: 'a`, the
-following code would be perfectly legal:
+Here, the where clause `T: 'a` that appears on the impl is not known to be
+satisfied on the struct. To make this example compile, you have to add
+a where-clause like `T: 'a` to the struct definition:
 
-```compile_fail,E0309
-struct Foo<'a, T> {
-    foo: &'a T
+```
+struct Foo<'a, T>
+where
+    T: 'a,
+{
+    foo: <T as SomeTrait<'a>>::Output
 }
 
-fn main() {
-    let v = "42".to_string();
-    let f = Foo{foo: &v};
-    drop(v);
-    println!("{}", f.foo); // but we've already dropped v!
+trait SomeTrait<'a> {
+    type Output;
+}
+
+impl<'a, T> SomeTrait<'a> for T
+where
+    T: 'a,
+{
+    type Output = u32;
 }
 ```
 "##,
@@ -1465,30 +1478,31 @@ struct Prince<'kiss, 'SnowWhite: 'kiss> { // You say here that 'kiss must live
 Erroneous code example:
 
 ```compile_fail,E0491
-// struct containing a reference requires a lifetime parameter,
-// because the data the reference points to must outlive the struct (see E0106)
-struct Struct<'a> {
-    ref_i32: &'a i32,
+trait SomeTrait<'a> {
+    type Output;
 }
 
-// However, a nested struct like this, the signature itself does not tell
-// whether 'a outlives 'b or the other way around.
-// So it could be possible that 'b of reference outlives 'a of the data.
-struct Nested<'a, 'b> {
-    ref_struct: &'b Struct<'a>, // compile error E0491
+impl<'a, T> SomeTrait<'a> for T {
+    type Output = &'a T; // compile error E0491
 }
 ```
 
-To fix this issue, you can specify a bound to the lifetime like below:
+Here, the problem is that a reference type like `&'a T` is only valid
+if all the data in T outlives the lifetime `'a`. But this impl as written
+is applicable to any lifetime `'a` and any type `T` -- we have no guarantee
+that `T` outlives `'a`. To fix this, you can add a where clause like
+`where T: 'a`.
 
 ```
-struct Struct<'a> {
-    ref_i32: &'a i32,
+trait SomeTrait<'a> {
+    type Output;
 }
 
-// 'a: 'b means 'a outlives 'b
-struct Nested<'a: 'b, 'b> {
-    ref_struct: &'b Struct<'a>,
+impl<'a, T> SomeTrait<'a> for T
+where
+    T: 'a,
+{
+    type Output = &'a T; // compile error E0491
 }
 ```
 "##,

src/librustc/lib.rs

@@ -52,7 +52,6 @@
 #![feature(exhaustive_patterns)]
 #![feature(extern_types)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(non_exhaustive)]
 #![feature(proc_macro_internals)]
 #![feature(quote)]

src/librustc_allocator/lib.rs

@@ -9,7 +9,6 @@
 // except according to those terms.
 
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(rustc_private)]
 
 #[macro_use] extern crate log;

src/librustc_apfloat/lib.rs

@@ -46,7 +46,6 @@
 #![forbid(unsafe_code)]
 
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(try_from)]
 // See librustc_cratesio_shim/Cargo.toml for a comment explaining this.
 #[allow(unused_extern_crates)]

src/librustc_asan/lib.rs

@@ -11,7 +11,6 @@
 #![sanitizer_runtime]
 #![feature(alloc_system)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(sanitizer_runtime)]
 #![feature(staged_api)]
 #![no_std]

src/librustc_borrowck/lib.rs

@@ -15,7 +15,6 @@
 #![allow(non_camel_case_types)]
 
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(quote)]
 
 #![recursion_limit="256"]

src/librustc_codegen_llvm/lib.rs

@@ -27,7 +27,6 @@
 #![allow(unused_attributes)]
 #![feature(libc)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(quote)]
 #![feature(range_contains)]
 #![feature(rustc_diagnostic_macros)]

src/librustc_codegen_utils/lib.rs

@@ -20,7 +20,6 @@
 #![feature(box_syntax)]
 #![feature(custom_attribute)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![allow(unused_attributes)]
 #![feature(quote)]
 #![feature(rustc_diagnostic_macros)]

src/librustc_cratesio_shim/src/lib.rs

@@ -12,7 +12,6 @@
 #![allow(unused_extern_crates)]
 
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 
 extern crate bitflags;
 extern crate log;

src/librustc_data_structures/lib.rs

@@ -29,7 +29,6 @@
 #![feature(optin_builtin_traits)]
 #![cfg_attr(stage0, feature(macro_vis_matcher))]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(allow_internal_unstable)]
 #![feature(vec_resize_with)]
 

src/librustc_driver/lib.rs

@@ -21,7 +21,6 @@
 #![feature(box_syntax)]
 #![cfg_attr(unix, feature(libc))]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(option_replace)]
 #![feature(quote)]
 #![feature(rustc_diagnostic_macros)]

src/librustc_errors/lib.rs

@@ -17,7 +17,6 @@
 #![feature(range_contains)]
 #![cfg_attr(unix, feature(libc))]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(optin_builtin_traits)]
 
 extern crate atty;

src/librustc_incremental/lib.rs

@@ -15,7 +15,6 @@
       html_root_url = "https://doc.rust-lang.org/nightly/")]
 
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(specialization)]
 
 #![recursion_limit="256"]

src/librustc_lint/lib.rs

@@ -28,7 +28,6 @@
 #![feature(box_syntax)]
 #![cfg_attr(stage0, feature(macro_vis_matcher))]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(quote)]
 #![feature(rustc_diagnostic_macros)]
 #![feature(macro_at_most_once_rep)]

src/librustc_llvm/lib.rs

@@ -9,7 +9,6 @@
 // except according to those terms.
 
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(static_nobundle)]
 
 #![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",

src/librustc_lsan/lib.rs

@@ -11,7 +11,6 @@
 #![sanitizer_runtime]
 #![feature(alloc_system)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(sanitizer_runtime)]
 #![feature(staged_api)]
 #![no_std]

src/librustc_metadata/lib.rs

@@ -16,7 +16,6 @@
 #![feature(libc)]
 #![feature(macro_at_most_once_rep)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(proc_macro_internals)]
 #![feature(proc_macro_quote)]
 #![feature(quote)]

src/librustc_mir/lib.rs

@@ -15,7 +15,6 @@
 */
 
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(in_band_lifetimes)]
 #![feature(impl_header_lifetime_elision)]
 #![feature(slice_patterns)]

src/librustc_msan/lib.rs

@@ -11,7 +11,6 @@
 #![sanitizer_runtime]
 #![feature(alloc_system)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(sanitizer_runtime)]
 #![feature(staged_api)]
 #![no_std]

src/librustc_passes/lib.rs

@@ -19,7 +19,6 @@
        html_root_url = "https://doc.rust-lang.org/nightly/")]
 
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(rustc_diagnostic_macros)]
 
 #[macro_use]

src/librustc_platform_intrinsics/lib.rs

@@ -11,7 +11,6 @@
 #![allow(nonstandard_style)]
 
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 
 pub struct Intrinsic {
     pub inputs: &'static [&'static Type],

src/librustc_plugin/lib.rs

@@ -65,7 +65,6 @@
        html_root_url = "https://doc.rust-lang.org/nightly/")]
 
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(rustc_diagnostic_macros)]
 
 #[macro_use] extern crate syntax;

src/librustc_privacy/lib.rs

@@ -13,7 +13,6 @@
        html_root_url = "https://doc.rust-lang.org/nightly/")]
 
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(rustc_diagnostic_macros)]
 
 #![recursion_limit="256"]
@@ -1381,7 +1380,13 @@ fn generics(&mut self) -> &mut Self {
     }
 
     fn predicates(&mut self) -> &mut Self {
-        let predicates = self.tcx.predicates_of(self.item_def_id);
+        // NB: We use `explicit_predicates_of` and not `predicates_of`
+        // because we don't want to report privacy errors due to where
+        // clauses that the compiler inferred. We only want to
+        // consider the ones that the user wrote. This is important
+        // for the inferred outlives rules; see
+        // `src/test/ui/rfc-2093-infer-outlives/privacy.rs`.
+        let predicates = self.tcx.explicit_predicates_of(self.item_def_id);
         for predicate in &predicates.predicates {
             predicate.visit_with(self);
             match predicate {

src/librustc_resolve/lib.rs

@@ -14,7 +14,6 @@
 
 #![feature(crate_visibility_modifier)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(rustc_diagnostic_macros)]
 #![feature(slice_sort_by_cached_key)]
 

src/librustc_save_analysis/lib.rs

@@ -13,7 +13,6 @@
        html_root_url = "https://doc.rust-lang.org/nightly/")]
 #![feature(custom_attribute)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![allow(unused_attributes)]
 
 #![recursion_limit="256"]

src/librustc_target/lib.rs

@@ -25,7 +25,6 @@
 #![cfg_attr(stage0, feature(const_fn))]
 #![cfg_attr(not(stage0), feature(min_const_fn))]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(slice_patterns)]
 
 #[macro_use]

src/librustc_traits/lib.rs

@@ -16,7 +16,6 @@
 #![feature(extern_prelude)]
 #![feature(in_band_lifetimes)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 
 #![recursion_limit="256"]
 

src/librustc_tsan/lib.rs

@@ -11,7 +11,6 @@
 #![sanitizer_runtime]
 #![feature(alloc_system)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(sanitizer_runtime)]
 #![feature(staged_api)]
 #![no_std]

src/librustc_typeck/collect.rs

@@ -1578,14 +1578,10 @@ fn predicates_defined_on<'a, 'tcx>(
     def_id: DefId,
 ) -> ty::GenericPredicates<'tcx> {
     let explicit = tcx.explicit_predicates_of(def_id);
-    let predicates = if tcx.sess.features_untracked().infer_outlives_requirements {
-        [
-            &explicit.predicates[..],
-            &tcx.inferred_outlives_of(def_id)[..],
-        ].concat()
-    } else {
-        explicit.predicates
-    };
+    let predicates = [
+      &explicit.predicates[..],
+      &tcx.inferred_outlives_of(def_id)[..],
+    ].concat();
 
     ty::GenericPredicates {
         parent: explicit.parent,

src/librustc_typeck/lib.rs

@@ -76,7 +76,6 @@
 #![feature(crate_visibility_modifier)]
 #![feature(exhaustive_patterns)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(quote)]
 #![feature(refcell_replace_swap)]
 #![feature(rustc_diagnostic_macros)]

src/librustc_typeck/outlives/implicit_infer.rs

@@ -66,7 +66,8 @@ fn visit_item(&mut self, item: &hir::Item) {
 
         debug!("InferVisitor::visit_item(item={:?})", item_did);
 
-        let node_id = self.tcx
+        let node_id = self
+            .tcx
             .hir
             .as_local_node_id(item_did)
             .expect("expected local def-id");
@@ -108,7 +109,8 @@ fn visit_item(&mut self, item: &hir::Item) {
         // Therefore mark `predicates_added` as true and which will ensure
         // we walk the crates again and re-calculate predicates for all
         // items.
-        let item_predicates_len: usize = self.global_inferred_outlives
+        let item_predicates_len: usize = self
+            .global_inferred_outlives
             .get(&item_did)
             .map(|p| p.len())
             .unwrap_or(0);

src/librustdoc/lib.rs

@@ -17,7 +17,6 @@
 #![feature(box_patterns)]
 #![feature(box_syntax)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(set_stdio)]
 #![feature(slice_sort_by_cached_key)]
 #![feature(test)]

src/libserialize/lib.rs

@@ -25,7 +25,6 @@
 #![feature(specialization)]
 #![feature(never_type)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![cfg_attr(test, feature(test))]
 
 pub use self::serialize::{Decoder, Encoder, Decodable, Encodable};

src/libstd/lib.rs

@@ -274,7 +274,6 @@
 #![feature(needs_panic_runtime)]
 #![feature(never_type)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(exhaustive_patterns)]
 #![feature(on_unimplemented)]
 #![feature(optin_builtin_traits)]

src/libsyntax/feature_gate.rs

@@ -412,9 +412,6 @@ pub fn walk_feature_fields<F>(&self, mut f: F)
     // Use `?` as the Kleene "at most one" operator
     (active, macro_at_most_once_rep, "1.25.0", Some(48075), None),
 
-    // Infer outlives requirements; RFC 2093
-    (active, infer_outlives_requirements, "1.26.0", Some(44493), None),
-
     // Infer static outlives requirements; RFC 2093
     (active, infer_static_outlives_requirements, "1.26.0", Some(44493), None),
 
@@ -672,6 +669,8 @@ pub fn walk_feature_fields<F>(&self, mut f: F)
     (accepted, proc_macro_path_invoc, "1.30.0", Some(38356), None),
     // Allows all literals in attribute lists and values of key-value pairs.
     (accepted, attr_literals, "1.30.0", Some(34981), None),
+    // Infer outlives requirements; RFC 2093
+    (accepted, infer_outlives_requirements, "1.30.0", Some(44493), None),
     (accepted, panic_handler, "1.30.0", Some(44489), None),
     // Used to preserve symbols (see llvm.used)
     (accepted, used, "1.30.0", Some(40289), None),
@@ -1124,12 +1123,6 @@ pub fn is_builtin_attr(attr: &ast::Attribute) -> bool {
                                  "never will be stable",
                                  cfg_fn!(rustc_attrs))),
 
-    // RFC #2093
-    ("infer_outlives_requirements", Normal, Gated(Stability::Unstable,
-                                   "infer_outlives_requirements",
-                                   "infer outlives requirements is an experimental feature",
-                                   cfg_fn!(infer_outlives_requirements))),
-
     // RFC #2093
     ("infer_static_outlives_requirements", Normal, Gated(Stability::Unstable,
                                    "infer_static_outlives_requirements",

src/libsyntax/lib.rs

@@ -22,7 +22,6 @@
 #![feature(crate_visibility_modifier)]
 #![feature(macro_at_most_once_rep)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(rustc_attrs)]
 #![feature(rustc_diagnostic_macros)]
 #![feature(slice_sort_by_cached_key)]

src/libsyntax_ext/lib.rs

@@ -17,7 +17,6 @@
 #![feature(proc_macro_internals)]
 #![feature(decl_macro)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(str_escape)]
 #![feature(quote)]
 #![feature(rustc_diagnostic_macros)]

src/libsyntax_pos/lib.rs

@@ -22,7 +22,6 @@
 #![feature(crate_visibility_modifier)]
 #![feature(custom_attribute)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(non_exhaustive)]
 #![feature(optin_builtin_traits)]
 #![feature(specialization)]

src/libterm/lib.rs

@@ -51,7 +51,6 @@
 // Handle rustfmt skips
 #![feature(custom_attribute)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![allow(unused_attributes)]
 
 use std::io::prelude::*;

src/libtest/lib.rs

@@ -36,7 +36,6 @@
 #![feature(fnbox)]
 #![cfg_attr(any(unix, target_os = "cloudabi"), feature(libc))]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(set_stdio)]
 #![feature(panic_unwind)]
 #![feature(staged_api)]

src/libunwind/lib.rs

@@ -14,7 +14,6 @@
 #![feature(cfg_target_vendor)]
 #![feature(link_cfg)]
 #![cfg_attr(not(stage0), feature(nll))]
-#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
 #![feature(staged_api)]
 #![feature(unwind_attributes)]
 #![feature(static_nobundle)]

src/test/incremental/issue-51409.rs

@@ -13,8 +13,6 @@
 // Regression test that `infer_outlives_predicates` can be
 // used with incremental without an ICE.
 
-#![feature(infer_outlives_requirements)]
-
 struct Foo<'a, T> {
   x: &'a T
 }

src/test/ui/dep-graph/dep-graph-struct-signature.rs

@@ -88,7 +88,6 @@ trait A {
     }
 
     #[rustc_then_this_would_need(FnSignature)] //~ ERROR no path
-    #[rustc_then_this_would_need(TypeckTables)] //~ ERROR no path
     fn b(x: WontChange) { }
 
     #[rustc_then_this_would_need(FnSignature)] //~ ERROR no path from `WillChange`

src/test/ui/dep-graph/dep-graph-struct-signature.stderr

@@ -82,20 +82,14 @@ error: no path from `WillChange` to `FnSignature`
 LL |     #[rustc_then_this_would_need(FnSignature)] //~ ERROR no path
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: no path from `WillChange` to `TypeckTables`
-  --> $DIR/dep-graph-struct-signature.rs:91:5
-   |
-LL |     #[rustc_then_this_would_need(TypeckTables)] //~ ERROR no path
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
 error: no path from `WillChange` to `FnSignature`
-  --> $DIR/dep-graph-struct-signature.rs:94:5
+  --> $DIR/dep-graph-struct-signature.rs:93:5
    |
 LL |     #[rustc_then_this_would_need(FnSignature)] //~ ERROR no path from `WillChange`
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: no path from `WillChange` to `TypeckTables`
-  --> $DIR/dep-graph-struct-signature.rs:95:5
+  --> $DIR/dep-graph-struct-signature.rs:94:5
    |
 LL |     #[rustc_then_this_would_need(TypeckTables)] //~ ERROR no path from `WillChange`
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -136,5 +130,5 @@ error: OK
 LL |         #[rustc_then_this_would_need(TypeckTables)] //~ ERROR OK
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 23 previous errors
+error: aborting due to 22 previous errors
 

src/test/ui/feature-gates/feature-gate-infer_outlives_requirements.stderr

-error[E0309]: the parameter type `T` may not live long enough
-  --> $DIR/feature-gate-infer_outlives_requirements.rs:15:5
-   |
-LL | struct Foo<'a, T> {
-   |                - help: consider adding an explicit lifetime bound `T: 'a`...
-LL |     bar: &'a [T] //~ ERROR the parameter type `T` may not live long enough [E0309]
-   |     ^^^^^^^^^^^^
-   |
-note: ...so that the reference type `&'a [T]` does not outlive the data it points at
-  --> $DIR/feature-gate-infer_outlives_requirements.rs:15:5
-   |
-LL |     bar: &'a [T] //~ ERROR the parameter type `T` may not live long enough [E0309]
-   |     ^^^^^^^^^^^^
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0309`.

src/test/ui/issue-53419.rs

@@ -10,8 +10,6 @@
 
 //compile-pass
 
-#![feature(infer_outlives_requirements)]
-
 struct Foo {
     bar: for<'r> Fn(usize, &'r FnMut())
 }

src/test/ui/issues/issue-37323.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// compile-pass
+
 #![feature(rustc_attrs)]
 #![allow(warnings)]
 
@@ -17,7 +19,6 @@ struct Point {
 
 struct NestedA<'a, 'b> {
     x: &'a NestedB<'b>
-    //~^ ERROR E0491
 }
 
 struct NestedB<'a> {

src/test/ui/issues/issue-37323.stderr

-error[E0491]: in type `&'a NestedB<'b>`, reference has a longer lifetime than the data it references
-  --> $DIR/issue-37323.rs:19:5
-   |
-LL |     x: &'a NestedB<'b>
-   |     ^^^^^^^^^^^^^^^^^^
-   |
-note: the pointer is valid for the lifetime 'a as defined on the struct at 18:16
-  --> $DIR/issue-37323.rs:18:16
-   |
-LL | struct NestedA<'a, 'b> {
-   |                ^^
-note: but the referenced data is only valid for the lifetime 'b as defined on the struct at 18:20
-  --> $DIR/issue-37323.rs:18:20
-   |
-LL | struct NestedA<'a, 'b> {
-   |                    ^^
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0491`.

src/test/ui/lifetimes/lifetime-doesnt-live-long-enough.rs

@@ -14,9 +14,9 @@ trait ListItem<'a> {
 
 trait Collection { fn len(&self) -> usize; }
 
+// is now well formed. RFC 2093
 struct List<'a, T: ListItem<'a>> {
     slice: &'a [T]
-    //~^ ERROR may not live long enough
 }
 
 impl<'a, T: ListItem<'a>> Collection for List<'a, T> {

src/test/ui/lifetimes/lifetime-doesnt-live-long-enough.stderr

-error[E0309]: the parameter type `T` may not live long enough
-  --> $DIR/lifetime-doesnt-live-long-enough.rs:18:5
-   |
-LL | struct List<'a, T: ListItem<'a>> {
-   |                 -- help: consider adding an explicit lifetime bound `T: 'a`...
-LL |     slice: &'a [T]
-   |     ^^^^^^^^^^^^^^
-   |
-note: ...so that the reference type `&'a [T]` does not outlive the data it points at
-  --> $DIR/lifetime-doesnt-live-long-enough.rs:18:5
-   |
-LL |     slice: &'a [T]
-   |     ^^^^^^^^^^^^^^
-
 error[E0310]: the parameter type `T` may not live long enough
   --> $DIR/lifetime-doesnt-live-long-enough.rs:29:5
    |
@@ -109,7 +95,7 @@ LL | |         //~^ ERROR may not live long enough
 LL | |     }
    | |_____^
 
-error: aborting due to 7 previous errors
+error: aborting due to 6 previous errors
 
 Some errors occurred: E0309, E0310.
 For more information about an error, try `rustc --explain E0309`.

src/test/ui/lint/lint-ctypes.rs

@@ -11,6 +11,8 @@
 #![deny(improper_ctypes)]
 #![feature(libc)]
 
+#![allow(private_in_public)]
+
 extern crate libc;
 
 use std::marker::PhantomData;

src/test/ui/lint/lint-ctypes.stderr

 error: `extern` block uses type `Foo` which is not FFI-safe: this struct has unspecified layout
-  --> $DIR/lint-ctypes.rs:54:28
+  --> $DIR/lint-ctypes.rs:56:28
    |
 LL |     pub fn ptr_type1(size: *const Foo); //~ ERROR: uses type `Foo`
    |                            ^^^^^^^^^^
@@ -11,26 +11,26 @@ LL | #![deny(improper_ctypes)]
    |         ^^^^^^^^^^^^^^^
    = help: consider adding a #[repr(C)] or #[repr(transparent)] attribute to this struct
 note: type defined here
-  --> $DIR/lint-ctypes.rs:32:1
+  --> $DIR/lint-ctypes.rs:34:1
    |
 LL | pub struct Foo;
    | ^^^^^^^^^^^^^^^
 
 error: `extern` block uses type `Foo` which is not FFI-safe: this struct has unspecified layout
-  --> $DIR/lint-ctypes.rs:55:28
+  --> $DIR/lint-ctypes.rs:57:28
    |
 LL |     pub fn ptr_type2(size: *const Foo); //~ ERROR: uses type `Foo`
    |                            ^^^^^^^^^^
    |
    = help: consider adding a #[repr(C)] or #[repr(transparent)] attribute to this struct
 note: type defined here
-  --> $DIR/lint-ctypes.rs:32:1
+  --> $DIR/lint-ctypes.rs:34:1
    |
 LL | pub struct Foo;
    | ^^^^^^^^^^^^^^^
 
 error: `extern` block uses type `[u32]` which is not FFI-safe: slices have no C equivalent
-  --> $DIR/lint-ctypes.rs:56:26
+  --> $DIR/lint-ctypes.rs:58:26
    |
 LL |     pub fn slice_type(p: &[u32]); //~ ERROR: uses type `[u32]`
    |                          ^^^^^^
@@ -38,7 +38,7 @@ LL |     pub fn slice_type(p: &[u32]); //~ ERROR: uses type `[u32]`
    = help: consider using a raw pointer instead
 
 error: `extern` block uses type `str` which is not FFI-safe: string slices have no C equivalent
-  --> $DIR/lint-ctypes.rs:57:24
+  --> $DIR/lint-ctypes.rs:59:24
    |
 LL |     pub fn str_type(p: &str); //~ ERROR: uses type `str`
    |                        ^^^^
@@ -46,7 +46,7 @@ LL |     pub fn str_type(p: &str); //~ ERROR: uses type `str`
    = help: consider using `*const u8` and a length instead
 
 error: `extern` block uses type `std::boxed::Box<u32>` which is not FFI-safe: this struct has unspecified layout
-  --> $DIR/lint-ctypes.rs:58:24
+  --> $DIR/lint-ctypes.rs:60:24
    |
 LL |     pub fn box_type(p: Box<u32>); //~ ERROR uses type `std::boxed::Box<u32>`
    |                        ^^^^^^^^
@@ -54,7 +54,7 @@ LL |     pub fn box_type(p: Box<u32>); //~ ERROR uses type `std::boxed::Box<u32>
    = help: consider adding a #[repr(C)] or #[repr(transparent)] attribute to this struct
 
 error: `extern` block uses type `char` which is not FFI-safe: the `char` type has no C equivalent
-  --> $DIR/lint-ctypes.rs:59:25
+  --> $DIR/lint-ctypes.rs:61:25
    |
 LL |     pub fn char_type(p: char); //~ ERROR uses type `char`
    |                         ^^^^
@@ -62,25 +62,25 @@ LL |     pub fn char_type(p: char); //~ ERROR uses type `char`
    = help: consider using `u32` or `libc::wchar_t` instead
 
 error: `extern` block uses type `i128` which is not FFI-safe: 128-bit integers don't currently have a known stable ABI
-  --> $DIR/lint-ctypes.rs:60:25
+  --> $DIR/lint-ctypes.rs:62:25
    |
 LL |     pub fn i128_type(p: i128); //~ ERROR uses type `i128`
    |                         ^^^^
 
 error: `extern` block uses type `u128` which is not FFI-safe: 128-bit integers don't currently have a known stable ABI
-  --> $DIR/lint-ctypes.rs:61:25
+  --> $DIR/lint-ctypes.rs:63:25
    |
 LL |     pub fn u128_type(p: u128); //~ ERROR uses type `u128`
    |                         ^^^^
 
 error: `extern` block uses type `dyn std::clone::Clone` which is not FFI-safe: trait objects have no C equivalent
-  --> $DIR/lint-ctypes.rs:62:26
+  --> $DIR/lint-ctypes.rs:64:26
    |
 LL |     pub fn trait_type(p: &Clone); //~ ERROR uses type `dyn std::clone::Clone`
    |                          ^^^^^^
 
 error: `extern` block uses type `(i32, i32)` which is not FFI-safe: tuples have unspecified layout
-  --> $DIR/lint-ctypes.rs:63:26
+  --> $DIR/lint-ctypes.rs:65:26
    |
 LL |     pub fn tuple_type(p: (i32, i32)); //~ ERROR uses type `(i32, i32)`
    |                          ^^^^^^^^^^
@@ -88,7 +88,7 @@ LL |     pub fn tuple_type(p: (i32, i32)); //~ ERROR uses type `(i32, i32)`
    = help: consider using a struct instead
 
 error: `extern` block uses type `(i32, i32)` which is not FFI-safe: tuples have unspecified layout
-  --> $DIR/lint-ctypes.rs:64:27
+  --> $DIR/lint-ctypes.rs:66:27
    |
 LL |     pub fn tuple_type2(p: I32Pair); //~ ERROR uses type `(i32, i32)`
    |                           ^^^^^^^
@@ -96,32 +96,32 @@ LL |     pub fn tuple_type2(p: I32Pair); //~ ERROR uses type `(i32, i32)`
    = help: consider using a struct instead
 
 error: `extern` block uses type `ZeroSize` which is not FFI-safe: this struct has no fields
-  --> $DIR/lint-ctypes.rs:65:25
+  --> $DIR/lint-ctypes.rs:67:25
    |
 LL |     pub fn zero_size(p: ZeroSize); //~ ERROR struct has no fields
    |                         ^^^^^^^^
    |
    = help: consider adding a member to this struct
 note: type defined here
-  --> $DIR/lint-ctypes.rs:28:1
+  --> $DIR/lint-ctypes.rs:30:1
    |
 LL | pub struct ZeroSize;
    | ^^^^^^^^^^^^^^^^^^^^
 
 error: `extern` block uses type `ZeroSizeWithPhantomData` which is not FFI-safe: composed only of PhantomData
-  --> $DIR/lint-ctypes.rs:66:33
+  --> $DIR/lint-ctypes.rs:68:33
    |
 LL |     pub fn zero_size_phantom(p: ZeroSizeWithPhantomData); //~ ERROR composed only of PhantomData
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `extern` block uses type `std::marker::PhantomData<bool>` which is not FFI-safe: composed only of PhantomData
-  --> $DIR/lint-ctypes.rs:68:12
+  --> $DIR/lint-ctypes.rs:70:12
    |
 LL |         -> ::std::marker::PhantomData<bool>; //~ ERROR: composed only of PhantomData
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `extern` block uses type `fn()` which is not FFI-safe: this function pointer has Rust-specific calling convention
-  --> $DIR/lint-ctypes.rs:69:23
+  --> $DIR/lint-ctypes.rs:71:23
    |
 LL |     pub fn fn_type(p: RustFn); //~ ERROR function pointer has Rust-specific
    |                       ^^^^^^
@@ -129,7 +129,7 @@ LL |     pub fn fn_type(p: RustFn); //~ ERROR function pointer has Rust-specific
    = help: consider using an `extern fn(...) -> ...` function pointer instead
 
 error: `extern` block uses type `fn()` which is not FFI-safe: this function pointer has Rust-specific calling convention
-  --> $DIR/lint-ctypes.rs:70:24
+  --> $DIR/lint-ctypes.rs:72:24
    |
 LL |     pub fn fn_type2(p: fn()); //~ ERROR function pointer has Rust-specific
    |                        ^^^^
@@ -137,7 +137,7 @@ LL |     pub fn fn_type2(p: fn()); //~ ERROR function pointer has Rust-specific
    = help: consider using an `extern fn(...) -> ...` function pointer instead
 
 error: `extern` block uses type `std::boxed::Box<u32>` which is not FFI-safe: this struct has unspecified layout
-  --> $DIR/lint-ctypes.rs:71:28
+  --> $DIR/lint-ctypes.rs:73:28
    |
 LL |     pub fn fn_contained(p: RustBadRet); //~ ERROR: uses type `std::boxed::Box<u32>`
    |                            ^^^^^^^^^^
@@ -145,13 +145,13 @@ LL |     pub fn fn_contained(p: RustBadRet); //~ ERROR: uses type `std::boxed::B
    = help: consider adding a #[repr(C)] or #[repr(transparent)] attribute to this struct
 
 error: `extern` block uses type `i128` which is not FFI-safe: 128-bit integers don't currently have a known stable ABI
-  --> $DIR/lint-ctypes.rs:72:32
+  --> $DIR/lint-ctypes.rs:74:32
    |
 LL |     pub fn transparent_i128(p: TransparentI128); //~ ERROR: uses type `i128`
    |                                ^^^^^^^^^^^^^^^
 
 error: `extern` block uses type `str` which is not FFI-safe: string slices have no C equivalent
-  --> $DIR/lint-ctypes.rs:73:31
+  --> $DIR/lint-ctypes.rs:75:31
    |
 LL |     pub fn transparent_str(p: TransparentStr); //~ ERROR: uses type `str`
    |                               ^^^^^^^^^^^^^^
@@ -159,7 +159,7 @@ LL |     pub fn transparent_str(p: TransparentStr); //~ ERROR: uses type `str`
    = help: consider using `*const u8` and a length instead
 
 error: `extern` block uses type `std::boxed::Box<u32>` which is not FFI-safe: this struct has unspecified layout
-  --> $DIR/lint-ctypes.rs:74:30
+  --> $DIR/lint-ctypes.rs:76:30
    |
 LL |     pub fn transparent_fn(p: TransparentBadFn); //~ ERROR: uses type `std::boxed::Box<u32>`
    |                              ^^^^^^^^^^^^^^^^

src/test/ui/no_owned_box_lang_item.rs

@@ -15,10 +15,12 @@
 #![feature(lang_items, box_syntax)]
 #![no_std]
 
+use core::panic::PanicInfo;
+
 fn main() {
     let x = box 1i32;
 }
 
 #[lang = "eh_personality"] extern fn eh_personality() {}
 #[lang = "eh_unwind_resume"] extern fn eh_unwind_resume() {}
-#[lang = "panic_impl"] fn panic_impl() -> ! { loop {} }
+#[lang = "panic_impl"] fn panic_impl(panic: &PanicInfo) -> ! { loop {} }

src/test/ui/regions/regions-enum-not-wf.rs

@@ -8,31 +8,43 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// ignore-tidy-linelength
+
 // Various examples of structs whose fields are not well-formed.
 
 #![allow(dead_code)]
 
+trait Dummy<'a> {
+  type Out;
+}
+impl<'a, T> Dummy<'a> for T
+where T: 'a
+{
+  type Out = ();
+}
+type RequireOutlives<'a, T> = <T as Dummy<'a>>::Out;
+
 enum Ref1<'a, T> {
-    Ref1Variant1(&'a T) //~ ERROR the parameter type `T` may not live long enough
+    Ref1Variant1(RequireOutlives<'a, T>) //~ ERROR the parameter type `T` may not live long enough
 }
 
 enum Ref2<'a, T> {
     Ref2Variant1,
-    Ref2Variant2(isize, &'a T), //~ ERROR the parameter type `T` may not live long enough
+    Ref2Variant2(isize, RequireOutlives<'a, T>), //~ ERROR the parameter type `T` may not live long enough
 }
 
 enum RefOk<'a, T:'a> {
     RefOkVariant1(&'a T)
 }
 
+// This is now well formed. RFC 2093
 enum RefIndirect<'a, T> {
     RefIndirectVariant1(isize, RefOk<'a,T>)
-        //~^ ERROR the parameter type `T` may not live long enough
 }
 
-enum RefDouble<'a, 'b, T> {
-    RefDoubleVariant1(&'a &'b T)
-        //~^ ERROR reference has a longer lifetime than the data
+enum RefDouble<'a, 'b, T> { //~ ERROR 45:1: 48:2: the parameter type `T` may not live long enough [E0309]
+    RefDoubleVariant1(&'a RequireOutlives<'b, T>)
+        //~^ 46:23: 46:49: the parameter type `T` may not live long enough [E0309]
 }
 
 fn main() { }

src/test/ui/regions/regions-enum-not-wf.stderr

 error[E0309]: the parameter type `T` may not live long enough
-  --> $DIR/regions-enum-not-wf.rs:16:18
+  --> $DIR/regions-enum-not-wf.rs:28:18
    |
 LL | enum Ref1<'a, T> {
    |               - help: consider adding an explicit lifetime bound `T: 'a`...
-LL |     Ref1Variant1(&'a T) //~ ERROR the parameter type `T` may not live long enough
-   |                  ^^^^^
+LL |     Ref1Variant1(RequireOutlives<'a, T>) //~ ERROR the parameter type `T` may not live long enough
+   |                  ^^^^^^^^^^^^^^^^^^^^^^
    |
-note: ...so that the reference type `&'a T` does not outlive the data it points at
-  --> $DIR/regions-enum-not-wf.rs:16:18
+note: ...so that the type `T` will meet its required lifetime bounds
+  --> $DIR/regions-enum-not-wf.rs:28:18
    |
-LL |     Ref1Variant1(&'a T) //~ ERROR the parameter type `T` may not live long enough
-   |                  ^^^^^
+LL |     Ref1Variant1(RequireOutlives<'a, T>) //~ ERROR the parameter type `T` may not live long enough
+   |                  ^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0309]: the parameter type `T` may not live long enough
-  --> $DIR/regions-enum-not-wf.rs:21:25
+  --> $DIR/regions-enum-not-wf.rs:33:25
    |
 LL | enum Ref2<'a, T> {
    |               - help: consider adding an explicit lifetime bound `T: 'a`...
 LL |     Ref2Variant1,
-LL |     Ref2Variant2(isize, &'a T), //~ ERROR the parameter type `T` may not live long enough
-   |                         ^^^^^
+LL |     Ref2Variant2(isize, RequireOutlives<'a, T>), //~ ERROR the parameter type `T` may not live long enough
+   |                         ^^^^^^^^^^^^^^^^^^^^^^
    |
-note: ...so that the reference type `&'a T` does not outlive the data it points at
-  --> $DIR/regions-enum-not-wf.rs:21:25
+note: ...so that the type `T` will meet its required lifetime bounds
+  --> $DIR/regions-enum-not-wf.rs:33:25
    |
-LL |     Ref2Variant2(isize, &'a T), //~ ERROR the parameter type `T` may not live long enough
-   |                         ^^^^^
+LL |     Ref2Variant2(isize, RequireOutlives<'a, T>), //~ ERROR the parameter type `T` may not live long enough
+   |                         ^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0309]: the parameter type `T` may not live long enough
-  --> $DIR/regions-enum-not-wf.rs:29:32
+  --> $DIR/regions-enum-not-wf.rs:45:1
    |
-LL | enum RefIndirect<'a, T> {
-   |                      - help: consider adding an explicit lifetime bound `T: 'a`...
-LL |     RefIndirectVariant1(isize, RefOk<'a,T>)
-   |                                ^^^^^^^^^^^
+LL |   enum RefDouble<'a, 'b, T> { //~ ERROR 45:1: 48:2: the parameter type `T` may not live long enough [E0309]
+   |   ^                      - help: consider adding an explicit lifetime bound `T: 'b`...
+   |  _|
+   | |
+LL | |     RefDoubleVariant1(&'a RequireOutlives<'b, T>)
+LL | |         //~^ 46:23: 46:49: the parameter type `T` may not live long enough [E0309]
+LL | | }
+   | |_^
    |
 note: ...so that the type `T` will meet its required lifetime bounds
-  --> $DIR/regions-enum-not-wf.rs:29:32
+  --> $DIR/regions-enum-not-wf.rs:45:1
    |
-LL |     RefIndirectVariant1(isize, RefOk<'a,T>)
-   |                                ^^^^^^^^^^^
+LL | / enum RefDouble<'a, 'b, T> { //~ ERROR 45:1: 48:2: the parameter type `T` may not live long enough [E0309]
+LL | |     RefDoubleVariant1(&'a RequireOutlives<'b, T>)
+LL | |         //~^ 46:23: 46:49: the parameter type `T` may not live long enough [E0309]
+LL | | }
+   | |_^
 
-error[E0491]: in type `&'a &'b T`, reference has a longer lifetime than the data it references
-  --> $DIR/regions-enum-not-wf.rs:34:23
-   |
-LL |     RefDoubleVariant1(&'a &'b T)
-   |                       ^^^^^^^^^
+error[E0309]: the parameter type `T` may not live long enough
+  --> $DIR/regions-enum-not-wf.rs:46:23
    |
-note: the pointer is valid for the lifetime 'a as defined on the enum at 33:16
-  --> $DIR/regions-enum-not-wf.rs:33:16
+LL | enum RefDouble<'a, 'b, T> { //~ ERROR 45:1: 48:2: the parameter type `T` may not live long enough [E0309]
+   |                        - help: consider adding an explicit lifetime bound `T: 'b`...
+LL |     RefDoubleVariant1(&'a RequireOutlives<'b, T>)
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-LL | enum RefDouble<'a, 'b, T> {
-   |                ^^
-note: but the referenced data is only valid for the lifetime 'b as defined on the enum at 33:20
-  --> $DIR/regions-enum-not-wf.rs:33:20
+note: ...so that the type `T` will meet its required lifetime bounds
+  --> $DIR/regions-enum-not-wf.rs:46:23
    |
-LL | enum RefDouble<'a, 'b, T> {
-   |                    ^^
+LL |     RefDoubleVariant1(&'a RequireOutlives<'b, T>)
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 4 previous errors
 
-Some errors occurred: E0309, E0491.
-For more information about an error, try `rustc --explain E0309`.
+For more information about this error, try `rustc --explain E0309`.

src/test/ui/regions/regions-outlives-nominal-type-enum-region-rev.rs

@@ -13,6 +13,8 @@
 //
 // Rule OutlivesNominalType from RFC 1214.
 
+// compile-pass
+
 #![feature(rustc_attrs)]
 #![allow(dead_code)]
 
@@ -21,9 +23,8 @@ struct Foo<'a> {
         x: fn(&'a i32),
     }
     enum Bar<'a,'b> {
-        V(&'a Foo<'b>) //~ ERROR reference has a longer lifetime
+        V(&'a Foo<'b>)
     }
 }
 
-#[rustc_error]
 fn main() { }

src/test/ui/regions/regions-outlives-nominal-type-enum-region.rs

@@ -13,6 +13,8 @@
 //
 // Rule OutlivesNominalType from RFC 1214.
 
+// compile-pass
+
 #![feature(rustc_attrs)]
 #![allow(dead_code)]
 
@@ -21,9 +23,8 @@ struct Foo<'a> {
         x: &'a i32,
     }
     enum Bar<'a,'b> {
-        V(&'a Foo<'b>) //~ ERROR reference has a longer lifetime
+        V(&'a Foo<'b>)
     }
 }
 
-#[rustc_error]
 fn main() { }

src/test/ui/regions/regions-outlives-nominal-type-enum-type-rev.rs

@@ -13,17 +13,18 @@
 //
 // Rule OutlivesNominalType from RFC 1214.
 
+//compile-pass
+
 #![feature(rustc_attrs)]
 #![allow(dead_code)]
 
-mod rev_variant_struct_type {
+mod variant_struct_type {
     struct Foo<T> {
         x: fn(T)
     }
     enum Bar<'a,'b> {
-        V(&'a Foo<&'b i32>) //~ ERROR reference has a longer lifetime
+        V(&'a Foo<&'b i32>)
     }
 }
 
-#[rustc_error]
 fn main() { }

src/test/ui/regions/regions-outlives-nominal-type-enum-type-rev.stderr

-error[E0491]: in type `&'a rev_variant_struct_type::Foo<&'b i32>`, reference has a longer lifetime than the data it references
-  --> $DIR/regions-outlives-nominal-type-enum-type-rev.rs:24:11
-   |
-LL |         V(&'a Foo<&'b i32>) //~ ERROR reference has a longer lifetime
-   |           ^^^^^^^^^^^^^^^^
-   |
-note: the pointer is valid for the lifetime 'a as defined on the enum at 23:14
-  --> $DIR/regions-outlives-nominal-type-enum-type-rev.rs:23:14
-   |
-LL |     enum Bar<'a,'b> {
-   |              ^^
-note: but the referenced data is only valid for the lifetime 'b as defined on the enum at 23:17
-  --> $DIR/regions-outlives-nominal-type-enum-type-rev.rs:23:17
-   |
-LL |     enum Bar<'a,'b> {
-   |                 ^^
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0491`.

src/test/ui/regions/regions-outlives-nominal-type-enum-type.rs

@@ -13,6 +13,8 @@
 //
 // Rule OutlivesNominalType from RFC 1214.
 
+// compile-pass
+
 #![feature(rustc_attrs)]
 #![allow(dead_code)]
 
@@ -21,9 +23,8 @@ struct Foo<T> {
         x: T
     }
     enum Bar<'a,'b> {
-        F(&'a Foo<&'b i32>) //~ ERROR reference has a longer lifetime
+        V(&'a Foo<&'b i32>)
     }
 }
 
-#[rustc_error]
 fn main() { }

src/test/ui/regions/regions-outlives-nominal-type-struct-region-rev.rs

@@ -13,6 +13,8 @@
 //
 // Rule OutlivesNominalType from RFC 1214.
 
+// compile-pass
+
 #![feature(rustc_attrs)]
 #![allow(dead_code)]
 
@@ -21,9 +23,8 @@ struct Foo<'a> {
         x: fn(&'a i32),
     }
     struct Bar<'a,'b> {
-        f: &'a Foo<'b> //~ ERROR reference has a longer lifetime
+        f: &'a Foo<'b>
     }
 }
 
-#[rustc_error]
 fn main() { }

src/test/ui/regions/regions-outlives-nominal-type-struct-region-rev.stderr

-error[E0491]: in type `&'a rev_variant_struct_region::Foo<'b>`, reference has a longer lifetime than the data it references
-  --> $DIR/regions-outlives-nominal-type-struct-region-rev.rs:24:9
-   |
-LL |         f: &'a Foo<'b> //~ ERROR reference has a longer lifetime
-   |         ^^^^^^^^^^^^^^
-   |
-note: the pointer is valid for the lifetime 'a as defined on the struct at 23:16
-  --> $DIR/regions-outlives-nominal-type-struct-region-rev.rs:23:16
-   |
-LL |     struct Bar<'a,'b> {
-   |                ^^
-note: but the referenced data is only valid for the lifetime 'b as defined on the struct at 23:19
-  --> $DIR/regions-outlives-nominal-type-struct-region-rev.rs:23:19
-   |
-LL |     struct Bar<'a,'b> {
-   |                   ^^
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0491`.

src/test/ui/regions/regions-outlives-nominal-type-struct-region.rs

@@ -13,6 +13,8 @@
 //
 // Rule OutlivesNominalType from RFC 1214.
 
+// compile-pass
+
 #![feature(rustc_attrs)]
 #![allow(dead_code)]
 
@@ -25,5 +27,4 @@ struct Bar<'a,'b> {
     }
 }
 
-#[rustc_error]
 fn main() { }

src/test/ui/regions/regions-outlives-nominal-type-struct-region.stderr

-error[E0491]: in type `&'a variant_struct_region::Foo<'b>`, reference has a longer lifetime than the data it references
-  --> $DIR/regions-outlives-nominal-type-struct-region.rs:24:9
-   |
-LL |         f: &'a Foo<'b> //~ ERROR reference has a longer lifetime
-   |         ^^^^^^^^^^^^^^
-   |
-note: the pointer is valid for the lifetime 'a as defined on the struct at 23:16
-  --> $DIR/regions-outlives-nominal-type-struct-region.rs:23:16
-   |
-LL |     struct Bar<'a,'b> {
-   |                ^^
-note: but the referenced data is only valid for the lifetime 'b as defined on the struct at 23:19
-  --> $DIR/regions-outlives-nominal-type-struct-region.rs:23:19
-   |
-LL |     struct Bar<'a,'b> {
-   |                   ^^
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0491`.

src/test/ui/regions/regions-outlives-nominal-type-struct-type-rev.rs

@@ -13,6 +13,8 @@
 //
 // Rule OutlivesNominalType from RFC 1214.
 
+// compile-pass
+
 #![feature(rustc_attrs)]
 #![allow(dead_code)]
 
@@ -25,5 +27,4 @@ struct Bar<'a,'b> {
     }
 }
 
-#[rustc_error]
 fn main() { }

src/test/ui/regions/regions-outlives-nominal-type-struct-type-rev.stderr

-error[E0491]: in type `&'a rev_variant_struct_type::Foo<&'b i32>`, reference has a longer lifetime than the data it references
-  --> $DIR/regions-outlives-nominal-type-struct-type-rev.rs:24:9
-   |
-LL |         f: &'a Foo<&'b i32> //~ ERROR reference has a longer lifetime
-   |         ^^^^^^^^^^^^^^^^^^^
-   |
-note: the pointer is valid for the lifetime 'a as defined on the struct at 23:16
-  --> $DIR/regions-outlives-nominal-type-struct-type-rev.rs:23:16
-   |
-LL |     struct Bar<'a,'b> {
-   |                ^^
-note: but the referenced data is only valid for the lifetime 'b as defined on the struct at 23:19
-  --> $DIR/regions-outlives-nominal-type-struct-type-rev.rs:23:19
-   |
-LL |     struct Bar<'a,'b> {
-   |                   ^^
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0491`.

src/test/ui/regions/regions-outlives-nominal-type-struct-type.rs

@@ -13,6 +13,8 @@
 //
 // Rule OutlivesNominalType from RFC 1214.
 
+// compile-pass
+
 #![feature(rustc_attrs)]
 #![allow(dead_code)]
 
@@ -25,5 +27,4 @@ struct Bar<'a,'b> {
     }
 }
 
-#[rustc_error]
 fn main() { }

src/test/ui/regions/regions-struct-not-wf.rs

@@ -10,31 +10,29 @@
 
 // Various examples of structs whose fields are not well-formed.
 
-// revisions:lexical nll
-
 #![allow(dead_code)]
-#![cfg_attr(nll, feature(nll))]
 
-struct Ref<'a, T> {
-    field: &'a T
-        //[lexical]~^ ERROR the parameter type `T` may not live long enough
-        //[nll]~^^ ERROR the parameter type `T` may not live long enough
+trait Trait<'a, T> {
+    type Out;
+}
+trait Trait1<'a, 'b, T> {
+    type Out;
+}
+
+impl<'a, T> Trait<'a, T> for usize {
+    type Out = &'a T;
 }
 
 struct RefOk<'a, T:'a> {
     field: &'a T
 }
 
-struct RefIndirect<'a, T> {
-    field: RefOk<'a, T>
-        //[lexical]~^ ERROR the parameter type `T` may not live long enough
-        //[nll]~^^ ERROR the parameter type `T` may not live long enough
+impl<'a, T> Trait<'a, T> for u32 {
+    type Out = RefOk<'a, T>;
 }
 
-struct DoubleRef<'a, 'b, T> {
-    field: &'a &'b T
-        //[lexical]~^ ERROR reference has a longer lifetime than the data it references
-        //[nll]~^^ ERROR reference has a longer lifetime than the data it references
+impl<'a, 'b, T> Trait1<'a, 'b, T> for u32 {
+    type Out = &'a &'b T;
 }
 
 fn main() { }

src/test/ui/regions/regions-struct-not-wf.lexical.stderr → src/test/ui/regions/regions-struct-not-wf.stderr

 error[E0309]: the parameter type `T` may not live long enough
-  --> $DIR/regions-struct-not-wf.rs:19:5
+  --> $DIR/regions-struct-not-wf.rs:23:5
    |
-LL | struct Ref<'a, T> {
-   |                - help: consider adding an explicit lifetime bound `T: 'a`...
-LL |     field: &'a T
-   |     ^^^^^^^^^^^^
+LL | impl<'a, T> Trait<'a, T> for usize {
+   |          - help: consider adding an explicit lifetime bound `T: 'a`...
+LL |     type Out = &'a T;
+   |     ^^^^^^^^^^^^^^^^^
    |
 note: ...so that the reference type `&'a T` does not outlive the data it points at
-  --> $DIR/regions-struct-not-wf.rs:19:5
+  --> $DIR/regions-struct-not-wf.rs:23:5
    |
-LL |     field: &'a T
-   |     ^^^^^^^^^^^^
+LL |     type Out = &'a T;
+   |     ^^^^^^^^^^^^^^^^^
 
 error[E0309]: the parameter type `T` may not live long enough
-  --> $DIR/regions-struct-not-wf.rs:29:5
+  --> $DIR/regions-struct-not-wf.rs:31:5
    |
-LL | struct RefIndirect<'a, T> {
-   |                        - help: consider adding an explicit lifetime bound `T: 'a`...
-LL |     field: RefOk<'a, T>
-   |     ^^^^^^^^^^^^^^^^^^^
+LL | impl<'a, T> Trait<'a, T> for u32 {
+   |          - help: consider adding an explicit lifetime bound `T: 'a`...
+LL |     type Out = RefOk<'a, T>;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: ...so that the type `T` will meet its required lifetime bounds
-  --> $DIR/regions-struct-not-wf.rs:29:5
+  --> $DIR/regions-struct-not-wf.rs:31:5
    |
-LL |     field: RefOk<'a, T>
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |     type Out = RefOk<'a, T>;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0491]: in type `&'a &'b T`, reference has a longer lifetime than the data it references
   --> $DIR/regions-struct-not-wf.rs:35:5
    |
-LL |     field: &'a &'b T
-   |     ^^^^^^^^^^^^^^^^
+LL |     type Out = &'a &'b T;
+   |     ^^^^^^^^^^^^^^^^^^^^^
    |
-note: the pointer is valid for the lifetime 'a as defined on the struct at 34:18
-  --> $DIR/regions-struct-not-wf.rs:34:18
+note: the pointer is valid for the lifetime 'a as defined on the impl at 34:6
+  --> $DIR/regions-struct-not-wf.rs:34:6
    |
-LL | struct DoubleRef<'a, 'b, T> {
-   |                  ^^
-note: but the referenced data is only valid for the lifetime 'b as defined on the struct at 34:22
-  --> $DIR/regions-struct-not-wf.rs:34:22
+LL | impl<'a, 'b, T> Trait1<'a, 'b, T> for u32 {
+   |      ^^
+note: but the referenced data is only valid for the lifetime 'b as defined on the impl at 34:10
+  --> $DIR/regions-struct-not-wf.rs:34:10
    |
-LL | struct DoubleRef<'a, 'b, T> {
-   |                      ^^
+LL | impl<'a, 'b, T> Trait1<'a, 'b, T> for u32 {
+   |          ^^
 
 error: aborting due to 3 previous errors
 

src/test/ui/rfc-2093-infer-outlives/cross-crate.rs

@@ -9,10 +9,9 @@
 // except according to those terms.
 
 #![feature(rustc_attrs)]
-#![feature(infer_outlives_requirements)]
 
 #[rustc_outlives]
-struct Foo<'a, T> { //~ ERROR 15:1: 17:2: rustc_outlives
+struct Foo<'a, T> { //~ ERROR 14:1: 16:2: rustc_outlives
     bar: std::slice::IterMut<'a, T>
 }
 

src/test/ui/rfc-2093-infer-outlives/cross-crate.stderr

 error: rustc_outlives
-  --> $DIR/cross-crate.rs:15:1
+  --> $DIR/cross-crate.rs:14:1
    |
-LL | / struct Foo<'a, T> { //~ ERROR 15:1: 17:2: rustc_outlives
+LL | / struct Foo<'a, T> { //~ ERROR 14:1: 16:2: rustc_outlives
 LL | |     bar: std::slice::IterMut<'a, T>
 LL | | }
    | |_^

src/test/ui/rfc-2093-infer-outlives/dont-infer-static.rs

@@ -10,8 +10,6 @@
 
 // ignore-tidy-linelength
 
-#![feature(infer_outlives_requirements)]
-
 /*
  * We don't infer `T: 'static` outlives relationships by default.
  * Instead an additional feature gate `infer_static_outlives_requirements`
@@ -19,7 +17,7 @@
  */
 
 struct Foo<U> {
-    bar: Bar<U> //~ ERROR 22:5: 22:16: the parameter type `U` may not live long enough [E0310]
+    bar: Bar<U> //~ ERROR 20:5: 20:16: the parameter type `U` may not live long enough [E0310]
 }
 struct Bar<T: 'static> {
     x: T,

src/test/ui/rfc-2093-infer-outlives/dont-infer-static.stderr

 error[E0310]: the parameter type `U` may not live long enough
-  --> $DIR/dont-infer-static.rs:22:5
+  --> $DIR/dont-infer-static.rs:20:5
    |
 LL | struct Foo<U> {
    |            - help: consider adding an explicit lifetime bound `U: 'static`...
-LL |     bar: Bar<U> //~ ERROR 22:5: 22:16: the parameter type `U` may not live long enough [E0310]
+LL |     bar: Bar<U> //~ ERROR 20:5: 20:16: the parameter type `U` may not live long enough [E0310]
    |     ^^^^^^^^^^^
    |
 note: ...so that the type `U` will meet its required lifetime bounds
-  --> $DIR/dont-infer-static.rs:22:5
+  --> $DIR/dont-infer-static.rs:20:5
    |
-LL |     bar: Bar<U> //~ ERROR 22:5: 22:16: the parameter type `U` may not live long enough [E0310]
+LL |     bar: Bar<U> //~ ERROR 20:5: 20:16: the parameter type `U` may not live long enough [E0310]
    |     ^^^^^^^^^^^
 
 error: aborting due to previous error

src/test/ui/rfc-2093-infer-outlives/enum.rs

@@ -10,24 +10,26 @@
 
 // ignore-tidy-linelength
 
+#![feature(rustc_attrs)]
+
 // Needs an explicit where clause stating outlives condition. (RFC 2093)
 
 // Type T needs to outlive lifetime 'a.
-enum Foo<'a, T> {
-
+#[rustc_outlives]
+enum Foo<'a, T> { //~ ERROR rustc_outlives
     One(Bar<'a, T>)
 }
 
 // Type U needs to outlive lifetime 'b
-struct Bar<'b, U> {
-    field2: &'b U //~ ERROR the parameter type `U` may not live long enough [E0309]
+#[rustc_outlives]
+struct Bar<'b, U> { //~ ERROR rustc_outlives
+    field2: &'b U
 }
 
-
-
 // Type K needs to outlive lifetime 'c.
-enum Ying<'c, K> {
-    One(&'c Yang<K>) //~ ERROR the parameter type `K` may not live long enough [E0309]
+#[rustc_outlives]
+enum Ying<'c, K> { //~ ERROR rustc_outlives
+    One(&'c Yang<K>)
 }
 
 struct Yang<V> {

src/test/ui/rfc-2093-infer-outlives/enum.stderr

-error[E0309]: the parameter type `U` may not live long enough
-  --> $DIR/enum.rs:23:5
+error: rustc_outlives
+  --> $DIR/enum.rs:19:1
    |
-LL | struct Bar<'b, U> {
-   |                - help: consider adding an explicit lifetime bound `U: 'b`...
-LL |     field2: &'b U //~ ERROR the parameter type `U` may not live long enough [E0309]
-   |     ^^^^^^^^^^^^^
+LL | / enum Foo<'a, T> { //~ ERROR rustc_outlives
+LL | |     One(Bar<'a, T>)
+LL | | }
+   | |_^
    |
-note: ...so that the reference type `&'b U` does not outlive the data it points at
-  --> $DIR/enum.rs:23:5
-   |
-LL |     field2: &'b U //~ ERROR the parameter type `U` may not live long enough [E0309]
-   |     ^^^^^^^^^^^^^
+   = note: T : 'a
 
-error[E0309]: the parameter type `K` may not live long enough
-  --> $DIR/enum.rs:30:9
+error: rustc_outlives
+  --> $DIR/enum.rs:25:1
+   |
+LL | / struct Bar<'b, U> { //~ ERROR rustc_outlives
+LL | |     field2: &'b U
+LL | | }
+   | |_^
    |
-LL | enum Ying<'c, K> {
-   |               - help: consider adding an explicit lifetime bound `K: 'c`...
-LL |     One(&'c Yang<K>) //~ ERROR the parameter type `K` may not live long enough [E0309]
-   |         ^^^^^^^^^^^
+   = note: U : 'b
+
+error: rustc_outlives
+  --> $DIR/enum.rs:31:1
    |
-note: ...so that the reference type `&'c Yang<K>` does not outlive the data it points at
-  --> $DIR/enum.rs:30:9
+LL | / enum Ying<'c, K> { //~ ERROR rustc_outlives
+LL | |     One(&'c Yang<K>)
+LL | | }
+   | |_^
    |
-LL |     One(&'c Yang<K>) //~ ERROR the parameter type `K` may not live long enough [E0309]
-   |         ^^^^^^^^^^^
+   = note: K : 'c
 
-error: aborting due to 2 previous errors
+error: aborting due to 3 previous errors
 
-For more information about this error, try `rustc --explain E0309`.

src/test/ui/rfc-2093-infer-outlives/explicit-dyn.rs

@@ -10,13 +10,12 @@
 
 #![feature(dyn_trait)]
 #![feature(rustc_attrs)]
-#![feature(infer_outlives_requirements)]
 
 trait Trait<'x, T> where T: 'x {
 }
 
 #[rustc_outlives]
-struct Foo<'a, A> //~ ERROR 19:1: 22:2: rustc_outlives
+struct Foo<'a, A> //~ ERROR 18:1: 21:2: rustc_outlives
 {
     foo: Box<dyn Trait<'a, A>>
 }

src/test/ui/rfc-2093-infer-outlives/explicit-dyn.stderr

 error: rustc_outlives
-  --> $DIR/explicit-dyn.rs:19:1
+  --> $DIR/explicit-dyn.rs:18:1
    |
-LL | / struct Foo<'a, A> //~ ERROR 19:1: 22:2: rustc_outlives
+LL | / struct Foo<'a, A> //~ ERROR 18:1: 21:2: rustc_outlives
 LL | | {
 LL | |     foo: Box<dyn Trait<'a, A>>
 LL | | }

src/test/ui/rfc-2093-infer-outlives/explicit-enum.rs

@@ -9,10 +9,9 @@
 // except according to those terms.
 
 #![feature(rustc_attrs)]
-#![feature(infer_outlives_requirements)]
 
 #[rustc_outlives]
-enum Foo<'a, U> { //~ ERROR 15:1: 17:2: rustc_outlives
+enum Foo<'a, U> { //~ ERROR 14:1: 16:2: rustc_outlives
     One(Bar<'a, U>)
 }
 

src/test/ui/rfc-2093-infer-outlives/explicit-enum.stderr

 error: rustc_outlives
-  --> $DIR/explicit-enum.rs:15:1
+  --> $DIR/explicit-enum.rs:14:1
    |
-LL | / enum Foo<'a, U> { //~ ERROR 15:1: 17:2: rustc_outlives
+LL | / enum Foo<'a, U> { //~ ERROR 14:1: 16:2: rustc_outlives
 LL | |     One(Bar<'a, U>)
 LL | | }
    | |_^

src/test/ui/rfc-2093-infer-outlives/explicit-projection.rs

@@ -9,7 +9,6 @@
 // except according to those terms.
 
 #![feature(rustc_attrs)]
-#![feature(infer_outlives_requirements)]
 
 trait Trait<'x, T> where T: 'x {
     type Type;

src/test/ui/rfc-2093-infer-outlives/explicit-projection.stderr

 error: rustc_outlives
-  --> $DIR/explicit-projection.rs:19:1
+  --> $DIR/explicit-projection.rs:18:1
    |
 LL | / struct Foo<'a, A, B> where A: Trait<'a, B> //~ ERROR rustc_outlives
 LL | | {

src/test/ui/rfc-2093-infer-outlives/explicit-struct.rs

@@ -9,10 +9,9 @@
 // except according to those terms.
 
 #![feature(rustc_attrs)]
-#![feature(infer_outlives_requirements)]
 
 #[rustc_outlives]
-struct Foo<'b, U> { //~ ERROR 15:1: 17:2: rustc_outlives
+struct Foo<'b, U> { //~ ERROR 14:1: 16:2: rustc_outlives
     bar: Bar<'b, U>
 }
 

src/test/ui/rfc-2093-infer-outlives/explicit-struct.stderr

 error: rustc_outlives
-  --> $DIR/explicit-struct.rs:15:1
+  --> $DIR/explicit-struct.rs:14:1
    |
-LL | / struct Foo<'b, U> { //~ ERROR 15:1: 17:2: rustc_outlives
+LL | / struct Foo<'b, U> { //~ ERROR 14:1: 16:2: rustc_outlives
 LL | |     bar: Bar<'b, U>
 LL | | }
    | |_^

src/test/ui/rfc-2093-infer-outlives/explicit-union.rs

@@ -9,13 +9,11 @@
 // except according to those terms.
 
 #![feature(rustc_attrs)]
-#![feature(infer_outlives_requirements)]
 #![feature(untagged_unions)]
 #![allow(unions_with_drop_fields)]
 
-
 #[rustc_outlives]
-union Foo<'b, U> { //~ ERROR 18:1: 20:2: rustc_outlives
+union Foo<'b, U> { //~ ERROR 16:1: 18:2: rustc_outlives
     bar: Bar<'b, U>
 }
 

src/test/ui/rfc-2093-infer-outlives/explicit-union.stderr

 error: rustc_outlives
-  --> $DIR/explicit-union.rs:18:1
+  --> $DIR/explicit-union.rs:16:1
    |
-LL | / union Foo<'b, U> { //~ ERROR 18:1: 20:2: rustc_outlives
+LL | / union Foo<'b, U> { //~ ERROR 16:1: 18:2: rustc_outlives
 LL | |     bar: Bar<'b, U>
 LL | | }
    | |_^

src/test/ui/rfc-2093-infer-outlives/infer-static.rs

@@ -9,11 +9,10 @@
 // except according to those terms.
 
 #![feature(rustc_attrs)]
-#![feature(infer_outlives_requirements)]
 #![feature(infer_static_outlives_requirements)]
 
 #[rustc_outlives]
-struct Foo<U> { //~ ERROR 16:1: 18:2: rustc_outlives
+struct Foo<U> { //~ ERROR 15:1: 17:2: rustc_outlives
     bar: Bar<U>
 }
 struct Bar<T: 'static> {

src/test/ui/rfc-2093-infer-outlives/infer-static.stderr

 error: rustc_outlives
-  --> $DIR/infer-static.rs:16:1
+  --> $DIR/infer-static.rs:15:1
    |
-LL | / struct Foo<U> { //~ ERROR 16:1: 18:2: rustc_outlives
+LL | / struct Foo<U> { //~ ERROR 15:1: 17:2: rustc_outlives
 LL | |     bar: Bar<U>
 LL | | }
    | |_^

src/test/ui/rfc-2093-infer-outlives/nested-enum.rs

@@ -9,11 +9,9 @@
 // except according to those terms.
 
 #![feature(rustc_attrs)]
-#![feature(infer_outlives_requirements)]
-
 
 #[rustc_outlives]
-enum Foo<'a, T> { //~ ERROR 16:1: 19:2: rustc_outlives
+enum Foo<'a, T> { //~ ERROR 14:1: 17:2: rustc_outlives
 
     One(Bar<'a, T>)
 }