Use a 'static default for fn arguments and returns.

Author: cjgillot

compiler/rustc_typeck/src/collect/object_lifetime_defaults.rs

@@ -345,6 +345,48 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
         }
     }
 
+    fn visit_fn_decl(&mut self, fd: &'tcx hir::FnDecl<'tcx>) {
+        let output = match fd.output {
+            hir::FnRetTy::DefaultReturn(_) => None,
+            hir::FnRetTy::Return(ref output) => {
+                let parent = self.tcx.hir().get_parent_node(output.hir_id);
+                let static_for_output = match self.tcx.hir().get(parent) {
+                    // `fn` definitions and methods.
+                    Node::Item(_) | Node::TraitItem(_) | Node::ImplItem(_) => true,
+
+                    // Foreign functions, `fn(...) -> R` and `Trait(...) -> R` (both types and bounds).
+                    Node::ForeignItem(_) | Node::Ty(_) | Node::TraitRef(_) => true,
+
+                    Node::TypeBinding(_) => matches!(
+                        self.tcx.hir().get(self.tcx.hir().get_parent_node(parent)),
+                        Node::TraitRef(_)
+                    ),
+
+                    // Everything else (only closures?) doesn't
+                    // actually enjoy elision in return types.
+                    _ => false,
+                };
+                Some((output, static_for_output))
+            }
+        };
+
+        // Lifetime elision prescribes a `'static` default lifetime.
+        let scope = Scope::ObjectLifetimeDefault { lifetime: Some(Region::Static), s: self.scope };
+        self.with(scope, |this| {
+            for ty in fd.inputs {
+                this.visit_ty(ty)
+            }
+
+            if let Some((output, static_for_output)) = output && static_for_output {
+                this.visit_ty(output)
+            }
+        });
+
+        if let Some((output, static_for_output)) = output && !static_for_output {
+            self.visit_ty(output)
+        }
+    }
+
     fn visit_path(&mut self, path: &'tcx hir::Path<'tcx>, _: hir::HirId) {
         for (i, segment) in path.segments.iter().enumerate() {
             let depth = path.segments.len() - i - 1;
@@ -423,11 +465,17 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
         generic_args: &'tcx hir::GenericArgs<'tcx>,
     ) {
         if generic_args.parenthesized {
-            for input in generic_args.inputs() {
-                self.visit_ty(input);
-            }
-            let output = generic_args.bindings[0].ty();
-            self.visit_ty(output);
+            // Lifetime elision rules require us to use a `'static` default lifetime.
+            let scope =
+                Scope::ObjectLifetimeDefault { lifetime: Some(Region::Static), s: self.scope };
+            self.with(scope, |this| {
+                for input in generic_args.inputs() {
+                    this.visit_ty(input);
+                }
+
+                let output = generic_args.bindings[0].ty();
+                this.visit_ty(output);
+            });
             return;
         }
 

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

@@ -8,5 +8,5 @@ fn main() {
     // This isn't great. The issue here is that `dyn Trait` is not sized, so
     // `dyn Fn() -> dyn Trait` is not well-formed.
     let t: &dyn Trait = &get_function()();
-    //~^ ERROR expected function, found `&dyn Fn() -> dyn Trait`
+    //~^ ERROR expected function, found `&dyn Fn() -> (dyn Trait + 'static)`
 }

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

@@ -1,8 +1,8 @@
-error[E0618]: expected function, found `&dyn Fn() -> dyn Trait`
+error[E0618]: expected function, found `&dyn Fn() -> (dyn Trait + 'static)`
   --> $DIR/issue-41139.rs:10:26
    |
 LL | fn get_function<'a>() -> &'a dyn Fn() -> dyn Trait {
-   | -------------------------------------------------- `get_function` defined here returns `&dyn Fn() -> dyn Trait`
+   | -------------------------------------------------- `get_function` defined here returns `&dyn Fn() -> (dyn Trait + 'static)`
 ...
 LL |     let t: &dyn Trait = &get_function()();
    |                          ^^^^^^^^^^^^^^--

src/test/ui/object-lifetime/object-lifetime-default-default-to-static.rs

@@ -31,5 +31,34 @@ fn d(t: Box<dyn Test+'static>, mut ss: SomeStruct) {
     ss.u = t;
 }
 
+// Check that closures obey the same rules.
+fn e() {
+    let _ = |t: Box<dyn Test>, mut ss: SomeStruct| {
+        ss.t = t;
+    };
+    let _ = |t: Box<dyn Test+'static>, mut ss: SomeStruct| {
+        ss.t = t;
+    };
+    let _ = |t: Box<dyn Test>, mut ss: SomeStruct| {
+        ss.u = t;
+    };
+    let _ = |t: Box<dyn Test+'static>, mut ss: SomeStruct| {
+        ss.u = t;
+    };
+}
+
+// Check that bare fns and Fn trait obey the same rules.
+fn f() {
+    let _: fn(Box<dyn Test>, SomeStruct) = a;
+    let _: fn(Box<dyn Test + 'static>, SomeStruct) = a;
+    let _: &dyn Fn(Box<dyn Test>, SomeStruct) = &a;
+    let _: &dyn Fn(Box<dyn Test + 'static>, SomeStruct) = &a;
+}
+
+// But closure return type does not need to.
+fn g<'a>(t: Box<dyn Test + 'a>) {
+    let _ = || -> Box<dyn Test> { t };
+}
+
 fn main() {
 }