Skip to content

Commit fd59d44

Browse files
RalfJungRalfJung
committed
make const_err a hard error
1 parent 5854680 commit fd59d44

File tree

254 files changed

+1379
-5321
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

254 files changed

+1379
-5321
lines changed

‎compiler/rustc_const_eval/src/const_eval/error.rs

+7-69
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,6 @@ use std::error::Error;
22
use std::fmt;
33

44
use rustc_errors::Diagnostic;
5-
use rustc_hir as hir;
65
use rustc_middle::mir::AssertKind;
76
use rustc_middle::ty::{layout::LayoutError, query::TyCtxtAt, ConstInt};
87
use rustc_span::{Span, Symbol};
@@ -23,11 +22,7 @@ pub enum ConstEvalErrKind {
2322
Abort(String),
2423
}
2524

26-
impl MachineStopType for ConstEvalErrKind {
27-
fn is_hard_err(&self) -> bool {
28-
matches!(self, Self::Panic { .. })
29-
}
30-
}
25+
impl MachineStopType for ConstEvalErrKind {}
3126

3227
// The errors become `MachineStop` with plain strings when being raised.
3328
// `ConstEvalErr` (in `librustc_middle/mir/interpret/error.rs`) knows to
@@ -87,48 +82,10 @@ impl<'tcx> ConstEvalErr<'tcx> {
8782
ConstEvalErr { error: error.into_kind(), stacktrace, span }
8883
}
8984

90-
pub fn struct_error(
91-
&self,
92-
tcx: TyCtxtAt<'tcx>,
93-
message: &str,
94-
decorate: impl FnOnce(&mut Diagnostic),
95-
) -> ErrorHandled {
96-
self.struct_generic(tcx, message, decorate, None)
97-
}
98-
9985
pub fn report_as_error(&self, tcx: TyCtxtAt<'tcx>, message: &str) -> ErrorHandled {
10086
self.struct_error(tcx, message, |_| {})
10187
}
10288

