Auto merge of #152627 - JonathanBrouwer:rollup-wjHXhK0, r=JonathanBrouwer

Rollup of 8 pull requests

Successful merges:

 - #152618 (stdarch subtree update)
 - #152001 (mGCA: Validate const literal against expected type)
 - #152120 (Don't ICE on layout error in vtable computation)
 - #152531 (`proc_macro::bridge`: simplify `ExecutionStrategy` and `DispatcherTrait`)
 - #152577 (Port #[rustc_proc_macro_decls] to the new attribute parser.)
 - #152570 (Port #[rustc_test_marker] to the attribute parser)
 - #152590 (DepGraphQuery: correctly skip adding edges with not-yet-added nodes)
 - #152612 (Rename `inline_fluent!` to `msg!`)

Author: bors

compiler/rustc_ast_lowering/src/asm.rs

@@ -3,7 +3,7 @@ use std::fmt::Write;
 
 use rustc_ast::*;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
-use rustc_errors::inline_fluent;
+use rustc_errors::msg;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_session::parse::feature_err;
@@ -67,7 +67,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     &self.tcx.sess,
                     sym::asm_experimental_arch,
                     sp,
-                    inline_fluent!("inline assembly is not stable yet on this architecture"),
+                    msg!("inline assembly is not stable yet on this architecture"),
                 )
                 .emit();
             }
@@ -84,7 +84,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 &self.tcx.sess,
                 sym::asm_unwind,
                 sp,
-                inline_fluent!("the `may_unwind` option is unstable"),
+                msg!("the `may_unwind` option is unstable"),
             )
             .emit();
         }
@@ -499,9 +499,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     sess,
                     sym::asm_goto_with_outputs,
                     *op_sp,
-                    inline_fluent!(
-                        "using both label and output operands for inline assembly is unstable"
-                    ),
+                    msg!("using both label and output operands for inline assembly is unstable"),
                 )
                 .emit();
             }

compiler/rustc_ast_lowering/src/expr.rs

@@ -5,7 +5,7 @@ use std::sync::Arc;
 use rustc_ast::*;
 use rustc_ast_pretty::pprust::expr_to_string;
 use rustc_data_structures::stack::ensure_sufficient_stack;
-use rustc_errors::inline_fluent;
+use rustc_errors::msg;
 use rustc_hir as hir;
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def::{DefKind, Res};
@@ -1702,7 +1702,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 &self.tcx.sess,
                 sym::yield_expr,
                 span,
-                inline_fluent!("yield syntax is experimental"),
+                msg!("yield syntax is experimental"),
             )
             .emit();
         }

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -1,6 +1,6 @@
 use rustc_ast::visit::{self, AssocCtxt, FnCtxt, FnKind, Visitor};
 use rustc_ast::{self as ast, AttrVec, NodeId, PatKind, attr, token};
-use rustc_errors::inline_fluent;
+use rustc_errors::msg;
 use rustc_feature::{AttributeGate, BUILTIN_ATTRIBUTE_MAP, BuiltinAttribute, Features};
 use rustc_session::Session;
 use rustc_session::parse::{feature_err, feature_warn};
@@ -125,7 +125,7 @@ impl<'a> PostExpansionVisitor<'a> {
             &self,
             non_lifetime_binders,
             non_lt_param_spans,
-            inline_fluent!("only lifetime parameters can be used in this context")
+            msg!("only lifetime parameters can be used in this context")
         );
 
         // FIXME(non_lifetime_binders): Const bound params are pretty broken.

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -3,7 +3,7 @@ use std::convert::identity;
 use rustc_ast::token::Delimiter;
 use rustc_ast::tokenstream::DelimSpan;
 use rustc_ast::{AttrItem, Attribute, CRATE_NODE_ID, LitKind, ast, token};
-use rustc_errors::{Applicability, PResult, inline_fluent};
+use rustc_errors::{Applicability, PResult, msg};
 use rustc_feature::{
     AttrSuggestionStyle, AttributeTemplate, Features, GatedCfg, find_gated_cfg, template,
 };
@@ -141,7 +141,7 @@ fn parse_cfg_entry_target<S: Stage>(
             cx.sess(),
             sym::cfg_target_compact,
             meta_span,
-            inline_fluent!("compact `cfg(target(..))` is experimental and subject to change"),
+            msg!("compact `cfg(target(..))` is experimental and subject to change"),
         )
         .emit();
     }

compiler/rustc_attr_parsing/src/attributes/link_attrs.rs

