use std::fmt;
use rustc_middle::mir::AssertKind;
-use rustc_span::Symbol;
+use rustc_span::{Span, Symbol};
use super::InterpCx;
use crate::interpret::{ConstEvalErr, InterpErrorInfo, Machine};
pub fn error_to_const_error<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>>(
ecx: &InterpCx<'mir, 'tcx, M>,
error: InterpErrorInfo<'tcx>,
+ span: Option<Span>,
) -> ConstEvalErr<'tcx> {
error.print_backtrace();
let stacktrace = ecx.generate_stacktrace();
- ConstEvalErr { error: error.kind, stacktrace, span: ecx.cur_span() }
+ ConstEvalErr { error: error.kind, stacktrace, span: span.unwrap_or_else(|| ecx.cur_span()) }
}
})();
val.map_err(|error| {
- let err = error_to_const_error(&ecx, error);
+ let err = error_to_const_error(&ecx, error, None);
err.struct_error(ecx.tcx_at(), "it is undefined behavior to use this value", |mut diag| {
diag.note(note_on_undefined_behavior_error());
diag.emit();
res.and_then(|body| eval_body_using_ecx(&mut ecx, cid, &body))
.map(|place| RawConst { alloc_id: place.ptr.assert_ptr().alloc_id, ty: place.layout.ty })
.map_err(|error| {
- let err = error_to_const_error(&ecx, error);
+ let err = error_to_const_error(&ecx, error, None);
// errors in statics are always emitted as fatal errors
if is_static {
// Ensure that if the above error was either `TooGeneric` or `Reported`
(&ty::Array(_, length), &ty::Slice(_)) => {
let ptr = self.read_immediate(src)?.to_scalar()?;
// u64 cast is from usize to u64, which is always good
- let val = Immediate::new_slice(
- ptr,
- length.eval_usize(self.tcx, self.param_env),
- self,
- );
+ let val =
+ Immediate::new_slice(ptr, length.eval_usize(self.tcx, self.param_env), self);
self.write_immediate(val, dest)
}
(&ty::Dynamic(..), &ty::Dynamic(..)) => {
#[inline(always)]
pub fn cur_span(&self) -> Span {
- self
- .stack()
+ self.stack()
.last()
.and_then(|f| f.current_source_info())
.map(|si| si.span)
let did = instance.def_id();
if let Some(did) = did.as_local() {
if self.tcx_at().has_typeck_tables(did) {
- if let Some(error_reported) = self.tcx_at().typeck_tables_of(did).tainted_by_errors {
+ if let Some(error_reported) = self.tcx_at().typeck_tables_of(did).tainted_by_errors
+ {
throw_inval!(TypeckError(error_reported))
}
}
// to get some code to work that probably ought to work.
field_layout.align.abi
}
- None => span_bug!(self.cur_span(), "cannot compute offset for extern type field at non-0 offset"),
+ None => span_bug!(
+ self.cur_span(),
+ "cannot compute offset for extern type field at non-0 offset"
+ ),
};
(base.meta, offset.align_to(align))
} else {
assert!(!field_layout.is_unsized());
base.offset(offset, MemPlaceMeta::None, field_layout, self)
}
- _ => span_bug!(self.cur_span(), "`mplace_index` called on non-array type {:?}", base.layout.ty),
+ _ => span_bug!(
+ self.cur_span(),
+ "`mplace_index` called on non-array type {:?}",
+ base.layout.ty
+ ),
}
}
// (that have count 0 in their layout).
let from_offset = match base.layout.fields {
FieldsShape::Array { stride, .. } => stride * from, // `Size` multiplication is checked
- _ => span_bug!(self.cur_span(), "unexpected layout of index access: {:#?}", base.layout),
+ _ => {
+ span_bug!(self.cur_span(), "unexpected layout of index access: {:#?}", base.layout)
+ }
};
// Compute meta and new layout
let len = Scalar::from_machine_usize(inner_len, self);
(MemPlaceMeta::Meta(len), base.layout.ty)
}
- _ => span_bug!(self.cur_span(), "cannot subslice non-array type: `{:?}`", base.layout.ty),
+ _ => {
+ span_bug!(self.cur_span(), "cannot subslice non-array type: `{:?}`", base.layout.ty)
+ }
};
let layout = self.layout_of(ty)?;
base.offset(from_offset, meta, layout, self)
Immediate::Scalar(scalar) => {
match dest.layout.abi {
Abi::Scalar(_) => {} // fine
- _ => {
- span_bug!(self.cur_span(), "write_immediate_to_mplace: invalid Scalar layout: {:#?}", dest.layout)
- }
+ _ => span_bug!(
+ self.cur_span(),
+ "write_immediate_to_mplace: invalid Scalar layout: {:#?}",
+ dest.layout
+ ),
}
self.memory.get_raw_mut(ptr.alloc_id)?.write_scalar(
&tcx,
Ok(op) => Some(op),
Err(error) => {
let tcx = self.ecx.tcx.at(c.span);
- let err = error_to_const_error(&self.ecx, error);
+ let err = error_to_const_error(&self.ecx, error, Some(c.span));
if let Some(lint_root) = self.lint_root(source_info) {
let lint_only = match c.literal.val {
// Promoteds must lint and not error as the user didn't ask for them
if lint_only {
// Out of backwards compatibility we cannot report hard errors in unused
// generic functions using associated constants of the generic parameters.
- err.report_as_lint(
- tcx,
- "erroneous constant used",
- lint_root,
- Some(c.span),
- );
+ err.report_as_lint(tcx, "erroneous constant used", lint_root, Some(c.span));
} else {
err.report_as_error(tcx, "erroneous constant used");
}
= help: add `#![feature(const_if_match)]` to the crate attributes to enable
error[E0080]: evaluation of constant value failed
- --> $DIR/infinite_loop.rs:8:20
+ --> $DIR/infinite_loop.rs:8:17
|
LL | n = if n % 2 == 0 { n/2 } else { 3*n + 1 };
- | ^^^^^^^^^^ exceeded interpreter step limit (see `#[const_eval_limit]`)
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ exceeded interpreter step limit (see `#[const_eval_limit]`)
error: aborting due to 3 previous errors
error: any use of this value will cause an error
- --> $DIR/const_eval_limit_reached.rs:8:11
+ --> $DIR/const_eval_limit_reached.rs:8:5
|
-LL | / const X: usize = {
-LL | | let mut x = 0;
-LL | | while x != 1000 {
- | | ^^^^^^^^^ exceeded interpreter step limit (see `#[const_eval_limit]`)
-LL | |
-... |
-LL | | x
-LL | | };
- | |__-
+LL | / const X: usize = {
+LL | | let mut x = 0;
+LL | | while x != 1000 {
+ | |_____^
+LL | ||
+LL | || x += 1;
+LL | || }
+ | ||_____^ exceeded interpreter step limit (see `#[const_eval_limit]`)
+LL | |
+LL | | x
+LL | | };
+ | |__-
|
= note: `#[deny(const_err)]` on by default
error[E0391]: cycle detected when const-evaluating `FOO`
- --> $DIR/recursive-zst-static.rs:10:18
+ --> $DIR/recursive-zst-static.rs:10:1
|
LL | static FOO: () = FOO;
- | ^^^
+ | ^^^^^^^^^^^^^^^^^^^^^
|
note: ...which requires const-evaluating `FOO`...
--> $DIR/recursive-zst-static.rs:10:1
error[E0391]: cycle detected when const-evaluating `FOO`
- --> $DIR/recursive-zst-static.rs:10:18
+ --> $DIR/recursive-zst-static.rs:10:1
|
LL | static FOO: () = FOO;
- | ^^^
+ | ^^^^^^^^^^^^^^^^^^^^^
|
note: ...which requires const-evaluating `FOO`...
--> $DIR/recursive-zst-static.rs:10:1
// build-fail
pub const unsafe fn fake_type<T>() -> T {
- hint_unreachable()
+ hint_unreachable() //~ ERROR evaluation of constant value failed
}
pub const unsafe fn hint_unreachable() -> ! {
- fake_type() //~ ERROR evaluation of constant value failed
+ fake_type()
}
trait Const {
error[E0080]: evaluation of constant value failed
- --> $DIR/uninhabited-const-issue-61744.rs:8:5
+ --> $DIR/uninhabited-const-issue-61744.rs:4:5
|
LL | hint_unreachable()
- | ------------------
+ | ^^^^^^^^^^^^^^^^^^
| |
+ | reached the configured maximum number of stack frames
| inside `fake_type::<!>` at $DIR/uninhabited-const-issue-61744.rs:4:5
| inside `fake_type::<!>` at $DIR/uninhabited-const-issue-61744.rs:4:5
| inside `fake_type::<!>` at $DIR/uninhabited-const-issue-61744.rs:4:5
| inside `fake_type::<i32>` at $DIR/uninhabited-const-issue-61744.rs:4:5
...
LL | fake_type()
- | ^^^^^^^^^^^
+ | -----------
| |
- | reached the configured maximum number of stack frames
| inside `hint_unreachable` at $DIR/uninhabited-const-issue-61744.rs:8:5
| inside `hint_unreachable` at $DIR/uninhabited-const-issue-61744.rs:8:5
| inside `hint_unreachable` at $DIR/uninhabited-const-issue-61744.rs:8:5
error[E0391]: cycle detected when const-evaluating `FOO`
- --> $DIR/recursive-static-definition.rs:1:23
+ --> $DIR/recursive-static-definition.rs:1:1
|
LL | pub static FOO: u32 = FOO;
- | ^^^
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
|
note: ...which requires const-evaluating `FOO`...
--> $DIR/recursive-static-definition.rs:1:1
| ^^^^^ modifying a static's initial value from another static's initializer
error[E0391]: cycle detected when const-evaluating `C`
- --> $DIR/write-to-static-mut-in-static.rs:5:34
+ --> $DIR/write-to-static-mut-in-static.rs:5:1
|
LL | pub static mut C: u32 = unsafe { C = 1; 0 };
- | ^^^^^
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
note: ...which requires const-evaluating `C`...
--> $DIR/write-to-static-mut-in-static.rs:5:1