Treat weak alias types more like ADTs when computing implied bounds

fmease · fmease · commit c5165ba850b7 · 2024-03-11T19:20:53.000+01:00
diff --git a/compiler/rustc_hir_analysis/src/outlives/utils.rs b/compiler/rustc_hir_analysis/src/outlives/utils.rs
@@ -21,7 +21,7 @@ pub(crate) fn insert_outlives_predicate<'tcx>(
 ) {
     // If the `'a` region is bound within the field type itself, we
     // don't want to propagate this constraint to the header.
-    if !is_free_region(outlived_region) {
+    if !is_early_bound_region(outlived_region) {
         return;
     }
 
@@ -132,7 +132,7 @@ pub(crate) fn insert_outlives_predicate<'tcx>(
         }
 
         GenericArgKind::Lifetime(r) => {
-            if !is_free_region(r) {
+            if !is_early_bound_region(r) {
                 return;
             }
             required_predicates.entry(ty::OutlivesPredicate(kind, outlived_region)).or_insert(span);
@@ -144,7 +144,7 @@ pub(crate) fn insert_outlives_predicate<'tcx>(
     }
 }
 
-fn is_free_region(region: Region<'_>) -> bool {
+fn is_early_bound_region(region: Region<'_>) -> bool {
     // First, screen for regions that might appear in a type header.
     match *region {
         // These correspond to `T: 'a` relationships:
diff --git a/compiler/rustc_infer/src/infer/outlives/components.rs b/compiler/rustc_infer/src/infer/outlives/components.rs
@@ -138,7 +138,7 @@ fn compute_components<'tcx>(
             // trait-ref. Therefore, if we see any higher-ranked regions,
             // we simply fallback to the most restrictive rule, which
             // requires that `Pi: 'a` for all `i`.
-            ty::Alias(_, alias_ty) => {
+            ty::Alias(ty::Projection | ty::Inherent | ty::Opaque, alias_ty) => {
                 if !alias_ty.has_escaping_bound_vars() {
                     // best case: no escaping regions, so push the
                     // projection and skip the subtree (thus generating no
@@ -171,21 +171,22 @@ fn compute_components<'tcx>(
             // the type and then visits the types that are lexically
             // contained within. (The comments refer to relevant rules
             // from RFC1214.)
-            ty::Bool |            // OutlivesScalar
-            ty::Char |            // OutlivesScalar
-            ty::Int(..) |         // OutlivesScalar
-            ty::Uint(..) |        // OutlivesScalar
-            ty::Float(..) |       // OutlivesScalar
-            ty::Never |           // ...
-            ty::Adt(..) |         // OutlivesNominalType
-            ty::Foreign(..) |     // OutlivesNominalType
-            ty::Str |             // OutlivesScalar (ish)
-            ty::Slice(..) |       // ...
-            ty::RawPtr(..) |      // ...
-            ty::Ref(..) |         // OutlivesReference
-            ty::Tuple(..) |       // ...
-            ty::FnPtr(_) |        // OutlivesFunction (*)
-            ty::Dynamic(..) |     // OutlivesObject, OutlivesFragment (*)
+            ty::Bool |               // OutlivesScalar
+            ty::Char |               // OutlivesScalar
+            ty::Int(..) |            // OutlivesScalar
+            ty::Uint(..) |           // OutlivesScalar
+            ty::Float(..) |          // OutlivesScalar
+            ty::Never |              // ...
+            ty::Adt(..) |            // OutlivesNominalType
+            ty::Alias(ty::Weak, _) | // OutlivesNominalType (ish)
+            ty::Foreign(..) |        // OutlivesNominalType
+            ty::Str |                // OutlivesScalar (ish)
+            ty::Slice(..) |          // ...
+            ty::RawPtr(..) |         // ...
+            ty::Ref(..) |            // OutlivesReference
+            ty::Tuple(..) |          // ...
+            ty::FnPtr(_) |           // OutlivesFunction (*)
+            ty::Dynamic(..) |        // OutlivesObject, OutlivesFragment (*)
             ty::Bound(..) |
             ty::Error(_) => {
                 // (*) Function pointers and trait objects are both binders.
diff --git a/tests/ui/lazy-type-alias/implied-outlives-bounds-1.print.stderr b/tests/ui/lazy-type-alias/implied-outlives-bounds-1.print.stderr
@@ -0,0 +1,11 @@
+error: rustc_outlives
+  --> $DIR/implied-outlives-bounds-1.rs:16:1
+   |
+LL | struct Type<'a, K, V>(&'a mut Alias<K, V>);
+   | ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: K: 'a
+   = note: V: 'a
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/lazy-type-alias/implied-outlives-bounds-1.rs b/tests/ui/lazy-type-alias/implied-outlives-bounds-1.rs
@@ -0,0 +1,20 @@
+// Check that we infer the outlives-predicates `K: 'a`, `V: 'a` for `Type`
+// from the weak alias `Alias`.
+// This mirrors the behavior of ADTs instead of other kinds of alias types
+// like projections and opaque types.
+// If we were to mirror the semantics of the latter, we would infer the
+// outlives-predicate `Alias<K, V>: 'a` instead which is not what we want.
+
+//@ revisions: default print
+//@[default] check-pass
+
+#![feature(lazy_type_alias)]
+#![cfg_attr(print, feature(rustc_attrs))]
+#![allow(incomplete_features)]
+
+#[cfg_attr(print, rustc_outlives)]
+struct Type<'a, K, V>(&'a mut Alias<K, V>); //[print]~ ERROR rustc_outlives
+
+type Alias<K, V> = (K, V);
+
+fn main() {}
diff --git a/tests/ui/type-alias-impl-trait/implied_lifetime_wf_check3.rs b/tests/ui/type-alias-impl-trait/implied_lifetime_wf_check3.rs
@@ -5,7 +5,6 @@ mod test_lifetime_param {
     fn defining(a: &str) -> Ty<'_> { a }
     fn assert_static<'a: 'static>() {}
     fn test<'a>() where Ty<'a>: 'static { assert_static::<'a>() }
-    //~^ ERROR: lifetime may not live long enough
 }
 
 mod test_higher_kinded_lifetime_param {
@@ -27,7 +26,6 @@ mod test_type_param {
     fn defining<A>(s: A) -> Ty<A> { s }
     fn assert_static<A: 'static>() {}
     fn test<A>() where Ty<A>: 'static { assert_static::<A>() }
-    //~^ ERROR: parameter type `A` may not live long enough
 }
 
 mod test_implied_from_fn_sig {
diff --git a/tests/ui/type-alias-impl-trait/implied_lifetime_wf_check3.stderr b/tests/ui/type-alias-impl-trait/implied_lifetime_wf_check3.stderr
@@ -1,37 +1,16 @@
 error: lifetime may not live long enough
-  --> $DIR/implied_lifetime_wf_check3.rs:7:43
-   |
-LL |     fn test<'a>() where Ty<'a>: 'static { assert_static::<'a>() }
-   |             -- lifetime `'a` defined here ^^^^^^^^^^^^^^^^^^^ requires that `'a` must outlive `'static`
-
-error: lifetime may not live long enough
-  --> $DIR/implied_lifetime_wf_check3.rs:15:46
+  --> $DIR/implied_lifetime_wf_check3.rs:14:46
    |
 LL |     fn test<'a>() where for<'b> Ty<'b>: 'a { assert_static::<'a>() }
    |             -- lifetime `'a` defined here    ^^^^^^^^^^^^^^^^^^^ requires that `'a` must outlive `'static`
 
 error: lifetime may not live long enough
-  --> $DIR/implied_lifetime_wf_check3.rs:21:21
+  --> $DIR/implied_lifetime_wf_check3.rs:20:21
    |
 LL |     fn test<'a>() { assert_static::<'a>() }
    |             --      ^^^^^^^^^^^^^^^^^^^ requires that `'a` must outlive `'static`
    |             |
    |             lifetime `'a` defined here
 
-error[E0310]: the parameter type `A` may not live long enough
-  --> $DIR/implied_lifetime_wf_check3.rs:29:41
-   |
-LL |     fn test<A>() where Ty<A>: 'static { assert_static::<A>() }
-   |                                         ^^^^^^^^^^^^^^^^^^
-   |                                         |
-   |                                         the parameter type `A` must be valid for the static lifetime...
-   |                                         ...so that the type `A` will meet its required lifetime bounds
-   |
-help: consider adding an explicit lifetime bound
-   |
-LL |     fn test<A: 'static>() where Ty<A>: 'static { assert_static::<A>() }
-   |              +++++++++
-
-error: aborting due to 4 previous errors
+error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0310`.
diff --git a/tests/ui/type-alias-impl-trait/implied_lifetime_wf_check4_static.rs b/tests/ui/type-alias-impl-trait/implied_lifetime_wf_check4_static.rs
@@ -6,7 +6,6 @@ mod test_type_param_static {
     fn defining<A: 'static>(s: A) -> Ty<A> { s }
     fn assert_static<A: 'static>() {}
     fn test<A>() where Ty<A>: 'static { assert_static::<A>() }
-    //~^ ERROR: the parameter type `A` may not live long enough
 }
 
 fn main() {}
diff --git a/tests/ui/type-alias-impl-trait/implied_lifetime_wf_check4_static.stderr b/tests/ui/type-alias-impl-trait/implied_lifetime_wf_check4_static.stderr
@@ -12,20 +12,6 @@ help: consider adding an explicit lifetime bound
 LL |     type Ty<A: 'static> = impl Sized + 'static;
    |              +++++++++
 
-error[E0310]: the parameter type `A` may not live long enough
-  --> $DIR/implied_lifetime_wf_check4_static.rs:8:41
-   |
-LL |     fn test<A>() where Ty<A>: 'static { assert_static::<A>() }
-   |                                         ^^^^^^^^^^^^^^^^^^
-   |                                         |
-   |                                         the parameter type `A` must be valid for the static lifetime...
-   |                                         ...so that the type `A` will meet its required lifetime bounds
-   |
-help: consider adding an explicit lifetime bound
-   |
-LL |     fn test<A: 'static>() where Ty<A>: 'static { assert_static::<A>() }
-   |              +++++++++
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0310`.

Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ pub(crate) fn insert_outlives_predicate<'tcx>(`
`21`	`21`	`) {`
`22`	`22`	// If the `'a` region is bound within the field type itself, we
`23`	`23`	`// don't want to propagate this constraint to the header.`
`24`		`- if !is_free_region(outlived_region) {`
	`24`	`+ if !is_early_bound_region(outlived_region) {`
`25`	`25`	`return;`
`26`	`26`	`}`
`27`	`27`
`@@ -132,7 +132,7 @@ pub(crate) fn insert_outlives_predicate<'tcx>(`
`132`	`132`	`}`
`133`	`133`
`134`	`134`	`GenericArgKind::Lifetime(r) => {`
`135`		`- if !is_free_region(r) {`
	`135`	`+ if !is_early_bound_region(r) {`
`136`	`136`	`return;`
`137`	`137`	`}`
`138`	`138`	`required_predicates.entry(ty::OutlivesPredicate(kind, outlived_region)).or_insert(span);`
`@@ -144,7 +144,7 @@ pub(crate) fn insert_outlives_predicate<'tcx>(`
`144`	`144`	`}`
`145`	`145`	`}`
`146`	`146`
`147`		`-fn is_free_region(region: Region<'_>) -> bool {`
	`147`	`+fn is_early_bound_region(region: Region<'_>) -> bool {`
`148`	`148`	`// First, screen for regions that might appear in a type header.`
`149`	`149`	`match *region {`
`150`	`150`	// These correspond to `T: 'a` relationships:
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,6 @@ mod test_lifetime_param {`
`5`	`5`	`fn defining(a: &str) -> Ty<'_> { a }`
`6`	`6`	`fn assert_static<'a: 'static>() {}`
`7`	`7`	`fn test<'a>() where Ty<'a>: 'static { assert_static::<'a>() }`
`8`		`- //~^ ERROR: lifetime may not live long enough`
`9`	`8`	`}`
`10`	`9`
`11`	`10`	`mod test_higher_kinded_lifetime_param {`
`@@ -27,7 +26,6 @@ mod test_type_param {`
`27`	`26`	`fn defining<A>(s: A) -> Ty<A> { s }`
`28`	`27`	`fn assert_static<A: 'static>() {}`
`29`	`28`	`fn test<A>() where Ty<A>: 'static { assert_static::<A>() }`
`30`		- //~^ ERROR: parameter type `A` may not live long enough
`31`	`29`	`}`
`32`	`30`
`33`	`31`	`mod test_implied_from_fn_sig {`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,6 @@ mod test_type_param_static {`
`6`	`6`	`fn defining<A: 'static>(s: A) -> Ty<A> { s }`
`7`	`7`	`fn assert_static<A: 'static>() {}`
`8`	`8`	`fn test<A>() where Ty<A>: 'static { assert_static::<A>() }`
`9`		- //~^ ERROR: the parameter type `A` may not live long enough
`10`	`9`	`}`
`11`	`10`
`12`	`11`	`fn main() {}`