@@ -1,4 +1,4 @@
-use rustc_errors::inline_fluent;
+use rustc_errors::msg;
 use rustc_feature::Features;
 use rustc_hir::attrs::AttributeKind::{LinkName, LinkOrdinal, LinkSection};
 use rustc_hir::attrs::*;
@@ -316,7 +316,7 @@ impl LinkParser {
                         sess,
                         sym::raw_dylib_elf,
                         nv.value_span,
-                        inline_fluent!("link kind `raw-dylib` is unstable on ELF platforms"),
+                        msg!("link kind `raw-dylib` is unstable on ELF platforms"),
                     )
                     .emit();
                 } else {
@@ -331,7 +331,7 @@ impl LinkParser {
                         sess,
                         sym::link_arg_attribute,
                         nv.value_span,
-                        inline_fluent!("link kind `link-arg` is unstable"),
+                        msg!("link kind `link-arg` is unstable"),
                     )
                     .emit();
                 }
@@ -396,8 +396,7 @@ impl LinkParser {
             return true;
         };
         if !features.link_cfg() {
-            feature_err(sess, sym::link_cfg, item.span(), inline_fluent!("link cfg is unstable"))
-                .emit();
+            feature_err(sess, sym::link_cfg, item.span(), msg!("link cfg is unstable")).emit();
         }
         *cfg = parse_cfg_entry(cx, link_cfg).ok();
         true

compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs

@@ -206,3 +206,12 @@ impl<S: Stage> SingleAttributeParser<S> for CollapseDebugInfoParser {
         Some(AttributeKind::CollapseDebugInfo(info))
     }
 }
+
+pub(crate) struct RustcProcMacroDeclsParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for RustcProcMacroDeclsParser {
+    const PATH: &[Symbol] = &[sym::rustc_proc_macro_decls];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Static)]);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcProcMacroDecls;
+}

compiler/rustc_attr_parsing/src/attributes/test_attrs.rs

@@ -257,3 +257,36 @@ impl<S: Stage> SingleAttributeParser<S> for TestRunnerParser {
         Some(AttributeKind::TestRunner(meta.path().0.clone()))
     }
 }
+
+pub(crate) struct RustcTestMarkerParser;
+
+impl<S: Stage> SingleAttributeParser<S> for RustcTestMarkerParser {
+    const PATH: &[Symbol] = &[sym::rustc_test_marker];
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
+        Allow(Target::Const),
+        Allow(Target::Fn),
+        Allow(Target::Static),
+    ]);
+    const TEMPLATE: AttributeTemplate = template!(NameValueStr: "test_path");
+
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
+        let Some(name_value) = args.name_value() else {
+            cx.expected_name_value(cx.attr_span, Some(sym::rustc_test_marker));
+            return None;
+        };
+
+        let Some(value_str) = name_value.value_as_str() else {
+            cx.expected_string_literal(name_value.value_span, None);
+            return None;
+        };
+
+        if value_str.as_str().trim().is_empty() {
+            cx.expected_non_empty_string_literal(name_value.value_span);
+            return None;
+        }
+
+        Some(AttributeKind::RustcTestMarker(value_str))
+    }
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -217,6 +217,7 @@ attribute_parsers!(
         Single<RustcScalableVectorParser>,
         Single<RustcSimdMonomorphizeLaneLimitParser>,
         Single<RustcSymbolName>,
+        Single<RustcTestMarkerParser>,
         Single<SanitizeParser>,
         Single<ShouldPanicParser>,
         Single<SkipDuringMethodDispatchParser>,
@@ -300,6 +301,7 @@ attribute_parsers!(
         Single<WithoutArgs<RustcOutlivesParser>>,
         Single<WithoutArgs<RustcPassIndirectlyInNonRusticAbisParser>>,
         Single<WithoutArgs<RustcPreserveUbChecksParser>>,
+        Single<WithoutArgs<RustcProcMacroDeclsParser>>,
         Single<WithoutArgs<RustcReallocatorParser>>,
         Single<WithoutArgs<RustcRegionsParser>>,
         Single<WithoutArgs<RustcShouldNotBeCalledOnConstItems>>,

compiler/rustc_borrowck/src/diagnostics/mod.rs

@@ -4,9 +4,7 @@ use std::collections::BTreeMap;
 
 use rustc_abi::{FieldIdx, VariantIdx};
 use rustc_data_structures::fx::FxIndexMap;
-use rustc_errors::{
-    Applicability, Diag, DiagMessage, EmissionGuarantee, MultiSpan, inline_fluent, listify,
-};
+use rustc_errors::{Applicability, Diag, DiagMessage, EmissionGuarantee, MultiSpan, listify, msg};
 use rustc_hir::def::{CtorKind, Namespace};
 use rustc_hir::{
     self as hir, CoroutineKind, GenericBound, LangItem, WhereBoundPredicate, WherePredicateKind,
@@ -1313,7 +1311,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                         let mut span: MultiSpan = spans.clone().into();
                         err.arg("ty", param_ty.to_string());
                         let msg = err.dcx.eagerly_translate_to_string(
-                            inline_fluent!("`{$ty}` is made to be an `FnOnce` closure here"),
+                            msg!("`{$ty}` is made to be an `FnOnce` closure here"),
                             err.args.iter(),
                         );
                         err.remove_arg("ty");
@@ -1322,12 +1320,9 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                         }
                         span.push_span_label(
                             fn_call_span,
-                            inline_fluent!("this value implements `FnOnce`, which causes it to be moved when called"),
-                        );
-                        err.span_note(
-                            span,
-                            inline_fluent!("`FnOnce` closures can only be called once"),
+                            msg!("this value implements `FnOnce`, which causes it to be moved when called"),
                         );
+                        err.span_note(span, msg!("`FnOnce` closures can only be called once"));
                     } else {
                         err.subdiagnostic(CaptureReasonNote::FnOnceMoveInCall { var_span });
                     }
@@ -1573,6 +1568,5 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
     }
 }
 
