From 8834cfc5c1a06cd8ebb03902c0598393101636a1 Mon Sep 17 00:00:00 2001
From: Ben Reeves <benwolverine2019@gmail.com>
Date: Thu, 10 Nov 2022 21:44:50 -0600
Subject: [PATCH 1/3] Use tracing::instrument in more places in
 rustc_resolve::late.

---
 compiler/rustc_resolve/src/late.rs | 46 ++++++++++++++----------------
 compiler/rustc_resolve/src/lib.rs  |  2 ++
 2 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index 6d2ee25df320d..d79441291d175 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -633,6 +633,7 @@ impl<'a: 'ast, 'ast> Visitor<'ast> for LateResolutionVisitor<'a, '_, 'ast> {
         self.resolve_local(local);
         self.diagnostic_metadata.current_let_binding = original;
     }
+    #[instrument(level = "trace", skip_all, fields(?ty.kind))]
     fn visit_ty(&mut self, ty: &'ast Ty) {
         let prev = self.diagnostic_metadata.current_trait_object;
         let prev_ty = self.diagnostic_metadata.current_type_path;
@@ -945,8 +946,8 @@ impl<'a: 'ast, 'ast> Visitor<'ast> for LateResolutionVisitor<'a, '_, 'ast> {
         }
     }
 
