Rollup of 25 pull requests

Cargo.lock

@@ -198,9 +198,9 @@ checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
 [[package]]
 name = "askama"
-version = "0.16.0"
+version = "0.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1bf825125edd887a019d0a3a837dcc5499a68b0d034cc3eb594070c3e18addc"
+checksum = "6024d73179f43f15ccd2b881bfea6fee7f3a46ec53f33b52210dea749ebebaa4"
 dependencies = [
  "askama_macros",
  "itoa",
@@ -211,9 +211,9 @@ dependencies = [
 
 [[package]]
 name = "askama_derive"
-version = "0.16.0"
+version = "0.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1c7065972a130eafa84215f21352ae15b4a7393da48c1f5e103904490736738"
+checksum = "071ee5ebf2138e3ad180e0aacf6940c2cab5e6d8333741d9925c7bee2b153f39"
 dependencies = [
  "askama_parser",
  "basic-toml",
@@ -224,23 +224,23 @@ dependencies = [
  "rustc-hash 2.1.1",
  "serde",
  "serde_derive",
- "syn 2.0.117",
+ "syn 3.0.3",
 ]
 
 [[package]]
 name = "askama_macros"
-version = "0.16.0"
+version = "0.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e23b1d2c4bd39a41971f6124cef4cc6fd0540913ecb90919b69ab3bbe44ae1a"
+checksum = "643e1c7cbb6aec1d920332fe51a7c0d8219e273dcb8602db03f5263e4d16487b"
 dependencies = [
  "askama_derive",
 ]
 
 [[package]]
 name = "askama_parser"
-version = "0.16.0"
+version = "0.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7db09fde9143e7ac4513358fb32ee32847125b63b18ea715afd487956da715da"
+checksum = "2c5ae75772275d268b03ab8bdccdd12117b6169ee23256942b34e46c9f476583"
 dependencies = [
  "rustc-hash 2.1.1",
  "serde",
@@ -4909,6 +4909,7 @@ dependencies = [
  "rustc_data_structures",
  "rustc_errors",
  "rustc_hir",
+ "rustc_index",
  "rustc_infer",
  "rustc_lint_defs",
  "rustc_macros",

compiler/rustc_ast/src/ast.rs

@@ -29,7 +29,6 @@ use rustc_data_structures::stable_hash::{StableHash, StableHashCtxt, StableHashe
 use rustc_data_structures::tagged_ptr::Tag;
 use rustc_macros::{Decodable, Encodable, StableHash, Walkable};
 pub use rustc_span::AttrId;
-use rustc_span::def_id::LocalDefId;
 use rustc_span::{
     ByteSymbol, DUMMY_SP, ErrorGuaranteed, Ident, LocalExpnId, Span, Spanned, Symbol, kw, respan,
     sym,
@@ -4081,6 +4080,8 @@ pub struct TestBinderBody {
     pub foralls: ThinVec<TestBinderForall>,
     pub exists: ThinVec<TestBinderExists>,
     pub constraints: Vec<TestBinderConstraint>,
+    /// These are not where clauses, but rather predicates within the body to be proven
+    pub predicates: Vec<WhereClause>,
 }
 
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]
@@ -4114,11 +4115,24 @@ pub enum TestBinderConstraint {
         #[visitable(extra = LifetimeCtxt::Bound)]
         rhs: Lifetime,
     },
-    Type {
+    PlaceholderOutlives {
         lhs: Box<Ty>,
         #[visitable(extra = LifetimeCtxt::Bound)]
         rhs: Lifetime,
     },
+    AliasOutlives {
+        bound_type_constraint: TestBinderBoundTypeConstraint,
+    },
+}
+
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
+pub struct TestBinderBoundTypeConstraint {
+    pub span: Span,
+    pub node_id: NodeId,
+    pub params: ThinVec<GenericParam>,
+    pub lhs: Box<Ty>,
+    #[visitable(extra = LifetimeCtxt::Bound)]
+    pub rhs: Lifetime,
 }
 
 // Adding a new variant? Please update `test_item` in `tests/ui/macros/stringify.rs`.
@@ -4445,24 +4459,6 @@ impl TryFrom<ItemKind> for ForeignItemKind {
 }
 
 pub type ForeignItem = Item<ForeignItemKind>;
-
-/// Fragment of the AST according to "HIR owner" semantics.
-///
-/// This is used to map each `LocalDefId` to its content's AST.
-#[derive(Debug)]
-pub enum AstOwner {
-    /// This definition does not correspond to a HIR owner.
-    NonOwner,
-    /// This definition corresponds to a nested `use` tree.
-    /// The `LocalDefId` points to its HIR owner.
-    NestedUseTree(LocalDefId),
-    Crate(Box<Crate>),
-    Item(Box<Item>),
-    TraitItem(Box<AssocItem>),
-    ImplItem(Box<AssocItem>),
-    ForeignItem(Box<ForeignItem>),
-}
-
 // Some nodes are used a lot. Make sure they don't unintentionally get bigger.
 #[cfg(target_pointer_width = "64")]
 mod size_asserts {

compiler/rustc_ast/src/visit.rs

@@ -600,6 +600,7 @@ macro_rules! common_visitor_and_walkers {
                 fn visit_qself(QSelf);
                 fn visit_test_binder_body(TestBinderBody);
                 fn visit_test_binder_constraint(TestBinderConstraint);
+                fn visit_test_binder_bound_type_constraint(TestBinderBoundTypeConstraint);
                 fn visit_test_binder_constraints(TestBinderConstraints);
                 fn visit_test_binder_exists(TestBinderExists);
                 fn visit_test_binder_forall(TestBinderForall);
@@ -1145,6 +1146,7 @@ macro_rules! common_visitor_and_walkers {
             pub fn walk_qself(QSelf);
             pub fn walk_test_binder_body(TestBinderBody);
             pub fn walk_test_binder_constraint(TestBinderConstraint);
+            pub fn walk_test_binder_bound_type_constraint(TestBinderBoundTypeConstraint);
             pub fn walk_test_binder_exists(TestBinderExists);
             pub fn walk_test_binder_forall(TestBinderForall);
             pub fn walk_trait_ref(TraitRef);

compiler/rustc_ast_lowering/src/index.rs

@@ -432,13 +432,27 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
         intravisit::walk_precise_capturing_arg(self, arg);
     }
 
-    fn visit_test_binder_forall(&mut self, forall: &'hir TestBinderForall<'hir>) -> Self::Result {
+    fn visit_test_binder_forall(&mut self, forall: &'hir TestBinderForall<'hir>) {
         self.insert(forall.span, forall.hir_id, Node::TestBinderForall(forall));
         self.with_parent(forall.hir_id, |this| intravisit::walk_test_binder_forall(this, forall))
     }
 
-    fn visit_test_binder_exists(&mut self, exists: &'hir TestBinderExists<'hir>) -> Self::Result {
+    fn visit_test_binder_exists(&mut self, exists: &'hir TestBinderExists<'hir>) {
         self.insert(exists.span, exists.hir_id, Node::TestBinderExists(exists));
         self.with_parent(exists.hir_id, |this| intravisit::walk_test_binder_exists(this, exists))
     }
+
+    fn visit_test_binder_bound_type_constraint(
+        &mut self,
+        bound_type: &'hir TestBinderBoundTypeConstraint<'hir>,
+    ) {
+        self.insert(
+            bound_type.span,
+            bound_type.hir_id,
+            Node::TestBinderBoundTypeConstraint(bound_type),
+        );
+        self.with_parent(bound_type.hir_id, |this| {
+            intravisit::walk_test_binder_bound_type_constraint(this, bound_type)
+        })
+    }
 }

compiler/rustc_ast_lowering/src/item.rs

@@ -8,9 +8,10 @@ use rustc_hir::{
     self as hir, CRATE_OWNER_ID, HirId, ImplItemImplKind, LifetimeSource, PredicateOrigin, Target,
     find_attr,
 };
+use rustc_middle::middle::resolve::ResolverAstLowering;
 use rustc_middle::span_bug;
+use rustc_middle::ty::TyCtxt;
 use rustc_middle::ty::data_structures::IndexMap;
-use rustc_middle::ty::{ResolverAstLowering, TyCtxt};
 use rustc_span::def_id::{DefId, LocalDefId};
 use rustc_span::edit_distance::find_best_match_for_name;
 use rustc_span::{DUMMY_SP, DesugaringKind, Ident, Span, Symbol, kw, sym};
@@ -2111,7 +2112,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
             body.exists.iter().map(|exists| self.lower_test_binder_exists(exists)),
         );
         let constraints = self.lower_test_binder_constraints_as_and(&body.constraints);
-        hir::TestBinderBody { foralls, exists, constraints }
+        let mut dedup_map = Default::default();
+        let predicates = self.arena.alloc_from_iter(
+            body.predicates
+                .iter()
+                .flat_map(|w| &w.predicates)
+                .map(|predicate| self.lower_where_predicate(predicate, &[], &mut dedup_map)),
+        );
+        hir::TestBinderBody { foralls, exists, constraints, predicates }
     }
 
     fn lower_test_binder_forall(
@@ -2193,12 +2201,45 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let rhs = self.lower_lifetime(rhs, LifetimeSource::OutlivesBound, rhs.ident.into());
                 hir::TestBinderConstraint::Lifetime { lhs, rhs }
             }
-            TestBinderConstraint::Type { lhs, rhs } => {
+            TestBinderConstraint::PlaceholderOutlives { lhs, rhs } => {
                 let lhs = self
                     .lower_ty_alloc(lhs, ImplTraitContext::Disallowed(ImplTraitPosition::Bound));
                 let rhs = self.lower_lifetime(rhs, LifetimeSource::OutlivesBound, rhs.ident.into());
-                hir::TestBinderConstraint::Type { lhs, rhs }
+                hir::TestBinderConstraint::PlaceholderOutlives { lhs, rhs }
+            }
+            TestBinderConstraint::AliasOutlives { bound_type_constraint } => {
+                hir::TestBinderConstraint::AliasOutlives {
+                    bound_type_constraint: self
+                        .arena
+                        .alloc(self.lower_test_binder_bound_type_constraint(bound_type_constraint)),
+                }
             }
         }
     }
+
+    fn lower_test_binder_bound_type_constraint(
+        &mut self,
+        bound_type: &TestBinderBoundTypeConstraint,
+    ) -> hir::TestBinderBoundTypeConstraint<'hir> {
+        let TestBinderBoundTypeConstraint { span, node_id, params, lhs, rhs } = bound_type;
+
+        let (generics, (lhs, rhs)) = self.lower_generics(
+            &Generics { params: params.clone(), where_clause: Default::default(), span: *span },
+            ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
+            |this| {
+                let lhs = this
+                    .lower_ty_alloc(lhs, ImplTraitContext::Disallowed(ImplTraitPosition::Bound));
+                let rhs = this.lower_lifetime(rhs, LifetimeSource::OutlivesBound, rhs.ident.into());
+                (lhs, rhs)
+            },
+        );
+
+        hir::TestBinderBoundTypeConstraint {
+            span: *span,
+            hir_id: self.lower_node_id(*node_id),
+            params: generics.params,
+            lhs,
+            rhs,
+        }
+    }
 }

compiler/rustc_ast_lowering/src/lib.rs

@@ -55,7 +55,7 @@ use rustc_data_structures::unord::ExtendUnord;
 use rustc_errors::codes::*;
 use rustc_errors::{DiagArgFromDisplay, DiagCtxtHandle, ErrorGuaranteed};
 use rustc_hir::attrs::lang_items::LangItem;
-use rustc_hir::def::{DefKind, LifetimeRes, Namespace, PartialRes, PerNS, Res};
+use rustc_hir::def::{DefKind, Namespace, PerNS, Res};
 use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId, LocalDefIdMap};
 use rustc_hir::definitions::PerParentDisambiguatorState;
 use rustc_hir::lints::DelayedLint;
@@ -65,9 +65,12 @@ use rustc_hir::{
 };
 use rustc_index::{Idx, IndexVec};
 use rustc_macros::extension;
+use rustc_middle::middle::resolve::{
+    AstOwner, LifetimeRes, PartialRes, PerOwnerResolverData, ResolverAstLowering,
+};
 use rustc_middle::queries::Providers;
 use rustc_middle::span_bug;
-use rustc_middle::ty::{PerOwnerResolverData, ResolverAstLowering, TyCtxt};
+use rustc_middle::ty::TyCtxt;
 use rustc_session::diagnostics::add_feature_diagnostics;
 use rustc_span::symbol::{Ident, Symbol, kw, sym};
 use rustc_span::{DUMMY_SP, DesugaringKind, Span};
@@ -2672,19 +2675,41 @@ impl<'hir> LoweringContext<'_, 'hir> {
     ) -> hir::ConstItemRhs<'hir> {
         match (body, kind) {
             (body, ConstItemKind::Body) => {
-                hir::ConstItemRhs::Body(self.lower_const_body(span, body.as_deref()))
-            }
-            (Some(body), ConstItemKind::TypeConst) => {
-                hir::ConstItemRhs::TypeConst(self.arena.alloc(
-                    match self.can_lower_expr_to_const_arg_direct(
-                        &body,
-                        DirectConstArgContext::MacrolessMinGenericConstArgs,
-                    ) {
-                        Ok(()) => self.lower_expr_to_const_arg_direct(&body, None),
-                        Err(err) => err.emit(self),
-                    },
-                ))
+                let is_direct = |body| {
+                    if self.tcx.features().macroless_generic_const_args() {
+                        self.can_lower_expr_to_const_arg_direct(
+                            body,
+                            DirectConstArgContext::MacrolessMinGenericConstArgs,
+                        )
+                        .is_ok()
+                    } else {
+                        // do not check can_lower_expr_to_const_arg_direct, but rather just
+                        // ExprKind::DirectConstArg, because we don't want e.g.
+                        // `impl<const N: u8> { const C: u8 = N; }` to be a direct-rhs const
+                        matches!(body, Expr { kind: ExprKind::DirectConstArg(_), .. })
+                    }
+                };
+                // N.B.: the feature gate for this is generic_const_args, not min_generic_const_args
+                if self.tcx.features().generic_const_args()
+                    && let Some(body) = body
+                    && is_direct(body)
+                {
+                    hir::ConstItemRhs::Direct(
+                        self.arena.alloc(self.lower_expr_to_const_arg_direct(&body, None)),
+                    )
+                } else {
+                    hir::ConstItemRhs::Body(self.lower_const_body(span, body.as_deref()))
+                }
             }
+            (Some(body), ConstItemKind::TypeConst) => hir::ConstItemRhs::Direct(self.arena.alloc(
+                match self.can_lower_expr_to_const_arg_direct(
+                    &body,
+                    DirectConstArgContext::MacrolessMinGenericConstArgs,
+                ) {
+                    Ok(()) => self.lower_expr_to_const_arg_direct(&body, None),
+                    Err(err) => err.emit(self),
+                },
+            )),
             (None, ConstItemKind::TypeConst) => {
                 let const_arg = ConstArg {
                     hir_id: self.next_id(),
@@ -2693,7 +2718,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     ),
                     span: DUMMY_SP,
                 };
-                hir::ConstItemRhs::TypeConst(self.arena.alloc(const_arg))
+                hir::ConstItemRhs::Direct(self.arena.alloc(const_arg))
             }
         }
     }

