wip

Author: cjgillot

compiler/rustc_ast_lowering/src/index.rs

@@ -146,10 +146,6 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
         self.visit_body(body);
     }
 
-    fn visit_nested_opaque_ty(&mut self, opaq: &'hir OpaqueTy<'hir>) -> Self::Result {
-        self.visit_opaque_ty(opaq)
-    }
-
     fn visit_param(&mut self, param: &'hir Param<'hir>) {
         let node = Node::Param(param);
         self.insert(param.pat.span, param.hir_id, node);

compiler/rustc_ast_lowering/src/lib.rs

@@ -1619,16 +1619,15 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         opaque_ty_span: Span,
         lower_item_bounds: impl FnOnce(&mut Self) -> &'hir [hir::GenericBound<'hir>],
     ) -> hir::TyKind<'hir> {
-        let opaque_ty_hir_id = self.next_id();
         let opaque_ty_def_id = self.create_def(
-            self.current_hir_id_owner.def_id, // FIXME: should this use self.current_def_id_parent?
+            self.current_def_id_parent,
             opaque_ty_node_id,
             kw::Empty,
             DefKind::OpaqueTy,
             opaque_ty_span,
         );
-        debug!(?opaque_ty_def_id);
-        self.children.push((opaque_ty_def_id, hir::MaybeOwner::NonOwner(opaque_ty_hir_id)));
+        let opaque_ty_hir_id = self.lower_node_id(opaque_ty_node_id);
+        debug!(?opaque_ty_def_id, ?opaque_ty_hir_id);
 
         // Map from captured (old) lifetime to synthetic (new) lifetime.
         // Used to resolve lifetimes in the bounds of the opaque.

compiler/rustc_hir/src/hir.rs

@@ -3959,7 +3959,7 @@ impl<'hir> Node<'hir> {
             | Node::TraitItem(TraitItem { generics, .. })
             | Node::ImplItem(ImplItem { generics, .. }) => Some(generics),
             Node::Item(item) => item.kind.generics(),
-            Node::OpaqueTy(opaq) => Some(opaq.generics),
+            Node::OpaqueTy(opaque) => Some(opaque.generics),
             _ => None,
         }
     }

compiler/rustc_hir/src/intravisit.rs

@@ -294,14 +294,6 @@ pub trait Visitor<'v>: Sized {
         Self::Result::output()
     }
 
-    #[track_caller]
-    fn visit_nested_opaque_ty(&mut self, opaq: &'v OpaqueTy<'v>) -> Self::Result {
-        if Self::NestedFilter::INTRA {
-            try_visit!(self.visit_opaque_ty(opaq));
-        }
-        Self::Result::output()
-    }
-
     fn visit_param(&mut self, param: &'v Param<'v>) -> Self::Result {
         walk_param(self, param)
     }
@@ -435,8 +427,8 @@ pub trait Visitor<'v>: Sized {
     fn visit_poly_trait_ref(&mut self, t: &'v PolyTraitRef<'v>) -> Self::Result {
         walk_poly_trait_ref(self, t)
     }
-    fn visit_opaque_ty(&mut self, opaq: &'v OpaqueTy<'v>) -> Self::Result {
-        walk_opaque_ty(self, opaq)
+    fn visit_opaque_ty(&mut self, opaque: &'v OpaqueTy<'v>) -> Self::Result {
+        walk_opaque_ty(self, opaque)
     }
     fn visit_variant_data(&mut self, s: &'v VariantData<'v>) -> Self::Result {
         walk_struct_def(self, s)
@@ -904,8 +896,8 @@ pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty<'v>) -> V::Resul
         TyKind::Path(ref qpath) => {
             try_visit!(visitor.visit_qpath(qpath, typ.hir_id, typ.span));
         }
-        TyKind::OpaqueDef(opaq, lifetimes, _in_trait) => {
-            try_visit!(visitor.visit_nested_opaque_ty(opaq));
+        TyKind::OpaqueDef(opaque, lifetimes, _in_trait) => {
+            try_visit!(visitor.visit_opaque_ty(opaque));
             walk_list!(visitor, visit_generic_arg, lifetimes);
         }
         TyKind::Array(ref ty, ref length) => {
@@ -1195,8 +1187,17 @@ pub fn walk_poly_trait_ref<'v, V: Visitor<'v>>(
     visitor.visit_trait_ref(&trait_ref.trait_ref)
 }
 
-pub fn walk_opaque_ty<'v, V: Visitor<'v>>(visitor: &mut V, opaq: &'v OpaqueTy<'v>) -> V::Result {
-    let &OpaqueTy { hir_id, generics, bounds, .. } = opaq;
+pub fn walk_opaque_ty<'v, V: Visitor<'v>>(visitor: &mut V, opaque: &'v OpaqueTy<'v>) -> V::Result {
+    let &OpaqueTy {
+        hir_id,
+        def_id: _,
+        generics,
+        bounds,
+        origin: _,
+        lifetime_mapping: _,
+        in_trait: _,
+        span: _,
+    } = opaque;
     try_visit!(visitor.visit_id(hir_id));
     try_visit!(walk_generics(visitor, generics));
     walk_list!(visitor, visit_param_bound, bounds);

compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

@@ -486,34 +486,27 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
     }
 
     #[instrument(level = "debug", skip(self))]
-    fn visit_opaque_ty(&mut self, opaq: &'tcx rustc_hir::OpaqueTy<'tcx>) {
-        let (hir::OpaqueTyOrigin::FnReturn(parent)
-        | hir::OpaqueTyOrigin::AsyncFn(parent)
-        | hir::OpaqueTyOrigin::TyAlias { parent, .. }) = opaq.origin;
-
+    fn visit_opaque_ty(&mut self, opaque: &'tcx rustc_hir::OpaqueTy<'tcx>) {
         // We want to start our early-bound indices at the end of the parent scope,
         // not including any parent `impl Trait`s.
         let mut bound_vars = FxIndexMap::default();
-        debug!(?opaq.generics.params);
-        for param in opaq.generics.params {
+        debug!(?opaque.generics.params);
+        for param in opaque.generics.params {
             let (def_id, reg) = ResolvedArg::early(param);
             bound_vars.insert(def_id, reg);
         }
 
-        let scope = Scope::Root { opt_parent_item: Some(parent) };
-        let hir_id = self.tcx.local_def_id_to_hir_id(opaq.def_id);
+        let hir_id = self.tcx.local_def_id_to_hir_id(opaque.def_id);
+        let scope = Scope::Binder {
+            hir_id,
+            bound_vars,
+            s: self.scope,
+            scope_type: BinderScopeType::Normal,
+            where_bound_origin: None,
+        };
         self.with(scope, |this| {
-            let scope = Scope::Binder {
-                hir_id,
-                bound_vars,
-                s: this.scope,
-                scope_type: BinderScopeType::Normal,
-                where_bound_origin: None,
-            };
-            this.with(scope, |this| {
-                let scope = Scope::TraitRefBoundary { s: this.scope };
-                this.with(scope, |this| intravisit::walk_opaque_ty(this, opaq))
-            });
+            let scope = Scope::TraitRefBoundary { s: this.scope };
+            this.with(scope, |this| intravisit::walk_opaque_ty(this, opaque))
         })
     }