Auto merge of #152025 - jhpratt:rollup-Kxb6k3Y, r=jhpratt

Rollup of 11 pull requests

Successful merges:

 - #151378 (Codegen tests for Arm Cortex-R82)
 - #151936 (Move the `fingerprint_style` special case into `DepKindVTable` creation)
 - #152018 (Move bigint helper tracking issues)
 - #151958 (Add codegen test for SLP vectorization)
 - #151974 (Update documentation for `Result::ok()`)
 - #151975 (Work around rustfmt giving up on a large expression)
 - #151990 (Fix missing unused_variables lint when using a match guard)
 - #151995 (stabilize ptr_as_ref_unchecked)
 - #151999 (attribute parsing: pass recovery mode to Parser.)
 - #152009 (Port rustc_preserve_ub_checks to attr parser)
 - #152022 (rustc-dev-guide subtree update)

Failed merges:

 - #151968 (Remove `HasDepContext` by merging it into `QueryContext`)

Author: bors

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -10,7 +10,7 @@ use rustc_feature::{
 use rustc_hir::attrs::CfgEntry;
 use rustc_hir::lints::AttributeLintKind;
 use rustc_hir::{AttrPath, RustcVersion, Target};
-use rustc_parse::parser::{ForceCollect, Parser};
+use rustc_parse::parser::{ForceCollect, Parser, Recovery};
 use rustc_parse::{exp, parse_in};
 use rustc_session::Session;
 use rustc_session::config::ExpectedValues;
@@ -360,8 +360,10 @@ fn parse_cfg_attr_internal<'a>(
 ) -> PResult<'a, (CfgEntry, Vec<(ast::AttrItem, Span)>)> {
     // Parse cfg predicate
     let pred_start = parser.token.span;
-    let meta =
-        MetaItemOrLitParser::parse_single(parser, ShouldEmit::ErrorsAndLints { recover: true })?;
+    let meta = MetaItemOrLitParser::parse_single(
+        parser,
+        ShouldEmit::ErrorsAndLints { recovery: Recovery::Allowed },
+    )?;
     let pred_span = pred_start.with_hi(parser.token.span.hi());
 
     let cfg_predicate = AttributeParser::parse_single_args(
@@ -376,7 +378,7 @@ fn parse_cfg_attr_internal<'a>(
         CRATE_NODE_ID,
         Target::Crate,
         features,
-        ShouldEmit::ErrorsAndLints { recover: true },
+        ShouldEmit::ErrorsAndLints { recovery: Recovery::Allowed },
         &meta,
         parse_cfg_entry,
         &CFG_ATTR_TEMPLATE,

compiler/rustc_attr_parsing/src/attributes/cfg_select.rs

@@ -5,7 +5,7 @@ use rustc_feature::{AttributeTemplate, Features};
 use rustc_hir::attrs::CfgEntry;
 use rustc_hir::{AttrPath, Target};
 use rustc_parse::exp;
-use rustc_parse::parser::Parser;
+use rustc_parse::parser::{Parser, Recovery};
 use rustc_session::Session;
 use rustc_span::{ErrorGuaranteed, Span, sym};
 
@@ -78,9 +78,11 @@ pub fn parse_cfg_select(
                 }
             }
         } else {
-            let meta =
-                MetaItemOrLitParser::parse_single(p, ShouldEmit::ErrorsAndLints { recover: true })
-                    .map_err(|diag| diag.emit())?;
+            let meta = MetaItemOrLitParser::parse_single(
+                p,
+                ShouldEmit::ErrorsAndLints { recovery: Recovery::Allowed },
+            )
+            .map_err(|diag| diag.emit())?;
             let cfg_span = meta.span();
             let cfg = AttributeParser::parse_single_args(
                 sess,
@@ -95,7 +97,7 @@ pub fn parse_cfg_select(
                 // Doesn't matter what the target actually is here.
                 Target::Crate,
                 features,
-                ShouldEmit::ErrorsAndLints { recover: true },
+                ShouldEmit::ErrorsAndLints { recovery: Recovery::Allowed },
                 &meta,
                 parse_cfg_entry,
                 &AttributeTemplate::default(),

compiler/rustc_attr_parsing/src/attributes/crate_level.rs

@@ -274,3 +274,12 @@ impl<S: Stage> NoArgsAttributeParser<S> for NoBuiltinsParser {
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::NoBuiltins;
 }
+
+pub(crate) struct RustcPreserveUbChecksParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for RustcPreserveUbChecksParser {
+    const PATH: &[Symbol] = &[sym::rustc_preserve_ub_checks];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcPreserveUbChecks;
+}

compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs

@@ -7,36 +7,36 @@ use crate::attributes::{NoArgsAttributeParser, OnDuplicate};
 use crate::context::Stage;
 use crate::target_checking::AllowedTargets;
 
-pub(crate) struct RustcDumpUserArgs;
+pub(crate) struct RustcDumpUserArgsParser;
 
-impl<S: Stage> NoArgsAttributeParser<S> for RustcDumpUserArgs {
+impl<S: Stage> NoArgsAttributeParser<S> for RustcDumpUserArgsParser {
     const PATH: &[Symbol] = &[sym::rustc_dump_user_args];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Fn)]);
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcDumpUserArgs;
 }
 
-pub(crate) struct RustcDumpDefParents;
+pub(crate) struct RustcDumpDefParentsParser;
 
-impl<S: Stage> NoArgsAttributeParser<S> for RustcDumpDefParents {
+impl<S: Stage> NoArgsAttributeParser<S> for RustcDumpDefParentsParser {
     const PATH: &[Symbol] = &[sym::rustc_dump_def_parents];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Fn)]);
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcDumpDefParents;
 }
 
