Rollup of 11 pull requests

Cargo.lock

@@ -3640,7 +3640,6 @@ dependencies = [
  "rustc_macros",
  "rustc_metadata",
  "rustc_middle",
- "rustc_query_system",
  "rustc_sanitizers",
  "rustc_session",
  "rustc_span",
@@ -4243,7 +4242,6 @@ dependencies = [
  "rustc_index",
  "rustc_lint_defs",
  "rustc_macros",
- "rustc_query_system",
  "rustc_serialize",
  "rustc_session",
  "rustc_span",
@@ -4507,23 +4505,6 @@ dependencies = [
  "tracing",
 ]
 
-[[package]]
-name = "rustc_query_system"
-version = "0.0.0"
-dependencies = [
- "rustc_abi",
- "rustc_ast",
- "rustc_data_structures",
- "rustc_errors",
- "rustc_feature",
- "rustc_hir",
- "rustc_macros",
- "rustc_serialize",
- "rustc_session",
- "rustc_span",
- "smallvec",
-]
-
 [[package]]
 name = "rustc_resolve"
 version = "0.0.0"

compiler/rustc_ast/src/ast.rs

@@ -3131,8 +3131,16 @@ pub enum Const {
 /// For details see the [RFC #2532](https://github.com/rust-lang/rfcs/pull/2532).
 #[derive(Copy, Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic, Walkable)]
 pub enum Defaultness {
+    /// Item is unmarked. Implicitly determined based off of position.
+    /// For impls, this is `final`; for traits, this is `default`.
+    ///
+    /// If you're expanding an item in a built-in macro or parsing an item
+    /// by hand, you probably want to use this.
+    Implicit,
+    /// `default`
     Default(Span),
-    Final,
+    /// `final`; per RFC 3678, only trait items may be *explicitly* marked final.
+    Final(Span),
 }
 
 #[derive(Copy, Clone, PartialEq, Encodable, Decodable, HashStable_Generic, Walkable)]
@@ -4140,7 +4148,7 @@ impl AssocItemKind {
             | Self::Fn(box Fn { defaultness, .. })
             | Self::Type(box TyAlias { defaultness, .. }) => defaultness,
             Self::MacCall(..) | Self::Delegation(..) | Self::DelegationMac(..) => {
-                Defaultness::Final
+                Defaultness::Implicit
             }
         }
     }

compiler/rustc_ast_lowering/src/item.rs

@@ -939,7 +939,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         );
         let trait_item_def_id = hir_id.expect_owner();
 
-        let (ident, generics, kind, has_default) = match &i.kind {
+        let (ident, generics, kind, has_value) = match &i.kind {
             AssocItemKind::Const(box ConstItem {
                 ident,
                 generics,
@@ -1088,13 +1088,17 @@ impl<'hir> LoweringContext<'_, 'hir> {
             }
         };
 
+        let (defaultness, _) = self.lower_defaultness(i.kind.defaultness(), has_value, || {
+            hir::Defaultness::Default { has_value }
+        });
+
         let item = hir::TraitItem {
             owner_id: trait_item_def_id,
             ident: self.lower_ident(ident),
             generics,
             kind,
             span: self.lower_span(i.span),
-            defaultness: hir::Defaultness::Default { has_value: has_default },
+            defaultness,
             has_delayed_lints: !self.delayed_lints.is_empty(),
         };
         self.arena.alloc(item)
@@ -1122,7 +1126,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
         // `defaultness.has_value()` is never called for an `impl`, always `true` in order
         // to not cause an assertion failure inside the `lower_defaultness` function.
         let has_val = true;
-        let (defaultness, defaultness_span) = self.lower_defaultness(defaultness, has_val);
+        let (defaultness, defaultness_span) =
+            self.lower_defaultness(defaultness, has_val, || hir::Defaultness::Final);
         let modifiers = TraitBoundModifiers {
             constness: BoundConstness::Never,
             asyncness: BoundAsyncness::Normal,
@@ -1151,7 +1156,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
     ) -> &'hir hir::ImplItem<'hir> {
         // Since `default impl` is not yet implemented, this is always true in impls.
         let has_value = true;
-        let (defaultness, _) = self.lower_defaultness(i.kind.defaultness(), has_value);
+        let (defaultness, _) =
+            self.lower_defaultness(i.kind.defaultness(), has_value, || hir::Defaultness::Final);
         let hir_id = hir::HirId::make_owner(self.current_hir_id_owner.def_id);
         let attrs = self.lower_attrs(
             hir_id,
@@ -1304,15 +1310,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
         &self,
         d: Defaultness,
         has_value: bool,
+        implicit: impl FnOnce() -> hir::Defaultness,
     ) -> (hir::Defaultness, Option<Span>) {
         match d {
+            Defaultness::Implicit => (implicit(), None),
             Defaultness::Default(sp) => {
                 (hir::Defaultness::Default { has_value }, Some(self.lower_span(sp)))
             }
-            Defaultness::Final => {
-                assert!(has_value);
-                (hir::Defaultness::Final, None)
-            }
+            Defaultness::Final(sp) => (hir::Defaultness::Final, Some(self.lower_span(sp))),
         }
     }
 

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -65,6 +65,28 @@ impl TraitOrImpl {
     }
 }
 
+enum AllowDefault {
+    Yes,
+    No,
+}
+
+impl AllowDefault {
+    fn when(b: bool) -> Self {
+        if b { Self::Yes } else { Self::No }
+    }
+}
+
+enum AllowFinal {
+    Yes,
+    No,
+}
+
+impl AllowFinal {
+    fn when(b: bool) -> Self {
+        if b { Self::Yes } else { Self::No }
+    }
+}
+
 struct AstValidator<'a> {
     sess: &'a Session,
     features: &'a Features,
@@ -563,10 +585,32 @@ impl<'a> AstValidator<'a> {
         }
     }
 
-    fn check_defaultness(&self, span: Span, defaultness: Defaultness) {
-        if let Defaultness::Default(def_span) = defaultness {
-            let span = self.sess.source_map().guess_head_span(span);
-            self.dcx().emit_err(errors::ForbiddenDefault { span, def_span });
+    fn check_defaultness(
+        &self,
+        span: Span,
+        defaultness: Defaultness,
+        allow_default: AllowDefault,
+        allow_final: AllowFinal,
+    ) {
+        match defaultness {
+            Defaultness::Default(def_span) if matches!(allow_default, AllowDefault::No) => {
+                let span = self.sess.source_map().guess_head_span(span);
+                self.dcx().emit_err(errors::ForbiddenDefault { span, def_span });
+            }
+            Defaultness::Final(def_span) if matches!(allow_final, AllowFinal::No) => {
+                let span = self.sess.source_map().guess_head_span(span);
+                self.dcx().emit_err(errors::ForbiddenFinal { span, def_span });
+            }
+            _ => (),
+        }
+    }
+
+    fn check_final_has_body(&self, item: &Item<AssocItemKind>, defaultness: Defaultness) {
+        if let AssocItemKind::Fn(box Fn { body: None, .. }) = &item.kind
+            && let Defaultness::Final(def_span) = defaultness
+        {
+            let span = self.sess.source_map().guess_head_span(item.span);
+            self.dcx().emit_err(errors::ForbiddenFinalWithoutBody { span, def_span });
         }
     }
 
@@ -1190,7 +1234,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                 },
             ) => {
                 self.visit_attrs_vis_ident(&item.attrs, &item.vis, ident);
-                self.check_defaultness(item.span, *defaultness);
+                self.check_defaultness(item.span, *defaultness, AllowDefault::No, AllowFinal::No);
 
                 for EiiImpl { eii_macro_path, .. } in eii_impls {
                     self.visit_path(eii_macro_path);
@@ -1360,7 +1404,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                 });
             }
             ItemKind::Const(box ConstItem { defaultness, ident, rhs_kind, .. }) => {
-                self.check_defaultness(item.span, *defaultness);
+                self.check_defaultness(item.span, *defaultness, AllowDefault::No, AllowFinal::No);
                 if !rhs_kind.has_expr() {
                     self.dcx().emit_err(errors::ConstWithoutBody {
                         span: item.span,
@@ -1398,7 +1442,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
             ItemKind::TyAlias(
                 ty_alias @ box TyAlias { defaultness, bounds, after_where_clause, ty, .. },
             ) => {
-                self.check_defaultness(item.span, *defaultness);
+                self.check_defaultness(item.span, *defaultness, AllowDefault::No, AllowFinal::No);
                 if ty.is_none() {
                     self.dcx().emit_err(errors::TyAliasWithoutBody {
                         span: item.span,
@@ -1428,7 +1472,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
     fn visit_foreign_item(&mut self, fi: &'a ForeignItem) {
         match &fi.kind {
             ForeignItemKind::Fn(box Fn { defaultness, ident, sig, body, .. }) => {
-                self.check_defaultness(fi.span, *defaultness);
+                self.check_defaultness(fi.span, *defaultness, AllowDefault::No, AllowFinal::No);
                 self.check_foreign_fn_bodyless(*ident, body.as_deref());
                 self.check_foreign_fn_headerless(sig.header);
                 self.check_foreign_item_ascii_only(*ident);
@@ -1448,7 +1492,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                 ty,
                 ..
             }) => {
-                self.check_defaultness(fi.span, *defaultness);
+                self.check_defaultness(fi.span, *defaultness, AllowDefault::No, AllowFinal::No);
                 self.check_foreign_kind_bodyless(*ident, "type", ty.as_ref().map(|b| b.span));
                 self.check_type_no_bounds(bounds, "`extern` blocks");
                 self.check_foreign_ty_genericless(generics, after_where_clause);
@@ -1707,9 +1751,19 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
             self.check_nomangle_item_asciionly(ident, item.span);
         }
 
-        if ctxt == AssocCtxt::Trait || self.outer_trait_or_trait_impl.is_none() {
-            self.check_defaultness(item.span, item.kind.defaultness());
-        }
+        let defaultness = item.kind.defaultness();
+        self.check_defaultness(
+            item.span,
+            defaultness,
+            // `default` is allowed on all associated items in impls.
+            AllowDefault::when(matches!(ctxt, AssocCtxt::Impl { .. })),
+            // `final` is allowed on all associated *functions* in traits.
+            AllowFinal::when(
+                ctxt == AssocCtxt::Trait && matches!(item.kind, AssocItemKind::Fn(..)),
+            ),
+        );
+
+        self.check_final_has_body(item, defaultness);
 
         if let AssocCtxt::Impl { .. } = ctxt {
             match &item.kind {

compiler/rustc_ast_passes/src/errors.rs

@@ -159,6 +159,24 @@ pub(crate) struct ForbiddenDefault {
     pub def_span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag("`final` is only allowed on associated functions in traits")]
+pub(crate) struct ForbiddenFinal {
+    #[primary_span]
+    pub span: Span,
+    #[label("`final` because of this")]
+    pub def_span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag("`final` is only allowed on associated functions if they have a body")]
+pub(crate) struct ForbiddenFinalWithoutBody {
+    #[primary_span]
+    pub span: Span,
+    #[label("`final` because of this")]
+    pub def_span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag("associated constant in `impl` without body")]
 pub(crate) struct AssocConstWithoutBody {

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -580,6 +580,7 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
     gate_all!(frontmatter, "frontmatters are experimental");
     gate_all!(coroutines, "coroutine syntax is experimental");
     gate_all!(const_block_items, "const block items are experimental");
+    gate_all!(final_associated_functions, "`final` on trait functions is experimental");
 
     if !visitor.features.never_patterns() {
         if let Some(spans) = spans.get(&sym::never_patterns) {

compiler/rustc_ast_pretty/src/pprust/state/item.rs

@@ -51,7 +51,7 @@ impl<'a> State<'a> {
                 expr.as_deref(),
                 vis,
                 *safety,
-                ast::Defaultness::Final,
+                ast::Defaultness::Implicit,
                 define_opaque.as_deref(),
             ),
             ast::ForeignItemKind::TyAlias(box ast::TyAlias {
@@ -201,7 +201,7 @@ impl<'a> State<'a> {
                     body.as_deref(),
                     &item.vis,
                     ast::Safety::Default,
-                    ast::Defaultness::Final,
+                    ast::Defaultness::Implicit,
                     define_opaque.as_deref(),
                 );
             }

compiler/rustc_attr_parsing/src/attributes/crate_level.rs

@@ -292,3 +292,12 @@ impl<S: Stage> NoArgsAttributeParser<S> for RustcNoImplicitBoundsParser {
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcNoImplicitBounds;
 }
+
+pub(crate) struct DefaultLibAllocatorParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for DefaultLibAllocatorParser {
+    const PATH: &[Symbol] = &[sym::default_lib_allocator];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::DefaultLibAllocator;
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -235,6 +235,7 @@ attribute_parsers!(
         Single<WithoutArgs<ConstContinueParser>>,
         Single<WithoutArgs<ConstStabilityIndirectParser>>,
         Single<WithoutArgs<CoroutineParser>>,
+        Single<WithoutArgs<DefaultLibAllocatorParser>>,
         Single<WithoutArgs<DenyExplicitImplParser>>,
         Single<WithoutArgs<DynIncompatibleTraitParser>>,
         Single<WithoutArgs<EiiForeignItemParser>>,

compiler/rustc_builtin_macros/src/alloc_error_handler.rs

@@ -83,7 +83,7 @@ fn generate_handler(cx: &ExtCtxt<'_>, handler: Ident, span: Span, sig_span: Span
 
     let body = Some(cx.block_expr(call));
     let kind = ItemKind::Fn(Box::new(Fn {
-        defaultness: ast::Defaultness::Final,
+        defaultness: ast::Defaultness::Implicit,
         sig,
         ident: Ident::from_str_and_span(&global_fn_name(ALLOC_ERROR_HANDLER), span),
         generics: Generics::default(),

compiler/rustc_builtin_macros/src/autodiff.rs

@@ -334,7 +334,7 @@ mod llvm_enzyme {
 
         // The first element of it is the name of the function to be generated
         let d_fn = Box::new(ast::Fn {
-            defaultness: ast::Defaultness::Final,
+            defaultness: ast::Defaultness::Implicit,
             sig: d_sig,
             ident: first_ident(&meta_item_vec[0]),
             generics,

compiler/rustc_builtin_macros/src/deriving/coerce_pointee.rs

@@ -136,7 +136,7 @@ pub(crate) fn expand_deriving_coerce_pointee(
                     of_trait: Some(Box::new(ast::TraitImplHeader {
                         safety: ast::Safety::Default,
                         polarity: ast::ImplPolarity::Positive,
-                        defaultness: ast::Defaultness::Final,
+                        defaultness: ast::Defaultness::Implicit,
                         trait_ref,
                     })),
                     constness: ast::Const::No,
@@ -159,7 +159,7 @@ pub(crate) fn expand_deriving_coerce_pointee(
                 of_trait: Some(Box::new(ast::TraitImplHeader {
                     safety: ast::Safety::Default,
                     polarity: ast::ImplPolarity::Positive,
-                    defaultness: ast::Defaultness::Final,
+                    defaultness: ast::Defaultness::Implicit,
                     trait_ref,
                 })),
                 constness: ast::Const::No,