#[derive(Clone, Debug)]
pub enum PatternError {
+ AssociatedConstInPattern(Span),
StaticInPattern(Span),
FloatBug,
NonConstPath(Span),
BindingMode::ByValue => mutability == Mutability::Mut,
BindingMode::ByRef(_, bk) => {
write!(f, "ref ")?;
- bk == BorrowKind::Mut
+ match bk { BorrowKind::Mut { .. } => true, _ => false }
}
};
if is_mut {
(Mutability::Not, BindingMode::ByValue),
ty::BindByReference(hir::MutMutable) =>
(Mutability::Not, BindingMode::ByRef(
- region.unwrap(), BorrowKind::Mut)),
+ region.unwrap(), BorrowKind::Mut { allow_two_phase_borrow: false })),
ty::BindByReference(hir::MutImmutable) =>
(Mutability::Not, BindingMode::ByRef(
region.unwrap(), BorrowKind::Shared)),
-> Pattern<'tcx> {
let ty = self.tables.node_id_to_type(id);
let def = self.tables.qpath_def(qpath, id);
+ let is_associated_const = match def {
+ Def::AssociatedConst(_) => true,
+ _ => false,
+ };
let kind = match def {
Def::Const(def_id) | Def::AssociatedConst(def_id) => {
let substs = self.tables.node_substs(id);
}
},
None => {
- self.errors.push(PatternError::StaticInPattern(span));
+ self.errors.push(if is_associated_const {
+ PatternError::AssociatedConstInPattern(span)
+ } else {
+ PatternError::StaticInPattern(span)
+ });
PatternKind::Wild
},
}
let field = Field::new(i);
let val = match cv.val {
ConstVal::Value(miri) => const_val_field(
- self.tcx, self.param_env, instance,
+ self.tcx, self.param_env, instance, span,
Some(variant_index), field, miri, cv.ty,
).unwrap(),
_ => bug!("{:#?} is not a valid tuple", cv),
let field = Field::new(i);
let val = match cv.val {
ConstVal::Value(miri) => const_val_field(
- self.tcx, self.param_env, instance, None, field, miri, cv.ty,
+ self.tcx, self.param_env, instance, span,
+ None, field, miri, cv.ty,
).unwrap(),
_ => bug!("{:#?} is not a valid tuple", cv),
};
let field = Field::new(i);
let val = match cv.val {
ConstVal::Value(miri) => const_val_field(
- self.tcx, self.param_env, instance, None, field, miri, cv.ty,
+ self.tcx, self.param_env, instance, span,
+ None, field, miri, cv.ty,
).unwrap(),
_ => bug!("{:#?} is not a valid tuple", cv),
};
let field = Field::new(i);
let val = match cv.val {
ConstVal::Value(miri) => const_val_field(
- self.tcx, self.param_env, instance, None, field, miri, cv.ty,
+ self.tcx, self.param_env, instance, span,
+ None, field, miri, cv.ty,
).unwrap(),
_ => bug!("{:#?} is not a valid tuple", cv),
};
tcx: TyCtxt<'a, 'tcx, 'tcx>,
param_env: ty::ParamEnv<'tcx>,
instance: ty::Instance<'tcx>,
+ span: Span,
variant: Option<usize>,
field: mir::Field,
val: Value,
ty,
})),
Err(err) => Err(ConstEvalErr {
- span: tcx.def_span(instance.def_id()),
+ span,
kind: err.into(),
}),
}
trace!("const eval: {:?}", key);
let cid = key.value;
let def_id = cid.instance.def.def_id();
- let span = tcx.def_span(def_id);
if tcx.is_foreign_item(def_id) {
let id = tcx.interpret_interner.get_cached(def_id);
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() {
if tcx.is_static(def_id).is_some() {
ecx.report(&mut err, true, None);
}
+ let span = ecx.frame().span;
ConstEvalErr {
kind: err.into(),
span,