-pub(crate) struct RustcDumpItemBounds;
+pub(crate) struct RustcDumpItemBoundsParser;
 
-impl<S: Stage> NoArgsAttributeParser<S> for RustcDumpItemBounds {
+impl<S: Stage> NoArgsAttributeParser<S> for RustcDumpItemBoundsParser {
     const PATH: &[Symbol] = &[sym::rustc_dump_item_bounds];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::AssocTy)]);
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcDumpItemBounds;
 }
 
-pub(crate) struct RustcDumpPredicates;
+pub(crate) struct RustcDumpPredicatesParser;
 
-impl<S: Stage> NoArgsAttributeParser<S> for RustcDumpPredicates {
+impl<S: Stage> NoArgsAttributeParser<S> for RustcDumpPredicatesParser {
     const PATH: &[Symbol] = &[sym::rustc_dump_predicates];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
@@ -49,9 +49,9 @@ impl<S: Stage> NoArgsAttributeParser<S> for RustcDumpPredicates {
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcDumpPredicates;
 }
 
-pub(crate) struct RustcDumpVtable;
+pub(crate) struct RustcDumpVtableParser;
 
-impl<S: Stage> NoArgsAttributeParser<S> for RustcDumpVtable {
+impl<S: Stage> NoArgsAttributeParser<S> for RustcDumpVtableParser {
     const PATH: &[Symbol] = &[sym::rustc_dump_vtable];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[

compiler/rustc_attr_parsing/src/context.rs

@@ -10,6 +10,7 @@ use rustc_feature::{AttrSuggestionStyle, AttributeTemplate};
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::lints::AttributeLintKind;
 use rustc_hir::{AttrPath, HirId};
+use rustc_parse::parser::Recovery;
 use rustc_session::Session;
 use rustc_session::lint::{Lint, LintId};
 use rustc_span::{ErrorGuaranteed, Span, Symbol};
@@ -31,7 +32,8 @@ use crate::attributes::crate_level::{
     CrateNameParser, CrateTypeParser, MoveSizeLimitParser, NeedsPanicRuntimeParser,
     NoBuiltinsParser, NoCoreParser, NoMainParser, NoStdParser, PanicRuntimeParser,
     PatternComplexityLimitParser, ProfilerRuntimeParser, RecursionLimitParser,
-    RustcCoherenceIsCoreParser, TypeLengthLimitParser, WindowsSubsystemParser,
+    RustcCoherenceIsCoreParser, RustcPreserveUbChecksParser, TypeLengthLimitParser,
+    WindowsSubsystemParser,
 };
 use crate::attributes::debugger::DebuggerViualizerParser;
 use crate::attributes::deprecation::DeprecationParser;
@@ -71,8 +73,8 @@ use crate::attributes::rustc_allocator::{
     RustcDeallocatorParser, RustcReallocatorParser,
 };
 use crate::attributes::rustc_dump::{
-    RustcDumpDefParents, RustcDumpItemBounds, RustcDumpPredicates, RustcDumpUserArgs,
-    RustcDumpVtable,
+    RustcDumpDefParentsParser, RustcDumpItemBoundsParser, RustcDumpPredicatesParser,
+    RustcDumpUserArgsParser, RustcDumpVtableParser,
 };
 use crate::attributes::rustc_internal::{
     RustcHasIncoherentInherentImplsParser, RustcHiddenTypeOfOpaquesParser, RustcLayoutParser,
@@ -294,11 +296,11 @@ attribute_parsers!(
         Single<WithoutArgs<RustcAllocatorZeroedParser>>,
         Single<WithoutArgs<RustcCoherenceIsCoreParser>>,
         Single<WithoutArgs<RustcDeallocatorParser>>,
-        Single<WithoutArgs<RustcDumpDefParents>>,
-        Single<WithoutArgs<RustcDumpItemBounds>>,
-        Single<WithoutArgs<RustcDumpPredicates>>,
-        Single<WithoutArgs<RustcDumpUserArgs>>,
-        Single<WithoutArgs<RustcDumpVtable>>,
+        Single<WithoutArgs<RustcDumpDefParentsParser>>,
+        Single<WithoutArgs<RustcDumpItemBoundsParser>>,
+        Single<WithoutArgs<RustcDumpPredicatesParser>>,
+        Single<WithoutArgs<RustcDumpUserArgsParser>>,
+        Single<WithoutArgs<RustcDumpVtableParser>>,
         Single<WithoutArgs<RustcHasIncoherentInherentImplsParser>>,
         Single<WithoutArgs<RustcHiddenTypeOfOpaquesParser>>,
         Single<WithoutArgs<RustcLintOptTyParser>>,
@@ -311,6 +313,7 @@ attribute_parsers!(
         Single<WithoutArgs<RustcNounwindParser>>,
         Single<WithoutArgs<RustcOffloadKernelParser>>,
         Single<WithoutArgs<RustcPassIndirectlyInNonRusticAbisParser>>,
+        Single<WithoutArgs<RustcPreserveUbChecksParser>>,
         Single<WithoutArgs<RustcReallocatorParser>>,
         Single<WithoutArgs<RustcShouldNotBeCalledOnConstItems>>,
         Single<WithoutArgs<RustcVarianceOfOpaquesParser>>,
@@ -385,7 +388,7 @@ impl Stage for Late {
     }
 
     fn should_emit(&self) -> ShouldEmit {
-        ShouldEmit::ErrorsAndLints { recover: true }
+        ShouldEmit::ErrorsAndLints { recovery: Recovery::Allowed }
     }
 }
 
@@ -772,10 +775,10 @@ pub enum ShouldEmit {
     ErrorsAndLints {
         /// Whether [`ArgParser`] will attempt to recover from errors.
         ///
-        /// If true, it will attempt to recover from bad input (like an invalid literal). Setting
-        /// this to false will instead return early, and not raise errors except at the top level
-        /// (in [`ArgParser::from_attr_args`]).
-        recover: bool,
+        /// Whether it is allowed to recover from bad input (like an invalid literal). Setting
+        /// this to `Forbidden` will instead return early, and not raise errors except at the top
+        /// level (in [`ArgParser::from_attr_args`]).
+        recovery: Recovery,
     },
     /// The operation will *not* emit errors and lints.
     ///

compiler/rustc_attr_parsing/src/parser.rs

@@ -15,7 +15,7 @@ use rustc_ast_pretty::pprust;
 use rustc_errors::{Diag, PResult};
 use rustc_hir::{self as hir, AttrPath};
 use rustc_parse::exp;
-use rustc_parse::parser::{ForceCollect, Parser, PathStyle, token_descr};
+use rustc_parse::parser::{ForceCollect, Parser, PathStyle, Recovery, token_descr};
 use rustc_session::errors::create_lit_error;
 use rustc_session::parse::ParseSess;
 use rustc_span::{Ident, Span, Symbol, sym};
@@ -121,7 +121,7 @@ impl ArgParser {
                         &args.tokens,
                         args.dspan.entire(),
                         psess,
-                        ShouldEmit::ErrorsAndLints { recover: false },
+                        ShouldEmit::ErrorsAndLints { recovery: Recovery::Forbidden },
                     ) {
                         Ok(p) => return Some(ArgParser::List(p)),
                         Err(e) => {
@@ -373,7 +373,10 @@ fn expr_to_lit<'sess>(
             }
             Err(err) => {
                 let err = create_lit_error(psess, err, token_lit, expr.span);
-                if matches!(should_emit, ShouldEmit::ErrorsAndLints { recover: false }) {
+                if matches!(
+                    should_emit,
+                    ShouldEmit::ErrorsAndLints { recovery: Recovery::Forbidden }
+                ) {
                     Err(err)
                 } else {
                     let lit = MetaItemLit {
@@ -431,7 +434,10 @@ impl<'a, 'sess> MetaItemListParserContext<'a, 'sess> {
         if !lit.kind.is_unsuffixed() {
             // Emit error and continue, we can still parse the attribute as if the suffix isn't there
             let err = self.parser.dcx().create_err(SuffixedLiteralInAttribute { span: lit.span });
-            if matches!(self.should_emit, ShouldEmit::ErrorsAndLints { recover: false }) {
+            if matches!(
+                self.should_emit,
+                ShouldEmit::ErrorsAndLints { recovery: Recovery::Forbidden }
+            ) {
                 return Err(err);
             } else {
                 self.should_emit.emit_err(err)
@@ -569,6 +575,10 @@ impl<'a, 'sess> MetaItemListParserContext<'a, 'sess> {
         should_emit: ShouldEmit,
     ) -> PResult<'sess, MetaItemListParser> {
         let mut parser = Parser::new(psess, tokens, None);
+        if let ShouldEmit::ErrorsAndLints { recovery } = should_emit {
+            parser = parser.recovery(recovery);
+        }
+
         let mut this = MetaItemListParserContext { parser: &mut parser, should_emit };
 
         // Presumably, the majority of the time there will only be one attr.

compiler/rustc_builtin_macros/src/cfg.rs

@@ -13,6 +13,7 @@ use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacEager, MacroExpa
 use rustc_hir::attrs::CfgEntry;
 use rustc_hir::{AttrPath, Target};
 use rustc_parse::exp;
+use rustc_parse::parser::Recovery;
 use rustc_span::{ErrorGuaranteed, Span, sym};
 
 use crate::errors;
@@ -42,7 +43,7 @@ fn parse_cfg(cx: &ExtCtxt<'_>, span: Span, tts: TokenStream) -> Result<CfgEntry,
 
     let meta = MetaItemOrLitParser::parse_single(
         &mut parser,
-        ShouldEmit::ErrorsAndLints { recover: true },
+        ShouldEmit::ErrorsAndLints { recovery: Recovery::Allowed },
     )
     .map_err(|diag| diag.emit())?;
     let cfg = AttributeParser::parse_single_args(
@@ -58,7 +59,7 @@ fn parse_cfg(cx: &ExtCtxt<'_>, span: Span, tts: TokenStream) -> Result<CfgEntry,
         // Doesn't matter what the target actually is here.
         Target::Crate,
         Some(cx.ecfg.features),
-        ShouldEmit::ErrorsAndLints { recover: true },
+        ShouldEmit::ErrorsAndLints { recovery: Recovery::Allowed },
         &meta,
         parse_cfg_entry,
         &CFG_TEMPLATE,

compiler/rustc_expand/src/config.rs

@@ -20,6 +20,7 @@ use rustc_feature::{
     UNSTABLE_LANG_FEATURES,
 };
 use rustc_hir::Target;
+use rustc_parse::parser::Recovery;
 use rustc_session::Session;
 use rustc_session::parse::feature_err;
 use rustc_span::{STDLIB_STABLE_CRATES, Span, Symbol, sym};
@@ -395,7 +396,9 @@ impl<'a> StripUnconfigured<'a> {
     fn in_cfg(&self, attrs: &[Attribute]) -> bool {
         attrs.iter().all(|attr| {
             !is_cfg(attr)
-                || self.cfg_true(attr, ShouldEmit::ErrorsAndLints { recover: true }).as_bool()
+                || self
+                    .cfg_true(attr, ShouldEmit::ErrorsAndLints { recovery: Recovery::Allowed })
+                    .as_bool()
         })
     }
 

compiler/rustc_expand/src/expand.rs

@@ -26,7 +26,7 @@ use rustc_hir::def::MacroKinds;
 use rustc_hir::limit::Limit;
 use rustc_parse::parser::{
     AllowConstBlockItems, AttemptLocalParseRecovery, CommaRecoveryMode, ForceCollect, Parser,
-    RecoverColon, RecoverComma, token_descr,
+    RecoverColon, RecoverComma, Recovery, token_descr,
 };
 use rustc_session::Session;
 use rustc_session::lint::builtin::{UNUSED_ATTRIBUTES, UNUSED_DOC_COMMENTS};
@@ -2170,7 +2170,7 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
                 call.span(),
                 self.cx.current_expansion.lint_node_id,
                 Some(self.cx.ecfg.features),
-                ShouldEmit::ErrorsAndLints { recover: true },
+                ShouldEmit::ErrorsAndLints { recovery: Recovery::Allowed },
             );
 
             let current_span = if let Some(sp) = span { sp.to(attr.span) } else { attr.span };
@@ -2220,7 +2220,7 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
             // Target doesn't matter for `cfg` parsing.
             Target::Crate,
             self.cfg().features,
-            ShouldEmit::ErrorsAndLints { recover: true },
+            ShouldEmit::ErrorsAndLints { recovery: Recovery::Allowed },
             parse_cfg,
             &CFG_TEMPLATE,
         ) else {

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -1126,6 +1126,9 @@ pub enum AttributeKind {
     /// Represents `#[rustc_pass_indirectly_in_non_rustic_abis]`
     RustcPassIndirectlyInNonRusticAbis(Span),
 
+    /// Represents `#[rustc_preserve_ub_checks]`
+    RustcPreserveUbChecks,
+
     /// Represents `#[rustc_pub_transparent]` (used by the `repr_transparent_external_private_fields` lint).
     RustcPubTransparent(Span),