[] UsedTraitImports(DefId),
[] HasTypeckTables(DefId),
[] ConstEval { param_env: ParamEnvAnd<'tcx, GlobalId<'tcx>> },
+ [] ConstEvalRaw { param_env: ParamEnvAnd<'tcx, GlobalId<'tcx>> },
[] CheckMatch(DefId),
[] SymbolName(DefId),
[] InstanceSymbolName { instance: Instance<'tcx> },
SelfCtor(DefId /* impl */), // DefId refers to the impl
Method(DefId),
AssociatedConst(DefId),
+ Closure(hir::BodyId),
Local(ast::NodeId),
Upvar(ast::NodeId, // node id of closed over local
id
}
+ Def::Closure(_) |
Def::Local(..) |
Def::Upvar(..) |
Def::Label(..) |
Def::Trait(..) => "trait",
Def::ForeignTy(..) => "foreign type",
Def::Method(..) => "method",
+ Def::Closure(_) => "closure",
Def::Const(..) => "constant",
Def::AssociatedConst(..) => "associated constant",
Def::TyParam(..) => "type parameter",
let def_id = self.local_def_id(variant.node.data.id());
Some(Def::Variant(def_id))
}
+ Node::Expr(expr) => {
+ match expr.node {
+ ExprKind::Closure(_, _, body_id, _, _) => Some(Def::Closure(body_id)),
+ _ => None,
+ }
+ }
Node::Field(_) |
Node::AnonConst(_) |
- Node::Expr(_) |
Node::Stmt(_) |
Node::Ty(_) |
Node::TraitRef(_) |
SelfCtor(impl_def_id),
VariantCtor(def_id, ctor_kind),
Method(def_id),
+ Closure(body_id),
AssociatedConst(def_id),
Local(def_id),
Upvar(def_id, index, expr_id),
val
});
-impl_stable_hash_for!(struct ::mir::interpret::ConstEvalErr<'tcx> {
- span,
- stacktrace,
- error
+impl_stable_hash_for!(enum mir::interpret::ErrorHandled {
+ Reported,
+ TooGeneric
});
impl_stable_hash_for!(struct ::mir::interpret::FrameInfo {
predicates
});
-impl_stable_hash_for!(struct ::mir::interpret::EvalError<'tcx> { kind });
-
impl<'a, 'gcx, O: HashStable<StableHashingContext<'a>>> HashStable<StableHashingContext<'a>>
for ::mir::interpret::EvalErrorKind<'gcx, O> {
fn hash_stable<W: StableHasherResult>(&self,
UnimplementedTraitSelection |
TypeckError |
TooGeneric |
- CheckMatchError |
DerefFunctionPointer |
ExecuteMemory |
OverflowNeg |
DivisionByZero |
GeneratorResumedAfterReturn |
GeneratorResumedAfterPanic |
+ ReferencedConstant |
InfiniteLoop => {}
ReadUndefBytes(offset) => offset.hash_stable(hcx, hasher),
InvalidDiscriminant(val) => val.hash_stable(hcx, hasher),
line.hash_stable(hcx, hasher);
col.hash_stable(hcx, hasher);
},
- ReferencedConstant(ref err) => err.hash_stable(hcx, hasher),
MachineError(ref err) => err.hash_stable(hcx, hasher),
FunctionAbiMismatch(a, b) => {
a.hash_stable(hcx, hasher);
use mir;
use ty::{Ty, layout};
use ty::layout::{Size, Align};
-use rustc_data_structures::sync::Lrc;
use rustc_target::spec::abi::Abi;
use super::{
use syntax::ast;
use syntax::symbol::Symbol;
-pub type ConstEvalResult<'tcx> = Result<&'tcx ty::Const<'tcx>, Lrc<ConstEvalErr<'tcx>>>;
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ErrorHandled {
+ /// Already reported a lint or an error for this evaluation
+ Reported,
+ /// Don't emit an error, the evaluation failed because the MIR was generic
+ /// and the substs didn't fully monomorphize it.
+ TooGeneric,
+}
+
+impl ErrorHandled {
+ pub fn assert_reported(self) {
+ match self {
+ ErrorHandled::Reported => {},
+ ErrorHandled::TooGeneric => bug!("MIR interpretation failed without reporting an error \
+ even though it was fully monomorphized"),
+ }
+ }
+}
+
+pub type ConstEvalResult<'tcx> = Result<&'tcx ty::Const<'tcx>, ErrorHandled>;
#[derive(Clone, Debug, RustcEncodable, RustcDecodable)]
pub struct ConstEvalErr<'tcx> {
pub fn struct_error(&self,
tcx: TyCtxtAt<'a, 'gcx, 'tcx>,
message: &str)
- -> Option<DiagnosticBuilder<'tcx>>
+ -> Result<DiagnosticBuilder<'tcx>, ErrorHandled>
{
self.struct_generic(tcx, message, None)
}
pub fn report_as_error(&self,
tcx: TyCtxtAt<'a, 'gcx, 'tcx>,
message: &str
- ) {
+ ) -> ErrorHandled {
let err = self.struct_error(tcx, message);
- if let Some(mut err) = err {
- err.emit();
+ match err {
+ Ok(mut err) => {
+ err.emit();
+ ErrorHandled::Reported
+ },
+ Err(err) => err,
}
}
tcx: TyCtxtAt<'a, 'gcx, 'tcx>,
message: &str,
lint_root: ast::NodeId,
- ) {
+ ) -> ErrorHandled {
let lint = self.struct_generic(
tcx,
message,
Some(lint_root),
);
- if let Some(mut lint) = lint {
- lint.emit();
+ match lint {
+ Ok(mut lint) => {
+ lint.emit();
+ ErrorHandled::Reported
+ },
+ Err(err) => err,
}
}
tcx: TyCtxtAt<'a, 'gcx, 'tcx>,
message: &str,
lint_root: Option<ast::NodeId>,
- ) -> Option<DiagnosticBuilder<'tcx>> {
+ ) -> Result<DiagnosticBuilder<'tcx>, ErrorHandled> {
match self.error.kind {
- ::mir::interpret::EvalErrorKind::TypeckError |
- ::mir::interpret::EvalErrorKind::TooGeneric |
- ::mir::interpret::EvalErrorKind::CheckMatchError |
- ::mir::interpret::EvalErrorKind::Layout(_) => return None,
- ::mir::interpret::EvalErrorKind::ReferencedConstant(ref inner) => {
- inner.struct_generic(tcx, "referenced constant has errors", lint_root)?.emit();
- },
+ EvalErrorKind::TooGeneric => return Err(ErrorHandled::TooGeneric),
+ EvalErrorKind::TypeckError |
+ EvalErrorKind::Layout(_) => return Err(ErrorHandled::Reported),
_ => {},
}
trace!("reporting const eval failure at {:?}", self.span);
for FrameInfo { span, location, .. } in &self.stacktrace {
err.span_label(*span, format!("inside call to `{}`", location));
}
- Some(err)
+ Ok(err)
}
}
TypeckError,
/// Resolution can fail if we are in a too generic context
TooGeneric,
- CheckMatchError,
/// Cannot compute this constant because it depends on another one
/// which already produced an error
- ReferencedConstant(Lrc<ConstEvalErr<'tcx>>),
+ ReferencedConstant,
GeneratorResumedAfterReturn,
GeneratorResumedAfterPanic,
InfiniteLoop,
"encountered constants with type errors, stopping evaluation",
TooGeneric =>
"encountered overly generic constant",
- CheckMatchError =>
- "match checking failed",
- ReferencedConstant(_) =>
+ ReferencedConstant =>
"referenced constant has errors",
Overflow(mir::BinOp::Add) => "attempt to add with overflow",
Overflow(mir::BinOp::Sub) => "attempt to subtract with overflow",
pub use self::error::{
EvalError, EvalResult, EvalErrorKind, AssertMessage, ConstEvalErr, struct_error,
- FrameInfo, ConstEvalResult,
+ FrameInfo, ConstEvalResult, ErrorHandled,
};
pub use self::value::{Scalar, ConstValue};
self.tcx.report_object_safety_error(span, did, violations)
}
- ConstEvalFailure(ref err) => {
- match err.struct_error(
- self.tcx.at(span),
- "could not evaluate constant expression",
- ) {
- Some(err) => err,
- None => {
- self.tcx.sess.delay_span_bug(span,
- &format!("constant in type had an ignored error: {:?}", err));
- return;
- }
- }
+ // already reported in the query
+ ConstEvalFailure => {
+ self.tcx.sess.delay_span_bug(span, "constant in type had an ignored error");
+ return;
}
Overflow => {
use rustc_data_structures::obligation_forest::{ObligationProcessor, ProcessResult};
use std::marker::PhantomData;
use hir::def_id::DefId;
-use mir::interpret::ConstEvalErr;
-use mir::interpret::EvalErrorKind;
use super::CodeAmbiguity;
use super::CodeProjectionError;
match self.selcx.tcx().at(obligation.cause.span)
.const_eval(param_env.and(cid)) {
Ok(_) => ProcessResult::Changed(vec![]),
- Err(err) => ProcessResult::Error(
- CodeSelectionError(ConstEvalFailure(err)))
+ Err(_) => ProcessResult::Error(
+ CodeSelectionError(ConstEvalFailure))
}
} else {
- ProcessResult::Error(
- CodeSelectionError(ConstEvalFailure(ConstEvalErr {
- span: obligation.cause.span,
- error: EvalErrorKind::TooGeneric.into(),
- stacktrace: vec![],
- }.into()))
- )
+ ProcessResult::Error(CodeSelectionError(ConstEvalFailure))
}
},
None => {
use infer::SuppressRegionErrors;
use infer::outlives::env::OutlivesEnvironment;
use middle::region;
-use mir::interpret::ConstEvalErr;
use ty::subst::Substs;
use ty::{self, AdtKind, List, Ty, TyCtxt, GenericParamDefKind, ToPredicate};
use ty::error::{ExpectedFound, TypeError};
ty::PolyTraitRef<'tcx>,
ty::error::TypeError<'tcx>),
TraitNotObjectSafe(DefId),
- ConstEvalFailure(Lrc<ConstEvalErr<'tcx>>),
+ ConstEvalFailure,
Overflow,
}
)
}
super::TraitNotObjectSafe(def_id) => Some(super::TraitNotObjectSafe(def_id)),
- super::ConstEvalFailure(ref err) => tcx.lift(&**err).map(|err| super::ConstEvalFailure(
- err.into(),
- )),
+ super::ConstEvalFailure(ref err) => Some(super::ConstEvalFailure),
super::Overflow => Some(super::Overflow),
}
}
use middle::privacy::AccessLevels;
use middle::resolve_lifetime::ObjectLifetimeDefault;
use mir::Mir;
-use mir::interpret::GlobalId;
+use mir::interpret::{GlobalId, ErrorHandled};
use mir::GeneratorLayout;
use session::CrateDisambiguator;
use traits::{self, Reveal};
None
}
}
- Err(err) => {
- err.report_as_error(
- tcx.at(tcx.def_span(expr_did)),
- "could not evaluate enum discriminant",
- );
+ Err(ErrorHandled::Reported) => {
if !expr_did.is_local() {
span_bug!(tcx.def_span(expr_did),
"variant discriminant evaluation succeeded \
}
None
}
+ Err(ErrorHandled::TooGeneric) => span_bug!(
+ tcx.def_span(expr_did),
+ "enum discriminant depends on generic arguments",
+ ),
}
}
}
impl<'tcx> QueryDescription<'tcx> for queries::const_eval<'tcx> {
+ fn describe(
+ tcx: TyCtxt<'_, '_, '_>,
+ key: ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>,
+ ) -> Cow<'static, str> {
+ format!(
+ "const-evaluating + checking `{}`",
+ tcx.item_path_str(key.value.instance.def.def_id()),
+ ).into()
+ }
+
+ #[inline]
+ fn cache_on_disk(_key: Self::Key) -> bool {
+ true
+ }
+
+ #[inline]
+ fn try_load_from_disk<'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
+ id: SerializedDepNodeIndex)
+ -> Option<Self::Value> {
+ tcx.queries.on_disk_cache.try_load_query_result(tcx, id).map(Ok)
+ }
+}
+
+impl<'tcx> QueryDescription<'tcx> for queries::const_eval_raw<'tcx> {
fn describe(tcx: TyCtxt<'_, '_, '_>, key: ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>)
-> Cow<'static, str>
{
},
Other {
+ /// Evaluate a constant without running sanity checks
+ ///
+ /// DO NOT USE THIS outside const eval. Const eval uses this to break query cycles during
+ /// validation. Please add a comment to every use site explaining why using `const_eval`
+ /// isn't sufficient
+ [] fn const_eval_raw: const_eval_raw_dep_node(ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>)
+ -> ConstEvalResult<'tcx>,
+
/// Results of evaluating const items or constants embedded in
/// other items (such as enum variant explicit discriminants).
[] fn const_eval: const_eval_dep_node(ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>)
-> DepConstructor<'tcx> {
DepConstructor::ConstEval { param_env }
}
+fn const_eval_raw_dep_node<'tcx>(param_env: ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>)
+ -> DepConstructor<'tcx> {
+ DepConstructor::ConstEvalRaw { param_env }
+}
fn mir_keys<'tcx>(_: CrateNum) -> DepConstructor<'tcx> {
DepConstructor::MirKeys
DepKind::NeedsDrop |
DepKind::Layout |
DepKind::ConstEval |
+ DepKind::ConstEvalRaw |
DepKind::InstanceSymbolName |
DepKind::MirShim |
DepKind::BorrowCheckKrate |
//! hand, though we've recently added some macros (e.g.,
//! `BraceStructLiftImpl!`) to help with the tedium.
-use mir::interpret::{ConstValue, ConstEvalErr};
+use mir::interpret::ConstValue;
use ty::{self, Lift, Ty, TyCtxt};
use ty::fold::{TypeFoldable, TypeFolder, TypeVisitor};
use rustc_data_structures::indexed_vec::{IndexVec, Idx};
}
}
-impl<'a, 'tcx> Lift<'tcx> for ConstEvalErr<'a> {
- type Lifted = ConstEvalErr<'tcx>;
- fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<Self::Lifted> {
- tcx.lift(&self.error).map(|error| {
- ConstEvalErr {
- span: self.span,
- stacktrace: self.stacktrace.clone(),
- error,
- }
- })
- }
-}
-
-impl<'a, 'tcx> Lift<'tcx> for interpret::EvalError<'a> {
- type Lifted = interpret::EvalError<'tcx>;
- fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<Self::Lifted> {
- Some(interpret::EvalError {
- kind: tcx.lift(&self.kind)?,
- })
- }
-}
-
-impl<'a, 'tcx, O: Lift<'tcx>> Lift<'tcx> for interpret::EvalErrorKind<'a, O> {
- type Lifted = interpret::EvalErrorKind<'tcx, <O as Lift<'tcx>>::Lifted>;
- fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<Self::Lifted> {
- use ::mir::interpret::EvalErrorKind::*;
- Some(match *self {
- MachineError(ref err) => MachineError(err.clone()),
- FunctionAbiMismatch(a, b) => FunctionAbiMismatch(a, b),
- FunctionArgMismatch(a, b) => FunctionArgMismatch(
- tcx.lift(&a)?,
- tcx.lift(&b)?,
- ),
- FunctionRetMismatch(a, b) => FunctionRetMismatch(
- tcx.lift(&a)?,
- tcx.lift(&b)?,
- ),
- FunctionArgCountMismatch => FunctionArgCountMismatch,
- NoMirFor(ref s) => NoMirFor(s.clone()),
- UnterminatedCString(ptr) => UnterminatedCString(ptr),
- DanglingPointerDeref => DanglingPointerDeref,
- DoubleFree => DoubleFree,
- InvalidMemoryAccess => InvalidMemoryAccess,
- InvalidFunctionPointer => InvalidFunctionPointer,
- InvalidBool => InvalidBool,
- InvalidDiscriminant(val) => InvalidDiscriminant(val),
- PointerOutOfBounds {
- ptr,
- access,
- allocation_size,
- } => PointerOutOfBounds { ptr, access, allocation_size },
- InvalidNullPointerUsage => InvalidNullPointerUsage,
- ReadPointerAsBytes => ReadPointerAsBytes,
- ReadBytesAsPointer => ReadBytesAsPointer,
- ReadForeignStatic => ReadForeignStatic,
- InvalidPointerMath => InvalidPointerMath,
- ReadUndefBytes(offset) => ReadUndefBytes(offset),
- DeadLocal => DeadLocal,
- InvalidBoolOp(bop) => InvalidBoolOp(bop),
- Unimplemented(ref s) => Unimplemented(s.clone()),
- DerefFunctionPointer => DerefFunctionPointer,
- ExecuteMemory => ExecuteMemory,
- BoundsCheck { ref len, ref index } => BoundsCheck {
- len: tcx.lift(len)?,
- index: tcx.lift(index)?,
- },
- Intrinsic(ref s) => Intrinsic(s.clone()),
- InvalidChar(c) => InvalidChar(c),
- StackFrameLimitReached => StackFrameLimitReached,
- OutOfTls => OutOfTls,
- TlsOutOfBounds => TlsOutOfBounds,
- AbiViolation(ref s) => AbiViolation(s.clone()),
- AlignmentCheckFailed {
- required,
- has,
- } => AlignmentCheckFailed { required, has },
- MemoryLockViolation {
- ptr,
- len,
- frame,
- access,
- ref lock,
- } => MemoryLockViolation { ptr, len, frame, access, lock: lock.clone() },
- MemoryAcquireConflict {
- ptr,
- len,
- kind,
- ref lock,
- } => MemoryAcquireConflict { ptr, len, kind, lock: lock.clone() },
- InvalidMemoryLockRelease {
- ptr,
- len,
- frame,
- ref lock,
- } => InvalidMemoryLockRelease { ptr, len, frame, lock: lock.clone() },
- DeallocatedLockedMemory {
- ptr,
- ref lock,
- } => DeallocatedLockedMemory { ptr, lock: lock.clone() },
- ValidationFailure(ref s) => ValidationFailure(s.clone()),
- CalledClosureAsFunction => CalledClosureAsFunction,
- VtableForArgumentlessMethod => VtableForArgumentlessMethod,
- ModifiedConstantMemory => ModifiedConstantMemory,
- AssumptionNotHeld => AssumptionNotHeld,
- InlineAsm => InlineAsm,
- TypeNotPrimitive(ty) => TypeNotPrimitive(tcx.lift(&ty)?),
- ReallocatedWrongMemoryKind(ref a, ref b) => {
- ReallocatedWrongMemoryKind(a.clone(), b.clone())
- },
- DeallocatedWrongMemoryKind(ref a, ref b) => {
- DeallocatedWrongMemoryKind(a.clone(), b.clone())
- },
- ReallocateNonBasePtr => ReallocateNonBasePtr,
- DeallocateNonBasePtr => DeallocateNonBasePtr,
- IncorrectAllocationInformation(a, b, c, d) => {
- IncorrectAllocationInformation(a, b, c, d)
- },
- Layout(lay) => Layout(tcx.lift(&lay)?),
- HeapAllocZeroBytes => HeapAllocZeroBytes,
- HeapAllocNonPowerOfTwoAlignment(n) => HeapAllocNonPowerOfTwoAlignment(n),
- Unreachable => Unreachable,
- Panic { ref msg, ref file, line, col } => Panic {
- msg: msg.clone(),
- file: file.clone(),
- line, col,
- },
- ReadFromReturnPointer => ReadFromReturnPointer,
- PathNotFound(ref v) => PathNotFound(v.clone()),
- UnimplementedTraitSelection => UnimplementedTraitSelection,
- TypeckError => TypeckError,
- TooGeneric => TooGeneric,
- CheckMatchError => CheckMatchError,
- ReferencedConstant(ref err) => ReferencedConstant(tcx.lift(&**err)?.into()),
- OverflowNeg => OverflowNeg,
- Overflow(op) => Overflow(op),
- DivisionByZero => DivisionByZero,
- RemainderByZero => RemainderByZero,
- GeneratorResumedAfterReturn => GeneratorResumedAfterReturn,
- GeneratorResumedAfterPanic => GeneratorResumedAfterPanic,
- InfiniteLoop => InfiniteLoop,
- })
- }
-}
-
-impl<'a, 'tcx> Lift<'tcx> for ty::layout::LayoutError<'a> {
- type Lifted = ty::layout::LayoutError<'tcx>;
- fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<Self::Lifted> {
- match *self {
- ty::layout::LayoutError::Unknown(ref ty) => {
- tcx.lift(ty).map(ty::layout::LayoutError::Unknown)
- }
- ty::layout::LayoutError::SizeOverflow(ref ty) => {
- tcx.lift(ty).map(ty::layout::LayoutError::SizeOverflow)
- }
- }
- }
-}
-
impl<'a, 'tcx> Lift<'tcx> for ty::InstanceDef<'a> {
type Lifted = ty::InstanceDef<'tcx>;
fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<Self::Lifted> {
// except according to those terms.
use llvm;
-use rustc::mir::interpret::{ConstEvalErr, read_target_uint};
+use rustc::mir::interpret::{ErrorHandled, read_target_uint};
use rustc_mir::const_eval::const_field;
use rustc::hir::def_id::DefId;
use rustc::mir;
use rustc_data_structures::indexed_vec::Idx;
-use rustc_data_structures::sync::Lrc;
use rustc::mir::interpret::{GlobalId, Pointer, Scalar, Allocation, ConstValue, AllocType};
use rustc::ty::{self, Ty};
use rustc::ty::layout::{self, HasDataLayout, LayoutOf, Size};
pub fn codegen_static_initializer(
cx: &CodegenCx<'ll, 'tcx>,
def_id: DefId,
-) -> Result<(&'ll Value, &'tcx Allocation), Lrc<ConstEvalErr<'tcx>>> {
+) -> Result<(&'ll Value, &'tcx Allocation), ErrorHandled> {
let instance = ty::Instance::mono(cx.tcx, def_id);
let cid = GlobalId {
instance,
&mut self,
bx: &Builder<'a, 'll, 'tcx>,
constant: &'tcx ty::Const<'tcx>,
- ) -> Result<&'tcx ty::Const<'tcx>, Lrc<ConstEvalErr<'tcx>>> {
+ ) -> Result<&'tcx ty::Const<'tcx>, ErrorHandled> {
match constant.val {
ConstValue::Unevaluated(def_id, ref substs) => {
let tcx = bx.tcx();
&mut self,
bx: &Builder<'a, 'll, 'tcx>,
constant: &mir::Constant<'tcx>,
- ) -> Result<&'tcx ty::Const<'tcx>, Lrc<ConstEvalErr<'tcx>>> {
+ ) -> Result<&'tcx ty::Const<'tcx>, ErrorHandled> {
let c = self.monomorphize(&constant.literal);
self.fully_evaluate(bx, c)
}
bx: &Builder<'a, 'll, 'tcx>,
span: Span,
ty: Ty<'tcx>,
- constant: Result<&'tcx ty::Const<'tcx>, Lrc<ConstEvalErr<'tcx>>>,
+ constant: Result<&'tcx ty::Const<'tcx>, ErrorHandled>,
) -> (&'ll Value, Ty<'tcx>) {
constant
.and_then(|c| {
ty::Array(_, n) => n.unwrap_usize(bx.tcx()),
ref other => bug!("invalid simd shuffle type: {}", other),
};
- let values: Result<Vec<_>, Lrc<_>> = (0..fields).map(|field| {
+ let values: Result<Vec<_>, ErrorHandled> = (0..fields).map(|field| {
let field = const_field(
bx.tcx(),
ty::ParamEnv::reveal_all(),
let llval = C_struct(bx.cx, &values?, false);
Ok((llval, c.ty))
})
- .unwrap_or_else(|e| {
- e.report_as_error(
- bx.tcx().at(span),
+ .unwrap_or_else(|_| {
+ bx.tcx().sess.span_err(
+ span,
"could not evaluate shuffle_indices at compile time",
);
// We've errored, so we don't have to produce working code.
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use rustc::mir::interpret::{ConstValue, ConstEvalErr};
+use rustc::mir::interpret::{ConstValue, ErrorHandled};
use rustc::mir;
use rustc::ty;
use rustc::ty::layout::{self, Align, LayoutOf, TyLayout};
use rustc_data_structures::sync::Lrc;
+use rustc_data_structures::indexed_vec::Idx;
use base;
use common::{CodegenCx, C_undef, C_usize};
pub fn from_const(bx: &Builder<'a, 'll, 'tcx>,
val: &'tcx ty::Const<'tcx>)
- -> Result<OperandRef<'ll, 'tcx>, Lrc<ConstEvalErr<'tcx>>> {
+ -> Result<OperandRef<'ll, 'tcx>, ErrorHandled> {
let layout = bx.cx.layout_of(val.ty);
if layout.is_zst() {
self.eval_mir_constant(bx, constant)
.and_then(|c| OperandRef::from_const(bx, c))
.unwrap_or_else(|err| {
- err.report_as_error(
- bx.tcx().at(constant.span),
- "could not evaluate constant operand",
- );
+ match err {
+ // errored or at least linted
+ ErrorHandled::Reported => {},
+ ErrorHandled::TooGeneric => {
+ bug!("codgen encountered polymorphic constant")
+ },
+ }
// Allow RalfJ to sleep soundly knowing that even refactorings that remove
// the above error (or silence it under some conditions) will not cause UB
let fnname = bx.cx.get_intrinsic(&("llvm.trap"));
}
}
-fn check_const(cx: &LateContext, body_id: hir::BodyId, what: &str) {
+fn check_const(cx: &LateContext, body_id: hir::BodyId) {
let def_id = cx.tcx.hir.body_owner_def_id(body_id);
let is_static = cx.tcx.is_static(def_id).is_some();
let param_env = if is_static {
instance: ty::Instance::mono(cx.tcx, def_id),
promoted: None
};
- match cx.tcx.const_eval(param_env.and(cid)) {
- Ok(val) => validate_const(cx.tcx, val, param_env, cid, what),
- Err(err) => {
- // errors for statics are already reported directly in the query, avoid duplicates
- if !is_static {
- let span = cx.tcx.def_span(def_id);
- err.report_as_lint(
- cx.tcx.at(span),
- &format!("this {} cannot be used", what),
- cx.current_lint_root(),
- );
- }
- },
- }
+ // trigger the query once for all constants since that will already report the errors
+ let _ = cx.tcx.const_eval(param_env.and(cid));
}
struct UnusedBrokenConstVisitor<'a, 'tcx: 'a>(&'a LateContext<'a, 'tcx>);
impl<'a, 'tcx, 'v> hir::intravisit::Visitor<'v> for UnusedBrokenConstVisitor<'a, 'tcx> {
fn visit_nested_body(&mut self, id: hir::BodyId) {
- check_const(self.0, id, "array length");
+ check_const(self.0, id);
}
fn nested_visit_map<'this>(&'this mut self) -> hir::intravisit::NestedVisitorMap<'this, 'v> {
hir::intravisit::NestedVisitorMap::None
fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
match it.node {
hir::ItemKind::Const(_, body_id) => {
- check_const(cx, body_id, "constant");
+ check_const(cx, body_id);
},
hir::ItemKind::Static(_, _, body_id) => {
- check_const(cx, body_id, "static");
+ check_const(cx, body_id);
},
hir::ItemKind::Ty(ref ty, _) => hir::intravisit::walk_ty(
&mut UnusedBrokenConstVisitor(cx),
UnreachablePub: UnreachablePub,
UnnameableTestItems: UnnameableTestItems::new(),
TypeAliasBounds: TypeAliasBounds,
- UnusedBrokenConst: UnusedBrokenConst,
TrivialConstraints: TrivialConstraints,
TypeLimits: TypeLimits::new(),
MissingDoc: MissingDoc::new(),
use std::collections::hash_map::Entry;
use rustc::hir::{self, def_id::DefId};
-use rustc::mir::interpret::ConstEvalErr;
+use rustc::hir::def::Def;
+use rustc::mir::interpret::{ConstEvalErr, ErrorHandled};
use rustc::mir;
use rustc::ty::{self, Ty, TyCtxt, Instance, query::TyCtxtAt};
use rustc::ty::layout::{self, Size, LayoutOf, TyLayout};
use rustc::ty::subst::Subst;
+use rustc::util::nodemap::FxHashSet;
use rustc_data_structures::indexed_vec::IndexVec;
use rustc_data_structures::fx::FxHashMap;
+use rustc::util::common::ErrorReported;
use syntax::ast::Mutability;
use syntax::source_map::{Span, DUMMY_SP};
// this is not called for statics.
op_to_const(&ecx, field, true)
})();
- result.map_err(|err| {
- let (trace, span) = ecx.generate_stacktrace(None);
- ConstEvalErr {
- error: err,
- stacktrace: trace,
- span,
- }.into()
+ result.map_err(|error| {
+ let stacktrace = ecx.generate_stacktrace(None);
+ let err = ::rustc::mir::interpret::ConstEvalErr { error, stacktrace, span: ecx.tcx.span };
+ err.report_as_error(ecx.tcx, "could not access field of constant");
+ ErrorHandled::Reported
})
}
Ok(ecx.read_discriminant(op)?.1)
}
-pub fn const_to_allocation_provider<'a, 'tcx>(
- _tcx: TyCtxt<'a, 'tcx, 'tcx>,
- val: &'tcx ty::Const<'tcx>,
-) -> &'tcx Allocation {
- // FIXME: This really does not need to be a query. Instead, we should have a query for statics
- // that returns an allocation directly (or an `AllocId`?), after doing a sanity check of the
- // value and centralizing error reporting.
- match val.val {
- ConstValue::ByRef(_, alloc, offset) => {
- assert_eq!(offset.bytes(), 0);
- return alloc;
- },
- _ => bug!("const_to_allocation called on non-static"),
- }
+fn validate_const<'a, 'tcx>(
+ tcx: ty::TyCtxt<'a, 'tcx, 'tcx>,
+ constant: &'tcx ty::Const<'tcx>,
+ key: ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>,
+) -> ::rustc::mir::interpret::ConstEvalResult<'tcx> {
+ let cid = key.value;
+ let ecx = mk_eval_cx(tcx, cid.instance, key.param_env).unwrap();
+ let val = (|| {
+ let op = ecx.const_to_op(constant)?;
+ let mut todo = vec![(op, Vec::new())];
+ let mut seen = FxHashSet();
+ seen.insert(op);
+ while let Some((op, mut path)) = todo.pop() {
+ ecx.validate_operand(
+ op,
+ &mut path,
+ &mut seen,
+ &mut todo,
+ )?;
+ }
+ Ok(constant)
+ })();
+
+ val.map_err(|error| {
+ let stacktrace = ecx.generate_stacktrace(None);
+ let err = ::rustc::mir::interpret::ConstEvalErr { error, stacktrace, span: ecx.tcx.span };
+ match err.struct_error(ecx.tcx, "it is undefined behavior to use this value") {
+ Ok(mut diag) => {
+ 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 rust compiler \
+ repository if you believe it should not be considered undefined behavior",
+ );
+ diag.emit();
+ ErrorHandled::Reported
+ }
+ Err(err) => err,
+ }
+ })
}
pub fn const_eval_provider<'a, 'tcx>(
tcx: TyCtxt<'a, 'tcx, 'tcx>,
key: ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>,
+) -> ::rustc::mir::interpret::ConstEvalResult<'tcx> {
+ tcx.const_eval_raw(key).and_then(|val| {
+ validate_const(tcx, val, key)
+ })
+}
+
+pub fn const_eval_raw_provider<'a, 'tcx>(
+ tcx: TyCtxt<'a, 'tcx, 'tcx>,
+ key: ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>,
) -> ::rustc::mir::interpret::ConstEvalResult<'tcx> {
trace!("const eval: {:?}", key);
let cid = key.value;
if let Some(id) = tcx.hir.as_local_node_id(def_id) {
let tables = tcx.typeck_tables_of(def_id);
- let span = tcx.def_span(def_id);
// Do match-check before building MIR
- if tcx.check_match(def_id).is_err() {
- return Err(ConstEvalErr {
- error: EvalErrorKind::CheckMatchError.into(),
- stacktrace: vec![],
- span,
- }.into());
+ if let Err(ErrorReported) = tcx.check_match(def_id) {
+ return Err(ErrorHandled::Reported)
}
if let hir::BodyOwnerKind::Const = tcx.hir.body_owner_kind(id) {
// Do not continue into miri if typeck errors occurred; it will fail horribly
if tables.tainted_by_errors {
- return Err(ConstEvalErr {
- error: EvalErrorKind::CheckMatchError.into(),
- stacktrace: vec![],
- span,
- }.into());
+ return Err(ErrorHandled::Reported)
}
};
}
}
op_to_const(&ecx, op, normalize)
- }).map_err(|err| {
- let (trace, span) = ecx.generate_stacktrace(None);
- let err = ConstEvalErr {
- error: err,
- stacktrace: trace,
- span,
- };
+ }).map_err(|error| {
+ let stacktrace = ecx.generate_stacktrace(None);
+ let err = ConstEvalErr { error, stacktrace, span: ecx.tcx.span };
if tcx.is_static(def_id).is_some() {
- err.report_as_error(ecx.tcx, "could not evaluate static initializer");
+ let err = err.report_as_error(ecx.tcx, "could not evaluate static initializer");
if tcx.sess.err_count() == 0 {
- span_bug!(span, "static eval failure didn't emit an error: {:#?}", err);
+ span_bug!(ecx.tcx.span, "static eval failure didn't emit an error: {:#?}", err);
+ }
+ err
+ } else if def_id.is_local() {
+ // constant defined in this crate, we can figure out a lint level!
+ match tcx.describe_def(def_id) {
+ Some(Def::Const(_)) | Some(Def::AssociatedConst(_)) => {
+ let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
+ err.report_as_lint(
+ tcx.at(tcx.def_span(def_id)),
+ "any use of this value will cause an error",
+ node_id,
+ )
+ },
+ _ => if let Some(p) = cid.promoted {
+ let span = tcx.optimized_mir(def_id).promoted[p].span;
+ if let EvalErrorKind::ReferencedConstant = err.error.kind {
+ err.report_as_error(
+ tcx.at(span),
+ "evaluation of constant expression failed",
+ )
+ } else {
+ err.report_as_lint(
+ tcx.at(span),
+ "reaching this expression at runtime will panic or abort",
+ tcx.hir.as_local_node_id(def_id).unwrap(),
+ )
+ }
+ } else {
+ err.report_as_error(
+ ecx.tcx,
+ "evaluation of constant value failed",
+ )
+ },
}
+ } else {
+ // use of constant from other crate
+ err.report_as_error(ecx.tcx, "could not evaluate constant")
}
- err.into()
})
}
use hair::cx::to_ref::ToRef;
use hair::util::UserAnnotatedTyHelpers;
use rustc::hir::def::{Def, CtorKind};
-use rustc::mir::interpret::GlobalId;
+use rustc::mir::interpret::{GlobalId, ErrorHandled};
use rustc::ty::{self, AdtKind, Ty};
use rustc::ty::adjustment::{Adjustment, Adjust, AutoBorrow, AutoBorrowMutability};
use rustc::ty::cast::CastKind as TyCastKind;
let span = cx.tcx.def_span(def_id);
let count = match cx.tcx.at(span).const_eval(cx.param_env.and(global_id)) {
Ok(cv) => cv.unwrap_usize(cx.tcx),
- Err(e) => {
- e.report_as_error(cx.tcx.at(span), "could not evaluate array length");
+ Err(ErrorHandled::Reported) => 0,
+ Err(ErrorHandled::TooGeneric) => {
+ cx.tcx.sess.span_err(span, "array lengths can't depend on generic parameters");
0
},
};
Ok(value) => {
return self.const_to_pat(instance, value, id, span)
},
- Err(err) => {
- err.report_as_error(
- self.tcx.at(span),
+ Err(_) => {
+ self.tcx.sess.span_err(
+ span,
"could not evaluate constant pattern",
);
PatternKind::Wild
- },
+ }
}
},
None => {
} else {
self.param_env
};
- self.tcx.const_eval(param_env.and(gid))
- .map_err(|err| EvalErrorKind::ReferencedConstant(err).into())
+ self.tcx.const_eval(param_env.and(gid)).map_err(|_| {
+ EvalErrorKind::ReferencedConstant.into()
+ })
}
pub fn dump_place(&self, place: Place<M::PointerTag>) {
}
}
- pub fn generate_stacktrace(&self, explicit_span: Option<Span>) -> (Vec<FrameInfo>, Span) {
+ pub fn generate_stacktrace(&self, explicit_span: Option<Span>) -> Vec<FrameInfo> {
let mut last_span = None;
let mut frames = Vec::new();
// skip 1 because the last frame is just the environment of the constant
frames.push(FrameInfo { span, location, lint_root });
}
trace!("generate stacktrace: {:#?}, {:?}", frames, explicit_span);
- (frames, self.tcx.span)
+ frames
}
#[inline(always)]
instance,
promoted: None,
};
- tcx.const_eval(ty::ParamEnv::reveal_all().and(gid)).map_err(|err| {
+ // use the raw query here to break validation cycles. Later uses of the static will call the
+ // full query anyway
+ tcx.const_eval_raw(ty::ParamEnv::reveal_all().and(gid)).map_err(|_| {
// no need to report anything, the const_eval call takes care of that for statics
assert!(tcx.is_static(def_id).is_some());
- EvalErrorKind::ReferencedConstant(err).into()
+ EvalErrorKind::ReferencedConstant.into()
}).map(|const_val| {
if let ConstValue::ByRef(_, allocation, _) = const_val.val {
// We got tcx memory. Let the machine figure out whether and how to
shim::provide(providers);
transform::provide(providers);
providers.const_eval = const_eval::const_eval_provider;
+ providers.const_eval_raw = const_eval::const_eval_raw_provider;
providers.check_match = hair::pattern::check_match;
}
use rustc::mir::{self, Location, Promoted};
use rustc::mir::visit::Visitor as MirVisitor;
use rustc::mir::mono::MonoItem;
-use rustc::mir::interpret::{Scalar, GlobalId, AllocType};
+use rustc::mir::interpret::{Scalar, GlobalId, AllocType, ErrorHandled};
use monomorphize::{self, Instance};
use rustc::util::nodemap::{FxHashSet, FxHashMap, DefIdMap};
hir::ItemKind::Const(..) => {
// const items only generate mono items if they are
// actually used somewhere. Just declaring them is insufficient.
+
+ // but even just declaring them must collect the items they refer to
+ let def_id = self.tcx.hir.local_def_id(item.id);
+
+ let instance = Instance::mono(self.tcx, def_id);
+ let cid = GlobalId {
+ instance,
+ promoted: None,
+ };
+ let param_env = ty::ParamEnv::reveal_all();
+
+ if let Ok(val) = self.tcx.const_eval(param_env.and(cid)) {
+ collect_const(self.tcx, val, instance.substs, &mut self.output);
+ }
}
hir::ItemKind::Fn(..) => {
let def_id = self.tcx.hir.local_def_id(item.id);
};
match tcx.const_eval(param_env.and(cid)) {
Ok(val) => collect_const(tcx, val, instance.substs, output),
- Err(err) => {
- use rustc::mir::interpret::EvalErrorKind;
- if let EvalErrorKind::ReferencedConstant(_) = err.error.kind {
- err.report_as_error(
- tcx.at(mir.promoted[i].span),
- "erroneous constant used",
- );
- }
- },
+ Err(ErrorHandled::Reported) => {},
+ Err(ErrorHandled::TooGeneric) => span_bug!(
+ mir.promoted[i].span, "collection encountered polymorphic constant",
+ ),
}
}
}
};
match tcx.const_eval(param_env.and(cid)) {
Ok(val) => val.val,
- Err(err) => {
- let span = tcx.def_span(def_id);
- err.report_as_error(
- tcx.at(span),
- "constant evaluation error",
- );
- return;
- }
+ Err(ErrorHandled::Reported) => return,
+ Err(ErrorHandled::TooGeneric) => span_bug!(
+ tcx.def_span(def_id), "collection encountered polymorphic constant",
+ ),
}
},
_ => constant.val,
use rustc::mir::{TerminatorKind, ClearCrossCrate, SourceInfo, BinOp, ProjectionElem};
use rustc::mir::visit::{Visitor, PlaceContext};
use rustc::mir::interpret::{
- ConstEvalErr, EvalErrorKind, Scalar, GlobalId, EvalResult
+ ConstEvalErr, EvalErrorKind, Scalar, GlobalId, EvalResult,
};
use rustc::ty::{TyCtxt, self, Instance};
use interpret::{self, EvalContext, Value, OpTy, MemoryKind, ScalarMaybeUndef};
return;
}
match tcx.describe_def(source.def_id) {
- // skip statics/consts because they'll be evaluated by miri anyway
- Some(Def::Const(..)) |
- Some(Def::Static(..)) => return,
- // we still run on associated constants, because they might not get evaluated
- // within the current crate
- _ => {},
+ // Only run const prop on functions, methods, closures and associated constants
+ | Some(Def::Fn(_))
+ | Some(Def::Method(_))
+ | Some(Def::AssociatedConst(_))
+ | Some(Def::Closure(_))
+ => {}
+ // skip anon_const/statics/consts because they'll be evaluated by miri anyway
+ def => {
+ trace!("ConstProp skipped for {:?} ({:?})", source.def_id, def);
+ return
+ },
}
trace!("ConstProp starting for {:?}", source.def_id);
let r = match f(self) {
Ok(val) => Some(val),
Err(error) => {
- let (stacktrace, span) = self.ecx.generate_stacktrace(None);
- let diagnostic = ConstEvalErr { span, error, stacktrace };
+ let stacktrace = self.ecx.generate_stacktrace(None);
+ let diagnostic = ConstEvalErr { span: source_info.span, error, stacktrace };
use rustc::mir::interpret::EvalErrorKind::*;
match diagnostic.error.kind {
// don't report these, they make no sense in a const prop context
| ReadFromReturnPointer
| GeneratorResumedAfterReturn
| GeneratorResumedAfterPanic
- | ReferencedConstant(_)
+ | ReferencedConstant
| InfiniteLoop
=> {
// FIXME: report UB here
| UnimplementedTraitSelection
| TypeckError
| TooGeneric
- | CheckMatchError
// these are just noise
=> {},
Some((op, c.span))
},
Err(error) => {
- let (stacktrace, span) = self.ecx.generate_stacktrace(None);
- let err = ConstEvalErr {
- span,
- error,
- stacktrace,
+ let stacktrace = self.ecx.generate_stacktrace(None);
+ let err = ::rustc::mir::interpret::ConstEvalErr {
+ error, stacktrace, span: source_info.span,
};
- err.report_as_error(
- self.tcx.at(source_info.span),
- "could not evaluate constant",
- );
+ err.report_as_error(self.ecx.tcx, "erroneous constant used");
None
},
}
ref_id: id_from_def_id(def_id),
})
}
+ HirDef::Closure(_) |
HirDef::PrimTy(..) |
HirDef::SelfTy(..) |
HirDef::Label(..) |
};
let count = tcx.const_eval(param_env.and(global_id));
- if let Err(ref err) = count {
- err.report_as_error(
- tcx.at(tcx.def_span(count_def_id)),
- "could not evaluate repeat length",
- );
- }
-
let uty = match expected {
ExpectHasType(uty) => {
match uty.sty {
let mut sum = 0;
//~^ let bindings in constant functions are unstable
//~| statements in constant functions are unstable
- for i in 0..x {
+ for i in 0..x { //~ ERROR E0080
//~^ ERROR E0015
//~| ERROR E0019
sum += i;
#[allow(unused_variables)]
fn main() {
- let a : [i32; f(X)]; //~ ERROR E0080
+ let a : [i32; f(X)];
}
[(); {while true {break}; 0}]; //~ ERROR constant contains unimplemented expression type
[(); { for _ in 0usize.. {}; 0}]; //~ ERROR calls in constants are limited to constant functions
//~^ ERROR constant contains unimplemented expression type
- //~| ERROR could not evaluate repeat length
+ //~| ERROR evaluation of constant value failed
}
const A: &'static [i32] = &[];
const B: i32 = (&A)[1];
//~^ index out of bounds: the len is 0 but the index is 1
-//~| ERROR this constant cannot be used
+//~| ERROR any use of this value will cause an error
+//~| ERROR any use of this value will cause an error
fn main() {
- let _ = B;
+ let _ = B; //~ ERROR erroneous constant used
}
-error: this constant cannot be used
+error: any use of this value will cause an error
--> $DIR/array_const_index-0.rs:12:1
|
LL | const B: i32 = (&A)[1];
|
= note: #[deny(const_err)] on by default
-error: aborting due to previous error
+error: any use of this value will cause an error
+ --> $DIR/array_const_index-0.rs:12:1
+ |
+LL | const B: i32 = (&A)[1];
+ | ^^^^^^^^^^^^^^^-------^
+ | |
+ | index out of bounds: the len is 0 but the index is 1
+
+error[E0080]: erroneous constant used
+ --> $DIR/array_const_index-0.rs:18:13
+ |
+LL | let _ = B; //~ ERROR erroneous constant used
+ | ^ referenced constant has errors
+
+error: aborting due to 3 previous errors
+For more information about this error, try `rustc --explain E0080`.
const A: [i32; 0] = [];
const B: i32 = A[1];
//~^ index out of bounds: the len is 0 but the index is 1
-//~| ERROR this constant cannot be used
+//~| ERROR any use of this value will cause an error
+//~| ERROR any use of this value will cause an error
fn main() {
- let _ = B;
+ let _ = B; //~ ERROR erroneous constant used
}
-error: this constant cannot be used
+error: any use of this value will cause an error
--> $DIR/array_const_index-1.rs:12:1
|
LL | const B: i32 = A[1];
|
= note: #[deny(const_err)] on by default
-error: aborting due to previous error
+error: any use of this value will cause an error
+ --> $DIR/array_const_index-1.rs:12:1
+ |
+LL | const B: i32 = A[1];
+ | ^^^^^^^^^^^^^^^----^
+ | |
+ | index out of bounds: the len is 0 but the index is 1
+
+error[E0080]: erroneous constant used
+ --> $DIR/array_const_index-1.rs:18:13
+ |
+LL | let _ = B; //~ ERROR erroneous constant used
+ | ^ referenced constant has errors
+
+error: aborting due to 3 previous errors
+For more information about this error, try `rustc --explain E0080`.
const BAR: usize = FOO[5]; // no error, because the error below occurs before regular const eval
const BLUB: [u32; FOO[4]] = [5, 6];
-//~^ ERROR could not evaluate constant expression [E0080]
+//~^ ERROR evaluation of constant value failed [E0080]
//~| index out of bounds: the len is 3 but the index is 4
fn main() {
-error: index out of bounds: the len is 3 but the index is 4
+error[E0080]: evaluation of constant value failed
--> $DIR/const-array-oob.rs:18:19
|
LL | const BLUB: [u32; FOO[4]] = [5, 6];
- | ^^^^^^
- |
- = note: #[deny(const_err)] on by default
-
-error[E0080]: could not evaluate constant expression
- --> $DIR/const-array-oob.rs:18:13
- |
-LL | const BLUB: [u32; FOO[4]] = [5, 6];
- | ^^^^^^------^
- | |
- | index out of bounds: the len is 3 but the index is 4
+ | ^^^^^^ index out of bounds: the len is 3 but the index is 4
-error: aborting due to 2 previous errors
+error: aborting due to previous error
For more information about this error, try `rustc --explain E0080`.
LL | let _ = [0; f(2)];
| ^^^^
-error: aborting due to previous error
+error[E0080]: evaluation of constant value failed
+ --> $DIR/const-call.rs:16:17
+ |
+LL | let _ = [0; f(2)];
+ | ^^^^ calling non-const fn `f`
+
+error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0015`.
#![deny(const_err)]
pub const A: i8 = -std::i8::MIN; //~ ERROR const_err
+//~^ ERROR const_err
pub const B: u8 = 200u8 + 200u8; //~ ERROR const_err
pub const C: u8 = 200u8 * 4; //~ ERROR const_err
pub const D: u8 = 42u8 - (42u8 + 1); //~ ERROR const_err
pub const E: u8 = [5u8][1]; //~ ERROR const_err
fn main() {
- let _a = A;
- let _b = B;
- let _c = C;
- let _d = D;
- let _e = E;
- let _e = [6u8][1];
+ let _a = A; //~ ERROR erroneous constant used
+ let _b = B; //~ ERROR erroneous constant used
+ let _c = C; //~ ERROR erroneous constant used
+ let _d = D; //~ ERROR erroneous constant used
+ let _e = E; //~ ERROR erroneous constant used
+ let _e = [6u8][1]; //~ ERROR index out of bounds
}
-error: this constant cannot be used
+error: any use of this value will cause an error
--> $DIR/const-err-early.rs:13:1
|
LL | pub const A: i8 = -std::i8::MIN; //~ ERROR const_err
LL | #![deny(const_err)]
| ^^^^^^^^^
-error: this constant cannot be used
- --> $DIR/const-err-early.rs:14:1
+error: any use of this value will cause an error
+ --> $DIR/const-err-early.rs:15:1
|
LL | pub const B: u8 = 200u8 + 200u8; //~ ERROR const_err
| ^^^^^^^^^^^^^^^^^^-------------^
| |
| attempt to add with overflow
-error: this constant cannot be used
- --> $DIR/const-err-early.rs:15:1
+error: any use of this value will cause an error
+ --> $DIR/const-err-early.rs:16:1
|
LL | pub const C: u8 = 200u8 * 4; //~ ERROR const_err
| ^^^^^^^^^^^^^^^^^^---------^
| |
| attempt to multiply with overflow
-error: this constant cannot be used
- --> $DIR/const-err-early.rs:16:1
+error: any use of this value will cause an error
+ --> $DIR/const-err-early.rs:17:1
|
LL | pub const D: u8 = 42u8 - (42u8 + 1); //~ ERROR const_err
| ^^^^^^^^^^^^^^^^^^-----------------^
| |
| attempt to subtract with overflow
-error: this constant cannot be used
- --> $DIR/const-err-early.rs:17:1
+error: any use of this value will cause an error
+ --> $DIR/const-err-early.rs:18:1
|
LL | pub const E: u8 = [5u8][1]; //~ ERROR const_err
| ^^^^^^^^^^^^^^^^^^--------^
| |
| index out of bounds: the len is 1 but the index is 1
-error: aborting due to 5 previous errors
+error: any use of this value will cause an error
+ --> $DIR/const-err-early.rs:13:1
+ |
+LL | pub const A: i8 = -std::i8::MIN; //~ ERROR const_err
+ | ^^^^^^^^^^^^^^^^^^-------------^
+ | |
+ | attempt to negate with overflow
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-err-early.rs:21:14
+ |
+LL | let _a = A; //~ ERROR erroneous constant used
+ | ^ referenced constant has errors
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-err-early.rs:22:14
+ |
+LL | let _b = B; //~ ERROR erroneous constant used
+ | ^ referenced constant has errors
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-err-early.rs:23:14
+ |
+LL | let _c = C; //~ ERROR erroneous constant used
+ | ^ referenced constant has errors
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-err-early.rs:24:14
+ |
+LL | let _d = D; //~ ERROR erroneous constant used
+ | ^ referenced constant has errors
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-err-early.rs:25:14
+ |
+LL | let _e = E; //~ ERROR erroneous constant used
+ | ^ referenced constant has errors
+
+error: index out of bounds: the len is 1 but the index is 1
+ --> $DIR/const-err-early.rs:26:14
+ |
+LL | let _e = [6u8][1]; //~ ERROR index out of bounds
+ | ^^^^^^^^
+
+error: aborting due to 12 previous errors
+For more information about this error, try `rustc --explain E0080`.
#![deny(const_err)]
pub const A: i8 = -std::i8::MIN;
-//~^ ERROR this constant cannot be used
-pub const B: i8 = A;
//~^ ERROR const_err
//~| ERROR const_err
+pub const B: i8 = A;
+//~^ ERROR const_err
pub const C: u8 = A as u8;
//~^ ERROR const_err
-//~| ERROR const_err
pub const D: i8 = 50 - A;
//~^ ERROR const_err
-//~| ERROR const_err
fn main() {
let _ = (A, B, C, D);
+ //~^ ERROR erroneous constant used
}
-error: this constant cannot be used
+error: any use of this value will cause an error
--> $DIR/const-err-multi.rs:13:1
|
LL | pub const A: i8 = -std::i8::MIN;
LL | #![deny(const_err)]
| ^^^^^^^^^
-error: referenced constant has errors
- --> $DIR/const-err-multi.rs:15:1
- |
-LL | pub const A: i8 = -std::i8::MIN;
- | ------------- attempt to negate with overflow
-LL | //~^ ERROR this constant cannot be used
-LL | pub const B: i8 = A;
- | ^^^^^^^^^^^^^^^^^^^^
-
-error: this constant cannot be used
- --> $DIR/const-err-multi.rs:15:1
+error: any use of this value will cause an error
+ --> $DIR/const-err-multi.rs:16:1
|
LL | pub const B: i8 = A;
| ^^^^^^^^^^^^^^^^^^-^
| |
| referenced constant has errors
-error: referenced constant has errors
- --> $DIR/const-err-multi.rs:18:1
- |
-LL | pub const A: i8 = -std::i8::MIN;
- | ------------- attempt to negate with overflow
-...
-LL | pub const C: u8 = A as u8;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: this constant cannot be used
+error: any use of this value will cause an error
--> $DIR/const-err-multi.rs:18:1
|
LL | pub const C: u8 = A as u8;
| |
| referenced constant has errors
-error: referenced constant has errors
- --> $DIR/const-err-multi.rs:21:1
- |
-LL | pub const A: i8 = -std::i8::MIN;
- | ------------- attempt to negate with overflow
-...
-LL | pub const D: i8 = 50 - A;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: this constant cannot be used
- --> $DIR/const-err-multi.rs:21:1
+error: any use of this value will cause an error
+ --> $DIR/const-err-multi.rs:20:1
|
LL | pub const D: i8 = 50 - A;
| ^^^^^^^^^^^^^^^^^^------^
| |
| referenced constant has errors
-error: aborting due to 7 previous errors
+error: any use of this value will cause an error
+ --> $DIR/const-err-multi.rs:13:1
+ |
+LL | pub const A: i8 = -std::i8::MIN;
+ | ^^^^^^^^^^^^^^^^^^-------------^
+ | |
+ | attempt to negate with overflow
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-err-multi.rs:24:13
+ |
+LL | let _ = (A, B, C, D);
+ | ^^^^^^^^^^^^ referenced constant has errors
+
+error: aborting due to 6 previous errors
+For more information about this error, try `rustc --explain E0080`.
// compile-flags: -Zforce-overflow-checks=on
-// these errors are not actually "const_err", they occur in codegen/consts
-// and are unconditional warnings that can't be denied or allowed
-
#![allow(exceeding_bitshifts)]
-#![allow(const_err)]
+#![warn(const_err)]
fn black_box<T>(_: T) {
unimplemented!()
}
-// Make sure that the two uses get two errors.
const FOO: u8 = [5u8][1];
-//~^ ERROR constant evaluation error
-//~| index out of bounds: the len is 1 but the index is 1
+//~^ WARN any use of this value will cause an error
+//~| WARN any use of this value will cause an error
fn main() {
black_box((FOO, FOO));
- //~^ ERROR referenced constant has errors
- //~| ERROR could not evaluate constant
+ //~^ ERROR erroneous constant used
}
-error[E0080]: referenced constant has errors
- --> $DIR/const-err.rs:29:15
+warning: any use of this value will cause an error
+ --> $DIR/const-err.rs:20:1
|
LL | const FOO: u8 = [5u8][1];
- | -------- index out of bounds: the len is 1 but the index is 1
-...
-LL | black_box((FOO, FOO));
- | ^^^^^^^^^^
-
-error[E0080]: could not evaluate constant
- --> $DIR/const-err.rs:29:15
+ | ^^^^^^^^^^^^^^^^--------^
+ | |
+ | index out of bounds: the len is 1 but the index is 1
|
-LL | black_box((FOO, FOO));
- | ^^^^^^^^^^ referenced constant has errors
+note: lint level defined here
+ --> $DIR/const-err.rs:14:9
+ |
+LL | #![warn(const_err)]
+ | ^^^^^^^^^
-error[E0080]: constant evaluation error
- --> $DIR/const-err.rs:24:1
+warning: any use of this value will cause an error
+ --> $DIR/const-err.rs:20:1
|
LL | const FOO: u8 = [5u8][1];
| ^^^^^^^^^^^^^^^^--------^
| |
| index out of bounds: the len is 1 but the index is 1
-error: aborting due to 3 previous errors
+error[E0080]: erroneous constant used
+ --> $DIR/const-err.rs:25:15
+ |
+LL | black_box((FOO, FOO));
+ | ^^^^^^^^^^ referenced constant has errors
+
+error: aborting due to previous error
For more information about this error, try `rustc --explain E0080`.
enum Bar {
Boo = [unsafe { Foo { b: () }.a }; 4][3],
- //~^ ERROR could not evaluate enum discriminant
+ //~^ ERROR evaluation of constant value failed
}
fn main() {
-error[E0080]: could not evaluate enum discriminant
+error[E0080]: evaluation of constant value failed
--> $DIR/const-err4.rs:18:11
|
LL | Boo = [unsafe { Foo { b: () }.a }; 4][3],
--- /dev/null
+warning: any use of this value will cause an error
+ --> $DIR/conditional_array_execution.rs:15:1
+ |
+LL | const FOO: u32 = [X - Y, Y - X][(X < Y) as usize];
+ | ^^^^^^^^^^^^^^^^^^-----^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | |
+ | attempt to subtract with overflow
+ |
+note: lint level defined here
+ --> $DIR/conditional_array_execution.rs:11:9
+ |
+LL | #![warn(const_err)]
+ | ^^^^^^^^^
+
+error[E0080]: evaluation of constant expression failed
+ --> $DIR/conditional_array_execution.rs:19:14
+ |
+LL | println!("{}", FOO);
+ | ^^^^ --- referenced constant has errors
+
+error[E0080]: evaluation of constant expression failed
+ --> $DIR/conditional_array_execution.rs:19:20
+ |
+LL | println!("{}", FOO);
+ | ^^^ referenced constant has errors
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0080`.
const X: u32 = 5;
const Y: u32 = 6;
const FOO: u32 = [X - Y, Y - X][(X < Y) as usize];
-//~^ WARN this constant cannot be used
+//~^ WARN any use of this value will cause an error
fn main() {
println!("{}", FOO);
//~^ ERROR
- //~| ERROR
}
-warning: this constant cannot be used
+warning: any use of this value will cause an error
--> $DIR/conditional_array_execution.rs:15:1
|
LL | const FOO: u32 = [X - Y, Y - X][(X < Y) as usize];
LL | #![warn(const_err)]
| ^^^^^^^^^
-error[E0080]: referenced constant has errors
- --> $DIR/conditional_array_execution.rs:19:20
- |
-LL | const FOO: u32 = [X - Y, Y - X][(X < Y) as usize];
- | ----- attempt to subtract with overflow
-...
-LL | println!("{}", FOO);
- | ^^^
-
-error[E0080]: erroneous constant used
+error[E0080]: evaluation of constant expression failed
--> $DIR/conditional_array_execution.rs:19:20
|
LL | println!("{}", FOO);
| ^^^ referenced constant has errors
-error: aborting due to 2 previous errors
+error: aborting due to previous error
For more information about this error, try `rustc --explain E0080`.
-error[E0080]: could not evaluate constant pattern
+error: could not evaluate constant pattern
--> $DIR/const-eval-overflow-2.rs:25:9
|
-LL | const NEG_NEG_128: i8 = -NEG_128;
- | -------- attempt to negate with overflow
-...
LL | NEG_NEG_128 => println!("A"),
| ^^^^^^^^^^^
error: aborting due to previous error
-For more information about this error, try `rustc --explain E0080`.
-error: attempt to add with overflow
+error[E0080]: evaluation of constant value failed
--> $DIR/const-eval-overflow-3.rs:30:11
|
LL | = [0; (i8::MAX + 1) as usize];
- | ^^^^^^^^^^^^^
- |
- = note: #[deny(const_err)] on by default
-
-error[E0080]: could not evaluate repeat length
- --> $DIR/const-eval-overflow-3.rs:30:11
- |
-LL | = [0; (i8::MAX + 1) as usize];
- | -------------^^^^^^^^^
- | |
- | attempt to add with overflow
+ | ^^^^^^^^^^^^^ attempt to add with overflow
-error: aborting due to 2 previous errors
+error: aborting due to previous error
For more information about this error, try `rustc --explain E0080`.
const A_I8_T
: [u32; (i8::MAX as i8 + 1i8) as usize]
- //~^ ERROR attempt to add with overflow
- //~| ERROR could not evaluate constant expression
+ //~^ ERROR evaluation of constant value failed
= [0; (i8::MAX as usize) + 1];
fn main() {
-error: attempt to add with overflow
+error[E0080]: evaluation of constant value failed
--> $DIR/const-eval-overflow-4.rs:23:13
|
LL | : [u32; (i8::MAX as i8 + 1i8) as usize]
- | ^^^^^^^^^^^^^^^^^^^^^
- |
- = note: #[deny(const_err)] on by default
-
-error[E0080]: could not evaluate constant expression
- --> $DIR/const-eval-overflow-4.rs:23:7
- |
-LL | : [u32; (i8::MAX as i8 + 1i8) as usize]
- | ^^^^^^---------------------^^^^^^^^^^
- | |
- | attempt to add with overflow
+ | ^^^^^^^^^^^^^^^^^^^^^ attempt to add with overflow
-error: aborting due to 2 previous errors
+error: aborting due to previous error
For more information about this error, try `rustc --explain E0080`.
use std::{i8, i16, i32, i64, isize};
use std::{u8, u16, u32, u64, usize};
-const VALS_I8: (i8,) =
- //~^ ERROR this constant cannot be used
+const VALS_I8: (i8,) = //~ ERROR any use of this value will cause an error
+ //~^ const_err
(
i8::MIN - 1,
);
-const VALS_I16: (i16,) =
- //~^ ERROR this constant cannot be used
+const VALS_I16: (i16,) = //~ ERROR any use of this value will cause an error
(
i16::MIN - 1,
);
-const VALS_I32: (i32,) =
- //~^ ERROR this constant cannot be used
+const VALS_I32: (i32,) = //~ ERROR any use of this value will cause an error
(
i32::MIN - 1,
);
-const VALS_I64: (i64,) =
- //~^ ERROR this constant cannot be used
+const VALS_I64: (i64,) = //~ ERROR any use of this value will cause an error
(
i64::MIN - 1,
);
-const VALS_U8: (u8,) =
- //~^ ERROR this constant cannot be used
+const VALS_U8: (u8,) = //~ ERROR any use of this value will cause an error
(
u8::MIN - 1,
);
-const VALS_U16: (u16,) = (
- //~^ ERROR this constant cannot be used
+const VALS_U16: (u16,) = ( //~ ERROR any use of this value will cause an error
u16::MIN - 1,
);
-const VALS_U32: (u32,) = (
- //~^ ERROR this constant cannot be used
+const VALS_U32: (u32,) = ( //~ ERROR any use of this value will cause an error
u32::MIN - 1,
);
-const VALS_U64: (u64,) =
- //~^ ERROR this constant cannot be used
+const VALS_U64: (u64,) = //~ ERROR any use of this value will cause an error
(
u64::MIN - 1,
);
fn main() {
- foo(VALS_I8);
- foo(VALS_I16);
- foo(VALS_I32);
- foo(VALS_I64);
+ foo(VALS_I8); //~ ERROR erroneous constant used
+ foo(VALS_I16); //~ ERROR erroneous constant used
+ foo(VALS_I32); //~ ERROR erroneous constant used
+ foo(VALS_I64); //~ ERROR erroneous constant used
- foo(VALS_U8);
- foo(VALS_U16);
- foo(VALS_U32);
- foo(VALS_U64);
+ foo(VALS_U8); //~ ERROR erroneous constant used
+ foo(VALS_U16); //~ ERROR erroneous constant used
+ foo(VALS_U32); //~ ERROR erroneous constant used
+ foo(VALS_U64); //~ ERROR erroneous constant used
}
fn foo<T>(_: T) {
-error: this constant cannot be used
+error: any use of this value will cause an error
--> $DIR/const-eval-overflow2.rs:24:1
|
-LL | / const VALS_I8: (i8,) =
-LL | | //~^ ERROR this constant cannot be used
+LL | / const VALS_I8: (i8,) = //~ ERROR any use of this value will cause an error
+LL | | //~^ const_err
LL | | (
LL | | i8::MIN - 1,
| | ----------- attempt to subtract with overflow
LL | #![deny(const_err)]
| ^^^^^^^^^
-error: this constant cannot be used
+error: any use of this value will cause an error
--> $DIR/const-eval-overflow2.rs:30:1
|
-LL | / const VALS_I16: (i16,) =
-LL | | //~^ ERROR this constant cannot be used
+LL | / const VALS_I16: (i16,) = //~ ERROR any use of this value will cause an error
LL | | (
LL | | i16::MIN - 1,
| | ------------ attempt to subtract with overflow
LL | | );
| |_______^
-error: this constant cannot be used
- --> $DIR/const-eval-overflow2.rs:36:1
+error: any use of this value will cause an error
+ --> $DIR/const-eval-overflow2.rs:35:1
|
-LL | / const VALS_I32: (i32,) =
-LL | | //~^ ERROR this constant cannot be used
+LL | / const VALS_I32: (i32,) = //~ ERROR any use of this value will cause an error
LL | | (
LL | | i32::MIN - 1,
| | ------------ attempt to subtract with overflow
LL | | );
| |_______^
-error: this constant cannot be used
- --> $DIR/const-eval-overflow2.rs:42:1
+error: any use of this value will cause an error
+ --> $DIR/const-eval-overflow2.rs:40:1
|
-LL | / const VALS_I64: (i64,) =
-LL | | //~^ ERROR this constant cannot be used
+LL | / const VALS_I64: (i64,) = //~ ERROR any use of this value will cause an error
LL | | (
LL | | i64::MIN - 1,
| | ------------ attempt to subtract with overflow
LL | | );
| |_______^
-error: this constant cannot be used
- --> $DIR/const-eval-overflow2.rs:48:1
+error: any use of this value will cause an error
+ --> $DIR/const-eval-overflow2.rs:45:1
|
-LL | / const VALS_U8: (u8,) =
-LL | | //~^ ERROR this constant cannot be used
+LL | / const VALS_U8: (u8,) = //~ ERROR any use of this value will cause an error
LL | | (
LL | | u8::MIN - 1,
| | ----------- attempt to subtract with overflow
LL | | );
| |_______^
-error: this constant cannot be used
- --> $DIR/const-eval-overflow2.rs:54:1
+error: any use of this value will cause an error
+ --> $DIR/const-eval-overflow2.rs:50:1
|
-LL | / const VALS_U16: (u16,) = (
-LL | | //~^ ERROR this constant cannot be used
+LL | / const VALS_U16: (u16,) = ( //~ ERROR any use of this value will cause an error
LL | | u16::MIN - 1,
| | ------------ attempt to subtract with overflow
LL | | );
| |_______^
-error: this constant cannot be used
- --> $DIR/const-eval-overflow2.rs:59:1
+error: any use of this value will cause an error
+ --> $DIR/const-eval-overflow2.rs:54:1
|
-LL | / const VALS_U32: (u32,) = (
-LL | | //~^ ERROR this constant cannot be used
+LL | / const VALS_U32: (u32,) = ( //~ ERROR any use of this value will cause an error
LL | | u32::MIN - 1,
| | ------------ attempt to subtract with overflow
LL | | );
| |_______^
-error: this constant cannot be used
- --> $DIR/const-eval-overflow2.rs:64:1
+error: any use of this value will cause an error
+ --> $DIR/const-eval-overflow2.rs:58:1
|
-LL | / const VALS_U64: (u64,) =
-LL | | //~^ ERROR this constant cannot be used
+LL | / const VALS_U64: (u64,) = //~ ERROR any use of this value will cause an error
LL | | (
LL | | u64::MIN - 1,
| | ------------ attempt to subtract with overflow
LL | | );
| |_______^
-error: aborting due to 8 previous errors
+error: any use of this value will cause an error
+ --> $DIR/const-eval-overflow2.rs:24:1
+ |
+LL | / const VALS_I8: (i8,) = //~ ERROR any use of this value will cause an error
+LL | | //~^ const_err
+LL | | (
+LL | | i8::MIN - 1,
+ | | ----------- attempt to subtract with overflow
+LL | | );
+ | |_______^
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-eval-overflow2.rs:64:5
+ |
+LL | foo(VALS_I8); //~ ERROR erroneous constant used
+ | ^^^^^^^^^^^^ referenced constant has errors
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-eval-overflow2.rs:65:5
+ |
+LL | foo(VALS_I16); //~ ERROR erroneous constant used
+ | ^^^^^^^^^^^^^ referenced constant has errors
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-eval-overflow2.rs:66:5
+ |
+LL | foo(VALS_I32); //~ ERROR erroneous constant used
+ | ^^^^^^^^^^^^^ referenced constant has errors
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-eval-overflow2.rs:67:5
+ |
+LL | foo(VALS_I64); //~ ERROR erroneous constant used
+ | ^^^^^^^^^^^^^ referenced constant has errors
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-eval-overflow2.rs:69:5
+ |
+LL | foo(VALS_U8); //~ ERROR erroneous constant used
+ | ^^^^^^^^^^^^ referenced constant has errors
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-eval-overflow2.rs:70:5
+ |
+LL | foo(VALS_U16); //~ ERROR erroneous constant used
+ | ^^^^^^^^^^^^^ referenced constant has errors
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-eval-overflow2.rs:71:5
+ |
+LL | foo(VALS_U32); //~ ERROR erroneous constant used
+ | ^^^^^^^^^^^^^ referenced constant has errors
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-eval-overflow2.rs:72:5
+ |
+LL | foo(VALS_U64); //~ ERROR erroneous constant used
+ | ^^^^^^^^^^^^^ referenced constant has errors
+
+error: aborting due to 17 previous errors
+For more information about this error, try `rustc --explain E0080`.
use std::{i8, i16, i32, i64, isize};
use std::{u8, u16, u32, u64, usize};
-const VALS_I8: (i8,) =
- //~^ ERROR this constant cannot be used
+const VALS_I8: (i8,) = //~ ERROR any use of this value will cause an error
+ //~^ const_err
(
i8::MAX + 1,
);
-const VALS_I16: (i16,) =
- //~^ ERROR this constant cannot be used
+const VALS_I16: (i16,) = //~ ERROR any use of this value will cause an error
(
i16::MAX + 1,
);
-const VALS_I32: (i32,) =
- //~^ ERROR this constant cannot be used
+const VALS_I32: (i32,) = //~ ERROR any use of this value will cause an error
(
i32::MAX + 1,
);
-const VALS_I64: (i64,) =
- //~^ ERROR this constant cannot be used
+const VALS_I64: (i64,) = //~ ERROR any use of this value will cause an error
(
i64::MAX + 1,
);
-const VALS_U8: (u8,) =
- //~^ ERROR this constant cannot be used
+const VALS_U8: (u8,) = //~ ERROR any use of this value will cause an error
(
u8::MAX + 1,
);
-const VALS_U16: (u16,) = (
- //~^ ERROR this constant cannot be used
+const VALS_U16: (u16,) = ( //~ ERROR any use of this value will cause an error
u16::MAX + 1,
);
-const VALS_U32: (u32,) = (
- //~^ ERROR this constant cannot be used
+const VALS_U32: (u32,) = ( //~ ERROR any use of this value will cause an error
u32::MAX + 1,
);
-const VALS_U64: (u64,) =
- //~^ ERROR this constant cannot be used
+const VALS_U64: (u64,) = //~ ERROR any use of this value will cause an error
(
u64::MAX + 1,
);
fn main() {
- foo(VALS_I8);
- foo(VALS_I16);
- foo(VALS_I32);
- foo(VALS_I64);
+ foo(VALS_I8); //~ ERROR erroneous constant used
+ foo(VALS_I16); //~ ERROR erroneous constant used
+ foo(VALS_I32); //~ ERROR erroneous constant used
+ foo(VALS_I64); //~ ERROR erroneous constant used
- foo(VALS_U8);
- foo(VALS_U16);
- foo(VALS_U32);
- foo(VALS_U64);
+ foo(VALS_U8); //~ ERROR erroneous constant used
+ foo(VALS_U16); //~ ERROR erroneous constant used
+ foo(VALS_U32); //~ ERROR erroneous constant used
+ foo(VALS_U64); //~ ERROR erroneous constant used
}
fn foo<T>(_: T) {
-error: this constant cannot be used
+error: any use of this value will cause an error
--> $DIR/const-eval-overflow2b.rs:24:1
|
-LL | / const VALS_I8: (i8,) =
-LL | | //~^ ERROR this constant cannot be used
+LL | / const VALS_I8: (i8,) = //~ ERROR any use of this value will cause an error
+LL | | //~^ const_err
LL | | (
LL | | i8::MAX + 1,
| | ----------- attempt to add with overflow
LL | #![deny(const_err)]
| ^^^^^^^^^
-error: this constant cannot be used
+error: any use of this value will cause an error
--> $DIR/const-eval-overflow2b.rs:30:1
|
-LL | / const VALS_I16: (i16,) =
-LL | | //~^ ERROR this constant cannot be used
+LL | / const VALS_I16: (i16,) = //~ ERROR any use of this value will cause an error
LL | | (
LL | | i16::MAX + 1,
| | ------------ attempt to add with overflow
LL | | );
| |_______^
-error: this constant cannot be used
- --> $DIR/const-eval-overflow2b.rs:36:1
+error: any use of this value will cause an error
+ --> $DIR/const-eval-overflow2b.rs:35:1
|
-LL | / const VALS_I32: (i32,) =
-LL | | //~^ ERROR this constant cannot be used
+LL | / const VALS_I32: (i32,) = //~ ERROR any use of this value will cause an error
LL | | (
LL | | i32::MAX + 1,
| | ------------ attempt to add with overflow
LL | | );
| |_______^
-error: this constant cannot be used
- --> $DIR/const-eval-overflow2b.rs:42:1
+error: any use of this value will cause an error
+ --> $DIR/const-eval-overflow2b.rs:40:1
|
-LL | / const VALS_I64: (i64,) =
-LL | | //~^ ERROR this constant cannot be used
+LL | / const VALS_I64: (i64,) = //~ ERROR any use of this value will cause an error
LL | | (
LL | | i64::MAX + 1,
| | ------------ attempt to add with overflow
LL | | );
| |_______^
-error: this constant cannot be used
- --> $DIR/const-eval-overflow2b.rs:48:1
+error: any use of this value will cause an error
+ --> $DIR/const-eval-overflow2b.rs:45:1
|
-LL | / const VALS_U8: (u8,) =
-LL | | //~^ ERROR this constant cannot be used
+LL | / const VALS_U8: (u8,) = //~ ERROR any use of this value will cause an error
LL | | (
LL | | u8::MAX + 1,
| | ----------- attempt to add with overflow
LL | | );
| |_______^
-error: this constant cannot be used
- --> $DIR/const-eval-overflow2b.rs:54:1
+error: any use of this value will cause an error
+ --> $DIR/const-eval-overflow2b.rs:50:1
|
-LL | / const VALS_U16: (u16,) = (
-LL | | //~^ ERROR this constant cannot be used
+LL | / const VALS_U16: (u16,) = ( //~ ERROR any use of this value will cause an error
LL | | u16::MAX + 1,
| | ------------ attempt to add with overflow
LL | | );
| |_______^
-error: this constant cannot be used
- --> $DIR/const-eval-overflow2b.rs:59:1
+error: any use of this value will cause an error
+ --> $DIR/const-eval-overflow2b.rs:54:1
|
-LL | / const VALS_U32: (u32,) = (
-LL | | //~^ ERROR this constant cannot be used
+LL | / const VALS_U32: (u32,) = ( //~ ERROR any use of this value will cause an error
LL | | u32::MAX + 1,
| | ------------ attempt to add with overflow
LL | | );
| |_______^
-error: this constant cannot be used
- --> $DIR/const-eval-overflow2b.rs:64:1
+error: any use of this value will cause an error
+ --> $DIR/const-eval-overflow2b.rs:58:1
|
-LL | / const VALS_U64: (u64,) =
-LL | | //~^ ERROR this constant cannot be used
+LL | / const VALS_U64: (u64,) = //~ ERROR any use of this value will cause an error
LL | | (
LL | | u64::MAX + 1,
| | ------------ attempt to add with overflow
LL | | );
| |_______^
-error: aborting due to 8 previous errors
+error: any use of this value will cause an error
+ --> $DIR/const-eval-overflow2b.rs:24:1
+ |
+LL | / const VALS_I8: (i8,) = //~ ERROR any use of this value will cause an error
+LL | | //~^ const_err
+LL | | (
+LL | | i8::MAX + 1,
+ | | ----------- attempt to add with overflow
+LL | | );
+ | |_______^
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-eval-overflow2b.rs:64:5
+ |
+LL | foo(VALS_I8); //~ ERROR erroneous constant used
+ | ^^^^^^^^^^^^ referenced constant has errors
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-eval-overflow2b.rs:65:5
+ |
+LL | foo(VALS_I16); //~ ERROR erroneous constant used
+ | ^^^^^^^^^^^^^ referenced constant has errors
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-eval-overflow2b.rs:66:5
+ |
+LL | foo(VALS_I32); //~ ERROR erroneous constant used
+ | ^^^^^^^^^^^^^ referenced constant has errors
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-eval-overflow2b.rs:67:5
+ |
+LL | foo(VALS_I64); //~ ERROR erroneous constant used
+ | ^^^^^^^^^^^^^ referenced constant has errors
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-eval-overflow2b.rs:69:5
+ |
+LL | foo(VALS_U8); //~ ERROR erroneous constant used
+ | ^^^^^^^^^^^^ referenced constant has errors
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-eval-overflow2b.rs:70:5
+ |
+LL | foo(VALS_U16); //~ ERROR erroneous constant used
+ | ^^^^^^^^^^^^^ referenced constant has errors
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-eval-overflow2b.rs:71:5
+ |
+LL | foo(VALS_U32); //~ ERROR erroneous constant used
+ | ^^^^^^^^^^^^^ referenced constant has errors
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-eval-overflow2b.rs:72:5
+ |
+LL | foo(VALS_U64); //~ ERROR erroneous constant used
+ | ^^^^^^^^^^^^^ referenced constant has errors
+
+error: aborting due to 17 previous errors
+For more information about this error, try `rustc --explain E0080`.
use std::{i8, i16, i32, i64, isize};
use std::{u8, u16, u32, u64, usize};
-const VALS_I8: (i8,) =
- //~^ ERROR this constant cannot be used
+const VALS_I8: (i8,) = //~ ERROR any use of this value will cause an error
+ //~^ const_err
(
i8::MIN * 2,
);
-const VALS_I16: (i16,) =
- //~^ ERROR this constant cannot be used
+const VALS_I16: (i16,) = //~ ERROR any use of this value will cause an error
(
i16::MIN * 2,
);
-const VALS_I32: (i32,) =
- //~^ ERROR this constant cannot be used
+const VALS_I32: (i32,) = //~ ERROR any use of this value will cause an error
(
i32::MIN * 2,
);
-const VALS_I64: (i64,) =
- //~^ ERROR this constant cannot be used
+const VALS_I64: (i64,) = //~ ERROR any use of this value will cause an error
(
i64::MIN * 2,
);
-const VALS_U8: (u8,) =
- //~^ ERROR this constant cannot be used
+const VALS_U8: (u8,) = //~ ERROR any use of this value will cause an error
(
u8::MAX * 2,
);
-const VALS_U16: (u16,) = (
- //~^ ERROR this constant cannot be used
+const VALS_U16: (u16,) = ( //~ ERROR any use of this value will cause an error
u16::MAX * 2,
);
-const VALS_U32: (u32,) = (
- //~^ ERROR this constant cannot be used
+const VALS_U32: (u32,) = ( //~ ERROR any use of this value will cause an error
u32::MAX * 2,
);
-const VALS_U64: (u64,) =
- //~^ ERROR this constant cannot be used
+const VALS_U64: (u64,) = //~ ERROR any use of this value will cause an error
(
u64::MAX * 2,
);
fn main() {
- foo(VALS_I8);
- foo(VALS_I16);
- foo(VALS_I32);
- foo(VALS_I64);
+ foo(VALS_I8); //~ ERROR erroneous constant used
+ foo(VALS_I16); //~ ERROR erroneous constant used
+ foo(VALS_I32); //~ ERROR erroneous constant used
+ foo(VALS_I64); //~ ERROR erroneous constant used
- foo(VALS_U8);
- foo(VALS_U16);
- foo(VALS_U32);
- foo(VALS_U64);
+ foo(VALS_U8); //~ ERROR erroneous constant used
+ foo(VALS_U16); //~ ERROR erroneous constant used
+ foo(VALS_U32); //~ ERROR erroneous constant used
+ foo(VALS_U64); //~ ERROR erroneous constant used
}
fn foo<T>(_: T) {
-error: this constant cannot be used
+error: any use of this value will cause an error
--> $DIR/const-eval-overflow2c.rs:24:1
|
-LL | / const VALS_I8: (i8,) =
-LL | | //~^ ERROR this constant cannot be used
+LL | / const VALS_I8: (i8,) = //~ ERROR any use of this value will cause an error
+LL | | //~^ const_err
LL | | (
LL | | i8::MIN * 2,
| | ----------- attempt to multiply with overflow
LL | #![deny(const_err)]
| ^^^^^^^^^
-error: this constant cannot be used
+error: any use of this value will cause an error
--> $DIR/const-eval-overflow2c.rs:30:1
|
-LL | / const VALS_I16: (i16,) =
-LL | | //~^ ERROR this constant cannot be used
+LL | / const VALS_I16: (i16,) = //~ ERROR any use of this value will cause an error
LL | | (
LL | | i16::MIN * 2,
| | ------------ attempt to multiply with overflow
LL | | );
| |_______^
-error: this constant cannot be used
- --> $DIR/const-eval-overflow2c.rs:36:1
+error: any use of this value will cause an error
+ --> $DIR/const-eval-overflow2c.rs:35:1
|
-LL | / const VALS_I32: (i32,) =
-LL | | //~^ ERROR this constant cannot be used
+LL | / const VALS_I32: (i32,) = //~ ERROR any use of this value will cause an error
LL | | (
LL | | i32::MIN * 2,
| | ------------ attempt to multiply with overflow
LL | | );
| |_______^
-error: this constant cannot be used
- --> $DIR/const-eval-overflow2c.rs:42:1
+error: any use of this value will cause an error
+ --> $DIR/const-eval-overflow2c.rs:40:1
|
-LL | / const VALS_I64: (i64,) =
-LL | | //~^ ERROR this constant cannot be used
+LL | / const VALS_I64: (i64,) = //~ ERROR any use of this value will cause an error
LL | | (
LL | | i64::MIN * 2,
| | ------------ attempt to multiply with overflow
LL | | );
| |_______^
-error: this constant cannot be used
- --> $DIR/const-eval-overflow2c.rs:48:1
+error: any use of this value will cause an error
+ --> $DIR/const-eval-overflow2c.rs:45:1
|
-LL | / const VALS_U8: (u8,) =
-LL | | //~^ ERROR this constant cannot be used
+LL | / const VALS_U8: (u8,) = //~ ERROR any use of this value will cause an error
LL | | (
LL | | u8::MAX * 2,
| | ----------- attempt to multiply with overflow
LL | | );
| |_______^
-error: this constant cannot be used
- --> $DIR/const-eval-overflow2c.rs:54:1
+error: any use of this value will cause an error
+ --> $DIR/const-eval-overflow2c.rs:50:1
|
-LL | / const VALS_U16: (u16,) = (
-LL | | //~^ ERROR this constant cannot be used
+LL | / const VALS_U16: (u16,) = ( //~ ERROR any use of this value will cause an error
LL | | u16::MAX * 2,
| | ------------ attempt to multiply with overflow
LL | | );
| |_______^
-error: this constant cannot be used
- --> $DIR/const-eval-overflow2c.rs:59:1
+error: any use of this value will cause an error
+ --> $DIR/const-eval-overflow2c.rs:54:1
|
-LL | / const VALS_U32: (u32,) = (
-LL | | //~^ ERROR this constant cannot be used
+LL | / const VALS_U32: (u32,) = ( //~ ERROR any use of this value will cause an error
LL | | u32::MAX * 2,
| | ------------ attempt to multiply with overflow
LL | | );
| |_______^
-error: this constant cannot be used
- --> $DIR/const-eval-overflow2c.rs:64:1
+error: any use of this value will cause an error
+ --> $DIR/const-eval-overflow2c.rs:58:1
|
-LL | / const VALS_U64: (u64,) =
-LL | | //~^ ERROR this constant cannot be used
+LL | / const VALS_U64: (u64,) = //~ ERROR any use of this value will cause an error
LL | | (
LL | | u64::MAX * 2,
| | ------------ attempt to multiply with overflow
LL | | );
| |_______^
-error: aborting due to 8 previous errors
+error: any use of this value will cause an error
+ --> $DIR/const-eval-overflow2c.rs:24:1
+ |
+LL | / const VALS_I8: (i8,) = //~ ERROR any use of this value will cause an error
+LL | | //~^ const_err
+LL | | (
+LL | | i8::MIN * 2,
+ | | ----------- attempt to multiply with overflow
+LL | | );
+ | |_______^
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-eval-overflow2c.rs:64:5
+ |
+LL | foo(VALS_I8); //~ ERROR erroneous constant used
+ | ^^^^^^^^^^^^ referenced constant has errors
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-eval-overflow2c.rs:65:5
+ |
+LL | foo(VALS_I16); //~ ERROR erroneous constant used
+ | ^^^^^^^^^^^^^ referenced constant has errors
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-eval-overflow2c.rs:66:5
+ |
+LL | foo(VALS_I32); //~ ERROR erroneous constant used
+ | ^^^^^^^^^^^^^ referenced constant has errors
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-eval-overflow2c.rs:67:5
+ |
+LL | foo(VALS_I64); //~ ERROR erroneous constant used
+ | ^^^^^^^^^^^^^ referenced constant has errors
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-eval-overflow2c.rs:69:5
+ |
+LL | foo(VALS_U8); //~ ERROR erroneous constant used
+ | ^^^^^^^^^^^^ referenced constant has errors
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-eval-overflow2c.rs:70:5
+ |
+LL | foo(VALS_U16); //~ ERROR erroneous constant used
+ | ^^^^^^^^^^^^^ referenced constant has errors
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-eval-overflow2c.rs:71:5
+ |
+LL | foo(VALS_U32); //~ ERROR erroneous constant used
+ | ^^^^^^^^^^^^^ referenced constant has errors
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-eval-overflow2c.rs:72:5
+ |
+LL | foo(VALS_U64); //~ ERROR erroneous constant used
+ | ^^^^^^^^^^^^^ referenced constant has errors
+
+error: aborting due to 17 previous errors
+For more information about this error, try `rustc --explain E0080`.
//~^ ERROR this constant likely exhibits undefined behavior
const I32_REF_U8_UNION: u8 = unsafe { Nonsense { int_32_ref: &3 }.uint_8 };
- //~^ ERROR this constant cannot be used
+ //~^ ERROR any use of this value will cause an error
const I32_REF_U16_UNION: u16 = unsafe { Nonsense { int_32_ref: &3 }.uint_16 };
- //~^ ERROR this constant cannot be used
+ //~^ ERROR any use of this value will cause an error
const I32_REF_U32_UNION: u32 = unsafe { Nonsense { int_32_ref: &3 }.uint_32 };
- //~^ ERROR this constant cannot be used
+ //~^ ERROR any use of this value will cause an error
const I32_REF_U64_UNION: u64 = unsafe { Nonsense { int_32_ref: &3 }.uint_64 };
//~^ ERROR this constant likely exhibits undefined behavior
const I32_REF_U128_UNION: u128 = unsafe { Nonsense { int_32_ref: &3 }.uint_128 };
- //~^ ERROR this constant cannot be used
+ //~^ ERROR any use of this value will cause an error
const I32_REF_I8_UNION: i8 = unsafe { Nonsense { int_32_ref: &3 }.int_8 };
- //~^ ERROR this constant cannot be used
+ //~^ ERROR any use of this value will cause an error
const I32_REF_I16_UNION: i16 = unsafe { Nonsense { int_32_ref: &3 }.int_16 };
- //~^ ERROR this constant cannot be used
+ //~^ ERROR any use of this value will cause an error
const I32_REF_I32_UNION: i32 = unsafe { Nonsense { int_32_ref: &3 }.int_32 };
- //~^ ERROR this constant cannot be used
+ //~^ ERROR any use of this value will cause an error
const I32_REF_I64_UNION: i64 = unsafe { Nonsense { int_32_ref: &3 }.int_64 };
//~^ ERROR this constant likely exhibits undefined behavior
const I32_REF_I128_UNION: i128 = unsafe { Nonsense { int_32_ref: &3 }.int_128 };
- //~^ ERROR this constant cannot be used
+ //~^ ERROR any use of this value will cause an error
const I32_REF_F32_UNION: f32 = unsafe { Nonsense { int_32_ref: &3 }.float_32 };
- //~^ ERROR this constant cannot be used
+ //~^ ERROR any use of this value will cause an error
const I32_REF_F64_UNION: f64 = unsafe { Nonsense { int_32_ref: &3 }.float_64 };
//~^ ERROR this constant likely exhibits undefined behavior
const I32_REF_BOOL_UNION: bool = unsafe { Nonsense { int_32_ref: &3 }.truthy_falsey };
- //~^ ERROR this constant cannot be used
+ //~^ ERROR any use of this value will cause an error
const I32_REF_CHAR_UNION: char = unsafe { Nonsense { int_32_ref: &3 }.character };
- //~^ ERROR this constant cannot be used
+ //~^ ERROR any use of this value will cause an error
const STR_U8_UNION: u8 = unsafe { Nonsense { stringy: "3" }.uint_8 };
- //~^ ERROR this constant cannot be used
+ //~^ ERROR any use of this value will cause an error
const STR_U16_UNION: u16 = unsafe { Nonsense { stringy: "3" }.uint_16 };
- //~^ ERROR this constant cannot be used
+ //~^ ERROR any use of this value will cause an error
const STR_U32_UNION: u32 = unsafe { Nonsense { stringy: "3" }.uint_32 };
- //~^ ERROR this constant cannot be used
+ //~^ ERROR any use of this value will cause an error
const STR_U64_UNION: u64 = unsafe { Nonsense { stringy: "3" }.uint_64 };
//~^ ERROR this constant likely exhibits undefined behavior
const STR_U128_UNION: u128 = unsafe { Nonsense { stringy: "3" }.uint_128 };
- //~^ ERROR this constant cannot be used
+ //~^ ERROR any use of this value will cause an error
const STR_I8_UNION: i8 = unsafe { Nonsense { stringy: "3" }.int_8 };
- //~^ ERROR this constant cannot be used
+ //~^ ERROR any use of this value will cause an error
const STR_I16_UNION: i16 = unsafe { Nonsense { stringy: "3" }.int_16 };
- //~^ ERROR this constant cannot be used
+ //~^ ERROR any use of this value will cause an error
const STR_I32_UNION: i32 = unsafe { Nonsense { stringy: "3" }.int_32 };
- //~^ ERROR this constant cannot be used
+ //~^ ERROR any use of this value will cause an error
const STR_I64_UNION: i64 = unsafe { Nonsense { stringy: "3" }.int_64 };
//~^ ERROR this constant likely exhibits undefined behavior
const STR_I128_UNION: i128 = unsafe { Nonsense { stringy: "3" }.int_128 };
- //~^ ERROR this constant cannot be used
+ //~^ ERROR any use of this value will cause an error
const STR_F32_UNION: f32 = unsafe { Nonsense { stringy: "3" }.float_32 };
- //~^ ERROR this constant cannot be used
+ //~^ ERROR any use of this value will cause an error
const STR_F64_UNION: f64 = unsafe { Nonsense { stringy: "3" }.float_64 };
//~^ ERROR this constant likely exhibits undefined behavior
const STR_BOOL_UNION: bool = unsafe { Nonsense { stringy: "3" }.truthy_falsey };
- //~^ ERROR this constant cannot be used
+ //~^ ERROR any use of this value will cause an error
const STR_CHAR_UNION: char = unsafe { Nonsense { stringy: "3" }.character };
- //~^ ERROR this constant cannot be used
+ //~^ ERROR any use of this value will cause an error
}
// except according to those terms.
#![feature(const_panic)]
+#![crate_type = "lib"]
-fn main() {}
+pub const Z: () = panic!("cheese");
+//~^ ERROR any use of this value will cause an error
-const Z: () = panic!("cheese");
-//~^ ERROR this constant cannot be used
+pub const Y: () = unreachable!();
+//~^ ERROR any use of this value will cause an error
-const Y: () = unreachable!();
-//~^ ERROR this constant cannot be used
-
-const X: () = unimplemented!();
-//~^ ERROR this constant cannot be used
+pub const X: () = unimplemented!();
+//~^ ERROR any use of this value will cause an error
-error: this constant cannot be used
- --> $DIR/const_panic.rs:15:1
+error: any use of this value will cause an error
+ --> $DIR/const_panic.rs:14:1
|
-LL | const Z: () = panic!("cheese");
- | ^^^^^^^^^^^^^^----------------^
- | |
- | the evaluated program panicked at 'cheese', $DIR/const_panic.rs:15:15
+LL | pub const Z: () = panic!("cheese");
+ | ^^^^^^^^^^^^^^^^^^----------------^
+ | |
+ | the evaluated program panicked at 'cheese', $DIR/const_panic.rs:14:19
|
= note: #[deny(const_err)] on by default
= note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
-error: this constant cannot be used
- --> $DIR/const_panic.rs:18:1
+error: any use of this value will cause an error
+ --> $DIR/const_panic.rs:17:1
|
-LL | const Y: () = unreachable!();
- | ^^^^^^^^^^^^^^--------------^
- | |
- | the evaluated program panicked at 'internal error: entered unreachable code', $DIR/const_panic.rs:18:15
+LL | pub const Y: () = unreachable!();
+ | ^^^^^^^^^^^^^^^^^^--------------^
+ | |
+ | the evaluated program panicked at 'internal error: entered unreachable code', $DIR/const_panic.rs:17:19
|
= note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
-error: this constant cannot be used
- --> $DIR/const_panic.rs:21:1
+error: any use of this value will cause an error
+ --> $DIR/const_panic.rs:20:1
|
-LL | const X: () = unimplemented!();
- | ^^^^^^^^^^^^^^----------------^
- | |
- | the evaluated program panicked at 'not yet implemented', $DIR/const_panic.rs:21:15
+LL | pub const X: () = unimplemented!();
+ | ^^^^^^^^^^^^^^^^^^----------------^
+ | |
+ | the evaluated program panicked at 'not yet implemented', $DIR/const_panic.rs:20:19
|
= note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
#![feature(const_panic)]
const Z: () = panic!("cheese");
-//~^ ERROR this constant cannot be used
+//~^ ERROR any use of this value will cause an error
const Y: () = unreachable!();
-//~^ ERROR this constant cannot be used
+//~^ ERROR any use of this value will cause an error
const X: () = unimplemented!();
-//~^ ERROR this constant cannot be used
+//~^ ERROR any use of this value will cause an error
-error: this constant cannot be used
+error: any use of this value will cause an error
--> $DIR/const_panic_libcore.rs:15:1
|
LL | const Z: () = panic!("cheese");
= note: #[deny(const_err)] on by default
= note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
-error: this constant cannot be used
+error: any use of this value will cause an error
--> $DIR/const_panic_libcore.rs:18:1
|
LL | const Y: () = unreachable!();
|
= note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
-error: this constant cannot be used
+error: any use of this value will cause an error
--> $DIR/const_panic_libcore.rs:21:1
|
LL | const X: () = unimplemented!();
use core::panic::PanicInfo;
const Z: () = panic!("cheese");
-//~^ ERROR this constant cannot be used
+//~^ ERROR any use of this value will cause an error
const Y: () = unreachable!();
-//~^ ERROR this constant cannot be used
+//~^ ERROR any use of this value will cause an error
const X: () = unimplemented!();
-//~^ ERROR this constant cannot be used
+//~^ ERROR any use of this value will cause an error
#[lang = "eh_personality"]
fn eh() {}
-error: this constant cannot be used
- --> $DIR/const_panic_libcore_main.rs:19:1
+error: any use of this value will cause an error
+ --> $DIR/const_panic_libcore_main.rs:20:1
|
LL | const Z: () = panic!("cheese");
| ^^^^^^^^^^^^^^----------------^
= note: #[deny(const_err)] on by default
= note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
-error: this constant cannot be used
- --> $DIR/const_panic_libcore_main.rs:22:1
+error: any use of this value will cause an error
+ --> $DIR/const_panic_libcore_main.rs:23:1
|
LL | const Y: () = unreachable!();
| ^^^^^^^^^^^^^^--------------^
|
= note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
-error: this constant cannot be used
- --> $DIR/const_panic_libcore_main.rs:25:1
+error: any use of this value will cause an error
+ --> $DIR/const_panic_libcore_main.rs:26:1
|
LL | const X: () = unimplemented!();
| ^^^^^^^^^^^^^^----------------^
fn main() {}
// unconst and bad, will thus error in miri
-const X: bool = &1 as *const i32 == &2 as *const i32; //~ ERROR cannot be used
+const X: bool = &1 as *const i32 == &2 as *const i32; //~ ERROR any use of this value will cause
// unconst and fine
const X2: bool = 42 as *const i32 == 43 as *const i32;
// unconst and fine
const Y: usize = 42usize as *const i32 as usize + 1;
// unconst and bad, will thus error in miri
-const Y2: usize = &1 as *const i32 as usize + 1; //~ ERROR cannot be used
+const Y2: usize = &1 as *const i32 as usize + 1; //~ ERROR any use of this value will cause
// unconst and fine
const Z: i32 = unsafe { *(&1 as *const i32) };
// unconst and bad, will thus error in miri
-const Z2: i32 = unsafe { *(42 as *const i32) }; //~ ERROR cannot be used
-const Z3: i32 = unsafe { *(44 as *const i32) }; //~ ERROR cannot be used
+const Z2: i32 = unsafe { *(42 as *const i32) }; //~ ERROR any use of this value will cause
+const Z3: i32 = unsafe { *(44 as *const i32) }; //~ ERROR any use of this value will cause
-error: this constant cannot be used
+error: any use of this value will cause an error
--> $DIR/const_raw_ptr_ops.rs:16:1
|
-LL | const X: bool = &1 as *const i32 == &2 as *const i32; //~ ERROR cannot be used
+LL | const X: bool = &1 as *const i32 == &2 as *const i32; //~ ERROR any use of this value will cause
| ^^^^^^^^^^^^^^^^------------------------------------^
| |
| "pointer arithmetic or comparison" needs an rfc before being allowed inside constants
|
= note: #[deny(const_err)] on by default
-error: this constant cannot be used
+error: any use of this value will cause an error
--> $DIR/const_raw_ptr_ops.rs:22:1
|
-LL | const Y2: usize = &1 as *const i32 as usize + 1; //~ ERROR cannot be used
+LL | const Y2: usize = &1 as *const i32 as usize + 1; //~ ERROR any use of this value will cause
| ^^^^^^^^^^^^^^^^^^-----------------------------^
| |
| "pointer arithmetic or comparison" needs an rfc before being allowed inside constants
-error: this constant cannot be used
+error: any use of this value will cause an error
--> $DIR/const_raw_ptr_ops.rs:26:1
|
-LL | const Z2: i32 = unsafe { *(42 as *const i32) }; //~ ERROR cannot be used
+LL | const Z2: i32 = unsafe { *(42 as *const i32) }; //~ ERROR any use of this value will cause
| ^^^^^^^^^^^^^^^^^^^^^^^^^-------------------^^^
| |
| a memory access tried to interpret some bytes as a pointer
-error: this constant cannot be used
+error: any use of this value will cause an error
--> $DIR/const_raw_ptr_ops.rs:27:1
|
-LL | const Z3: i32 = unsafe { *(44 as *const i32) }; //~ ERROR cannot be used
+LL | const Z3: i32 = unsafe { *(44 as *const i32) }; //~ ERROR any use of this value will cause
| ^^^^^^^^^^^^^^^^^^^^^^^^^-------------------^^^
| |
| a memory access tried to interpret some bytes as a pointer
-error[E0080]: this static likely exhibits undefined behavior
+error[E0080]: it is undefined behavior to use this value
--> $DIR/double_check2.rs:25:1
|
LL | / static FOO: (&Foo, &Bar) = unsafe {( //~ undefined behavior
// The value of `n` will loop indefinitely (4 - 2 - 1 - 4).
let _ = [(); {
//~^ WARNING Constant evaluating a complex constant, this might take some time
- //~| ERROR could not evaluate repeat length
let mut n = 113383; // #20 in https://oeis.org/A006884
while n != 0 { //~ ERROR constant contains unimplemented expression type
n = if n % 2 == 0 { n/2 } else { 3*n + 1 };
+ //~^ ERROR evaluation of constant value failed
}
n
}];
error[E0019]: constant contains unimplemented expression type
- --> $DIR/infinite_loop.rs:20:9
+ --> $DIR/infinite_loop.rs:19:9
|
LL | / while n != 0 { //~ ERROR constant contains unimplemented expression type
LL | | n = if n % 2 == 0 { n/2 } else { 3*n + 1 };
+LL | | //~^ ERROR evaluation of constant value failed
LL | | }
| |_________^
LL | let _ = [(); {
| __________________^
LL | | //~^ WARNING Constant evaluating a complex constant, this might take some time
-LL | | //~| ERROR could not evaluate repeat length
LL | | let mut n = 113383; // #20 in https://oeis.org/A006884
+LL | | while n != 0 { //~ ERROR constant contains unimplemented expression type
... |
LL | | n
LL | | }];
| |_____^
-error[E0080]: could not evaluate repeat length
- --> $DIR/infinite_loop.rs:16:18
+error[E0080]: evaluation of constant value failed
+ --> $DIR/infinite_loop.rs:20:20
|
-LL | let _ = [(); {
- | __________________^
-LL | | //~^ WARNING Constant evaluating a complex constant, this might take some time
-LL | | //~| ERROR could not evaluate repeat length
-LL | | let mut n = 113383; // #20 in https://oeis.org/A006884
-LL | | while n != 0 { //~ ERROR constant contains unimplemented expression type
-LL | | n = if n % 2 == 0 { n/2 } else { 3*n + 1 };
- | | ---------- duplicate interpreter state observed here, const evaluation will never terminate
-LL | | }
-LL | | n
-LL | | }];
- | |_____^
+LL | n = if n % 2 == 0 { n/2 } else { 3*n + 1 };
+ | ^^^^^^^^^^ duplicate interpreter state observed here, const evaluation will never terminate
error: aborting due to 2 previous errors
--- /dev/null
+warning: any use of this value will cause an error
+ --> $DIR/issue-43197.rs:20:5
+ |
+LL | const X: u32 = 0-1;
+ | ^^^^^^^^^^^^^^^---^
+ | |
+ | attempt to subtract with overflow
+ |
+note: lint level defined here
+ --> $DIR/issue-43197.rs:11:9
+ |
+LL | #![warn(const_err)]
+ | ^^^^^^^^^
+
+warning: any use of this value will cause an error
+ --> $DIR/issue-43197.rs:22:5
+ |
+LL | const Y: u32 = foo(0-1);
+ | ^^^^^^^^^^^^^^^^^^^---^^
+ | |
+ | attempt to subtract with overflow
+
+error[E0080]: evaluation of constant expression failed
+ --> $DIR/issue-43197.rs:24:14
+ |
+LL | println!("{} {}", X, Y);
+ | ^^^^^^^ - referenced constant has errors
+
+error[E0080]: evaluation of constant expression failed
+ --> $DIR/issue-43197.rs:24:26
+ |
+LL | println!("{} {}", X, Y);
+ | ^ referenced constant has errors
+
+error[E0080]: evaluation of constant expression failed
+ --> $DIR/issue-43197.rs:24:23
+ |
+LL | println!("{} {}", X, Y);
+ | ^ referenced constant has errors
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0080`.
fn main() {
const X: u32 = 0-1;
- //~^ WARN this constant cannot be used
+ //~^ WARN any use of this value will cause
const Y: u32 = foo(0-1);
- //~^ WARN this constant cannot be used
+ //~^ WARN any use of this value will cause
println!("{} {}", X, Y);
- //~^ ERROR erroneous constant used
- //~| ERROR erroneous constant used
- //~| ERROR E0080
- //~| ERROR E0080
+ //~^ ERROR evaluation of constant expression failed
+ //~| ERROR evaluation of constant expression failed
}
-warning: this constant cannot be used
- --> $DIR/issue-43197.rs:18:5
+warning: any use of this value will cause an error
+ --> $DIR/issue-43197.rs:20:5
|
LL | const X: u32 = 0-1;
| ^^^^^^^^^^^^^^^---^
LL | #![warn(const_err)]
| ^^^^^^^^^
-warning: this constant cannot be used
- --> $DIR/issue-43197.rs:20:5
+warning: any use of this value will cause an error
+ --> $DIR/issue-43197.rs:22:5
|
LL | const Y: u32 = foo(0-1);
| ^^^^^^^^^^^^^^^^^^^---^^
| |
| attempt to subtract with overflow
-error[E0080]: referenced constant has errors
- --> $DIR/issue-43197.rs:22:26
- |
-LL | const Y: u32 = foo(0-1);
- | --- attempt to subtract with overflow
-LL | //~^ WARN this constant cannot be used
-LL | println!("{} {}", X, Y);
- | ^
-
-error[E0080]: erroneous constant used
- --> $DIR/issue-43197.rs:22:26
+error[E0080]: evaluation of constant expression failed
+ --> $DIR/issue-43197.rs:24:26
|
LL | println!("{} {}", X, Y);
| ^ referenced constant has errors
-error[E0080]: referenced constant has errors
- --> $DIR/issue-43197.rs:22:23
- |
-LL | const X: u32 = 0-1;
- | --- attempt to subtract with overflow
-...
-LL | println!("{} {}", X, Y);
- | ^
-
-error[E0080]: erroneous constant used
- --> $DIR/issue-43197.rs:22:23
+error[E0080]: evaluation of constant expression failed
+ --> $DIR/issue-43197.rs:24:23
|
LL | println!("{} {}", X, Y);
| ^ referenced constant has errors
-error: aborting due to 4 previous errors
+error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0080`.
--- /dev/null
+error[E0080]: evaluation of constant expression failed
+ --> $DIR/issue-44578.rs:35:14
+ |
+LL | println!("{}", <Bar<u16, u8> as Foo>::AMT);
+ | ^^^^ -------------------------- referenced constant has errors
+
+error[E0080]: evaluation of constant expression failed
+ --> $DIR/issue-44578.rs:35:20
+ |
+LL | println!("{}", <Bar<u16, u8> as Foo>::AMT);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^ referenced constant has errors
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0080`.
fn main() {
println!("{}", <Bar<u16, u8> as Foo>::AMT);
- //~^ ERROR erroneous constant used
- //~| ERROR E0080
+ //~^ ERROR E0080
}
-error[E0080]: referenced constant has errors
- --> $DIR/issue-44578.rs:35:20
- |
-LL | const AMT: usize = [A::AMT][(A::AMT > B::AMT) as usize];
- | ------------------------------------ index out of bounds: the len is 1 but the index is 1
-...
-LL | println!("{}", <Bar<u16, u8> as Foo>::AMT);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0080]: erroneous constant used
+error[E0080]: evaluation of constant expression failed
--> $DIR/issue-44578.rs:35:20
|
LL | println!("{}", <Bar<u16, u8> as Foo>::AMT);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ referenced constant has errors
-error: aborting due to 2 previous errors
+error: aborting due to previous error
For more information about this error, try `rustc --explain E0080`.
struct A<T>(T);
impl<T: C> Foo<T> for A<T> {
- const BAR: usize = [5, 6, 7][T::BOO];
+ const BAR: usize = [5, 6, 7][T::BOO]; //~ ERROR any use of this value will cause an error
}
fn foo<T: C>() -> &'static usize {
- &<A<T> as Foo<T>>::BAR //~ ERROR erroneous constant used
-//~| ERROR E0080
+ &<A<T> as Foo<T>>::BAR //~ ERROR E0080
}
impl C for () {
-error[E0080]: referenced constant has errors
- --> $DIR/issue-50814-2.rs:26:5
+error: any use of this value will cause an error
+ --> $DIR/issue-50814-2.rs:22:5
+ |
+LL | const BAR: usize = [5, 6, 7][T::BOO]; //~ ERROR any use of this value will cause an error
+ | ^^^^^^^^^^^^^^^^^^^-----------------^
+ | |
+ | index out of bounds: the len is 3 but the index is 42
|
-LL | const BAR: usize = [5, 6, 7][T::BOO];
- | ----------------- index out of bounds: the len is 3 but the index is 42
-...
-LL | &<A<T> as Foo<T>>::BAR //~ ERROR erroneous constant used
- | ^^^^^^^^^^^^^^^^^^^^^^
+ = note: #[deny(const_err)] on by default
-error[E0080]: erroneous constant used
+error[E0080]: evaluation of constant expression failed
--> $DIR/issue-50814-2.rs:26:5
|
-LL | &<A<T> as Foo<T>>::BAR //~ ERROR erroneous constant used
+LL | &<A<T> as Foo<T>>::BAR //~ ERROR E0080
| ^---------------------
| |
| referenced constant has errors
struct Sum<A,B>(A,B);
impl<A: Unsigned, B: Unsigned> Unsigned for Sum<A,B> {
- const MAX: u8 = A::MAX + B::MAX;
+ const MAX: u8 = A::MAX + B::MAX; //~ ERROR any use of this value will cause an error
}
fn foo<T>(_: T) -> &'static u8 {
- &Sum::<U8,U8>::MAX //~ ERROR erroneous constant used
-//~| ERROR E0080
+ &Sum::<U8,U8>::MAX //~ ERROR E0080
}
fn main() {
-error[E0080]: referenced constant has errors
- --> $DIR/issue-50814.rs:27:5
+error: any use of this value will cause an error
+ --> $DIR/issue-50814.rs:23:5
+ |
+LL | const MAX: u8 = A::MAX + B::MAX; //~ ERROR any use of this value will cause an error
+ | ^^^^^^^^^^^^^^^^---------------^
+ | |
+ | attempt to add with overflow
|
-LL | const MAX: u8 = A::MAX + B::MAX;
- | --------------- attempt to add with overflow
-...
-LL | &Sum::<U8,U8>::MAX //~ ERROR erroneous constant used
- | ^^^^^^^^^^^^^^^^^^
+ = note: #[deny(const_err)] on by default
-error[E0080]: erroneous constant used
+error[E0080]: evaluation of constant expression failed
--> $DIR/issue-50814.rs:27:5
|
-LL | &Sum::<U8,U8>::MAX //~ ERROR erroneous constant used
+LL | &Sum::<U8,U8>::MAX //~ ERROR E0080
| ^-----------------
| |
| referenced constant has errors
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/issue-52443.rs:12:10
+ |
+LL | [(); & { loop { continue } } ]; //~ ERROR mismatched types
+ | ^^^^^^^^^^^^^^^^^^^^^^^
+ | |
+ | expected usize, found reference
+ | help: consider removing the borrow: `{ loop { continue } }`
+ |
+ = note: expected type `usize`
+ found type `&_`
+
+error[E0308]: mismatched types
+ --> $DIR/issue-52443.rs:13:17
+ |
+LL | [(); loop { break }]; //~ ERROR mismatched types
+ | ^^^^^ expected (), found usize
+ |
+ = note: expected type `()`
+ found type `usize`
+
+error[E0019]: constant contains unimplemented expression type
+ --> $DIR/issue-52443.rs:14:11
+ |
+LL | [(); {while true {break}; 0}]; //~ ERROR constant contains unimplemented expression type
+ | ^^^^^^^^^^^^^^^^^^
+
+error[E0015]: calls in constants are limited to constant functions, tuple structs and tuple variants
+ --> $DIR/issue-52443.rs:15:21
+ |
+LL | [(); { for _ in 0usize.. {}; 0}]; //~ ERROR calls in constants are limited to constant functions
+ | ^^^^^^^^
+
+error[E0019]: constant contains unimplemented expression type
+ --> $DIR/issue-52443.rs:15:21
+ |
+LL | [(); { for _ in 0usize.. {}; 0}]; //~ ERROR calls in constants are limited to constant functions
+ | ^^^^^^^^
+
+error[E0080]: evaluation of constant value failed
+ --> $DIR/issue-52443.rs:15:21
+ |
+LL | [(); { for _ in 0usize.. {}; 0}]; //~ ERROR calls in constants are limited to constant functions
+ | ^^^^^^^^ calling non-const fn `<I as std::iter::IntoIterator><std::ops::RangeFrom<usize>>::into_iter`
+
+error: aborting due to 6 previous errors
+
+Some errors occurred: E0015, E0019, E0080, E0308.
+For more information about an error, try `rustc --explain E0015`.
// Make sure match uses the usual pointer comparison code path -- i.e., it should complain
// that pointer comparison is disallowed, not that parts of a pointer are accessed as raw
// bytes.
- let _: [u8; 0] = [4; { //~ ERROR could not evaluate repeat length
+ let _: [u8; 0] = [4; {
match &1 as *const i32 as usize { //~ ERROR casting pointers to integers in constants
0 => 42, //~ ERROR constant contains unimplemented expression type
//~^ NOTE "pointer arithmetic or comparison" needs an rfc before being allowed
+ //~| ERROR evaluation of constant value failed
n => n,
}
}];
LL | 0 => 42, //~ ERROR constant contains unimplemented expression type
| ^
-error[E0080]: could not evaluate repeat length
- --> $DIR/match-test-ptr-null.rs:15:26
+error[E0080]: evaluation of constant value failed
+ --> $DIR/match-test-ptr-null.rs:17:13
|
-LL | let _: [u8; 0] = [4; { //~ ERROR could not evaluate repeat length
- | __________________________^
-LL | | match &1 as *const i32 as usize { //~ ERROR casting pointers to integers in constants
-LL | | 0 => 42, //~ ERROR constant contains unimplemented expression type
- | | - "pointer arithmetic or comparison" needs an rfc before being allowed inside constants
-LL | | //~^ NOTE "pointer arithmetic or comparison" needs an rfc before being allowed
-LL | | n => n,
-LL | | }
-LL | | }];
- | |_____^
+LL | 0 => 42, //~ ERROR constant contains unimplemented expression type
+ | ^ "pointer arithmetic or comparison" needs an rfc before being allowed inside constants
error: aborting due to 3 previous errors
#![feature(const_fn, const_fn_union)]
-#![deny(const_err)]
+#![allow(const_err)]
union Bar {
a: &'static u8,
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(const_fn, const_fn_union)]
+
+#![deny(const_err)]
+
+union Bar {
+ a: &'static u8,
+ b: usize,
+}
+
+const fn bar() -> u8 {
+ unsafe {
+ // this will error as long as this test
+ // is run on a system whose pointers need more
+ // than 8 bits
+ Bar { a: &42 }.b as u8
+ }
+}
+
+fn main() {
+ // FIXME(oli-obk): this should panic at runtime
+ // this will actually compile, but then
+ // abort at runtime (not panic, hard abort).
+ let x: &'static u8 = &(bar() + 1);
+ let y = *x;
+ unreachable!();
+}
--- /dev/null
+error: reaching this expression at runtime will panic or abort
+ --> $DIR/promoted_const_fn_fail_deny_const_err.rs:33:26
+ |
+LL | Bar { a: &42 }.b as u8
+ | ---------------------- a raw memory access tried to access part of a pointer value as raw bytes
+...
+LL | let x: &'static u8 = &(bar() + 1);
+ | ^^-----^^^^^
+ | |
+ | inside call to `bar`
+ |
+note: lint level defined here
+ --> $DIR/promoted_const_fn_fail_deny_const_err.rs:13:9
+ |
+LL | #![deny(const_err)]
+ | ^^^^^^^^^
+
+error: aborting due to previous error
+
LL | let _x = 1/(false as u32);
| ^^^^^^^^^^^^^^^^ attempt to divide by zero
+warning: reaching this expression at runtime will panic or abort
+ --> $DIR/promoted_errors.rs:24:20
+ |
+LL | println!("{}", 1/(false as u32));
+ | ^^^^^^^^^^^^^^^^ attempt to divide by zero
+
+warning: reaching this expression at runtime will panic or abort
+ --> $DIR/promoted_errors.rs:19:20
+ |
+LL | println!("{}", 1/(1-1));
+ | ^^^^^^^ attempt to divide by zero
+
#![crate_type = "lib"]
pub const Z: u32 = 0 - 1;
-//~^ WARN this constant cannot be used
+//~^ WARN any use of this value will cause an error
pub type Foo = [i32; 0 - 1];
//~^ WARN attempt to subtract with overflow
-warning: this constant cannot be used
+warning: any use of this value will cause an error
--> $DIR/pub_const_err.rs:16:1
|
LL | pub const Z: u32 = 0 - 1;
LL | #![warn(const_err)]
| ^^^^^^^^^
-warning: attempt to subtract with overflow
- --> $DIR/pub_const_err.rs:19:22
- |
-LL | pub type Foo = [i32; 0 - 1];
- | ^^^^^
-
-warning: this array length cannot be used
- --> $DIR/pub_const_err.rs:19:22
- |
-LL | pub type Foo = [i32; 0 - 1];
- | ^^^^^ attempt to subtract with overflow
-
#![warn(const_err)]
pub const Z: u32 = 0 - 1;
-//~^ WARN this constant cannot be used
+//~^ WARN any use of this value will cause an error
pub type Foo = [i32; 0 - 1];
//~^ WARN attempt to subtract with overflow
-warning: this constant cannot be used
+warning: any use of this value will cause an error
--> $DIR/pub_const_err_bin.rs:14:1
|
LL | pub const Z: u32 = 0 - 1;
LL | #![warn(const_err)]
| ^^^^^^^^^
-warning: attempt to subtract with overflow
- --> $DIR/pub_const_err_bin.rs:17:22
- |
-LL | pub type Foo = [i32; 0 - 1];
- | ^^^^^
-
-warning: this array length cannot be used
- --> $DIR/pub_const_err_bin.rs:17:22
- |
-LL | pub type Foo = [i32; 0 - 1];
- | ^^^^^ attempt to subtract with overflow
-
-error[E0080]: could not evaluate enum discriminant
+error[E0080]: evaluation of constant value failed
--> $DIR/shift_overflow.rs:13:9
|
LL | X = 1 << ((u32::max_value() as u64) + 1), //~ ERROR E0080
// A pointer is guaranteed non-null
const BAD_ENUM: Enum = unsafe { TransmuteEnum { a: &1 }.b };
-//~^ ERROR this constant likely exhibits undefined behavior
+//~^ ERROR is undefined behavior
// Invalid enum discriminant
#[repr(usize)]
b: Enum2,
}
const BAD_ENUM2 : Enum2 = unsafe { TransmuteEnum2 { a: 0 }.b };
-//~^ ERROR this constant likely exhibits undefined behavior
+//~^ ERROR is undefined behavior
// Invalid enum field content (mostly to test printing of apths for enum tuple
// variants and tuples).
}
// Need to create something which does not clash with enum layout optimizations.
const BAD_ENUM_CHAR : Option<(char, char)> = Some(('x', unsafe { TransmuteChar { a: !0 }.b }));
-//~^ ERROR this constant likely exhibits undefined behavior
+//~^ ERROR is undefined behavior
fn main() {
}
-error[E0080]: this constant likely exhibits undefined behavior
+error[E0080]: it is undefined behavior to use this value
--> $DIR/ub-enum.rs:22:1
|
LL | const BAD_ENUM: Enum = unsafe { TransmuteEnum { a: &1 }.b };
|
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rust compiler repository if you believe it should not be considered undefined behavior
-error[E0080]: this constant likely exhibits undefined behavior
+error[E0080]: it is undefined behavior to use this value
--> $DIR/ub-enum.rs:35:1
|
LL | const BAD_ENUM2 : Enum2 = unsafe { TransmuteEnum2 { a: 0 }.b };
|
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rust compiler repository if you believe it should not be considered undefined behavior
-error[E0080]: this constant likely exhibits undefined behavior
+error[E0080]: it is undefined behavior to use this value
--> $DIR/ub-enum.rs:45:1
|
LL | const BAD_ENUM_CHAR : Option<(char, char)> = Some(('x', unsafe { TransmuteChar { a: !0 }.b }));
}
const fn read_field3() -> Field3 {
- const FIELD3: Field3 = unsafe { UNION.field3 }; //~ ERROR cannot be used
+ const FIELD3: Field3 = unsafe { UNION.field3 }; //~ ERROR any use of this value
+ //~^ ERROR any use of this value
FIELD3
+ //~^ erroneous constant used
}
fn main() {
assert_eq!(read_field1(), FLOAT1_AS_I32);
assert_eq!(read_field2(), 1.0);
assert_eq!(read_field3(), unsafe { UNION.field3 });
+ //~^ ERROR evaluation of constant expression failed
}
-error: this constant cannot be used
+error: any use of this value will cause an error
--> $DIR/union-const-eval-field.rs:37:5
|
-LL | const FIELD3: Field3 = unsafe { UNION.field3 }; //~ ERROR cannot be used
+LL | const FIELD3: Field3 = unsafe { UNION.field3 }; //~ ERROR any use of this value
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ attempted to read undefined bytes
|
= note: #[deny(const_err)] on by default
-error: aborting due to previous error
+error: any use of this value will cause an error
+ --> $DIR/union-const-eval-field.rs:37:5
+ |
+LL | const FIELD3: Field3 = unsafe { UNION.field3 }; //~ ERROR any use of this value
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ attempted to read undefined bytes
+
+error[E0080]: erroneous constant used
+ --> $DIR/union-const-eval-field.rs:39:5
+ |
+LL | FIELD3
+ | ^^^^^^ referenced constant has errors
+
+error[E0080]: evaluation of constant expression failed
+ --> $DIR/union-const-eval-field.rs:46:5
+ |
+LL | FIELD3
+ | ------ referenced constant has errors
+...
+LL | assert_eq!(read_field3(), unsafe { UNION.field3 });
+ | ^^^^^^^^^^^-------------^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | |
+ | inside call to `read_field3`
+ |
+ = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
+
+error: aborting due to 4 previous errors
+For more information about this error, try `rustc --explain E0080`.
const UNION: DummyUnion = DummyUnion { field1: 1065353216 };
-const FIELD3: Field3 = unsafe { UNION.field3 }; //~ ERROR this constant cannot be used
+const FIELD3: Field3 = unsafe { UNION.field3 }; //~ ERROR will cause an error
-const FIELD_PATH: Struct = Struct { //~ ERROR this constant likely exhibits undefined behavior
+const FIELD_PATH: Struct = Struct { //~ ERROR any use of this value will cause an error
a: 42,
b: unsafe { UNION.field3 },
};
b: Field3,
}
-const FIELD_PATH2: Struct2 = Struct2 { //~ ERROR this constant likely exhibits undefined behavior
+const FIELD_PATH2: Struct2 = Struct2 { //~ ERROR it is undefined behavior to use this value
b: [
21,
unsafe { UNION.field3 },
-error: this constant cannot be used
+error: any use of this value will cause an error
--> $DIR/union-ice.rs:23:1
|
-LL | const FIELD3: Field3 = unsafe { UNION.field3 }; //~ ERROR this constant cannot be used
+LL | const FIELD3: Field3 = unsafe { UNION.field3 }; //~ ERROR will cause an error
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ attempted to read undefined bytes
|
= note: #[deny(const_err)] on by default
-error[E0080]: this constant likely exhibits undefined behavior
+error: any use of this value will cause an error
--> $DIR/union-ice.rs:25:1
|
-LL | / const FIELD_PATH: Struct = Struct { //~ ERROR this constant likely exhibits undefined behavior
+LL | / const FIELD_PATH: Struct = Struct { //~ ERROR any use of this value will cause an error
LL | | a: 42,
LL | | b: unsafe { UNION.field3 },
LL | | };
|
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rust compiler repository if you believe it should not be considered undefined behavior
-error[E0080]: this constant likely exhibits undefined behavior
+error[E0080]: it is undefined behavior to use this value
--> $DIR/union-ice.rs:35:1
|
-LL | / const FIELD_PATH2: Struct2 = Struct2 { //~ ERROR this constant likely exhibits undefined behavior
+LL | / const FIELD_PATH2: Struct2 = Struct2 { //~ ERROR it is undefined behavior to use this value
LL | | b: [
LL | | 21,
LL | | unsafe { UNION.field3 },
const A: &str = unsafe { SliceTransmute { repr: SliceRepr { ptr: &42, len: 1 } }.str};
// bad str
const B: &str = unsafe { SliceTransmute { repr: SliceRepr { ptr: &42, len: 999 } }.str};
-//~^ ERROR this constant likely exhibits undefined behavior
+//~^ ERROR it is undefined behavior to use this value
// bad str
const C: &str = unsafe { SliceTransmute { bad: BadSliceRepr { ptr: &42, len: &3 } }.str};
-//~^ ERROR this constant likely exhibits undefined behavior
+//~^ ERROR it is undefined behavior to use this value
// bad str in user-defined unsized type
const C2: &MyStr = unsafe { SliceTransmute { bad: BadSliceRepr { ptr: &42, len: &3 } }.my_str};
-//~^ ERROR this constant likely exhibits undefined behavior
+//~^ ERROR it is undefined behavior to use this value
// OK
const A2: &[u8] = unsafe { SliceTransmute { repr: SliceRepr { ptr: &42, len: 1 } }.slice};
// bad slice
const B2: &[u8] = unsafe { SliceTransmute { repr: SliceRepr { ptr: &42, len: 999 } }.slice};
-//~^ ERROR this constant likely exhibits undefined behavior
+//~^ ERROR it is undefined behavior to use this value
// bad slice
const C3: &[u8] = unsafe { SliceTransmute { bad: BadSliceRepr { ptr: &42, len: &3 } }.slice};
-//~^ ERROR this constant likely exhibits undefined behavior
+//~^ ERROR it is undefined behavior to use this value
// bad trait object
const D: &Trait = unsafe { DynTransmute { repr: DynRepr { ptr: &92, vtable: &3 } }.rust};
-//~^ ERROR this constant likely exhibits undefined behavior
+//~^ ERROR it is undefined behavior to use this value
// bad trait object
const E: &Trait = unsafe { DynTransmute { repr2: DynRepr2 { ptr: &92, vtable: &3 } }.rust};
-//~^ ERROR this constant likely exhibits undefined behavior
+//~^ ERROR it is undefined behavior to use this value
// bad trait object
const F: &Trait = unsafe { DynTransmute { bad: BadDynRepr { ptr: &92, vtable: 3 } }.rust};
-//~^ ERROR this constant likely exhibits undefined behavior
+//~^ ERROR it is undefined behavior to use this value
// bad data *inside* the trait object
const G: &Trait = &unsafe { BoolTransmute { val: 3 }.bl };
-//~^ ERROR this constant likely exhibits undefined behavior
+//~^ ERROR it is undefined behavior to use this value
+
// bad data *inside* the slice
const H: &[bool] = &[unsafe { BoolTransmute { val: 3 }.bl }];
-//~^ ERROR this constant likely exhibits undefined behavior
+//~^ ERROR it is undefined behavior to use this value
// good MySliceBool
const I1: &MySliceBool = &MySlice(true, [false]);
// bad: sized field is not okay
const I2: &MySliceBool = &MySlice(unsafe { BoolTransmute { val: 3 }.bl }, [false]);
-//~^ ERROR this constant likely exhibits undefined behavior
+//~^ ERROR it is undefined behavior to use this value
// bad: unsized part is not okay
const I3: &MySliceBool = &MySlice(true, [unsafe { BoolTransmute { val: 3 }.bl }]);
-//~^ ERROR this constant likely exhibits undefined behavior
+//~^ ERROR it is undefined behavior to use this value
// invalid UTF-8
const J1: &str = unsafe { SliceTransmute { slice: &[0xFF] }.str };
-//~^ ERROR this constant likely exhibits undefined behavior
+//~^ ERROR it is undefined behavior to use this value
// invalid UTF-8 in user-defined str-like
const J2: &MyStr = unsafe { SliceTransmute { slice: &[0xFF] }.my_str };
-//~^ ERROR this constant likely exhibits undefined behavior
+//~^ ERROR it is undefined behavior to use this value
fn main() {
}
-error[E0080]: this constant likely exhibits undefined behavior
+error[E0080]: it is undefined behavior to use this value
--> $DIR/union-ub-fat-ptr.rs:87:1
|
LL | const B: &str = unsafe { SliceTransmute { repr: SliceRepr { ptr: &42, len: 999 } }.str};
|
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rust compiler repository if you believe it should not be considered undefined behavior
-error[E0080]: this constant likely exhibits undefined behavior
+error[E0080]: it is undefined behavior to use this value
--> $DIR/union-ub-fat-ptr.rs:90:1
|
LL | const C: &str = unsafe { SliceTransmute { bad: BadSliceRepr { ptr: &42, len: &3 } }.str};
|
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rust compiler repository if you believe it should not be considered undefined behavior
-error[E0080]: this constant likely exhibits undefined behavior
+error[E0080]: it is undefined behavior to use this value
--> $DIR/union-ub-fat-ptr.rs:93:1
|
LL | const C2: &MyStr = unsafe { SliceTransmute { bad: BadSliceRepr { ptr: &42, len: &3 } }.my_str};
|
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rust compiler repository if you believe it should not be considered undefined behavior
-error[E0080]: this constant likely exhibits undefined behavior
+error[E0080]: it is undefined behavior to use this value
--> $DIR/union-ub-fat-ptr.rs:99:1
|
LL | const B2: &[u8] = unsafe { SliceTransmute { repr: SliceRepr { ptr: &42, len: 999 } }.slice};
|
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rust compiler repository if you believe it should not be considered undefined behavior
-error[E0080]: this constant likely exhibits undefined behavior
+error[E0080]: it is undefined behavior to use this value
--> $DIR/union-ub-fat-ptr.rs:102:1
|
LL | const C3: &[u8] = unsafe { SliceTransmute { bad: BadSliceRepr { ptr: &42, len: &3 } }.slice};
|
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rust compiler repository if you believe it should not be considered undefined behavior
-error[E0080]: this constant likely exhibits undefined behavior
+error[E0080]: it is undefined behavior to use this value
--> $DIR/union-ub-fat-ptr.rs:106:1
|
LL | const D: &Trait = unsafe { DynTransmute { repr: DynRepr { ptr: &92, vtable: &3 } }.rust};
|
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rust compiler repository if you believe it should not be considered undefined behavior
-error[E0080]: this constant likely exhibits undefined behavior
+error[E0080]: it is undefined behavior to use this value
--> $DIR/union-ub-fat-ptr.rs:109:1
|
LL | const E: &Trait = unsafe { DynTransmute { repr2: DynRepr2 { ptr: &92, vtable: &3 } }.rust};
|
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rust compiler repository if you believe it should not be considered undefined behavior
-error[E0080]: this constant likely exhibits undefined behavior
+error[E0080]: it is undefined behavior to use this value
--> $DIR/union-ub-fat-ptr.rs:112:1
|
LL | const F: &Trait = unsafe { DynTransmute { bad: BadDynRepr { ptr: &92, vtable: 3 } }.rust};
|
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rust compiler repository if you believe it should not be considered undefined behavior
-error[E0080]: this constant likely exhibits undefined behavior
+error[E0080]: it is undefined behavior to use this value
--> $DIR/union-ub-fat-ptr.rs:116:1
|
LL | const G: &Trait = &unsafe { BoolTransmute { val: 3 }.bl };
|
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rust compiler repository if you believe it should not be considered undefined behavior
-error[E0080]: this constant likely exhibits undefined behavior
- --> $DIR/union-ub-fat-ptr.rs:119:1
+error[E0080]: it is undefined behavior to use this value
+ --> $DIR/union-ub-fat-ptr.rs:120:1
|
LL | const H: &[bool] = &[unsafe { BoolTransmute { val: 3 }.bl }];
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered 3 at .<deref>[0], but expected something in the range 0..=1
|
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rust compiler repository if you believe it should not be considered undefined behavior
-error[E0080]: this constant likely exhibits undefined behavior
- --> $DIR/union-ub-fat-ptr.rs:125:1
+error[E0080]: it is undefined behavior to use this value
+ --> $DIR/union-ub-fat-ptr.rs:126:1
|
LL | const I2: &MySliceBool = &MySlice(unsafe { BoolTransmute { val: 3 }.bl }, [false]);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered 3 at .<deref>.0, but expected something in the range 0..=1
|
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rust compiler repository if you believe it should not be considered undefined behavior
-error[E0080]: this constant likely exhibits undefined behavior
- --> $DIR/union-ub-fat-ptr.rs:128:1
+error[E0080]: it is undefined behavior to use this value
+ --> $DIR/union-ub-fat-ptr.rs:129:1
|
LL | const I3: &MySliceBool = &MySlice(true, [unsafe { BoolTransmute { val: 3 }.bl }]);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered 3 at .<deref>.1[0], but expected something in the range 0..=1
|
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rust compiler repository if you believe it should not be considered undefined behavior
-error[E0080]: this constant likely exhibits undefined behavior
- --> $DIR/union-ub-fat-ptr.rs:132:1
+error[E0080]: it is undefined behavior to use this value
+ --> $DIR/union-ub-fat-ptr.rs:133:1
|
LL | const J1: &str = unsafe { SliceTransmute { slice: &[0xFF] }.str };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered uninitialized or non-UTF-8 data in str at .<deref>
|
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rust compiler repository if you believe it should not be considered undefined behavior
-error[E0080]: this constant likely exhibits undefined behavior
- --> $DIR/union-ub-fat-ptr.rs:135:1
+error[E0080]: it is undefined behavior to use this value
+ --> $DIR/union-ub-fat-ptr.rs:136:1
|
LL | const J2: &MyStr = unsafe { SliceTransmute { slice: &[0xFF] }.my_str };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered uninitialized or non-UTF-8 data in str at .<deref>.0
// the value is not valid for bools
const BAD_BOOL: bool = unsafe { DummyUnion { u8: 42 }.bool};
-//~^ ERROR this constant likely exhibits undefined behavior
+//~^ ERROR it is undefined behavior to use this value
// The value is not valid for any union variant, but that's fine
// unions are just a convenient way to transmute bits around
-error[E0080]: this constant likely exhibits undefined behavior
+error[E0080]: it is undefined behavior to use this value
--> $DIR/union-ub.rs:36:1
|
LL | const BAD_BOOL: bool = unsafe { DummyUnion { u8: 42 }.bool};
--- /dev/null
+error[E0658]: let bindings in constant functions are unstable (see issue #48821)
+ --> $DIR/const-fn-error.rs:16:19
+ |
+LL | let mut sum = 0;
+ | ^
+ |
+ = help: add #![feature(const_let)] to the crate attributes to enable
+
+error[E0658]: statements in constant functions are unstable (see issue #48821)
+ --> $DIR/const-fn-error.rs:16:19
+ |
+LL | let mut sum = 0;
+ | ^
+ |
+ = help: add #![feature(const_let)] to the crate attributes to enable
+
+error[E0015]: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+ --> $DIR/const-fn-error.rs:19:14
+ |
+LL | for i in 0..x { //~ ERROR E0080
+ | ^^^^
+
+error[E0019]: constant function contains unimplemented expression type
+ --> $DIR/const-fn-error.rs:19:14
+ |
+LL | for i in 0..x { //~ ERROR E0080
+ | ^^^^
+
+error[E0080]: evaluation of constant value failed
+ --> $DIR/const-fn-error.rs:19:14
+ |
+LL | for i in 0..x { //~ ERROR E0080
+ | ^^^^ calling non-const fn `<I as std::iter::IntoIterator><std::ops::Range<usize>>::into_iter`
+...
+LL | let a : [i32; f(X)];
+ | ---- inside call to `f`
+
+error: aborting due to 5 previous errors
+
+Some errors occurred: E0015, E0019, E0080, E0658.
+For more information about an error, try `rustc --explain E0015`.
//~| ERROR mismatched types
//~| expected usize, found bool
const ARR: [i32; X] = [99; 34];
+//~^ ERROR evaluation of constant value failed
const X1: usize = 42 || 39;
//~^ ERROR mismatched types
//~| ERROR mismatched types
//~| expected usize, found bool
const ARR1: [i32; X1] = [99; 47];
+//~^ ERROR evaluation of constant value failed
const X2: usize = -42 || -39;
//~^ ERROR mismatched types
//~| ERROR mismatched types
//~| expected usize, found bool
const ARR2: [i32; X2] = [99; 18446744073709551607];
+//~^ ERROR evaluation of constant value failed
const X3: usize = -42 && -39;
//~^ ERROR mismatched types
//~| ERROR mismatched types
//~| expected usize, found bool
const ARR3: [i32; X3] = [99; 6];
+//~^ ERROR evaluation of constant value failed
const Y: usize = 42.0 == 42.0;
//~^ ERROR mismatched types
//~| expected usize, found bool
const ARRR: [i32; Y] = [99; 1];
+//~^ ERROR evaluation of constant value failed
const Y1: usize = 42.0 >= 42.0;
//~^ ERROR mismatched types
//~| expected usize, found bool
const ARRR1: [i32; Y1] = [99; 1];
+//~^ ERROR evaluation of constant value failed
const Y2: usize = 42.0 <= 42.0;
//~^ ERROR mismatched types
//~| expected usize, found bool
const ARRR2: [i32; Y2] = [99; 1];
+//~^ ERROR evaluation of constant value failed
const Y3: usize = 42.0 > 42.0;
//~^ ERROR mismatched types
//~| expected usize, found bool
const ARRR3: [i32; Y3] = [99; 0];
+//~^ ERROR evaluation of constant value failed
const Y4: usize = 42.0 < 42.0;
//~^ ERROR mismatched types
//~| expected usize, found bool
const ARRR4: [i32; Y4] = [99; 0];
+//~^ ERROR evaluation of constant value failed
const Y5: usize = 42.0 != 42.0;
//~^ ERROR mismatched types
//~| expected usize, found bool
const ARRR5: [i32; Y5] = [99; 0];
+//~^ ERROR evaluation of constant value failed
fn main() {
let _ = ARR;
LL | const X: usize = 42 && 39;
| ^^^^^^^^ expected usize, found bool
+error[E0080]: evaluation of constant value failed
+ --> $DIR/const-integer-bool-ops.rs:18:18
+ |
+LL | const ARR: [i32; X] = [99; 34];
+ | ^ referenced constant has errors
+
error[E0308]: mismatched types
- --> $DIR/const-integer-bool-ops.rs:20:19
+ --> $DIR/const-integer-bool-ops.rs:21:19
|
LL | const X1: usize = 42 || 39;
| ^^ expected bool, found integral variable
found type `{integer}`
error[E0308]: mismatched types
- --> $DIR/const-integer-bool-ops.rs:20:25
+ --> $DIR/const-integer-bool-ops.rs:21:25
|
LL | const X1: usize = 42 || 39;
| ^^ expected bool, found integral variable
found type `{integer}`
error[E0308]: mismatched types
- --> $DIR/const-integer-bool-ops.rs:20:19
+ --> $DIR/const-integer-bool-ops.rs:21:19
|
LL | const X1: usize = 42 || 39;
| ^^^^^^^^ expected usize, found bool
+error[E0080]: evaluation of constant value failed
+ --> $DIR/const-integer-bool-ops.rs:28:19
+ |
+LL | const ARR1: [i32; X1] = [99; 47];
+ | ^^ referenced constant has errors
+
error[E0308]: mismatched types
- --> $DIR/const-integer-bool-ops.rs:29:19
+ --> $DIR/const-integer-bool-ops.rs:31:19
|
LL | const X2: usize = -42 || -39;
| ^^^ expected bool, found integral variable
found type `{integer}`
error[E0308]: mismatched types
- --> $DIR/const-integer-bool-ops.rs:29:26
+ --> $DIR/const-integer-bool-ops.rs:31:26
|
LL | const X2: usize = -42 || -39;
| ^^^ expected bool, found integral variable
found type `{integer}`
error[E0308]: mismatched types
- --> $DIR/const-integer-bool-ops.rs:29:19
+ --> $DIR/const-integer-bool-ops.rs:31:19
|
LL | const X2: usize = -42 || -39;
| ^^^^^^^^^^ expected usize, found bool
-error[E0308]: mismatched types
+error[E0080]: evaluation of constant value failed
--> $DIR/const-integer-bool-ops.rs:38:19
|
+LL | const ARR2: [i32; X2] = [99; 18446744073709551607];
+ | ^^ referenced constant has errors
+
+error[E0308]: mismatched types
+ --> $DIR/const-integer-bool-ops.rs:41:19
+ |
LL | const X3: usize = -42 && -39;
| ^^^ expected bool, found integral variable
|
found type `{integer}`
error[E0308]: mismatched types
- --> $DIR/const-integer-bool-ops.rs:38:26
+ --> $DIR/const-integer-bool-ops.rs:41:26
|
LL | const X3: usize = -42 && -39;
| ^^^ expected bool, found integral variable
found type `{integer}`
error[E0308]: mismatched types
- --> $DIR/const-integer-bool-ops.rs:38:19
+ --> $DIR/const-integer-bool-ops.rs:41:19
|
LL | const X3: usize = -42 && -39;
| ^^^^^^^^^^ expected usize, found bool
+error[E0080]: evaluation of constant value failed
+ --> $DIR/const-integer-bool-ops.rs:48:19
+ |
+LL | const ARR3: [i32; X3] = [99; 6];
+ | ^^ referenced constant has errors
+
error[E0308]: mismatched types
- --> $DIR/const-integer-bool-ops.rs:47:18
+ --> $DIR/const-integer-bool-ops.rs:51:18
|
LL | const Y: usize = 42.0 == 42.0;
| ^^^^^^^^^^^^ expected usize, found bool
+error[E0080]: evaluation of constant value failed
+ --> $DIR/const-integer-bool-ops.rs:54:19
+ |
+LL | const ARRR: [i32; Y] = [99; 1];
+ | ^ referenced constant has errors
+
error[E0308]: mismatched types
- --> $DIR/const-integer-bool-ops.rs:52:19
+ --> $DIR/const-integer-bool-ops.rs:57:19
|
LL | const Y1: usize = 42.0 >= 42.0;
| ^^^^^^^^^^^^ expected usize, found bool
+error[E0080]: evaluation of constant value failed
+ --> $DIR/const-integer-bool-ops.rs:60:20
+ |
+LL | const ARRR1: [i32; Y1] = [99; 1];
+ | ^^ referenced constant has errors
+
error[E0308]: mismatched types
- --> $DIR/const-integer-bool-ops.rs:57:19
+ --> $DIR/const-integer-bool-ops.rs:63:19
|
LL | const Y2: usize = 42.0 <= 42.0;
| ^^^^^^^^^^^^ expected usize, found bool
+error[E0080]: evaluation of constant value failed
+ --> $DIR/const-integer-bool-ops.rs:66:20
+ |
+LL | const ARRR2: [i32; Y2] = [99; 1];
+ | ^^ referenced constant has errors
+
error[E0308]: mismatched types
- --> $DIR/const-integer-bool-ops.rs:62:19
+ --> $DIR/const-integer-bool-ops.rs:69:19
|
LL | const Y3: usize = 42.0 > 42.0;
| ^^^^^^^^^^^ expected usize, found bool
+error[E0080]: evaluation of constant value failed
+ --> $DIR/const-integer-bool-ops.rs:72:20
+ |
+LL | const ARRR3: [i32; Y3] = [99; 0];
+ | ^^ referenced constant has errors
+
error[E0308]: mismatched types
- --> $DIR/const-integer-bool-ops.rs:67:19
+ --> $DIR/const-integer-bool-ops.rs:75:19
|
LL | const Y4: usize = 42.0 < 42.0;
| ^^^^^^^^^^^ expected usize, found bool
+error[E0080]: evaluation of constant value failed
+ --> $DIR/const-integer-bool-ops.rs:78:20
+ |
+LL | const ARRR4: [i32; Y4] = [99; 0];
+ | ^^ referenced constant has errors
+
error[E0308]: mismatched types
- --> $DIR/const-integer-bool-ops.rs:72:19
+ --> $DIR/const-integer-bool-ops.rs:81:19
|
LL | const Y5: usize = 42.0 != 42.0;
| ^^^^^^^^^^^^ expected usize, found bool
-error: aborting due to 18 previous errors
+error[E0080]: evaluation of constant value failed
+ --> $DIR/const-integer-bool-ops.rs:84:20
+ |
+LL | const ARRR5: [i32; Y5] = [99; 0];
+ | ^^ referenced constant has errors
+
+error: aborting due to 28 previous errors
-For more information about this error, try `rustc --explain E0308`.
+Some errors occurred: E0080, E0308.
+For more information about an error, try `rustc --explain E0080`.
const ONE: usize = 1;
const TWO: usize = 2;
const LEN: usize = ONE - TWO;
+//~^ ERROR any use of this value will cause an error
fn main() {
let a: [i8; LEN] = unimplemented!();
//~^ ERROR E0080
-//~| ERROR E0080
-//~| ERROR E0080
-//~| ERROR E0080
}
-error[E0080]: referenced constant has errors
- --> $DIR/const-len-underflow-separate-spans.rs:20:17
+error: any use of this value will cause an error
+ --> $DIR/const-len-underflow-separate-spans.rs:17:1
|
LL | const LEN: usize = ONE - TWO;
- | --------- attempt to subtract with overflow
-...
-LL | let a: [i8; LEN] = unimplemented!();
- | ^^^
-
-error[E0080]: could not evaluate constant
- --> $DIR/const-len-underflow-separate-spans.rs:20:17
+ | ^^^^^^^^^^^^^^^^^^^---------^
+ | |
+ | attempt to subtract with overflow
|
-LL | let a: [i8; LEN] = unimplemented!();
- | ^^^ referenced constant has errors
+ = note: #[deny(const_err)] on by default
-error[E0080]: referenced constant has errors
- --> $DIR/const-len-underflow-separate-spans.rs:20:12
+error[E0080]: evaluation of constant value failed
+ --> $DIR/const-len-underflow-separate-spans.rs:21:17
|
-LL | const LEN: usize = ONE - TWO;
- | --------- attempt to subtract with overflow
-...
LL | let a: [i8; LEN] = unimplemented!();
- | ^^^^^^^^^
-
-error[E0080]: could not evaluate constant expression
- --> $DIR/const-len-underflow-separate-spans.rs:20:12
- |
-LL | let a: [i8; LEN] = unimplemented!();
- | ^^^^^---^
- | |
- | referenced constant has errors
+ | ^^^ referenced constant has errors
-error: aborting due to 4 previous errors
+error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0080`.
fn main() {
let a: [i8; ONE - TWO] = unimplemented!();
- //~^ ERROR could not evaluate constant expression
+ //~^ ERROR evaluation of constant value failed
//~| attempt to subtract with overflow
}
-error: attempt to subtract with overflow
+error[E0080]: evaluation of constant value failed
--> $DIR/const-len-underflow-subspans.rs:18:17
|
LL | let a: [i8; ONE - TWO] = unimplemented!();
- | ^^^^^^^^^
- |
- = note: #[deny(const_err)] on by default
-
-error[E0080]: could not evaluate constant expression
- --> $DIR/const-len-underflow-subspans.rs:18:12
- |
-LL | let a: [i8; ONE - TWO] = unimplemented!();
- | ^^^^^---------^
- | |
- | attempt to subtract with overflow
+ | ^^^^^^^^^ attempt to subtract with overflow
-error: aborting due to 2 previous errors
+error: aborting due to previous error
For more information about this error, try `rustc --explain E0080`.
error[E0391]: cycle detected when computing layout of `Foo`
|
note: ...which requires normalizing `ParamEnvAnd { param_env: ParamEnv { caller_bounds: [], reveal: All }, value: [u8; _] }`...
+note: ...which requires const-evaluating + checking `Foo::bytes::{{constant}}`...
+ --> $DIR/const-size_of-cycle.rs:16:17
+ |
+LL | bytes: [u8; std::mem::size_of::<Foo>()]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
note: ...which requires const-evaluating `Foo::bytes::{{constant}}`...
--> $SRC_DIR/libcore/mem.rs:LL:COL
|
const FOO: &'static[u32] = &[1, 2, 3];
const BAR: u32 = FOO[5];
//~^ index out of bounds: the len is 3 but the index is 5
-//~| ERROR this constant cannot be used
+//~| ERROR any use of this value will cause an error
+//~| ERROR any use of this value will cause an error
fn main() {
let _ = BAR;
+ //~^ ERROR erroneous constant used
}
-error: this constant cannot be used
+error: any use of this value will cause an error
--> $DIR/const-slice-oob.rs:14:1
|
LL | const BAR: u32 = FOO[5];
|
= note: #[deny(const_err)] on by default
-error: aborting due to previous error
+error: any use of this value will cause an error
+ --> $DIR/const-slice-oob.rs:14:1
+ |
+LL | const BAR: u32 = FOO[5];
+ | ^^^^^^^^^^^^^^^^^------^
+ | |
+ | index out of bounds: the len is 3 but the index is 5
+
+error[E0080]: erroneous constant used
+ --> $DIR/const-slice-oob.rs:20:13
+ |
+LL | let _ = BAR;
+ | ^^^ referenced constant has errors
+
+error: aborting due to 3 previous errors
+For more information about this error, try `rustc --explain E0080`.
//~^ ERROR mismatched types
//~| expected tuple, found usize
const ARR: [i32; TUP.0] = [];
+//~^ ERROR evaluation of constant value failed
fn main() {
}
= note: expected type `(usize,)`
found type `usize`
-error: aborting due to previous error
+error[E0080]: evaluation of constant value failed
+ --> $DIR/const-tup-index-span.rs:16:18
+ |
+LL | const ARR: [i32; TUP.0] = [];
+ | ^^^ referenced constant has errors
+
+error: aborting due to 2 previous errors
-For more information about this error, try `rustc --explain E0308`.
+Some errors occurred: E0080, E0308.
+For more information about an error, try `rustc --explain E0080`.
X = (1 << 500), //~ ERROR E0080
//~| shift left with overflow
Y = (1 / 0) //~ ERROR E0080
- //~| const_err
- //~| const_err
- //~| const_err
}
fn main() {
-error: attempt to shift left with overflow
- --> $DIR/E0080.rs:12:9
- |
-LL | X = (1 << 500), //~ ERROR E0080
- | ^^^^^^^^^^
- |
- = note: #[deny(exceeding_bitshifts)] on by default
-
-error[E0080]: could not evaluate enum discriminant
+error[E0080]: evaluation of constant value failed
--> $DIR/E0080.rs:12:9
|
LL | X = (1 << 500), //~ ERROR E0080
| ^^^^^^^^^^ attempt to shift left with overflow
-error: attempt to divide by zero
- --> $DIR/E0080.rs:14:9
- |
-LL | Y = (1 / 0) //~ ERROR E0080
- | ^^^^^^^
- |
- = note: #[deny(const_err)] on by default
-
-error: this expression will panic at runtime
- --> $DIR/E0080.rs:14:9
- |
-LL | Y = (1 / 0) //~ ERROR E0080
- | ^^^^^^^ attempt to divide by zero
-
-error[E0080]: could not evaluate enum discriminant
+error[E0080]: evaluation of constant value failed
--> $DIR/E0080.rs:14:9
|
LL | Y = (1 / 0) //~ ERROR E0080
| ^^^^^^^ attempt to divide by zero
-error: aborting due to 5 previous errors
+error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0080`.
const REG_ADDR: *const u8 = 0x5f3759df as *const u8;
const VALUE: u8 = unsafe { *REG_ADDR };
-//~^ ERROR this constant cannot be used
+//~^ ERROR any use of this value will cause an error
fn main() {
}
-error: this constant cannot be used
+error: any use of this value will cause an error
--> $DIR/E0396-fixed.rs:15:1
|
LL | const VALUE: u8 = unsafe { *REG_ADDR };
enum Test {
DivZero = 1/0,
//~^ attempt to divide by zero
- //~| ERROR could not evaluate enum discriminant
- //~| ERROR this expression will panic at runtime
+ //~| ERROR evaluation of constant value failed
RemZero = 1%0,
//~^ attempt to calculate the remainder with a divisor of zero
- //~| ERROR could not evaluate enum discriminant
- //~| ERROR this expression will panic at runtime
+ //~| ERROR evaluation of constant value failed
}
fn main() {}
-error: attempt to divide by zero
- --> $DIR/eval-enum.rs:12:15
- |
-LL | DivZero = 1/0,
- | ^^^
- |
- = note: #[deny(const_err)] on by default
-
-error: this expression will panic at runtime
+error[E0080]: evaluation of constant value failed
--> $DIR/eval-enum.rs:12:15
|
LL | DivZero = 1/0,
| ^^^ attempt to divide by zero
-error[E0080]: could not evaluate enum discriminant
- --> $DIR/eval-enum.rs:12:15
- |
-LL | DivZero = 1/0,
- | ^^^ attempt to divide by zero
-
-error: attempt to calculate the remainder with a divisor of zero
- --> $DIR/eval-enum.rs:16:15
- |
-LL | RemZero = 1%0,
- | ^^^
-
-error: this expression will panic at runtime
- --> $DIR/eval-enum.rs:16:15
- |
-LL | RemZero = 1%0,
- | ^^^ attempt to calculate the remainder with a divisor of zero
-
-error[E0080]: could not evaluate enum discriminant
- --> $DIR/eval-enum.rs:16:15
+error[E0080]: evaluation of constant value failed
+ --> $DIR/eval-enum.rs:15:15
|
LL | RemZero = 1%0,
| ^^^ attempt to calculate the remainder with a divisor of zero
-error: aborting due to 6 previous errors
+error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0080`.
//https://github.com/rust-lang/rust/issues/31364
-const fn a() -> usize { b() }
+const fn a() -> usize { b() } //~ ERROR evaluation of constant value failed
const fn b() -> usize { a() }
-const ARR: [i32; a()] = [5; 6]; //~ ERROR could not evaluate constant expression
+const ARR: [i32; a()] = [5; 6];
fn main(){}
-error[E0080]: could not evaluate constant expression
- --> $DIR/infinite-recursion-const-fn.rs:15:12
+error[E0080]: evaluation of constant value failed
+ --> $DIR/infinite-recursion-const-fn.rs:14:25
|
-LL | const fn a() -> usize { b() }
- | ---
+LL | const fn a() -> usize { b() } //~ ERROR evaluation of constant value failed
+ | ^^^
| |
| reached the configured maximum number of stack frames
| inside call to `b`
| inside call to `a`
| inside call to `a`
| inside call to `a`
-LL | const ARR: [i32; a()] = [5; 6]; //~ ERROR could not evaluate constant expression
- | ^^^^^^---^
- | |
- | inside call to `a`
+LL | const ARR: [i32; a()] = [5; 6];
+ | --- inside call to `a`
error: aborting due to previous error
LL | let array: [usize; Dim3::dim()]
| ^^^^^^^^^^^
+error[E0080]: evaluation of constant value failed
+ --> $DIR/issue-39559-2.rs:24:24
+ |
+LL | let array: [usize; Dim3::dim()]
+ | ^^^^^^^^^^^ calling non-const fn `<Dim3 as Dim>::dim`
+
error[E0015]: calls in constants are limited to constant functions, tuple structs and tuple variants
--> $DIR/issue-39559-2.rs:26:15
|
LL | = [0; Dim3::dim()];
| ^^^^^^^^^^^
-error: aborting due to 2 previous errors
+error[E0080]: evaluation of constant value failed
+ --> $DIR/issue-39559-2.rs:27:15
+ |
+LL | = [0; Dim3::dim()];
+ | ^^^^^^^^^^^ calling non-const fn `<Dim3 as Dim>::dim`
+
+error: aborting due to 4 previous errors
For more information about this error, try `rustc --explain E0015`.
enum Bar {
A = Foo::A as isize
+ //~^ ERROR evaluation of constant value failed
}
fn main() {}
|
= note: an implementation of `std::ops::Add` might be missing for `&str`
-error: aborting due to previous error
+error[E0080]: evaluation of constant value failed
+ --> $DIR/issue-41394.rs:17:9
+ |
+LL | A = Foo::A as isize
+ | ^^^^^^^^^^^^^^^ referenced constant has errors
+
+error: aborting due to 2 previous errors
-For more information about this error, try `rustc --explain E0369`.
+Some errors occurred: E0080, E0369.
+For more information about an error, try `rustc --explain E0080`.
const NUM: u8 = xyz();
//~^ ERROR calls in constants are limited to constant functions, tuple structs and tuple variants
+//~| ERROR any use of this value will cause an error
fn main() {
match 1 {
- NUM => unimplemented!(),
+ NUM => unimplemented!(), //~ ERROR could not evaluate constant pattern
_ => unimplemented!(),
}
}
LL | const NUM: u8 = xyz();
| ^^^^^
-error: aborting due to previous error
+error: any use of this value will cause an error
+ --> $DIR/issue-43105.rs:13:1
+ |
+LL | const NUM: u8 = xyz();
+ | ^^^^^^^^^^^^^^^^-----^
+ | |
+ | calling non-const fn `xyz`
+ |
+ = note: #[deny(const_err)] on by default
+
+error: could not evaluate constant pattern
+ --> $DIR/issue-43105.rs:19:9
+ |
+LL | NUM => unimplemented!(), //~ ERROR could not evaluate constant pattern
+ | ^^^
+
+error: aborting due to 3 previous errors
For more information about this error, try `rustc --explain E0015`.
error[E0391]: cycle detected when computing layout of `Foo`
|
note: ...which requires normalizing `ParamEnvAnd { param_env: ParamEnv { caller_bounds: [], reveal: All }, value: [u8; _] }`...
+note: ...which requires const-evaluating + checking `Foo::bytes::{{constant}}`...
+ --> $DIR/issue-44415.rs:19:17
+ |
+LL | bytes: [u8; unsafe { intrinsics::size_of::<Foo>() }],
+ | ^^^^^^
note: ...which requires const-evaluating `Foo::bytes::{{constant}}`...
--> $DIR/issue-44415.rs:19:26
|
const N: u32 = 1_000;
const M: usize = (f64::from(N) * std::f64::LOG10_2) as usize; //~ ERROR cannot find value
let mut digits = [0u32; M];
+ //~^ ERROR evaluation of constant value failed
}
LL | use std::f64::consts::LOG10_2;
|
-error: aborting due to previous error
+error[E0080]: evaluation of constant value failed
+ --> $DIR/issue-50599.rs:14:29
+ |
+LL | let mut digits = [0u32; M];
+ | ^ referenced constant has errors
+
+error: aborting due to 2 previous errors
-For more information about this error, try `rustc --explain E0425`.
+Some errors occurred: E0080, E0425.
+For more information about an error, try `rustc --explain E0080`.
| ^^^
|
= note: ...which again requires const-evaluating `FOO`, completing the cycle
+note: cycle used when const-evaluating + checking `FOO`
+ --> $DIR/recursive-static-definition.rs:11:1
+ |
+LL | pub static FOO: u32 = FOO;
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to previous error
let v = vec![0];
const l: usize = v.count(); //~ ERROR can't capture dynamic environment in a fn item
let s: [u32; l] = v.into_iter().collect();
+ //~^ ERROR evaluation of constant value failed
}
|
= help: use the `|| { ... }` closure form instead
-error: aborting due to previous error
+error[E0080]: evaluation of constant value failed
+ --> $DIR/type-dependent-def-issue-49241.rs:14:18
+ |
+LL | let s: [u32; l] = v.into_iter().collect();
+ | ^ referenced constant has errors
+
+error: aborting due to 2 previous errors
-For more information about this error, try `rustc --explain E0434`.
+Some errors occurred: E0080, E0434.
+For more information about an error, try `rustc --explain E0080`.
projects / rust.git / commitdiff