Rollup of 14 pull requests

compiler/rustc_ast/src/ast.rs

@@ -4239,11 +4239,20 @@ pub struct TestBinderBody {
     pub span: Span,
     pub foralls: ThinVec<TestBinderForall>,
     pub exists: ThinVec<TestBinderExists>,
+    pub region_equalities: Vec<TestBinderRegionEquality>,
     pub constraints: Vec<TestBinderConstraint>,
     /// These are not where clauses, but rather predicates within the body to be proven
     pub predicates: Vec<WherePredicate>,
 }
 
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
+pub struct TestBinderRegionEquality {
+    #[visitable(extra = LifetimeCtxt::Bound)]
+    pub lhs: Lifetime,
+    #[visitable(extra = LifetimeCtxt::Bound)]
+    pub rhs: Lifetime,
+}
+
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct TestBinderForall {
     pub span: Span,

compiler/rustc_ast/src/visit.rs

@@ -560,6 +560,7 @@ macro_rules! common_visitor_and_walkers {
             StructExpr,
             StructRest,
             Term,
+            TestBinderRegionEquality,
             Trait,
             TraitBoundModifiers,
             TraitObjectSyntax,

compiler/rustc_ast_lowering/src/block.rs

@@ -1,5 +1,5 @@
 use rustc_ast::{Block, BlockCheckMode, Local, LocalKind, Stmt, StmtKind};
-use rustc_attr_ir::target::Target;
+use rustc_attr_ir::target::{AstTarget, Target};
 use rustc_hir as hir;
 use rustc_span::sym;
 use smallvec::SmallVec;
@@ -37,7 +37,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             match &s.kind {
                 StmtKind::Let(local) => {
                     let hir_id = self.lower_node_id(s.id);
-                    let local = self.lower_local(local);
+                    let local = self.lower_local(local, &s);
                     self.alias_attrs(hir_id, local.hir_id);
                     let kind = hir::StmtKind::Let(local);
                     let span = self.lower_span(s.span);
@@ -88,7 +88,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
-    fn lower_local(&mut self, l: &Local) -> &'hir hir::LetStmt<'hir> {
+    fn lower_local(&mut self, l: &Local, s: &Stmt) -> &'hir hir::LetStmt<'hir> {
         // Let statements are allowed to have impl trait in bindings.
         let super_ = l.super_.map(|span| self.lower_span(span));
         let ty = l.ty.as_ref().map(|t| {
@@ -104,7 +104,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         };
         let span = self.lower_span(l.span);
         let source = hir::LocalSource::Normal;
-        self.lower_attrs(hir_id, &l.attrs, l.span, Target::Statement);
+        self.lower_attrs(hir_id, &l.attrs, l.span, Target::Statement, AstTarget::Statement(s));
         self.arena.alloc(hir::LetStmt { hir_id, super_, ty, pat, init, els, span, source })
     }
 

compiler/rustc_ast_lowering/src/expr.rs

@@ -6,7 +6,7 @@ use rustc_ast::node_id::NodeMap;
 use rustc_ast::visit::{Visitor, walk_expr};
 use rustc_ast::*;
 use rustc_attr_ir::lang_items::LangItem;
-use rustc_attr_ir::target::Target;
+use rustc_attr_ir::target::{AstTarget, Target};
 use rustc_errors::msg;
 use rustc_hir as hir;
 use rustc_hir::HirId;
@@ -231,7 +231,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     let old_attrs =
                         self.curr_owner.attrs.get(&ex.hir_id.local_id).copied().unwrap_or(&[]);
                     let new_attrs = self
-                        .lower_attrs_vec(&e.attrs, e.span, ex.hir_id, Target::from_expr(e), None)
+                        .lower_attrs_vec(
+                            &e.attrs,
+                            e.span,
+                            ex.hir_id,
+                            Target::from_expr(e),
+                            AstTarget::Expression(e),
+                        )
                         .into_iter()
                         .chain(old_attrs.iter().cloned());
                     let new_attrs = &*self.arena.alloc_from_iter(new_attrs);
@@ -255,7 +261,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
 
         let expr_hir_id = self.lower_node_id(e.id);
-        self.lower_attrs(expr_hir_id, &e.attrs, e.span, Target::from_expr(e));
+        self.lower_attrs(
+            expr_hir_id,
+            &e.attrs,
+            e.span,
+            Target::from_expr(e),
+            AstTarget::Expression(e),
+        );
 
         let kind = match &e.kind {
             ExprKind::Array(exprs) => hir::ExprKind::Array(self.lower_exprs(exprs)),
@@ -480,8 +492,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
             ExprKind::Continue(opt_label) => {
                 hir::ExprKind::Continue(self.lower_jump_destination(e.id, *opt_label))
             }
-            ExprKind::Ret(e) => {
-                let expr = e.as_ref().map(|x| self.lower_expr(x));
+            ExprKind::Ret(box_e) => {
+                let expr = box_e.as_ref().map(|x| self.lower_expr(x));
                 self.checked_return(expr)
             }
             ExprKind::Yeet(sub_expr) => self.lower_expr_yeet(e.span, sub_expr.as_deref()),
@@ -795,7 +807,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let guard = arm.guard.as_ref().map(|guard| self.lower_expr(&guard.cond));
         let hir_id = self.next_id();
         let span = self.lower_span(arm.span);
-        self.lower_attrs(hir_id, &arm.attrs, arm.span, Target::Arm);
+        self.lower_attrs(hir_id, &arm.attrs, arm.span, Target::Arm, AstTarget::Arm(arm));
         let is_never_pattern = pat.is_never_pattern();
         // We need to lower the body even if it's unneeded for never pattern in match,
         // ensure that we can get HirId for DefId if need (issue #137708).
@@ -1659,7 +1671,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     fn lower_expr_field(&mut self, f: &ExprField) -> hir::ExprField<'hir> {
         let hir_id = self.lower_node_id(f.id);
-        self.lower_attrs(hir_id, &f.attrs, f.span, Target::ExprField);
+        self.lower_attrs(hir_id, &f.attrs, f.span, Target::ExprField, AstTarget::ExprField(f));
         hir::ExprField {
             hir_id,
             ident: self.lower_ident(f.ident),
@@ -1926,7 +1938,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
         //
         // Also, add the attributes to the outer returned expr node.
         let expr = self.expr_drop_temps_mut(for_span, match_expr);
-        self.lower_attrs(expr.hir_id, &e.attrs, e.span, Target::from_expr(e));
+        self.lower_attrs(
+            expr.hir_id,
+            &e.attrs,
+            e.span,
+            Target::from_expr(e),
+            AstTarget::Expression(e),
+        );
         expr
     }
 

compiler/rustc_ast_lowering/src/expr/closure.rs

@@ -1,6 +1,6 @@
 use rustc_ast::*;
 use rustc_attr_ir::find_attr;
-use rustc_attr_ir::target::Target;
+use rustc_attr_ir::target::{AstTarget, Target};
 use rustc_hir as hir;
 use rustc_hir::HirId;
 use rustc_span::{Span, span_bug};
@@ -20,7 +20,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
         closure: &Closure,
     ) -> hir::Expr<'hir> {
         let expr_hir_id = self.lower_node_id(e.id);
-        let attrs = self.lower_attrs(expr_hir_id, &e.attrs, e.span, Target::from_expr(e));
+        let attrs = self.lower_attrs(
+            expr_hir_id,
+            &e.attrs,
+            e.span,
+            Target::from_expr(e),
+            AstTarget::Closure(closure),
+        );
 
         match closure.coroutine_marker {
             Some(coroutine_marker) => self.lower_expr_coroutine_closure_with_move_exprs(

compiler/rustc_ast_lowering/src/item.rs

@@ -1,7 +1,7 @@
 use rustc_abi::ExternAbi;
 use rustc_ast::visit::AssocCtxt;
 use rustc_ast::*;
-use rustc_attr_ir::target::Target;
+use rustc_attr_ir::target::{AstTarget, Target};
 use rustc_attr_ir::{AttributeKind, EiiImplResolution, find_attr};
 use rustc_errors::{E0570, ErrorGuaranteed, struct_span_code_err};
 use rustc_hir::def::{DefKind, Res};
@@ -165,7 +165,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             &i.attrs,
             i.span,
             Target::from_ast_item(i),
-            Some(i),
+            AstTarget::from_ast_item(&i.kind),
             &extra_hir_attributes,
         );
 
@@ -614,8 +614,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
     pub(super) fn lower_foreign_item(&mut self, i: &ForeignItem) -> &'hir hir::ForeignItem<'hir> {
         let owner_id = self.curr_owner.owner_id();
         let hir_id: HirId = owner_id.into();
-        let attrs =
-            self.lower_attrs(hir_id, &i.attrs, i.span, Target::from_foreign_item_kind(&i.kind));
+        let attrs = self.lower_attrs(
+            hir_id,
+            &i.attrs,
+            i.span,
+            Target::from_foreign_item_kind(&i.kind),
+            AstTarget::from_foreign_item_kind(&i.kind),
+        );
         let (ident, kind) = match &i.kind {
             ForeignItemKind::Fn(Fn { sig, ident, generics, define_opaque, .. }) => {
                 let fdec = &sig.decl;
@@ -693,7 +698,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             self.dcx().span_fatal(v.span, "unnamed enum variants are not yet implemented");
         }
         let hir_id = self.lower_node_id(v.id);
-        self.lower_attrs(hir_id, &v.attrs, v.span, Target::Variant);
+        self.lower_attrs(hir_id, &v.attrs, v.span, Target::Variant, AstTarget::Variant(v));
         hir::Variant {
             hir_id,
             def_id: self.local_def_id(v.id),
@@ -780,7 +785,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let ty =
             self.lower_ty_alloc(&f.ty, ImplTraitContext::Disallowed(ImplTraitPosition::FieldTy));
         let hir_id = self.lower_node_id(f.id);
-        self.lower_attrs(hir_id, &f.attrs, f.span, Target::Field);
+        self.lower_attrs(hir_id, &f.attrs, f.span, Target::Field, AstTarget::Field(f));
         hir::FieldDef {
             span: self.lower_span(f.span),
             hir_id,
@@ -808,6 +813,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             &i.attrs,
             i.span,
             Target::from_assoc_item_kind(&i.kind, AssocCtxt::Trait),
+            AstTarget::from_assoc_item_kind(&i.kind),
         );
 
         let (ident, generics, kind, has_value) = match &i.kind {
@@ -1070,6 +1076,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             &i.attrs,
             i.span,
             Target::from_assoc_item_kind(&i.kind, AssocCtxt::Impl { of_trait: is_in_trait_impl }),
+            AstTarget::from_assoc_item_kind(&i.kind),
         );
 
         let (ident, (generics, kind)) = match &i.kind {
@@ -1238,7 +1245,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     fn lower_param(&mut self, param: &Param) -> hir::Param<'hir> {
         let hir_id = self.lower_node_id(param.id);
-        self.lower_attrs(hir_id, &param.attrs, param.span, Target::Param);
+        self.lower_attrs(hir_id, &param.attrs, param.span, Target::Param, AstTarget::Param(param));
         hir::Param {
             hir_id,
             pat: self.lower_pat(&param.pat),
@@ -1948,7 +1955,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
     ) -> hir::WherePredicate<'hir> {
         let hir_id = self.lower_node_id(pred.id);
         let span = self.lower_span(pred.span);
-        self.lower_attrs(hir_id, &pred.attrs, span, Target::WherePredicate);
+        self.lower_attrs(
+            hir_id,
+            &pred.attrs,
+            span,
+            Target::WherePredicate,
+            AstTarget::WherePredicate(pred),
+        );
         let kind = self.arena.alloc(match &pred.kind {
             WherePredicateKind::BoundPredicate(WhereBoundPredicate {
                 bound_generic_params,
@@ -2008,6 +2021,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let exists = self.arena.alloc_from_iter(
             body.exists.iter().map(|exists| self.lower_test_binder_exists(exists)),
         );
+        let region_equalities = self.arena.alloc_from_iter(body.region_equalities.iter().map(
+            |TestBinderRegionEquality { lhs, rhs }| {
+                let lhs = self.lower_lifetime(lhs, LifetimeSource::Other, lhs.ident.into());
+                let rhs = self.lower_lifetime(rhs, LifetimeSource::Other, rhs.ident.into());
+                (lhs, rhs)
+            },
+        ));
         let constraints = self.lower_test_binder_constraints_as_and(&body.constraints);
         let mut dedup_map = Default::default();
         let predicates = self.arena.alloc_from_iter(
@@ -2016,7 +2036,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 .map(|predicate| self.lower_where_predicate(predicate, &[], &mut dedup_map)),
         );
         let span = self.lower_span(body.span);
-        hir::TestBinderBody { foralls, exists, constraints, predicates, span }
+        hir::TestBinderBody { span, foralls, exists, region_equalities, constraints, predicates }
     }
 
     fn lower_test_binder_forall(