Remove NEW_COLLECT_LIFETIMES env var

1 files changed, 82 insertions, 104 deletions

diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index b8383af521f..aa84373b6cf 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -1377,125 +1377,103 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             let hir_bounds = if origin == hir::OpaqueTyOrigin::TyAlias {
                 lctx.lower_param_bounds(bounds, itctx, true)
             } else {
-                if std::env::var("NEW_COLLECT_LIFETIMES").is_ok() {
-                    debug!(?lctx.captured_lifetimes);
-
-                    let lifetime_stash = std::mem::replace(
-                        &mut lctx.captured_lifetimes,
-                        Some(LifetimeCaptureContext {
-                            parent_def_id: opaque_ty_def_id,
-                            captures: std::mem::take(&mut collected_lifetimes),
-                            binders_to_ignore: Default::default(),
-                        }),
-                    );
-
-                    let (lifetimes_in_bounds, binders_to_ignore) = ast::lifetimes_in_bounds(bounds);
-                    debug!(?lifetimes_in_bounds);
-                    debug!(?binders_to_ignore);
-
-                    for lifetime in &lifetimes_in_bounds {
-                        let ident = lifetime.ident;
-                        let span = ident.span;
-
-                        let res = lctx
-                            .resolver
-                            .get_lifetime_res(lifetime.id)
-                            .unwrap_or(LifetimeRes::Error);
-                        debug!(?res);
-
-                        if let Some(mut captured_lifetimes) = lctx.captured_lifetimes.take() {
-                            match res {
-                                LifetimeRes::Param { param, binder } => {
-                                    if !captured_lifetimes.binders_to_ignore.contains(&binder)
-                                        && !binders_to_ignore
-                                            .get(&lifetime.id)
-                                            .unwrap_or(&Vec::new())
-                                            .contains(&binder)
-                                    {
-                                        match captured_lifetimes.captures.entry(param) {
-                                            Entry::Occupied(_) => {}
-                                            Entry::Vacant(v) => {
-                                                let node_id = lctx.next_node_id();
-                                                let name = ParamName::Plain(ident);
-
-                                                lctx.create_def(
-                                                    captured_lifetimes.parent_def_id,
-                                                    node_id,
-                                                    DefPathData::LifetimeNs(name.ident().name),
-                                                );
-
-                                                v.insert((span, node_id, name, res));
-                                            }
+                debug!(?lctx.captured_lifetimes);
+
+                let lifetime_stash = std::mem::replace(
+                    &mut lctx.captured_lifetimes,
+                    Some(LifetimeCaptureContext {
+                        parent_def_id: opaque_ty_def_id,
+                        captures: std::mem::take(&mut collected_lifetimes),
+                        binders_to_ignore: Default::default(),
+                    }),
+                );
+
+                let (lifetimes_in_bounds, binders_to_ignore) = ast::lifetimes_in_bounds(bounds);
+                debug!(?lifetimes_in_bounds);
+                debug!(?binders_to_ignore);
+
+                for lifetime in &lifetimes_in_bounds {
+                    let ident = lifetime.ident;
+                    let span = ident.span;
+
+                    let res =
+                        lctx.resolver.get_lifetime_res(lifetime.id).unwrap_or(LifetimeRes::Error);
+                    debug!(?res);
+
+                    if let Some(mut captured_lifetimes) = lctx.captured_lifetimes.take() {
+                        match res {
+                            LifetimeRes::Param { param, binder } => {
+                                if !captured_lifetimes.binders_to_ignore.contains(&binder)
+                                    && !binders_to_ignore
+                                        .get(&lifetime.id)
+                                        .unwrap_or(&Vec::new())
+                                        .contains(&binder)
+                                {
+                                    match captured_lifetimes.captures.entry(param) {
+                                        Entry::Occupied(_) => {}
+                                        Entry::Vacant(v) => {
+                                            let node_id = lctx.next_node_id();
+                                            let name = ParamName::Plain(ident);
+
+                                            lctx.create_def(
+                                                captured_lifetimes.parent_def_id,
+                                                node_id,
+                                                DefPathData::LifetimeNs(name.ident().name),
+                                            );
+
+                                            v.insert((span, node_id, name, res));
                                         }
                                     }
                                 }
+                            }
 
-                                LifetimeRes::Fresh { param, binder } => {
-                                    debug_assert_eq!(ident.name, kw::UnderscoreLifetime);
-                                    if !captured_lifetimes.binders_to_ignore.contains(&binder)
-                                        && !binders_to_ignore
-                                            .get(&lifetime.id)
-                                            .unwrap_or(&Vec::new())
-                                            .contains(&binder)
-                                    {
-                                        let param = lctx.local_def_id(param);
-                                        match captured_lifetimes.captures.entry(param) {
-                                            Entry::Occupied(_) => {}
-                                            Entry::Vacant(v) => {
-                                                let node_id = lctx.next_node_id();
-
-                                                let name = ParamName::Fresh;
-
-                                                lctx.create_def(
-                                                    captured_lifetimes.parent_def_id,
-                                                    node_id,
-                                                    DefPathData::LifetimeNs(kw::UnderscoreLifetime),
-                                                );
-
-                                                v.insert((span, node_id, name, res));
-                                            }
+                            LifetimeRes::Fresh { param, binder } => {
+                                debug_assert_eq!(ident.name, kw::UnderscoreLifetime);
+                                if !captured_lifetimes.binders_to_ignore.contains(&binder)
+                                    && !binders_to_ignore
+                                        .get(&lifetime.id)
+                                        .unwrap_or(&Vec::new())
+                                        .contains(&binder)
+                                {
+                                    let param = lctx.local_def_id(param);
+                                    match captured_lifetimes.captures.entry(param) {
+                                        Entry::Occupied(_) => {}
+                                        Entry::Vacant(v) => {
+                                            let node_id = lctx.next_node_id();
+
+                                            let name = ParamName::Fresh;
+
+                                            lctx.create_def(
+                                                captured_lifetimes.parent_def_id,
+                                                node_id,
+                                                DefPathData::LifetimeNs(kw::UnderscoreLifetime),
+                                            );
+
+                                            v.insert((span, node_id, name, res));
                                         }
                                     }
                                 }
-
-                                LifetimeRes::Infer | LifetimeRes::Static | LifetimeRes::Error => {}
-
-                                res => panic!(
-                                    "Unexpected lifetime resolution {:?} for {:?} at {:?}",
-                                    res, lifetime.ident, lifetime.ident.span
-                                ),
                             }
 
-                            lctx.captured_lifetimes = Some(captured_lifetimes);
-                        }
-                    }
-
-                    let ret = lctx.lower_param_bounds(bounds, itctx, false);
+                            LifetimeRes::Infer | LifetimeRes::Static | LifetimeRes::Error => {}
 
-                    let ctxt =
-                        std::mem::replace(&mut lctx.captured_lifetimes, lifetime_stash).unwrap();
+                            res => panic!(
+                                "Unexpected lifetime resolution {:?} for {:?} at {:?}",
+                                res, lifetime.ident, lifetime.ident.span
+                            ),
+                        }
 
-                    collected_lifetimes = ctxt.captures;
+                        lctx.captured_lifetimes = Some(captured_lifetimes);
+                    }
+                }
 
-                    ret
-                } else {
-                    let lifetime_stash = std::mem::replace(
-                        &mut lctx.captured_lifetimes,
-                        Some(LifetimeCaptureContext {
-                            parent_def_id: opaque_ty_def_id,
-                            captures: std::mem::take(&mut collected_lifetimes),
-                            binders_to_ignore: Default::default(),
-                        }),
-                    );
+                let ret = lctx.lower_param_bounds(bounds, itctx, false);
 
-                    let ret = lctx.lower_param_bounds(bounds, itctx, true);
+                let ctxt = std::mem::replace(&mut lctx.captured_lifetimes, lifetime_stash).unwrap();
 
-                    let ctxt =
-                        std::mem::replace(&mut lctx.captured_lifetimes, lifetime_stash).unwrap();
-                    collected_lifetimes = ctxt.captures;
+                collected_lifetimes = ctxt.captures;
 
-                    ret
-                }
+                ret
             };
             debug!(?collected_lifetimes);