-const LIMITATION_NOTE: DiagMessage = inline_fluent!(
-    "due to a current limitation of the type system, this implies a `'static` lifetime"
-);
+const LIMITATION_NOTE: DiagMessage =
+    msg!("due to a current limitation of the type system, this implies a `'static` lifetime");

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -1,7 +1,7 @@
 //! Error reporting machinery for lifetime errors.
 
 use rustc_data_structures::fx::FxIndexSet;
-use rustc_errors::{Applicability, Diag, ErrorGuaranteed, MultiSpan, inline_fluent};
+use rustc_errors::{Applicability, Diag, ErrorGuaranteed, MultiSpan, msg};
 use rustc_hir as hir;
 use rustc_hir::GenericBound::Trait;
 use rustc_hir::QPath::Resolved;
@@ -291,7 +291,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
         if suggestions.len() > 0 {
             suggestions.dedup();
             diag.multipart_suggestion_verbose(
-                inline_fluent!("consider restricting the type parameter to the `'static` lifetime"),
+                msg!("consider restricting the type parameter to the `'static` lifetime"),
                 suggestions,
                 Applicability::MaybeIncorrect,
             );
@@ -982,18 +982,16 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                 let mut multi_span: MultiSpan = vec![*span].into();
                 multi_span.push_span_label(
                     *span,
-                    inline_fluent!("this has an implicit `'static` lifetime requirement"),
+                    msg!("this has an implicit `'static` lifetime requirement"),
                 );
                 multi_span.push_span_label(
                     ident.span,
-                    inline_fluent!(
-                        "calling this method introduces the `impl`'s `'static` requirement"
-                    ),
+                    msg!("calling this method introduces the `impl`'s `'static` requirement"),
                 );
                 err.subdiagnostic(RequireStaticErr::UsedImpl { multi_span });
                 err.span_suggestion_verbose(
                     span.shrink_to_hi(),
-                    inline_fluent!("consider relaxing the implicit `'static` requirement"),
+                    msg!("consider relaxing the implicit `'static` requirement"),
                     " + '_",
                     Applicability::MaybeIncorrect,
                 );
@@ -1156,7 +1154,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
         if ocx.evaluate_obligations_error_on_ambiguity().is_empty() && count > 0 {
             diag.span_suggestion_verbose(
                 tcx.hir_body(*body).value.peel_blocks().span.shrink_to_lo(),
-                inline_fluent!("dereference the return value"),
+                msg!("dereference the return value"),
                 "*".repeat(count),
                 Applicability::MachineApplicable,
             );
@@ -1200,7 +1198,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
         if let Some(closure_span) = closure_span {
             diag.span_suggestion_verbose(
                 closure_span,
-                inline_fluent!("consider adding 'move' keyword before the nested closure"),
+                msg!("consider adding 'move' keyword before the nested closure"),
                 "move ",
                 Applicability::MaybeIncorrect,
             );