Render trait object lifetime defaults indeterminate in lifetime-instantiated assoc ty bindings

Namely, on the RHS and in the args of the bindings.

Author: fmease

compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

@@ -1805,38 +1805,43 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
             }
         }
 
-        // Hack: When resolving the type `XX` in an assoc ty binding like
-        // `dyn Foo<'b, Item = XX>`, the current object-lifetime default
-        // would be to examine the trait `Foo` to check whether it has
-        // a lifetime bound declared on `Item`. e.g., if `Foo` is
-        // declared like so, then the default object lifetime bound in
-        // `XX` should be `'b`:
-        //
-        // ```rust
-        // trait Foo<'a> {
-        //   type Item: 'a;
-        // }
-        // ```
-        //
-        // but if we just have `type Item;`, then it would be
-        // `'static`. However, we don't get all of this logic correct.
-        //
-        // Instead, we do something hacky: if there are no lifetime parameters
-        // to the trait, then we simply use a default object lifetime
-        // bound of `'static`, because there is no other possibility. On the other hand,
-        // if there ARE lifetime parameters, then we require the user to give an
-        // explicit bound for now.
-        //
-        // This is intended to leave room for us to implement the
-        // correct behavior in the future.
-        let has_lifetime_parameter =
-            generic_args.args.iter().any(|arg| matches!(arg, GenericArg::Lifetime(_)));
+        let has_lifetime_args = generic_args.has_lifetime_args();
 
-        // Resolve lifetimes found in the bindings, so either in the type `XX` in `Item = XX` or
-        // in the trait ref `YY<...>` in `Item: YY<...>`.
         for constraint in generic_args.constraints {
             let scope = Scope::ObjectLifetimeDefault {
-                lifetime: if has_lifetime_parameter {
+                // FIXME: Ideally we would consider the *item bounds* of assoc types when deducing
+                //        the trait object lifetime default for the RHS of assoc type bindings.
+                //        For example, given
+                //
+                //            trait TraitA<'a> { type AssocTy: ?Sized + 'a; }
+                //            trait TraitB { type AssocTy<'a>: ?Sized + 'a; }
+                //
+                //        we would elaborate the `dyn Bound` in `TraitA<'r, AssocTy = dyn Bound>`
+                //        and `TraitB<AssocTy<'r> = dyn Bound>` to `dyn Bound + 'r`.
+                //
+                // FIXME: Moreover, ideally GAT args in bindings could induce
+                //        trait object lifetime defaults. For example, given
+                //
+                //           trait TraitA<'a> { type AssocTy<T: ?Sized + 'a>; }
+                //           trait TraitB { type AssocTy<'a, T: ?Sized + 'a>; }
+                //
+                //        we would elab the `dyn Bound` in `TraitA<'r, AssocTy<dyn Bound> = ()>`
+                //        and `TraitB<AssocTy<'r, dyn Bound> = ()>` to `dyn Bound + 'r`.
+                //
+                // HACK: For now however, if the user passes any lifetime arguments to the trait or
+                //       the (generic) assoc type, we will treat the trait object lifetime default
+                //       as indeterminate thus forcing the user to explicitly specify the lifetime.
+                //
+                //       If the trait or the assoc type have lifetime parameters, it's *possible*
+                //       that they occur in the predicates or item bounds of the assoc type, so we
+                //       conservatively reject such cases to allow us to implement the correct
+                //       behavior in the future (here we assume that the number of arguments equals
+                //       the number of parameters which is fine since a mismatch would get rejected
+                //       later anyway).
+                //
+                //       If the items don't have any lifetime parameters we can safely use `'static`
+                //       since there is no other possibility.
+                lifetime: if has_lifetime_args || constraint.gen_args.has_lifetime_args() {
                     None
                 } else {
                     Some(ResolvedArg::StaticLifetime)

tests/ui/object-lifetime/object-lifetime-default-assoc-ty-binding-item-bounds-non-static.rs

@@ -0,0 +1,33 @@
+// Ideally, given an assoc type binding `dyn Trait<AssocTy = Ty>`, we'd factor in the item bounds of
+// assoc type `AssocTy` when computing the trait object lifetime default for type `Ty`.
+//
+// However, since the current implementation can't handle this we instead conservatively and hackily
+// treat the trait object lifetime default of the RHS as indeterminate if any lifetime arguments are
+// passed to the trait ref (or the GAT) thus rejecting any implicit trait object lifetime bounds.
+// This way, we can still implement the desired behavior in the future.
+
+trait Foo<'a> {
+    type Item: 'a + ?Sized;
+
+    fn item(&self) -> Box<Self::Item> { panic!() }
+}
+
+trait Bar {}
+
+impl<T> Foo<'_> for T {
+    type Item = dyn Bar;
+}
+
+fn is_static<T>(_: T) where T: 'static {}
+
+// FIXME: Ideally, we'd elaborate `dyn Bar` to `dyn Bar + 'a` instead of rejecting it.
+fn bar<'a>(x: &'a str) -> &'a dyn Foo<'a, Item = dyn Bar> { &() }
+//~^ ERROR cannot deduce the lifetime bound for this trait object type from context
+
+fn main() {
+    let s = format!("foo");
+    let r = bar(&s);
+
+    // If it weren't for the conservative path above, we'd expect an error here.
+    is_static(r.item());
+}

…me-default-dyn-binding-nonstatic1.stderr …ty-binding-item-bounds-non-static.stderrtests/ui/object-lifetime/object-lifetime-default-dyn-binding-nonstatic1.stderr renamed to tests/ui/object-lifetime/object-lifetime-default-assoc-ty-binding-item-bounds-non-static.stderr tests/ui/object-lifetime/object-lifetime-default-dyn-binding-nonstatic1.stderr renamed to tests/ui/object-lifetime/object-lifetime-default-assoc-ty-binding-item-bounds-non-static.stderr

@@ -1,5 +1,5 @@
 error[E0228]: cannot deduce the lifetime bound for this trait object type from context
-  --> $DIR/object-lifetime-default-dyn-binding-nonstatic1.rs:20:50
+  --> $DIR/object-lifetime-default-assoc-ty-binding-item-bounds-non-static.rs:24:50
    |
 LL | fn bar<'a>(x: &'a str) -> &'a dyn Foo<'a, Item = dyn Bar> { &() }
    |                                                  ^^^^^^^

