use super::{error_to_const_error, CompileTimeEvalContext, CompileTimeInterpreter, MemoryExtra};
use crate::interpret::eval_nullary_intrinsic;
use crate::interpret::{
- intern_const_alloc_recursive, Allocation, ConstValue, GlobalId, ImmTy, Immediate, InternKind,
+ intern_const_alloc_recursive, Allocation, ConstValue, GlobalId, Immediate, InternKind,
InterpCx, InterpResult, MPlaceTy, MemoryKind, OpTy, RawConst, RefTracking, Scalar,
ScalarMaybeUndef, StackPopCleanup,
};
-use rustc::mir;
-use rustc::mir::interpret::{ConstEvalErr, ErrorHandled};
-use rustc::traits::Reveal;
-use rustc::ty::{self, layout, layout::LayoutOf, subst::Subst, TyCtxt};
use rustc_hir::def::DefKind;
+use rustc_middle::mir;
+use rustc_middle::mir::interpret::{ConstEvalErr, ErrorHandled};
+use rustc_middle::traits::Reveal;
+use rustc_middle::ty::{self, subst::Subst, TyCtxt};
use rustc_span::source_map::Span;
+use rustc_target::abi::{Abi, LayoutOf};
use std::convert::TryInto;
pub fn note_on_undefined_behavior_error() -> &'static str {
ecx.push_stack_frame(
cid.instance,
- body.span,
body,
Some(ret.into()),
StackPopCleanup::None { cleanup: false },
// the usual cases of extracting e.g. a `usize`, without there being a real use case for the
// `Undef` situation.
let try_as_immediate = match op.layout.abi {
- layout::Abi::Scalar(..) => true,
- layout::Abi::ScalarPair(..) => match op.layout.ty.kind {
+ Abi::Scalar(..) => true,
+ Abi::ScalarPair(..) => match op.layout.ty.kind {
ty::Ref(_, inner, _) => match inner.kind {
ty::Slice(elem) => elem == ecx.tcx.types.u8,
ty::Str => true,
match immediate {
Ok(mplace) => to_const_value(mplace),
// see comment on `let try_as_immediate` above
- Err(ImmTy { imm: Immediate::Scalar(x), .. }) => match x {
- ScalarMaybeUndef::Scalar(s) => ConstValue::Scalar(s),
- ScalarMaybeUndef::Undef => to_const_value(op.assert_mem_place(ecx)),
+ Err(imm) => match *imm {
+ Immediate::Scalar(x) => match x {
+ ScalarMaybeUndef::Scalar(s) => ConstValue::Scalar(s),
+ ScalarMaybeUndef::Undef => to_const_value(op.assert_mem_place(ecx)),
+ },
+ Immediate::ScalarPair(a, b) => {
+ let (data, start) = match a.not_undef().unwrap() {
+ Scalar::Ptr(ptr) => {
+ (ecx.tcx.alloc_map.lock().unwrap_memory(ptr.alloc_id), ptr.offset.bytes())
+ }
+ Scalar::Raw { .. } => (
+ ecx.tcx
+ .intern_const_alloc(Allocation::from_byte_aligned_bytes(b"" as &[u8])),
+ 0,
+ ),
+ };
+ let len = b.to_machine_usize(&ecx.tcx.tcx).unwrap();
+ let start = start.try_into().unwrap();
+ let len: usize = len.try_into().unwrap();
+ ConstValue::Slice { data, start, end: start + len }
+ }
},
- Err(ImmTy { imm: Immediate::ScalarPair(a, b), .. }) => {
- let (data, start) = match a.not_undef().unwrap() {
- Scalar::Ptr(ptr) => {
- (ecx.tcx.alloc_map.lock().unwrap_memory(ptr.alloc_id), ptr.offset.bytes())
- }
- Scalar::Raw { .. } => (
- ecx.tcx.intern_const_alloc(Allocation::from_byte_aligned_bytes(b"" as &[u8])),
- 0,
- ),
- };
- let len = b.to_machine_usize(&ecx.tcx.tcx).unwrap();
- let start = start.try_into().unwrap();
- let len: usize = len.try_into().unwrap();
- ConstValue::Slice { data, start, end: start + len }
- }
}
}
tcx: TyCtxt<'tcx>,
constant: RawConst<'tcx>,
key: ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>,
-) -> ::rustc::mir::interpret::ConstEvalResult<'tcx> {
+) -> ::rustc_middle::mir::interpret::ConstEvalResult<'tcx> {
let cid = key.value;
let def_id = cid.instance.def.def_id();
let is_static = tcx.is_static(def_id);
val.map_err(|error| {
let err = error_to_const_error(&ecx, error);
- match err.struct_error(ecx.tcx, "it is undefined behavior to use this value", |mut diag| {
+ err.struct_error(ecx.tcx, "it is undefined behavior to use this value", |mut diag| {
diag.note(note_on_undefined_behavior_error());
diag.emit();
- }) {
- Ok(_) => ErrorHandled::Reported,
- Err(err) => err,
- }
+ })
})
}
pub fn const_eval_validated_provider<'tcx>(
tcx: TyCtxt<'tcx>,
key: ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>,
-) -> ::rustc::mir::interpret::ConstEvalResult<'tcx> {
+) -> ::rustc_middle::mir::interpret::ConstEvalResult<'tcx> {
// see comment in const_eval_raw_provider for what we're doing here
if key.param_env.reveal == Reveal::All {
let mut key = key;
pub fn const_eval_raw_provider<'tcx>(
tcx: TyCtxt<'tcx>,
key: ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>,
-) -> ::rustc::mir::interpret::ConstEvalRawResult<'tcx> {
+) -> ::rustc_middle::mir::interpret::ConstEvalRawResult<'tcx> {
// Because the constant is computed twice (once per value of `Reveal`), we are at risk of
// reporting the same error twice here. To resolve this, we check whether we can evaluate the
// constant in the more restrictive `Reveal::UserFacing`, which most likely already was
let cid = key.value;
let def_id = cid.instance.def.def_id();
- if def_id.is_local()
- && tcx.has_typeck_tables(def_id)
- && tcx.typeck_tables_of(def_id).tainted_by_errors
- {
- return Err(ErrorHandled::Reported);
+ if def_id.is_local() && tcx.has_typeck_tables(def_id) {
+ if let Some(error_reported) = tcx.typeck_tables_of(def_id).tainted_by_errors {
+ return Err(ErrorHandled::Reported(error_reported));
+ }
}
let is_static = tcx.is_static(def_id);
);
let res = ecx.load_mir(cid.instance.def, cid.promoted);
- res.and_then(|body| eval_body_using_ecx(&mut ecx, cid, *body))
+ res.and_then(|body| eval_body_using_ecx(&mut ecx, cid, &body))
.and_then(|place| {
Ok(RawConst { alloc_id: place.ptr.assert_ptr().alloc_id, ty: place.layout.ty })
})
// because any code that existed before validation could not have failed
// validation thus preventing such a hard error from being a backwards
// compatibility hazard
- Some(DefKind::Const) | Some(DefKind::AssocConst) => {
+ Some(DefKind::Const | DefKind::AssocConst) => {
let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
err.report_as_lint(
tcx.at(tcx.def_span(def_id)),
projects / rustc.git / blobdiff