103-
pub fn report_as_lint(
104-
&self,
105-
tcx: TyCtxtAt<'tcx>,
106-
message: &str,
107-
lint_root: hir::HirId,
108-
span: Option<Span>,
109-
) -> ErrorHandled {
110-
self.struct_generic(
111-
tcx,
112-
message,
113-
|lint: &mut Diagnostic| {
114-
// Apply the span.
115-
if let Some(span) = span {
116-
let primary_spans = lint.span.primary_spans().to_vec();
117-
// point at the actual error as the primary span
118-
lint.replace_span_with(span);
119-
// point to the `const` statement as a secondary span
120-
// they don't have any label
121-
for sp in primary_spans {
122-
if sp != span {
123-
lint.span_label(sp, "");
124-
}
125-
}
126-
}
127-
},
128-
Some(lint_root),
129-
)
130-
}
131-
13289
/// Create a diagnostic for this const eval error.
13390
///
13491
/// Sets the message passed in via `message` and adds span labels with detailed error
@@ -137,13 +94,12 @@ impl<'tcx> ConstEvalErr<'tcx> {
13794
///
13895
/// If `lint_root.is_some()` report it as a lint, else report it as a hard error.
13996
/// (Except that for some errors, we ignore all that -- see `must_error` below.)
140-
#[instrument(skip(self, tcx, decorate, lint_root), level = "debug")]
141-
fn struct_generic(
97+
#[instrument(skip(self, tcx, decorate), level = "debug")]
98+
pub fn struct_error(
14299
&self,
143100
tcx: TyCtxtAt<'tcx>,
144101
message: &str,
145102
decorate: impl FnOnce(&mut Diagnostic),
146-
lint_root: Option<hir::HirId>,
147103
) -> ErrorHandled {
148104
let finish = |err: &mut Diagnostic, span_msg: Option<String>| {
149105
trace!("reporting const eval failure at {:?}", self.span);
@@ -224,27 +180,9 @@ impl<'tcx> ConstEvalErr<'tcx> {
224180

225181
let err_msg = self.error.to_string();
226182

227-
// Regular case - emit a lint.
228-
if let Some(lint_root) = lint_root {
229-
// Report as lint.
230-
let hir_id =
231-
self.stacktrace.iter().rev().find_map(|frame| frame.lint_root).unwrap_or(lint_root);
232-
tcx.struct_span_lint_hir(
233-
rustc_session::lint::builtin::CONST_ERR,
234-
hir_id,
235-
tcx.span,
236-
message,
237-
|lint| {
238-
finish(lint, Some(err_msg));
239-
lint
240-
},
241-
);
242-
ErrorHandled::Linted
243-
} else {
244-
// Report as hard error.
245-
let mut err = struct_error(tcx, message);
246-
finish(&mut err, Some(err_msg));
247-
ErrorHandled::Reported(err.emit())
248-
}
183+
// Report as hard error.
184+
let mut err = struct_error(tcx, message);
185+
finish(&mut err, Some(err_msg));
186+
ErrorHandled::Reported(err.emit())
249187
}
250188
}

‎compiler/rustc_const_eval/src/const_eval/eval_queries.rs

+14-36
Original file line numberDiff line numberDiff line change
@@ -317,45 +317,23 @@ pub fn eval_to_allocation_raw_provider<'tcx>(
317317
match res.and_then(|body| eval_body_using_ecx(&mut ecx, cid, &body)) {
318318
Err(error) => {
319319
let err = ConstEvalErr::new(&ecx, error, None);
320-
// Some CTFE errors raise just a lint, not a hard error; see
321-
// <https://github.com/rust-lang/rust/issues/71800>.
322-
let is_hard_err = if let Some(def) = def.as_local() {
323-
// (Associated) consts only emit a lint, since they might be unused.
324-
!matches!(tcx.def_kind(def.did.to_def_id()), DefKind::Const | DefKind::AssocConst)
325-
// check if the inner InterpError is hard
326-
|| err.error.is_hard_err()
320+
let msg = if is_static {
321+
Cow::from("could not evaluate static initializer")
327322
} else {
328-
// use of broken constant from other crate: always an error
329-
true
330-
};
331-
332-
if is_hard_err {
333-
let msg = if is_static {
334-
Cow::from("could not evaluate static initializer")
323+
// If the current item has generics, we'd like to enrich the message with the
324+
// instance and its substs: to show the actual compile-time values, in addition to
325+
// the expression, leading to the const eval error.
326+
let instance = &key.value.instance;
327+
if !instance.substs.is_empty() {
328+
let instance = with_no_trimmed_paths!(instance.to_string());
329+
let msg = format!("evaluation of `{}` failed", instance);
330+
Cow::from(msg)
335331
} else {
336-
// If the current item has generics, we'd like to enrich the message with the
337-
// instance and its substs: to show the actual compile-time values, in addition to
338-
// the expression, leading to the const eval error.
339-
let instance = &key.value.instance;
340-
if !instance.substs.is_empty() {
341-
let instance = with_no_trimmed_paths!(instance.to_string());
342-
let msg = format!("evaluation of `{}` failed", instance);
343-
Cow::from(msg)
344-
} else {
345-
Cow::from("evaluation of constant value failed")
346-
}
347-
};
332+
Cow::from("evaluation of constant value failed")
333+
}
334+
};
348335

349-
Err(err.report_as_error(ecx.tcx.at(err.span), &msg))
350-
} else {
351-
let hir_id = tcx.hir().local_def_id_to_hir_id(def.as_local().unwrap().did);
352-
Err(err.report_as_lint(
353-
tcx.at(tcx.def_span(def.did)),
354-
"any use of this value will cause an error",
355-
hir_id,
356-
Some(err.span),
357-
))
358-
}
336+
Err(err.report_as_error(ecx.tcx.at(err.span), &msg))
359337
}
360338
Ok(mplace) => {
361339
// Since evaluation had no errors, validate the resulting constant.

‎compiler/rustc_const_eval/src/interpret/eval_context.rs

+3
Original file line numberDiff line numberDiff line change
@@ -258,6 +258,9 @@ impl<'tcx> fmt::Display for FrameInfo<'tcx> {
258258
{
259259
write!(f, "inside closure")?;
260260
} else {
261+
// Note: this triggers a `good_path_bug` state, which means that if we ever get here
262+
// we must emit a diagnostic. We should never display a `FrameInfo` unless we
263+
// actually want to emit a warning or error to the user.
261264
write!(f, "inside `{}`", self.instance)?;
262265
}
263266
if !self.span.is_dummy() {

‎compiler/rustc_const_eval/src/interpret/intern.rs

-2
Original file line numberDiff line numberDiff line change
@@ -332,8 +332,6 @@ pub enum InternKind {
332332
///
333333
/// This *cannot raise an interpreter error*. Doing so is left to validation, which
334334
/// tracks where in the value we are and thus can show much better error messages.
335-
/// Any errors here would anyway be turned into `const_err` lints, whereas validation failures
336-
/// are hard errors.
337335
#[instrument(level = "debug", skip(ecx))]
338336
pub fn intern_const_alloc_recursive<
339337
'mir,

‎compiler/rustc_lint/src/lib.rs

+5
Original file line numberDiff line numberDiff line change
@@ -522,6 +522,11 @@ fn register_builtins(store: &mut LintStore, no_interleave_lints: bool) {
522522
"now allowed, see issue #59159 \
523523
<https://github.com/rust-lang/rust/issues/59159> for more information",
524524
);
525+
store.register_removed(
526+
"const_err",
527+
"converted into hard error, see issue #71800 \
528+
<https://github.com/rust-lang/rust/issues/71800> for more information",
529+
);
525530
}
526531

527532
fn register_internals(store: &mut LintStore) {

‎compiler/rustc_lint_defs/src/builtin.rs

-32
Original file line numberDiff line numberDiff line change
@@ -263,37 +263,6 @@ declare_lint! {
263263
"operation will cause a panic at runtime"
264264
}
265265

266-
declare_lint! {
267-
/// The `const_err` lint detects an erroneous expression while doing
268-
/// constant evaluation.
269-
///
270-
/// ### Example
271-
///
272-
/// ```rust,compile_fail
273-
/// #![allow(unconditional_panic)]
274-
/// const C: i32 = 1/0;
275-
/// ```
276-
///
277-
/// {{produces}}
278-
///
279-
/// ### Explanation
280-
///
281-
/// This lint detects constants that fail to evaluate. Allowing the lint will accept the
282-
/// constant declaration, but any use of this constant will still lead to a hard error. This is
283-
/// a future incompatibility lint; the plan is to eventually entirely forbid even declaring
284-
/// constants that cannot be evaluated. See [issue #71800] for more details.
285-
///
286-
/// [issue #71800]: https://github.com/rust-lang/rust/issues/71800
287-
pub CONST_ERR,
288-
Deny,
289-
"constant evaluation encountered erroneous expression",
290-
@future_incompatible = FutureIncompatibleInfo {
291-
reference: "issue #71800 <https://github.com/rust-lang/rust/issues/71800>",
292-
reason: FutureIncompatibilityReason::FutureReleaseErrorReportNow,
293-
};
294-
report_in_external_macro
295-
}
296-
297266
declare_lint! {
298267
/// The `unused_imports` lint detects imports that are never used.
299268
///
@@ -3295,7 +3264,6 @@ declare_lint_pass! {
32953264
EXPORTED_PRIVATE_DEPENDENCIES,
32963265
PUB_USE_OF_PRIVATE_EXTERN_CRATE,
32973266
INVALID_TYPE_PARAM_DEFAULT,
3298-
CONST_ERR,
32993267
RENAMED_AND_REMOVED_LINTS,
33003268
UNALIGNED_REFERENCES,
33013269
CONST_ITEM_MUTATION,

‎compiler/rustc_middle/src/mir/interpret/error.rs

+1-18
Original file line numberDiff line numberDiff line change
@@ -479,12 +479,7 @@ impl<T: Any> AsAny for T {
479479
}
480480

481481
/// A trait for machine-specific errors (or other "machine stop" conditions).
482-
pub trait MachineStopType: AsAny + fmt::Display + Send {
483-
/// If `true`, emit a hard error instead of going through the `CONST_ERR` lint
484-
fn is_hard_err(&self) -> bool {
485-
false
486-
}
487-
}
482+
pub trait MachineStopType: AsAny + fmt::Display + Send {}
488483

489484
impl dyn MachineStopType {
490485
#[inline(always)]
@@ -543,16 +538,4 @@ impl InterpError<'_> {
543538
| InterpError::UndefinedBehavior(UndefinedBehaviorInfo::Ub(_))
544539
)
545540
}
546-
547-
/// Should this error be reported as a hard error, preventing compilation, or a soft error,
548-
/// causing a deny-by-default lint?
549-
pub fn is_hard_err(&self) -> bool {
550-
use InterpError::*;
551-
match *self {
552-
MachineStop(ref err) => err.is_hard_err(),
553-
UndefinedBehavior(_) => true,
554-
ResourceExhaustion(ResourceExhaustionInfo::MemoryExhausted) => true,
555-
_ => false,
556-
}
557-
}
558541
}

‎compiler/rustc_mir_transform/src/const_prop_lint.rs

+9-26
Original file line numberDiff line numberDiff line change
@@ -16,9 +16,9 @@ use rustc_index::bit_set::BitSet;
1616
use rustc_index::vec::IndexVec;
1717
use rustc_middle::mir::visit::Visitor;
1818
use rustc_middle::mir::{
19-
self, AssertKind, BinOp, Body, Constant, ConstantKind, Local, LocalDecl, Location, Operand,
20-
Place, Rvalue, SourceInfo, SourceScope, SourceScopeData, Statement, StatementKind, Terminator,
21-
TerminatorKind, UnOp, RETURN_PLACE,
19+
AssertKind, BinOp, Body, Constant, Local, LocalDecl, Location, Operand, Place, Rvalue,
20+
SourceInfo, SourceScope, SourceScopeData, Statement, StatementKind, Terminator, TerminatorKind,
21+
UnOp, RETURN_PLACE,
2222
};
2323
use rustc_middle::ty::layout::{LayoutError, LayoutOf, LayoutOfHelpers, TyAndLayout};
2424
use rustc_middle::ty::InternalSubsts;
@@ -286,7 +286,11 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
286286
}
287287

288288
/// Returns the value, if any, of evaluating `c`.
289-
fn eval_constant(&mut self, c: &Constant<'tcx>, source_info: SourceInfo) -> Option<OpTy<'tcx>> {
289+
fn eval_constant(
290+
&mut self,
291+
c: &Constant<'tcx>,
292+
_source_info: SourceInfo,
293+
) -> Option<OpTy<'tcx>> {
290294
// FIXME we need to revisit this for #67176
291295
if c.needs_subst() {
292296
return None;
@@ -297,28 +301,7 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
297301
Err(error) => {
298302
let tcx = self.ecx.tcx.at(c.span);
299303
let err = ConstEvalErr::new(&self.ecx, error, Some(c.span));
300-
if let Some(lint_root) = self.lint_root(source_info) {
301-
let lint_only = match c.literal {
302-
ConstantKind::Ty(ct) => ct.needs_subst(),
303-
ConstantKind::Unevaluated(
304-
mir::UnevaluatedConst { def: _, substs: _, promoted: Some(_) },
305-
_,
306-
) => {
307-
// Promoteds must lint and not error as the user didn't ask for them
308-
true
309-
}
310-
ConstantKind::Unevaluated(..) | ConstantKind::Val(..) => c.needs_subst(),
311-
};
312-
if lint_only {
313-
// Out of backwards compatibility we cannot report hard errors in unused
314-
// generic functions using associated constants of the generic parameters.
315-
err.report_as_lint(tcx, "erroneous constant used", lint_root, Some(c.span));
316-
} else {
317-
err.report_as_error(tcx, "erroneous constant used");
318-
}
319-
} else {
320-
err.report_as_error(tcx, "erroneous constant used");
321-
}
304+
err.report_as_error(tcx, "erroneous constant used");
322305
None
323306
}
324307
}

‎library/core/tests/num/wrapping.rs

-2
Original file line numberDiff line numberDiff line change
@@ -75,8 +75,6 @@ wrapping_test!(test_wrapping_u64, u64, u64::MIN, u64::MAX);
7575
wrapping_test!(test_wrapping_u128, u128, u128::MIN, u128::MAX);
7676
wrapping_test!(test_wrapping_usize, usize, usize::MIN, usize::MAX);
7777

78-
// Don't warn about overflowing ops on 32-bit platforms
79-
#[cfg_attr(target_pointer_width = "32", allow(const_err))]
8078
#[test]
8179
fn wrapping_int_api() {
8280
assert_eq!(i8::MAX.wrapping_add(1), i8::MIN);

‎library/core/tests/slice.rs

-1
Original file line numberDiff line numberDiff line change
@@ -1284,7 +1284,6 @@ fn test_windows_zip() {
12841284
}
12851285

12861286
#[test]
1287-
#[allow(const_err)]
12881287
fn test_iter_ref_consistency() {
12891288
use std::fmt::Debug;
12901289

‎src/test/mir-opt/remove-never-const.rs

-1
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,6 @@
66
// compile-flags: --emit mir,link
77

88
#![feature(never_type)]
9-
#![warn(const_err)]
109

1110
struct PrintName<T>(T);
1211

‎src/test/ui/array-slice-vec/array_const_index-0.rs

+1-2
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,7 @@
11
const A: &'static [i32] = &[];
22
const B: i32 = (&A)[1];
33
//~^ index out of bounds: the length is 0 but the index is 1
4-
//~| ERROR any use of this value will cause an error
5-
//~| WARN this was previously accepted by the compiler but is being phased out
4+
//~| ERROR evaluation of constant value failed
65

76
fn main() {
87
let _ = B;

0 commit comments

Comments
 (0)