compiler/rustc_ast_lowering/src/path.rs

@@ -2,9 +2,10 @@ use std::sync::Arc;
 
 use rustc_ast::{self as ast, *};
 use rustc_errors::StashKey;
-use rustc_hir::def::{DefKind, PartialRes, PerNS, Res};
+use rustc_hir::def::{DefKind, PerNS, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::{self as hir, GenericArg};
+use rustc_middle::middle::resolve::PartialRes;
 use rustc_middle::{span_bug, ty};
 use rustc_session::diagnostics::add_feature_diagnostics;
 use rustc_span::{BytePos, DUMMY_SP, DesugaringKind, Ident, Span, Symbol, sym};

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -395,6 +395,14 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
         self.check_late_bound_lifetime_defs(&exists.params);
         visit::walk_test_binder_exists(self, exists)
     }
+
+    fn visit_test_binder_bound_type_constraint(
+        &mut self,
+        bound_type: &'a ast::TestBinderBoundTypeConstraint,
+    ) -> Self::Result {
+        self.check_late_bound_lifetime_defs(&bound_type.params);
+        visit::walk_test_binder_bound_type_constraint(self, bound_type)
+    }
 }
 
 // -----------------------------------------------------------------------------

compiler/rustc_attr_ir/src/stability.rs

@@ -139,8 +139,9 @@ pub enum StabilityLevel {
         /// Rust release which stabilized this feature.
         since: StableSince,
         /// This is `Some` if this item allowed to be referred to on stable via unstable modules;
-        /// the `Symbol` is the deprecation message printed in that case.
-        allowed_through_unstable_modules: Option<Symbol>,
+        /// the first `Symbol` is the deprecation message printed in that case,
+        /// the second `Symbol` is the correct module to use.
+        allowed_through_unstable_modules: Option<(Symbol, Symbol)>,
     },
 }