Rollup merge of #152186 - GuillaumeGomez:inline-diag-rustc_const_eval, r=JonathanBrouwer

Convert to inline diagnostics in `rustc_const_eval`

Part of #151366.

r? @JonathanBrouwer

Author: JonathanBrouwer

Cargo.lock

@@ -3703,7 +3703,6 @@ dependencies = [
  "rustc_ast",
  "rustc_data_structures",
  "rustc_errors",
- "rustc_fluent_macro",
  "rustc_hir",
  "rustc_index",
  "rustc_infer",

compiler/rustc_const_eval/Cargo.toml

@@ -11,7 +11,6 @@ rustc_apfloat = "0.2.0"
 rustc_ast = { path = "../rustc_ast" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }
-rustc_fluent_macro = { path = "../rustc_fluent_macro" }
 rustc_hir = { path = "../rustc_hir" }
 rustc_index = { path = "../rustc_index" }
 rustc_infer = { path = "../rustc_infer" }

compiler/rustc_const_eval/messages.ftl

@@ -2,7 +2,7 @@
 
 use hir::{ConstContext, LangItem};
 use rustc_errors::codes::*;
-use rustc_errors::{Applicability, Diag, MultiSpan};
+use rustc_errors::{Applicability, Diag, MultiSpan, inline_fluent};
 use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
 use rustc_infer::infer::TyCtxtInferExt;
@@ -23,7 +23,7 @@ use rustc_trait_selection::traits::SelectionContext;
 use tracing::debug;
 
 use super::ConstCx;
-use crate::{errors, fluent_generated};
+use crate::errors;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum Status {
@@ -181,7 +181,9 @@ impl<'tcx> NonConstOp<'tcx> for FnCallNonConst<'tcx> {
         );
 
         if let ConstContext::Static(_) = ccx.const_kind() {
-            err.note(fluent_generated::const_eval_lazy_lock);
+            err.note(inline_fluent!(
+                "consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`"
+            ));
         }
 
         err

compiler/rustc_const_eval/src/check_consts/ops.rs

@@ -43,21 +43,41 @@ pub enum ConstEvalErrKind {
 impl MachineStopType for ConstEvalErrKind {
     fn diagnostic_message(&self) -> DiagMessage {
         use ConstEvalErrKind::*;
+        use rustc_errors::inline_fluent;
 
-        use crate::fluent_generated::*;
         match self {
-            ConstAccessesMutGlobal => const_eval_const_accesses_mut_global,
-            ModifiedGlobal => const_eval_modified_global,
-            Panic { .. } => const_eval_panic,
-            RecursiveStatic => const_eval_recursive_static,
+            ConstAccessesMutGlobal => "constant accesses mutable global memory".into(),
+            ModifiedGlobal => {
+                "modifying a static's initial value from another static's initializer".into()
+            }
+            Panic { .. } => inline_fluent!("evaluation panicked: {$msg}"),
+            RecursiveStatic => {
+                "encountered static that tried to access itself during initialization".into()
+            }
             AssertFailure(x) => x.diagnostic_message(),
-            WriteThroughImmutablePointer => const_eval_write_through_immutable_pointer,
+            WriteThroughImmutablePointer => {
+                inline_fluent!(
+                    "writing through a pointer that was derived from a shared (immutable) reference"
+                )
+            }
             ConstMakeGlobalPtrAlreadyMadeGlobal { .. } => {
-                const_eval_const_make_global_ptr_already_made_global
+                inline_fluent!(
+                    "attempting to call `const_make_global` twice on the same allocation {$alloc}"
+                )
+            }
+            ConstMakeGlobalPtrIsNonHeap(_) => {
+                inline_fluent!(
+                    "pointer passed to `const_make_global` does not point to a heap allocation: {$ptr}"
+                )
+            }
+            ConstMakeGlobalWithDanglingPtr(_) => {
+                inline_fluent!("pointer passed to `const_make_global` is dangling: {$ptr}")
+            }
+            ConstMakeGlobalWithOffset(_) => {
+                inline_fluent!(
+                    "making {$ptr} global which does not point to the beginning of an object"
+                )
             }
-            ConstMakeGlobalPtrIsNonHeap(_) => const_eval_const_make_global_ptr_is_non_heap,
-            ConstMakeGlobalWithDanglingPtr(_) => const_eval_const_make_global_with_dangling_ptr,
-            ConstMakeGlobalWithOffset(_) => const_eval_const_make_global_with_offset,
         }
     }
     fn add_args(self: Box<Self>, adder: &mut dyn FnMut(DiagArgName, DiagArgValue)) {

compiler/rustc_const_eval/src/const_eval/error.rs

@@ -2,7 +2,7 @@ use std::sync::atomic::Ordering::Relaxed;
 
 use either::{Left, Right};
 use rustc_abi::{self as abi, BackendRepr};
-use rustc_errors::E0080;
+use rustc_errors::{E0080, inline_fluent};
 use rustc_hir::def::DefKind;
 use rustc_middle::mir::interpret::{AllocId, ErrorHandled, InterpErrorInfo, ReportedErrorInfo};
 use rustc_middle::mir::{self, ConstAlloc, ConstValue};
@@ -467,7 +467,15 @@ fn report_eval_error<'tcx>(
             let num_frames = frames.len();
             // FIXME(oli-obk): figure out how to use structured diagnostics again.
             diag.code(E0080);
-            diag.span_label(span, crate::fluent_generated::const_eval_error);
+            diag.span_label(
+                span,
+                inline_fluent!(
+                    "evaluation of `{$instance}` failed {$num_frames ->
+    [0] here
+    *[other] inside this call
+}"
+                ),
+            );
             for frame in frames {
                 diag.subdiagnostic(frame);
             }
@@ -506,8 +514,8 @@ fn report_validation_error<'tcx>(
         move |diag, span, frames| {
             // FIXME(oli-obk): figure out how to use structured diagnostics again.
             diag.code(E0080);
-            diag.span_label(span, crate::fluent_generated::const_eval_validation_failure);
-            diag.note(crate::fluent_generated::const_eval_validation_failure_note);
+            diag.span_label(span, "it is undefined behavior to use this value");
+            diag.note("the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.");
             for frame in frames {
                 diag.subdiagnostic(frame);
             }

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -5,6 +5,7 @@ use std::hash::Hash;
 use rustc_abi::{Align, Size};
 use rustc_ast::Mutability;
 use rustc_data_structures::fx::{FxHashMap, FxIndexMap, IndexEntry};
+use rustc_errors::inline_fluent;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::{self as hir, CRATE_HIR_ID, LangItem};
 use rustc_middle::mir::AssertMessage;
@@ -19,7 +20,6 @@ use tracing::debug;
 
 use super::error::*;
 use crate::errors::{LongRunning, LongRunningWarn};
-use crate::fluent_generated as fluent;
 use crate::interpret::{
     self, AllocId, AllocInit, AllocRange, ConstAllocation, CtfeProvenance, FnArg, Frame,
     GlobalAlloc, ImmTy, InterpCx, InterpResult, OpTy, PlaceTy, RangeSet, Scalar,
@@ -489,7 +489,13 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
                 let align = match Align::from_bytes(align) {
                     Ok(a) => a,
                     Err(err) => throw_ub_custom!(
-                        fluent::const_eval_invalid_align_details,
+                        inline_fluent!(
+                            "invalid align passed to `{$name}`: {$align} is {$err_kind ->
+    [not_power_of_two] not a power of 2
+    [too_large] too large
+    *[other] {\"\"}
+}"
+                        ),
                         name = "const_allocate",
                         err_kind = err.diag_ident(),
                         align = err.align()
@@ -513,7 +519,13 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
                 let align = match Align::from_bytes(align) {
                     Ok(a) => a,
                     Err(err) => throw_ub_custom!(
-                        fluent::const_eval_invalid_align_details,
+                        inline_fluent!(
+                            "invalid align passed to `{$name}`: {$align} is {$err_kind ->
+    [not_power_of_two] not a power of 2
+    [too_large] too large
+    *[other] {\"\"}
+}"
+                        ),
                         name = "const_deallocate",
                         err_kind = err.diag_ident(),
                         align = err.align()