tests/ui/object-lifetime/object-lifetime-default-assoc-ty-binding-item-bounds-static.rs

@@ -0,0 +1,30 @@
+// Check that assoc item bindings correctly induce trait object lifetime defaults `'static` if the
+// the trait & assoc ty doesn't have any lifetime params & the assoc ty isn't bounded by a lifetime.
+//
+//@ check-pass
+
+trait Foo {
+    type Item: ?Sized;
+
+    fn item(&self) -> Box<Self::Item> { loop {} }
+}
+
+trait Bar {}
+
+impl<T> Foo for T {
+    type Item = dyn Bar;
+}
+
+fn is_static<T>(_: T) where T: 'static {}
+
+// We elaborate `dyn Bar` to `dyn Bar + 'static` since the assoc ty isn't bounded by any lifetime.
+// Notably, we don't elaborate it to `dyn Bar + 'r` since the trait object lifetime default induced
+// by `Foo` (i.e., `'static`) shadows the one induced by `&` (`'r`).
+fn bar<'r>(x: &'r str) -> &'r dyn Foo<Item = dyn Bar> { &() }
+
+fn main() {
+    let s = format!("foo");
+    let r = bar(&s);
+
+    is_static(r.item());
+}

tests/ui/object-lifetime/object-lifetime-default-assoc-ty-binding-item-bounds.rs

@@ -0,0 +1,37 @@
+// Ideally, given an assoc type binding `dyn Trait<AssocTy = Ty>`, we'd factor in the item bounds of
+// assoc type `AssocTy` when computing the trait object lifetime default for type `Ty`.
+//
+// However, since the current implementation can't handle this we instead conservatively and hackily
+// treat the trait object lifetime default of the RHS as indeterminate if any lifetime arguments are
+// passed to the trait ref (or the GAT) thus rejecting any implicit trait object lifetime bounds.
+// This way, we can still implement the desired behavior in the future.
+
+trait Foo<'a> {
+    type Item: ?Sized;
+
+    fn item(&self) -> Box<Self::Item> { panic!() }
+}
+
+trait Bar {}
+
+impl<T> Foo<'_> for T {
+    type Item = dyn Bar;
+}
+
+fn is_static<T>(_: T) where T: 'static {}
+
+// FIXME: Ideally, we'd elaborate `dyn Bar` to `dyn Bar + 'static` instead of rejecting it.
+fn bar<'a>(x: &'a str) -> &'a dyn Foo<'a, Item = dyn Bar> { &() }
+//~^ ERROR cannot deduce the lifetime bound for this trait object type from context
+
+// FIXME: Ideally, we'd elaborate `dyn Bar` to `dyn Bar + 'static` instead of rejecting it.
+fn baz(x: &str) -> &dyn Foo<Item = dyn Bar> { &() }
+//~^ ERROR cannot deduce the lifetime bound for this trait object type from context
+
+fn main() {
+    let s = format!("foo");
+    let r = bar(&s);
+    is_static(r.item());
+    let r = baz(&s);
+    is_static(r.item());
+}

tests/ui/object-lifetime/object-lifetime-default-assoc-ty-binding-item-bounds.stderr

@@ -0,0 +1,25 @@
+error[E0228]: cannot deduce the lifetime bound for this trait object type from context
+  --> $DIR/object-lifetime-default-assoc-ty-binding-item-bounds.rs:24:50
+   |
+LL | fn bar<'a>(x: &'a str) -> &'a dyn Foo<'a, Item = dyn Bar> { &() }
+   |                                                  ^^^^^^^
+   |
+help: please supply an explicit bound
+   |
+LL | fn bar<'a>(x: &'a str) -> &'a dyn Foo<'a, Item = dyn Bar + /* 'a */> { &() }
+   |                                                          ++++++++++
+
+error[E0228]: cannot deduce the lifetime bound for this trait object type from context
+  --> $DIR/object-lifetime-default-assoc-ty-binding-item-bounds.rs:28:36
+   |
+LL | fn baz(x: &str) -> &dyn Foo<Item = dyn Bar> { &() }
+   |                                    ^^^^^^^
+   |
+help: please supply an explicit bound
+   |
+LL | fn baz(x: &str) -> &dyn Foo<Item = dyn Bar + /* 'a */> { &() }
+   |                                            ++++++++++
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0228`.