+    #[instrument(level = "debug", skip(self))]
     fn visit_generic_arg(&mut self, arg: &'ast GenericArg) {
-        debug!("visit_generic_arg({:?})", arg);
         let prev = replace(&mut self.diagnostic_metadata.currently_processing_generics, true);
         match arg {
             GenericArg::Type(ref ty) => {
@@ -1072,8 +1073,8 @@ impl<'a: 'ast, 'ast> Visitor<'ast> for LateResolutionVisitor<'a, '_, 'ast> {
         }
     }
 
+    #[instrument(level = "debug", skip(self))]
     fn visit_where_predicate(&mut self, p: &'ast WherePredicate) {
-        debug!("visit_where_predicate {:?}", p);
         let previous_value =
             replace(&mut self.diagnostic_metadata.current_where_predicate, Some(p));
         self.with_lifetime_rib(LifetimeRibKind::AnonymousReportError, |this| {
@@ -1846,16 +1847,20 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
             let Err(failure_info) = elision_lifetime else { bug!() };
             self.report_missing_lifetime_specifiers(elision_failures, Some(failure_info));
         }
+
+        self.in_func_params = outer_in_params;
     }
 
     /// Resolve inside function parameters and parameter types.
     /// Returns the lifetime for elision in fn return type,
     /// or diagnostic information in case of elision failure.
+    #[instrument(level = "debug", skip(self, inputs))]
     fn resolve_fn_params(
         &mut self,
         has_self: bool,
         inputs: impl Iterator<Item = (Option<&'ast Pat>, &'ast Ty)>,
     ) -> Result<LifetimeRes, (Vec<MissingLifetime>, Vec<ElisionFnParameter>)> {
+        #[derive(Debug)]
         enum Elision {
             /// We have not found any candidate.
             None,
@@ -2085,8 +2090,8 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
         true
     }
 
+    #[instrument(level = "debug", skip_all)]
     fn resolve_adt(&mut self, item: &'ast Item, generics: &'ast Generics) {
-        debug!("resolve_adt");
         self.with_current_self_item(item, |this| {
             this.with_generic_param_rib(
                 &generics.params,
@@ -2156,10 +2161,8 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
         }
     }
 
+    #[instrument(level = "debug", skip_all, fields(name = %item.ident.name, kind = ?item.kind))]
     fn resolve_item(&mut self, item: &'ast Item) {
-        let name = item.ident.name;
-        debug!("(resolving item) resolving {} ({:?})", name, item.kind);
-
         match item.kind {
             ItemKind::TyAlias(box TyAlias { ref generics, .. }) => {
                 self.with_generic_param_rib(
@@ -2293,6 +2296,7 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
         }
     }
 
+    #[instrument(level = "debug", skip(self, f))]
     fn with_generic_param_rib<'c, F>(
         &'c mut self,
         params: &'c [GenericParam],
@@ -2302,7 +2306,6 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
     ) where
         F: FnOnce(&mut Self),
     {
-        debug!("with_generic_param_rib");
         let LifetimeRibKind::Generics { binder, span: generics_span, kind: generics_kind, .. }
             = lifetime_kind else { panic!() };
 
@@ -2337,7 +2340,7 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
 
         for param in params {
             let ident = param.ident.normalize_to_macros_2_0();
-            debug!("with_generic_param_rib: {}", param.id);
+            debug!(%param.id);
 
             if let GenericParamKind::Lifetime = param.kind
                 && let Some(&original) = seen_lifetimes.get(&ident)
@@ -2601,6 +2604,7 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
         self.with_self_rib_ns(TypeNS, self_res, f)
     }
 
+    #[instrument(level = "debug", skip_all)]
     fn resolve_implementation(
         &mut self,
         generics: &'ast Generics,
@@ -2609,7 +2613,6 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
         item_id: NodeId,
         impl_items: &'ast [P<AssocItem>],
     ) {
-        debug!("resolve_implementation");
         // If applicable, create a rib for the type parameters.
         self.with_generic_param_rib(
             &generics.params,
@@ -2680,6 +2683,7 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
         );
     }
 
+    #[instrument(level = "debug", skip_all)]
     fn resolve_impl_item(
         &mut self,
         item: &'ast AssocItem,
@@ -2688,7 +2692,7 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
         use crate::ResolutionError::*;
         match &item.kind {
             AssocItemKind::Const(_, ty, default) => {
-                debug!("resolve_implementation AssocItemKind::Const");
+                debug!("AssocItemKind::Const");
                 // If this is a trait impl, ensure the const
                 // exists in trait
                 self.check_trait_item(
@@ -2719,7 +2723,7 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
                 }
             }
             AssocItemKind::Fn(box Fn { generics, .. }) => {
-                debug!("resolve_implementation AssocItemKind::Fn");
+                debug!("AssocItemKind::Fn");
                 // We also need a new scope for the impl item type parameters.
                 self.with_generic_param_rib(
                     &generics.params,
@@ -2747,7 +2751,7 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
                 );
             }
             AssocItemKind::Type(box TyAlias { generics, .. }) => {
-                debug!("resolve_implementation AssocItemKind::Type");
+                debug!("AssocItemKind::Type");
                 // We also need a new scope for the impl item type parameters.
                 self.with_generic_param_rib(
                     &generics.params,
@@ -2884,8 +2888,8 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
         }
     }
 
+    #[instrument(level = "debug", skip(self))]
     fn resolve_local(&mut self, local: &'ast Local) {
-        debug!("resolving local ({:?})", local);
         // Resolve the type.
         walk_list!(self, visit_ty, &local.ty);
 
@@ -3310,6 +3314,7 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
         );
     }
 
+    #[instrument(level = "debug", skip(self, source), ret)]
     fn smart_resolve_path_fragment(
         &mut self,
         qself: Option<&QSelf>,
@@ -3317,10 +3322,6 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
         source: PathSource<'ast>,
         finalize: Finalize,
     ) -> PartialRes {
-        debug!(
-            "smart_resolve_path_fragment(qself={:?}, path={:?}, finalize={:?})",
-            qself, path, finalize,
-        );
         let ns = source.namespace();
 
         let Finalize { node_id, path_span, .. } = finalize;
@@ -3575,6 +3576,7 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
     }
 
     /// Handles paths that may refer to associated items.
+    #[instrument(level = "debug", skip(self), ret)]
     fn resolve_qpath(
         &mut self,
         qself: Option<&QSelf>,
@@ -3582,11 +3584,6 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
         ns: Namespace,
         finalize: Finalize,
     ) -> Result<Option<PartialRes>, Spanned<ResolutionError<'a>>> {
-        debug!(
-            "resolve_qpath(qself={:?}, path={:?}, ns={:?}, finalize={:?})",
-            qself, path, ns, finalize,
-        );
-
         if let Some(qself) = qself {
             if qself.position == 0 {
                 // This is a case like `<T>::B`, where there is no
@@ -3685,6 +3682,7 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
         Ok(Some(result))
     }
 
+    #[instrument(level = "trace", skip(self, f))]
     fn with_resolved_label(&mut self, label: Option<Label>, id: NodeId, f: impl FnOnce(&mut Self)) {
         if let Some(label) = label {
             if label.ident.as_str().as_bytes()[1] != b'_' {
@@ -3760,8 +3758,8 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
         debug!("(resolving block) leaving block");
     }
 
+    #[instrument(level = "debug", skip(self))]
     fn resolve_anon_const(&mut self, constant: &'ast AnonConst, is_repeat: IsRepeatExpr) {
-        debug!("resolve_anon_const {:?} is_repeat: {:?}", constant, is_repeat);
         self.with_constant_rib(
             is_repeat,
             if constant.value.is_potential_trivial_const_param() {
@@ -3774,8 +3772,8 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
         );
     }
 
+    #[instrument(level = "debug", skip(self))]
     fn resolve_inline_const(&mut self, constant: &'ast AnonConst) {
-        debug!("resolve_anon_const {constant:?}");
         self.with_constant_rib(IsRepeatExpr::No, ConstantHasGenerics::Yes, None, |this| {
             visit::walk_anon_const(this, constant)
         });
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index a1ff477c6fefb..908c0650f3690 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -161,6 +161,7 @@ enum ImplTraitContext {
     Universal(LocalDefId),
 }
 
+#[derive(Debug)]
 struct BindingError {
     name: Symbol,
     origin: BTreeSet<Span>,
@@ -168,6 +169,7 @@ struct BindingError {
     could_be_path: bool,
 }
 
+#[derive(Debug)]
 enum ResolutionError<'a> {
     /// Error E0401: can't use type or const parameters from outer function.
     GenericParamsFromOuterFunction(Res, HasGenericParams),

From 8636dd45714934f3e07848fbcdef90848566d063 Mon Sep 17 00:00:00 2001
From: Ben Reeves <benwolverine2019@gmail.com>
Date: Thu, 10 Nov 2022 21:46:59 -0600
Subject: [PATCH 2/3] First attempt at fixing compiler regression.

See #103762.
---
 compiler/rustc_resolve/src/late.rs          |  65 ++++++++-
 src/test/ui/lifetimes/issue-103762-1.rs     |  38 ++++++
 src/test/ui/lifetimes/issue-103762-2.rs     |  44 +++++++
 src/test/ui/lifetimes/issue-103762-2.stderr | 139 ++++++++++++++++++++
 src/test/ui/lifetimes/issue-103762-3.rs     |  17 +++
 src/test/ui/lifetimes/issue-103762-3.stderr |  15 +++
 6 files changed, 316 insertions(+), 2 deletions(-)
 create mode 100644 src/test/ui/lifetimes/issue-103762-1.rs
 create mode 100644 src/test/ui/lifetimes/issue-103762-2.rs
 create mode 100644 src/test/ui/lifetimes/issue-103762-2.stderr
 create mode 100644 src/test/ui/lifetimes/issue-103762-3.rs
 create mode 100644 src/test/ui/lifetimes/issue-103762-3.stderr

diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index d79441291d175..1773433ff495d 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -584,6 +584,12 @@ struct LateResolutionVisitor<'a, 'b, 'ast> {
     /// If it is `true`, then it will be updated when entering a nested function or trait body.
     in_func_body: bool,
 
+    /// State used to know whether we are currently resolving params for a
+    /// function or closure.
+    ///
+    /// Notably, rustc uses this to allow `dyn Trait + '_` in certain cases.
+    in_func_params: bool,
+
     /// Count the number of places a lifetime is used.
     lifetime_uses: FxHashMap<LocalDefId, LifetimeUseSet>,
 }
@@ -923,6 +929,16 @@ impl<'a: 'ast, 'ast> Visitor<'ast> for LateResolutionVisitor<'a, '_, 'ast> {
     fn visit_lifetime(&mut self, lifetime: &'ast Lifetime, use_ctxt: visit::LifetimeCtxt) {
         self.resolve_lifetime(lifetime, use_ctxt)
     }
+    fn visit_param_bound(&mut self, bound: &'ast GenericBound, bound_kind: BoundKind) {
+        match (bound_kind, bound) {
+            (BoundKind::TraitObject, GenericBound::Outlives(lifetime @ Lifetime { ident, .. }))
+                if ident.name == kw::UnderscoreLifetime =>
+            {
+                self.resolve_anonymous_lifetime_in_trait_object_bounds(lifetime);
+            }
+            _ => visit::walk_param_bound(self, bound),
+        }
+    }
 
     fn visit_generics(&mut self, generics: &'ast Generics) {
         self.visit_generic_params(
@@ -1173,6 +1189,7 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
             diagnostic_metadata: Box::new(DiagnosticMetadata::default()),
             // errors at module scope should always be reported
             in_func_body: false,
+            in_func_params: false,
             lifetime_uses: Default::default(),
         }
     }
@@ -1788,6 +1805,32 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
         }
     }
 
+    /// For backwards compatibility, we need to accept the following:
+    ///
+    /// ```
+    /// trait AsStr {
+    ///     fn as_str(&self) -> &str;
+    /// }
+    ///
+    /// fn foo(a: &(dyn AsStr + '_)) -> &str { a.as_str() }
+    /// ```
+    ///
+    /// When we're resolving function parameters, we usually want each elided or
+    /// anonymous lifetime to result in a new elision candidate, but not in this case.
+    #[instrument(level = "trace", skip(self))]
+    fn resolve_anonymous_lifetime_in_trait_object_bounds(&mut self, lifetime: &Lifetime) {
+        debug_assert_eq!(lifetime.ident.name, kw::UnderscoreLifetime);
+        debug_assert!(self.diagnostic_metadata.current_trait_object.is_some());
+
+        if self.in_func_params {
+            self.with_lifetime_rib(LifetimeRibKind::Elided(LifetimeRes::Infer), |this| {
+                this.resolve_anonymous_lifetime(lifetime, false)
+            });
+        } else {
+            self.resolve_anonymous_lifetime(lifetime, false);
+        }
+    }
+
     #[instrument(level = "debug", skip(self))]
     fn record_lifetime_res(
         &mut self,
@@ -1834,6 +1877,19 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
         let elision_lifetime = self.resolve_fn_params(has_self, inputs);
         debug!(?elision_lifetime);
 
+        // We might be about to resolve the return type of some
+        // `fn() -> T`-typed parameter, like:
+        //
+        // ```
+        // fn foo(f: fn(&str) -> Box<dyn Trait + '_>) { ... }
+        // ```
+        //
+        // In that case, we don't want to act like we're resolving function
+        // parameters.
+        //
+        // FIXME(bgr360): test multiple levels of this
+        let outer_in_params = replace(&mut self.in_func_params, false);
+
         let outer_failures = take(&mut self.diagnostic_metadata.current_elision_failures);
         let output_rib = if let Ok(res) = elision_lifetime.as_ref() {
             LifetimeRibKind::Elided(*res)
@@ -1872,7 +1928,8 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
             Err,
         }
 
-        // Save elision state to reinstate it later.
+        // Save state to reinstate it later.
+        let outer_in_params = replace(&mut self.in_func_params, true);
         let outer_candidates = self.lifetime_elision_candidates.take();
 
         // Result of elision.
@@ -1895,9 +1952,11 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
             self.lifetime_elision_candidates = Some(Default::default());
             self.visit_ty(ty);
             let local_candidates = self.lifetime_elision_candidates.take();
+            trace!(?local_candidates);
 
             if let Some(candidates) = local_candidates {
                 let distinct: FxHashSet<_> = candidates.iter().map(|(res, _)| *res).collect();
+                trace!(?distinct);
                 let lifetime_count = distinct.len();
                 if lifetime_count != 0 {
                     parameter_info.push(ElisionFnParameter {
@@ -1952,12 +2011,14 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
                     elision_lifetime = Elision::None;
                 }
             }
+            trace!(?elision_lifetime);
             debug!("(resolving function / closure) recorded parameter");
         }
 
-        // Reinstate elision state.
+        // Reinstate state.
         debug_assert_matches!(self.lifetime_elision_candidates, None);
         self.lifetime_elision_candidates = outer_candidates;
+        self.in_func_params = outer_in_params;
 
         if let Elision::Param(res) | Elision::Self_(res) = elision_lifetime {
             return Ok(res);
diff --git a/src/test/ui/lifetimes/issue-103762-1.rs b/src/test/ui/lifetimes/issue-103762-1.rs
new file mode 100644
index 0000000000000..a1f9764d20cd6
--- /dev/null
+++ b/src/test/ui/lifetimes/issue-103762-1.rs
@@ -0,0 +1,38 @@
+// Prior to 1.64.0, '_ in dyn trait bounds was not counted as a new lifetime.
+// Changes made in 1.64.0 broke this. This is a regression test for the fix.
+
+// check-pass
+
+trait Trait {}
+
+// Case 1: Anonymous/elided lifetime on return type should refer to the `&` in `&(dyn ...)`.
+fn a1(_: &(dyn Trait + '_)) -> &str { loop {} }
+fn a2(_: &(dyn Trait + '_)) -> &'_ str { loop {} }
+fn a3(_: &'_ (dyn Trait + '_)) -> &'_ str { loop {} }
+fn a4(_: &(Trait + '_)) -> &str { loop {} } //~ WARNING deprecated
+fn a_closure() {
+    let _ = |_: &(dyn Trait + '_)| -> &str { loop {} };
+    let _ = |_: &(Trait + '_)| -> &str { loop {} }; //~ WARNING deprecated
+}
+
+// Case 2: Elided lifetime on return type should refer to the `&` in `&i32`.
+fn b1(_: &i32, _: Box<dyn Trait + '_>) -> &str { loop {} }
+fn b2(_: &i32, _: Box<Trait + '_>) -> & str { loop {} } //~ WARNING deprecated
+fn b3(_: Box<dyn Trait + '_>, _: &i32) -> &str { loop {} }
+fn b4(_: Box<Trait + '_>, _: &i32) -> & str { loop {} } //~ WARNING deprecated
+fn b_closure() {
+    let _ = |_: &i32, _: Box<dyn Trait + '_>| -> &str { loop {} };
+    let _ = |_: &i32, _: Box<Trait + '_>| -> &str { loop {} };
+    let _ = |_: Box<dyn Trait + '_>, _: &i32| -> &str { loop {} };
+    let _ = |_: Box<Trait + '_>, _: &i32| -> &str { loop {} };
+}
+
+// Case 3: Anonymous lifetime bound in trait object should not be resolved against previous ones.
+fn c1(_: &i32, _: &i32, _: Box<dyn Trait + '_>) {}
+fn c2(_: &i32, _: &i32, _: Box<Trait + '_>) {}
+fn c_closure() {
+    let _ = |_: &i32, _: &i32, _: Box<dyn Trait + '_>| loop {};
+    let _ = |_: &i32, _: &i32, _: Box<Trait + '_>| loop {};
+}
+
+fn main() {}
diff --git a/src/test/ui/lifetimes/issue-103762-2.rs b/src/test/ui/lifetimes/issue-103762-2.rs
new file mode 100644
index 0000000000000..531f1e1e67f1e
--- /dev/null
+++ b/src/test/ui/lifetimes/issue-103762-2.rs
@@ -0,0 +1,44 @@
+// Failure cases for #103762.
+
+trait Trait {}
+
+// Case 1: '_ in trait object bound without any other anonymous/elided lifetimes.
+// Pre-1.64 rejected this, but 1.64 did not. Make sure it does.
+fn a1(_: Box<dyn Trait + '_>) -> &str { loop {} } //~ ERROR missing lifetime specifier
+fn a2(_: Box<Trait + '_>) -> &str { loop {} } //~ ERROR missing lifetime specifier
+//~^ WARNING deprecated
+
+// Case 2: Inside fn() type.
+// Pre-1.64 and 1.64 rejected this, should still reject.
+fn b1(_: fn(&(dyn Trait + '_)) -> &str) { loop {} } //~ ERROR missing lifetime specifier
+fn b2(_: fn(&(Trait + '_)) -> &str) { loop {} } //~ ERROR missing lifetime specifier
+//~^ WARNING deprecated
+
+// Case 3: Inside generic bound.
+// Pre-1.64 and 1.64 rejected this, should still reject.
+fn c1<T: Trait + '_>(_: &T) -> &str { loop {} } //~ ERROR `'_` cannot be used here
+fn c2<T>(_: &T) -> &str where T: Trait + '_ { loop {} } //~ ERROR `'_` cannot be used here
+
+// Case 4.a: Inside impl Trait without any other anonymous/elided lifetimes.
+//  * Pre-1.64 rejected this because it thought `+ '_` needed to be a named lifetime,
+//    and did not report on `&str`.
+//  * 1.64 rejected this because of unstable anonymous_lifetime_in_impl_trait,
+//    and because `&str` needs a named lifetime.
+// It makes sense to keep doing what 1.64 did.
+fn d1(_: impl Trait + '_) //~ ERROR anonymous lifetimes in `impl Trait` are unstable
+    -> &str { loop {} } //~ ERROR missing lifetime specifier
+
+// Case 4.b: Inside impl Trait with other anonymous/elided lifetimes.
+//  * Pre-1.64 rejected these because it thought `+ '_` needed to be a named lifetime.
+//  * 1.64 rejected these because of unstable anonymous_lifetime_in_impl_trait,
+//    and because it thought `&str` needed a named lifetime parameter.
+// It should continue reporting on the unstable feature, but not on `&str`, since we
+// shouldn't count `+ '_` as a new elision candidate.
+fn d2(_: &(impl Trait + '_)) //~ ERROR anonymous lifetimes in `impl Trait` are unstable
+    -> &str { loop {} }
+fn d3(_: &i32, _: impl Trait + '_) //~ ERROR anonymous lifetimes in `impl Trait` are unstable
+    -> &str { loop {} }
+fn d4(_: impl Trait + '_, _: &i32) //~ ERROR anonymous lifetimes in `impl Trait` are unstable
+    -> &str { loop {} }
+
+fn main() {}
diff --git a/src/test/ui/lifetimes/issue-103762-2.stderr b/src/test/ui/lifetimes/issue-103762-2.stderr
new file mode 100644
index 0000000000000..0c8e510c8f825
--- /dev/null
+++ b/src/test/ui/lifetimes/issue-103762-2.stderr
@@ -0,0 +1,139 @@
+error[E0106]: missing lifetime specifier
+  --> $DIR/issue-103762-2.rs:7:34
+   |
+LL | fn a1(_: Box<dyn Trait + '_>) -> &str { loop {} }
+   |                                  ^ expected named lifetime parameter
+   |
+   = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
+help: consider using the `'static` lifetime
+   |
+LL | fn a1(_: Box<dyn Trait + '_>) -> &'static str { loop {} }
+   |                                   +++++++
+
+error[E0106]: missing lifetime specifier
+  --> $DIR/issue-103762-2.rs:8:30
+   |
+LL | fn a2(_: Box<Trait + '_>) -> &str { loop {} }
+   |                              ^ expected named lifetime parameter
+   |
+   = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
+help: consider using the `'static` lifetime
+   |
+LL | fn a2(_: Box<Trait + '_>) -> &'static str { loop {} }
+   |                               +++++++
+
+error[E0637]: `'_` cannot be used here
+  --> $DIR/issue-103762-2.rs:19:18
+   |
+LL | fn c1<T: Trait + '_>(_: &T) -> &str { loop {} }
+   |                  ^^ `'_` is a reserved lifetime name
+
+error[E0637]: `'_` cannot be used here
+  --> $DIR/issue-103762-2.rs:20:42
+   |
+LL | fn c2<T>(_: &T) -> &str where T: Trait + '_ { loop {} }
+   |                                          ^^ `'_` is a reserved lifetime name
+
+error[E0106]: missing lifetime specifier
+  --> $DIR/issue-103762-2.rs:29:8
+   |
+LL |     -> &str { loop {} }
+   |        ^ expected named lifetime parameter
+   |
+   = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
+help: consider using the `'static` lifetime
+   |
+LL |     -> &'static str { loop {} }
+   |         +++++++
+
+error[E0228]: the lifetime bound for this object type cannot be deduced from context; please supply an explicit bound
+  --> $DIR/issue-103762-2.rs:7:14
+   |
+LL | fn a1(_: Box<dyn Trait + '_>) -> &str { loop {} }
+   |              ^^^^^^^^^^^^^^
+
+warning: trait objects without an explicit `dyn` are deprecated
+  --> $DIR/issue-103762-2.rs:8:14
+   |
+LL | fn a2(_: Box<Trait + '_>) -> &str { loop {} }
+   |              ^^^^^^^^^^
+   |
+   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
+   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
+   = note: `#[warn(bare_trait_objects)]` on by default
+help: use `dyn`
+   |
+LL | fn a2(_: Box<dyn Trait + '_>) -> &str { loop {} }
+   |              +++
+
+error[E0228]: the lifetime bound for this object type cannot be deduced from context; please supply an explicit bound
+  --> $DIR/issue-103762-2.rs:8:14
+   |
+LL | fn a2(_: Box<Trait + '_>) -> &str { loop {} }
+   |              ^^^^^^^^^^
+
+warning: trait objects without an explicit `dyn` are deprecated
+  --> $DIR/issue-103762-2.rs:14:15
+   |
+LL | fn b2(_: fn(&(Trait + '_)) -> &str) { loop {} }
+   |               ^^^^^^^^^^
+   |
+   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
+   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
+help: use `dyn`
+   |
+LL | fn b2(_: fn(&(dyn Trait + '_)) -> &str) { loop {} }
+   |               +++
+
+error[E0658]: anonymous lifetimes in `impl Trait` are unstable
+  --> $DIR/issue-103762-2.rs:28:23
+   |
+LL | fn d1(_: impl Trait + '_)
+   |                       ^^ expected named lifetime parameter
+   |
+   = help: add `#![feature(anonymous_lifetime_in_impl_trait)]` to the crate attributes to enable
+help: consider introducing a named lifetime parameter
+   |
+LL | fn d1<'a>(_: impl Trait + '_'a )
+   |      ++++                   ++
+
+error[E0658]: anonymous lifetimes in `impl Trait` are unstable
+  --> $DIR/issue-103762-2.rs:37:25
+   |
+LL | fn d2(_: &(impl Trait + '_))
+   |                         ^^ expected named lifetime parameter
+   |
+   = help: add `#![feature(anonymous_lifetime_in_impl_trait)]` to the crate attributes to enable
+help: consider introducing a named lifetime parameter
+   |
+LL | fn d2<'a>(_: &(impl Trait + '_'a ))
+   |      ++++                     ++
+
+error[E0658]: anonymous lifetimes in `impl Trait` are unstable
+  --> $DIR/issue-103762-2.rs:39:32
+   |
+LL | fn d3(_: &i32, _: impl Trait + '_)
+   |                                ^^ expected named lifetime parameter
+   |
+   = help: add `#![feature(anonymous_lifetime_in_impl_trait)]` to the crate attributes to enable
+help: consider introducing a named lifetime parameter
+   |
+LL | fn d3<'a>(_: &i32, _: impl Trait + '_'a )
+   |      ++++                            ++
+
+error[E0658]: anonymous lifetimes in `impl Trait` are unstable
+  --> $DIR/issue-103762-2.rs:41:23
+   |
+LL | fn d4(_: impl Trait + '_, _: &i32)
+   |                       ^^ expected named lifetime parameter
+   |
+   = help: add `#![feature(anonymous_lifetime_in_impl_trait)]` to the crate attributes to enable
+help: consider introducing a named lifetime parameter
+   |
+LL | fn d4<'a>(_: impl Trait + '_'a , _: &i32)
+   |      ++++                   ++
+
+error: aborting due to 11 previous errors; 2 warnings emitted
+
+Some errors have detailed explanations: E0106, E0228, E0637, E0658.
+For more information about an error, try `rustc --explain E0106`.
diff --git a/src/test/ui/lifetimes/issue-103762-3.rs b/src/test/ui/lifetimes/issue-103762-3.rs
new file mode 100644
index 0000000000000..b4c4d3feb825a
--- /dev/null
+++ b/src/test/ui/lifetimes/issue-103762-3.rs
@@ -0,0 +1,17 @@
+#![feature(anonymous_lifetime_in_impl_trait)]
+
+trait Trait {}
+
+// Pre-1.64 rejected this because of `+ '_`, 1.64 rejects it because of `-> &str`.
+// We should keep rejecting it.
+fn d1(_: impl Trait + '_)
+    -> &str { loop {} } //~ ERROR missing lifetime specifier
+
+// Pre-1.64 rejected these because of `+ '_`, 1.64 allows them with the feature enabled.
+// We should keep allowing them.
+fn d2(_: &(impl Trait + '_)) -> &str { loop {} }
+fn d3(_: &i32, _: impl Trait + '_) -> &str { loop {} }
+fn d4(_: impl Trait + '_, _: &i32) -> &str { loop {} }
+
+
+fn main() {}
diff --git a/src/test/ui/lifetimes/issue-103762-3.stderr b/src/test/ui/lifetimes/issue-103762-3.stderr
new file mode 100644
index 0000000000000..d3791013d22c2
--- /dev/null
+++ b/src/test/ui/lifetimes/issue-103762-3.stderr
@@ -0,0 +1,15 @@
+error[E0106]: missing lifetime specifier
+  --> $DIR/issue-103762-3.rs:10:8
+   |
+LL |     -> &str { loop {} }
+   |        ^ expected named lifetime parameter
+   |
+   = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
+help: consider using the `'static` lifetime
+   |
+LL |     -> &'static str { loop {} }
+   |         +++++++
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0106`.

From fb3c318d5f1cd9249fdc38621091a8be713996c7 Mon Sep 17 00:00:00 2001
From: Ben Reeves <benwolverine2019@gmail.com>
Date: Fri, 11 Nov 2022 15:10:28 -0600
Subject: [PATCH 3/3] Introduce LifetimeRes::ImplicitObjectLifetimeDefault to
 deal with `+ '_` in trait objects.

---
 compiler/rustc_ast_lowering/src/lib.rs        |  3 +
 compiler/rustc_hir/src/def.rs                 |  7 +-
 compiler/rustc_resolve/src/late.rs            | 12 ++-
 src/test/ui/lifetimes/issue-103762-1.rs       | 14 ++--
 .../{issue-103762-2.rs => issue-103762-2a.rs} | 29 +++----
 ...103762-2.stderr => issue-103762-2a.stderr} | 81 +++++--------------
 src/test/ui/lifetimes/issue-103762-2b.rs      | 19 +++++
 ...103762-3.stderr => issue-103762-2b.stderr} |  2 +-
 src/test/ui/lifetimes/issue-103762-3.rs       | 23 +++---
 9 files changed, 91 insertions(+), 99 deletions(-)
 rename src/test/ui/lifetimes/{issue-103762-2.rs => issue-103762-2a.rs} (61%)
 rename src/test/ui/lifetimes/{issue-103762-2.stderr => issue-103762-2a.stderr} (54%)
 create mode 100644 src/test/ui/lifetimes/issue-103762-2b.rs
 rename src/test/ui/lifetimes/{issue-103762-3.stderr => issue-103762-2b.stderr} (92%)

diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index ff29d15f1b525..f47815f9bcb0c 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -2131,6 +2131,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
                 hir::LifetimeName::Param(param, ParamName::Fresh)
             }
+            LifetimeRes::ImplicitObjectLifetimeDefault => {
+                hir::LifetimeName::ImplicitObjectLifetimeDefault
+            }
             LifetimeRes::Infer => hir::LifetimeName::Infer,
             LifetimeRes::Static => hir::LifetimeName::Static,
             LifetimeRes::Error => hir::LifetimeName::Error,
diff --git a/compiler/rustc_hir/src/def.rs b/compiler/rustc_hir/src/def.rs
index 4ef4aad902c68..489305fd44f84 100644
--- a/compiler/rustc_hir/src/def.rs
+++ b/compiler/rustc_hir/src/def.rs
@@ -765,6 +765,8 @@ pub enum LifetimeRes {
         /// Id of the introducing place. See `Param`.
         binder: NodeId,
     },
+    /// FIXME(bgr360): document this.
+    ImplicitObjectLifetimeDefault,
     /// This variant is used for anonymous lifetimes that we did not resolve during
     /// late resolution.  Those lifetimes will be inferred by typechecking.
     Infer,
@@ -773,5 +775,8 @@ pub enum LifetimeRes {
     /// Resolution failure.
     Error,
     /// HACK: This is used to recover the NodeId of an elided lifetime.
-    ElidedAnchor { start: NodeId, end: NodeId },
+    ElidedAnchor {
+        start: NodeId,
+        end: NodeId,
+    },
 }
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index 1773433ff495d..d82cec74b1667 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -1823,9 +1823,10 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
         debug_assert!(self.diagnostic_metadata.current_trait_object.is_some());
 
         if self.in_func_params {
-            self.with_lifetime_rib(LifetimeRibKind::Elided(LifetimeRes::Infer), |this| {
-                this.resolve_anonymous_lifetime(lifetime, false)
-            });
+            self.with_lifetime_rib(
+                LifetimeRibKind::Elided(LifetimeRes::ImplicitObjectLifetimeDefault),
+                |this| this.resolve_anonymous_lifetime(lifetime, false),
+            );
         } else {
             self.resolve_anonymous_lifetime(lifetime, false);
         }
@@ -1850,7 +1851,10 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
                     candidates.push((res, candidate));
                 }
             }
-            LifetimeRes::Infer | LifetimeRes::Error | LifetimeRes::ElidedAnchor { .. } => {}
+            LifetimeRes::ImplicitObjectLifetimeDefault
+            | LifetimeRes::Infer
+            | LifetimeRes::Error
+            | LifetimeRes::ElidedAnchor { .. } => {}
         }
     }
 
diff --git a/src/test/ui/lifetimes/issue-103762-1.rs b/src/test/ui/lifetimes/issue-103762-1.rs
index a1f9764d20cd6..becfa2924e9c1 100644
--- a/src/test/ui/lifetimes/issue-103762-1.rs
+++ b/src/test/ui/lifetimes/issue-103762-1.rs
@@ -1,25 +1,29 @@
 // Prior to 1.64.0, '_ in dyn trait bounds was not counted as a new lifetime.
-// Changes made in 1.64.0 broke this. This is a regression test for the fix.
+// Changes made in 1.64.0 broke this. These files serve as regression tests for
+// the fix.
+// This file contains cases that pre-1.64 accepted.
 
 // check-pass
 
+#![allow(bare_trait_objects)]
+
 trait Trait {}
 
 // Case 1: Anonymous/elided lifetime on return type should refer to the `&` in `&(dyn ...)`.
 fn a1(_: &(dyn Trait + '_)) -> &str { loop {} }
 fn a2(_: &(dyn Trait + '_)) -> &'_ str { loop {} }
 fn a3(_: &'_ (dyn Trait + '_)) -> &'_ str { loop {} }
-fn a4(_: &(Trait + '_)) -> &str { loop {} } //~ WARNING deprecated
+fn a4(_: &(Trait + '_)) -> &str { loop {} }
 fn a_closure() {
     let _ = |_: &(dyn Trait + '_)| -> &str { loop {} };
-    let _ = |_: &(Trait + '_)| -> &str { loop {} }; //~ WARNING deprecated
+    let _ = |_: &(Trait + '_)| -> &str { loop {} };
 }
 
 // Case 2: Elided lifetime on return type should refer to the `&` in `&i32`.
 fn b1(_: &i32, _: Box<dyn Trait + '_>) -> &str { loop {} }
-fn b2(_: &i32, _: Box<Trait + '_>) -> & str { loop {} } //~ WARNING deprecated
+fn b2(_: &i32, _: Box<Trait + '_>) -> &str { loop {} }
 fn b3(_: Box<dyn Trait + '_>, _: &i32) -> &str { loop {} }
-fn b4(_: Box<Trait + '_>, _: &i32) -> & str { loop {} } //~ WARNING deprecated
+fn b4(_: Box<Trait + '_>, _: &i32) -> &str { loop {} }
 fn b_closure() {
     let _ = |_: &i32, _: Box<dyn Trait + '_>| -> &str { loop {} };
     let _ = |_: &i32, _: Box<Trait + '_>| -> &str { loop {} };
diff --git a/src/test/ui/lifetimes/issue-103762-2.rs b/src/test/ui/lifetimes/issue-103762-2a.rs
similarity index 61%
rename from src/test/ui/lifetimes/issue-103762-2.rs
rename to src/test/ui/lifetimes/issue-103762-2a.rs
index 531f1e1e67f1e..c5b7fd22645d2 100644
--- a/src/test/ui/lifetimes/issue-103762-2.rs
+++ b/src/test/ui/lifetimes/issue-103762-2a.rs
@@ -1,4 +1,6 @@
-// Failure cases for #103762.
+// #103762: cases that pre-1.64 rejected that we should keep rejecting.
+
+#![allow(bare_trait_objects)]
 
 trait Trait {}
 
@@ -6,39 +8,32 @@ trait Trait {}
 // Pre-1.64 rejected this, but 1.64 did not. Make sure it does.
 fn a1(_: Box<dyn Trait + '_>) -> &str { loop {} } //~ ERROR missing lifetime specifier
 fn a2(_: Box<Trait + '_>) -> &str { loop {} } //~ ERROR missing lifetime specifier
-//~^ WARNING deprecated
-
-// Case 2: Inside fn() type.
-// Pre-1.64 and 1.64 rejected this, should still reject.
-fn b1(_: fn(&(dyn Trait + '_)) -> &str) { loop {} } //~ ERROR missing lifetime specifier
-fn b2(_: fn(&(Trait + '_)) -> &str) { loop {} } //~ ERROR missing lifetime specifier
-//~^ WARNING deprecated
 
-// Case 3: Inside generic bound.
+// Case 2: Inside generic bound.
 // Pre-1.64 and 1.64 rejected this, should still reject.
-fn c1<T: Trait + '_>(_: &T) -> &str { loop {} } //~ ERROR `'_` cannot be used here
-fn c2<T>(_: &T) -> &str where T: Trait + '_ { loop {} } //~ ERROR `'_` cannot be used here
+fn b1<T: Trait + '_>(_: &T) -> &str { loop {} } //~ ERROR `'_` cannot be used here
+fn b2<T>(_: &T) -> &str where T: Trait + '_ { loop {} } //~ ERROR `'_` cannot be used here
 
-// Case 4.a: Inside impl Trait without any other anonymous/elided lifetimes.
+// Case 3.a: Inside impl Trait without any other anonymous/elided lifetimes.
 //  * Pre-1.64 rejected this because it thought `+ '_` needed to be a named lifetime,
 //    and did not report on `&str`.
 //  * 1.64 rejected this because of unstable anonymous_lifetime_in_impl_trait,
 //    and because `&str` needs a named lifetime.
 // It makes sense to keep doing what 1.64 did.
-fn d1(_: impl Trait + '_) //~ ERROR anonymous lifetimes in `impl Trait` are unstable
+fn c1(_: impl Trait + '_) //~ ERROR anonymous lifetimes in `impl Trait` are unstable
     -> &str { loop {} } //~ ERROR missing lifetime specifier
 
-// Case 4.b: Inside impl Trait with other anonymous/elided lifetimes.
+// Case 3.b: Inside impl Trait with other anonymous/elided lifetimes.
 //  * Pre-1.64 rejected these because it thought `+ '_` needed to be a named lifetime.
 //  * 1.64 rejected these because of unstable anonymous_lifetime_in_impl_trait,
 //    and because it thought `&str` needed a named lifetime parameter.
 // It should continue reporting on the unstable feature, but not on `&str`, since we
 // shouldn't count `+ '_` as a new elision candidate.
-fn d2(_: &(impl Trait + '_)) //~ ERROR anonymous lifetimes in `impl Trait` are unstable
+fn c2(_: &(impl Trait + '_)) //~ ERROR anonymous lifetimes in `impl Trait` are unstable
     -> &str { loop {} }
-fn d3(_: &i32, _: impl Trait + '_) //~ ERROR anonymous lifetimes in `impl Trait` are unstable
+fn c3(_: &i32, _: impl Trait + '_) //~ ERROR anonymous lifetimes in `impl Trait` are unstable
     -> &str { loop {} }
-fn d4(_: impl Trait + '_, _: &i32) //~ ERROR anonymous lifetimes in `impl Trait` are unstable
+fn c4(_: impl Trait + '_, _: &i32) //~ ERROR anonymous lifetimes in `impl Trait` are unstable
     -> &str { loop {} }
 
 fn main() {}
diff --git a/src/test/ui/lifetimes/issue-103762-2.stderr b/src/test/ui/lifetimes/issue-103762-2a.stderr
similarity index 54%
rename from src/test/ui/lifetimes/issue-103762-2.stderr
rename to src/test/ui/lifetimes/issue-103762-2a.stderr
index 0c8e510c8f825..c5eb58655e65f 100644
--- a/src/test/ui/lifetimes/issue-103762-2.stderr
+++ b/src/test/ui/lifetimes/issue-103762-2a.stderr
@@ -1,5 +1,5 @@
 error[E0106]: missing lifetime specifier
-  --> $DIR/issue-103762-2.rs:7:34
+  --> $DIR/issue-103762-2a.rs:9:34
    |
 LL | fn a1(_: Box<dyn Trait + '_>) -> &str { loop {} }
    |                                  ^ expected named lifetime parameter
@@ -11,7 +11,7 @@ LL | fn a1(_: Box<dyn Trait + '_>) -> &'static str { loop {} }
    |                                   +++++++
 
 error[E0106]: missing lifetime specifier
-  --> $DIR/issue-103762-2.rs:8:30
+  --> $DIR/issue-103762-2a.rs:10:30
    |
 LL | fn a2(_: Box<Trait + '_>) -> &str { loop {} }
    |                              ^ expected named lifetime parameter
@@ -23,19 +23,19 @@ LL | fn a2(_: Box<Trait + '_>) -> &'static str { loop {} }
    |                               +++++++
 
 error[E0637]: `'_` cannot be used here
-  --> $DIR/issue-103762-2.rs:19:18
+  --> $DIR/issue-103762-2a.rs:14:18
    |
-LL | fn c1<T: Trait + '_>(_: &T) -> &str { loop {} }
+LL | fn b1<T: Trait + '_>(_: &T) -> &str { loop {} }
    |                  ^^ `'_` is a reserved lifetime name
 
 error[E0637]: `'_` cannot be used here
-  --> $DIR/issue-103762-2.rs:20:42
+  --> $DIR/issue-103762-2a.rs:15:42
    |
-LL | fn c2<T>(_: &T) -> &str where T: Trait + '_ { loop {} }
+LL | fn b2<T>(_: &T) -> &str where T: Trait + '_ { loop {} }
    |                                          ^^ `'_` is a reserved lifetime name
 
 error[E0106]: missing lifetime specifier
-  --> $DIR/issue-103762-2.rs:29:8
+  --> $DIR/issue-103762-2a.rs:24:8
    |
 LL |     -> &str { loop {} }
    |        ^ expected named lifetime parameter
@@ -46,94 +46,55 @@ help: consider using the `'static` lifetime
 LL |     -> &'static str { loop {} }
    |         +++++++
 
-error[E0228]: the lifetime bound for this object type cannot be deduced from context; please supply an explicit bound
-  --> $DIR/issue-103762-2.rs:7:14
-   |
-LL | fn a1(_: Box<dyn Trait + '_>) -> &str { loop {} }
-   |              ^^^^^^^^^^^^^^
-
-warning: trait objects without an explicit `dyn` are deprecated
-  --> $DIR/issue-103762-2.rs:8:14
-   |
-LL | fn a2(_: Box<Trait + '_>) -> &str { loop {} }
-   |              ^^^^^^^^^^
-   |
-   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
-   = note: `#[warn(bare_trait_objects)]` on by default
-help: use `dyn`
-   |
-LL | fn a2(_: Box<dyn Trait + '_>) -> &str { loop {} }
-   |              +++
-
-error[E0228]: the lifetime bound for this object type cannot be deduced from context; please supply an explicit bound
-  --> $DIR/issue-103762-2.rs:8:14
-   |
-LL | fn a2(_: Box<Trait + '_>) -> &str { loop {} }
-   |              ^^^^^^^^^^
-
-warning: trait objects without an explicit `dyn` are deprecated
-  --> $DIR/issue-103762-2.rs:14:15
-   |
-LL | fn b2(_: fn(&(Trait + '_)) -> &str) { loop {} }
-   |               ^^^^^^^^^^
-   |
-   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
-help: use `dyn`
-   |
-LL | fn b2(_: fn(&(dyn Trait + '_)) -> &str) { loop {} }
-   |               +++
-
 error[E0658]: anonymous lifetimes in `impl Trait` are unstable
-  --> $DIR/issue-103762-2.rs:28:23
+  --> $DIR/issue-103762-2a.rs:23:23
    |
-LL | fn d1(_: impl Trait + '_)
+LL | fn c1(_: impl Trait + '_)
    |                       ^^ expected named lifetime parameter
    |
    = help: add `#![feature(anonymous_lifetime_in_impl_trait)]` to the crate attributes to enable
 help: consider introducing a named lifetime parameter
    |
-LL | fn d1<'a>(_: impl Trait + '_'a )
+LL | fn c1<'a>(_: impl Trait + '_'a )
    |      ++++                   ++
 
 error[E0658]: anonymous lifetimes in `impl Trait` are unstable
-  --> $DIR/issue-103762-2.rs:37:25
+  --> $DIR/issue-103762-2a.rs:32:25
    |
-LL | fn d2(_: &(impl Trait + '_))
+LL | fn c2(_: &(impl Trait + '_))
    |                         ^^ expected named lifetime parameter
    |
    = help: add `#![feature(anonymous_lifetime_in_impl_trait)]` to the crate attributes to enable
 help: consider introducing a named lifetime parameter
    |
-LL | fn d2<'a>(_: &(impl Trait + '_'a ))
+LL | fn c2<'a>(_: &(impl Trait + '_'a ))
    |      ++++                     ++
 
 error[E0658]: anonymous lifetimes in `impl Trait` are unstable
-  --> $DIR/issue-103762-2.rs:39:32
+  --> $DIR/issue-103762-2a.rs:34:32
    |
-LL | fn d3(_: &i32, _: impl Trait + '_)
+LL | fn c3(_: &i32, _: impl Trait + '_)
    |                                ^^ expected named lifetime parameter
    |
    = help: add `#![feature(anonymous_lifetime_in_impl_trait)]` to the crate attributes to enable
 help: consider introducing a named lifetime parameter
    |
-LL | fn d3<'a>(_: &i32, _: impl Trait + '_'a )
+LL | fn c3<'a>(_: &i32, _: impl Trait + '_'a )
    |      ++++                            ++
 
 error[E0658]: anonymous lifetimes in `impl Trait` are unstable
-  --> $DIR/issue-103762-2.rs:41:23
+  --> $DIR/issue-103762-2a.rs:36:23
    |
-LL | fn d4(_: impl Trait + '_, _: &i32)
+LL | fn c4(_: impl Trait + '_, _: &i32)
    |                       ^^ expected named lifetime parameter
    |
    = help: add `#![feature(anonymous_lifetime_in_impl_trait)]` to the crate attributes to enable
 help: consider introducing a named lifetime parameter
    |
-LL | fn d4<'a>(_: impl Trait + '_'a , _: &i32)
+LL | fn c4<'a>(_: impl Trait + '_'a , _: &i32)
    |      ++++                   ++
 
-error: aborting due to 11 previous errors; 2 warnings emitted
+error: aborting due to 9 previous errors
 
-Some errors have detailed explanations: E0106, E0228, E0637, E0658.
+Some errors have detailed explanations: E0106, E0637, E0658.
 For more information about an error, try `rustc --explain E0106`.
diff --git a/src/test/ui/lifetimes/issue-103762-2b.rs b/src/test/ui/lifetimes/issue-103762-2b.rs
new file mode 100644
index 0000000000000..f2211bea918b2
--- /dev/null
+++ b/src/test/ui/lifetimes/issue-103762-2b.rs
@@ -0,0 +1,19 @@
+// #103762: re-testing some cases from 2a with anonymous_lifetime_in_impl_trait enabled.
+
+#![feature(anonymous_lifetime_in_impl_trait)]
+
+trait Trait {}
+
+// Pre-1.64 rejected this because of `+ '_`, 1.64 rejects it because of `-> &str`.
+// We should keep rejecting it.
+fn c1(_: impl Trait + '_)
+    -> &str { loop {} } //~ ERROR missing lifetime specifier
+
+// Pre-1.64 rejected these because of `+ '_`, 1.64 allows them with the feature enabled.
+// We should keep allowing them.
+fn c2(_: &(impl Trait + '_)) -> &str { loop {} }
+fn c3(_: &i32, _: impl Trait + '_) -> &str { loop {} }
+fn c4(_: impl Trait + '_, _: &i32) -> &str { loop {} }
+
+
+fn main() {}
diff --git a/src/test/ui/lifetimes/issue-103762-3.stderr b/src/test/ui/lifetimes/issue-103762-2b.stderr
similarity index 92%
rename from src/test/ui/lifetimes/issue-103762-3.stderr
rename to src/test/ui/lifetimes/issue-103762-2b.stderr
index d3791013d22c2..036081205436e 100644
--- a/src/test/ui/lifetimes/issue-103762-3.stderr
+++ b/src/test/ui/lifetimes/issue-103762-2b.stderr
@@ -1,5 +1,5 @@
 error[E0106]: missing lifetime specifier
-  --> $DIR/issue-103762-3.rs:10:8
+  --> $DIR/issue-103762-2b.rs:10:8
    |
 LL |     -> &str { loop {} }
    |        ^ expected named lifetime parameter
diff --git a/src/test/ui/lifetimes/issue-103762-3.rs b/src/test/ui/lifetimes/issue-103762-3.rs
index b4c4d3feb825a..7fccd5b23f2d1 100644
--- a/src/test/ui/lifetimes/issue-103762-3.rs
+++ b/src/test/ui/lifetimes/issue-103762-3.rs
@@ -1,17 +1,18 @@
-#![feature(anonymous_lifetime_in_impl_trait)]
+// #103762: cases that pre-1.64 rejected, but that we now allow after the fix.
 
-trait Trait {}
+// check-pass
 
-// Pre-1.64 rejected this because of `+ '_`, 1.64 rejects it because of `-> &str`.
-// We should keep rejecting it.
-fn d1(_: impl Trait + '_)
-    -> &str { loop {} } //~ ERROR missing lifetime specifier
+#![allow(bare_trait_objects)]
 
-// Pre-1.64 rejected these because of `+ '_`, 1.64 allows them with the feature enabled.
-// We should keep allowing them.
-fn d2(_: &(impl Trait + '_)) -> &str { loop {} }
-fn d3(_: &i32, _: impl Trait + '_) -> &str { loop {} }
-fn d4(_: impl Trait + '_, _: &i32) -> &str { loop {} }
+trait Trait {}
 
+// Case 1: Inside fn() type.
+// Pre-1.64 and 1.64 rejected this, but we can allow it.
+fn a1(_: fn(&(dyn Trait + '_)) -> &str) { loop {} }
+fn a2(_: fn(&(Trait + '_)) -> &str) { loop {} }
+fn a_closure() {
+    let _ = |_: fn(&(dyn Trait + '_)) -> &str| loop {};
+    let _ = |_: fn(&(Trait + '_)) -> &str| loop {};
+}
 
 fn main() {}