Clean up type alias impl trait implementation

src/librustc_ast/ast.rs

@@ -1858,15 +1858,6 @@ impl TyKind {
     pub fn is_unit(&self) -> bool {
         if let TyKind::Tup(ref tys) = *self { tys.is_empty() } else { false }
     }
-
-    /// HACK(type_alias_impl_trait, Centril): A temporary crutch used
-    /// in lowering to avoid making larger changes there and beyond.
-    pub fn opaque_top_hack(&self) -> Option<&GenericBounds> {
-        match self {
-            Self::ImplTrait(_, bounds) => Some(bounds),
-            _ => None,
-        }
-    }
 }
 
 /// Syntax used to declare a trait object.

src/librustc_ast_lowering/item.rs

@@ -1,12 +1,13 @@
 use super::{AnonymousLifetimeMode, LoweringContext, ParamMode};
-use super::{ImplTraitContext, ImplTraitPosition, ImplTraitTypeIdVisitor};
+use super::{ImplTraitContext, ImplTraitPosition};
 use crate::Arena;
 
 use rustc_ast::ast::*;
 use rustc_ast::attr;
 use rustc_ast::node_id::NodeMap;
 use rustc_ast::ptr::P;
 use rustc_ast::visit::{self, AssocCtxt, Visitor};
+use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::struct_span_err;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
@@ -165,13 +166,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
             }
             ItemKind::MacroDef(..) => SmallVec::new(),
             ItemKind::Fn(..) | ItemKind::Impl { of_trait: None, .. } => smallvec![i.id],
-            ItemKind::Static(ref ty, ..) | ItemKind::Const(_, ref ty, ..) => {
-                let mut ids = smallvec![i.id];
-                if self.sess.features_untracked().impl_trait_in_bindings {
-                    ImplTraitTypeIdVisitor { ids: &mut ids }.visit_ty(ty);
-                }
-                ids
-            }
             _ => smallvec![i.id],
         };
 
@@ -292,23 +286,25 @@ impl<'hir> LoweringContext<'_, 'hir> {
             ItemKind::Mod(ref m) => hir::ItemKind::Mod(self.lower_mod(m)),
             ItemKind::ForeignMod(ref nm) => hir::ItemKind::ForeignMod(self.lower_foreign_mod(nm)),
             ItemKind::GlobalAsm(ref ga) => hir::ItemKind::GlobalAsm(self.lower_global_asm(ga)),
-            ItemKind::TyAlias(_, ref gen, _, Some(ref ty)) => match ty.kind.opaque_top_hack() {
-                None => {
-                    let ty = self.lower_ty(ty, ImplTraitContext::disallowed());
-                    let generics = self.lower_generics(gen, ImplTraitContext::disallowed());
-                    hir::ItemKind::TyAlias(ty, generics)
-                }
-                Some(bounds) => {
-                    let ctx = || ImplTraitContext::OpaqueTy(None, hir::OpaqueTyOrigin::Misc);
-                    let ty = hir::OpaqueTy {
-                        generics: self.lower_generics(gen, ctx()),
-                        bounds: self.lower_param_bounds(bounds, ctx()),
-                        impl_trait_fn: None,
-                        origin: hir::OpaqueTyOrigin::TypeAlias,
-                    };
-                    hir::ItemKind::OpaqueTy(ty)
-                }
-            },
+            ItemKind::TyAlias(_, ref gen, _, Some(ref ty)) => {
+                // We lower
+                //
+                // type Foo = impl Trait
+                //
+                // to
+                //
+                // type Foo = Foo1
+                // opaque type Foo1: Trait
+                let ty = self.lower_ty(
+                    ty,
+                    ImplTraitContext::OtherOpaqueTy {
+                        capturable_lifetimes: &mut FxHashSet::default(),
+                        origin: hir::OpaqueTyOrigin::Misc,
+                    },
+                );
+                let generics = self.lower_generics(gen, ImplTraitContext::disallowed());
+                hir::ItemKind::TyAlias(ty, generics)
+            }
             ItemKind::TyAlias(_, ref generics, _, None) => {
                 let ty = self.arena.alloc(self.ty(span, hir::TyKind::Err));
                 let generics = self.lower_generics(generics, ImplTraitContext::disallowed());
@@ -438,8 +434,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
         span: Span,
         body: Option<&Expr>,
     ) -> (&'hir hir::Ty<'hir>, hir::BodyId) {
+        let mut capturable_lifetimes;
         let itctx = if self.sess.features_untracked().impl_trait_in_bindings {
-            ImplTraitContext::OpaqueTy(None, hir::OpaqueTyOrigin::Misc)
+            capturable_lifetimes = FxHashSet::default();
+            ImplTraitContext::OtherOpaqueTy {
+                capturable_lifetimes: &mut capturable_lifetimes,
+                origin: hir::OpaqueTyOrigin::Misc,
+            }
         } else {
             ImplTraitContext::Disallowed(ImplTraitPosition::Binding)
         };
@@ -844,16 +845,16 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         let ty = self.arena.alloc(self.ty(i.span, hir::TyKind::Err));
                         hir::ImplItemKind::TyAlias(ty)
                     }
-                    Some(ty) => match ty.kind.opaque_top_hack() {
-                        None => {
-                            let ty = self.lower_ty(ty, ImplTraitContext::disallowed());
-                            hir::ImplItemKind::TyAlias(ty)
-                        }
-                        Some(bs) => {
-                            let bs = self.lower_param_bounds(bs, ImplTraitContext::disallowed());
-                            hir::ImplItemKind::OpaqueTy(bs)
-                        }
-                    },
+                    Some(ty) => {
+                        let ty = self.lower_ty(
+                            ty,
+                            ImplTraitContext::OtherOpaqueTy {
+                                capturable_lifetimes: &mut FxHashSet::default(),
+                                origin: hir::OpaqueTyOrigin::Misc,
+                            },
+                        );
+                        hir::ImplItemKind::TyAlias(ty)
+                    }
                 };
                 (generics, kind)
             }
@@ -887,12 +888,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             defaultness,
             kind: match &i.kind {
                 AssocItemKind::Const(..) => hir::AssocItemKind::Const,
-                AssocItemKind::TyAlias(.., ty) => {
-                    match ty.as_deref().and_then(|ty| ty.kind.opaque_top_hack()) {
-                        None => hir::AssocItemKind::Type,
-                        Some(_) => hir::AssocItemKind::OpaqueTy,
-                    }
-                }
+                AssocItemKind::TyAlias(..) => hir::AssocItemKind::Type,
                 AssocItemKind::Fn(_, sig, ..) => {
                     hir::AssocItemKind::Fn { has_self: sig.decl.has_self() }
                 }