span_err!(cx.tcx.sess, ex.span, E0002,
"non-exhaustive patterns: type {} is non-empty",
pat_ty);
+ span_help!(cx.tcx.sess, ex.span,
+ "Please ensure that all possible cases are being handled; \
+ possibly adding wildcards or more match arms.");
}
// If the type *is* empty, it's vacuously exhaustive
return;
let pat_ty = cx.tcx.pat_ty(p);
if let ty::TyEnum(edef, _) = pat_ty.sty {
let def = cx.tcx.def_map.borrow().get(&p.id).map(|d| d.full_def());
- if let Some(DefLocal(_)) = def {
+ if let Some(DefLocal(..)) = def {
if edef.variants.iter().any(|variant|
variant.name == ident.node.name
&& variant.kind() == VariantKind::Unit
Err(err) => {
let subspan = p.span.lo <= err.span.lo && err.span.hi <= p.span.hi;
- cx.tcx.sess.span_err(err.span,
- &format!("constant evaluation error: {}",
- err.description()));
+ span_err!(cx.tcx.sess, err.span, E0471,
+ "constant evaluation error: {}",
+ err.description());
if !subspan {
cx.tcx.sess.span_note(p.span,
"in pattern here")
fn const_val_to_expr(value: &ConstVal) -> P<hir::Expr> {
let node = match value {
- &ConstVal::Bool(b) => hir::LitBool(b),
+ &ConstVal::Bool(b) => ast::LitBool(b),
_ => unreachable!()
};
P(hir::Expr {
.map(|(field, pat)| Spanned {
span: DUMMY_SP,
node: hir::FieldPat {
- ident: ast::Ident::new(field.name),
+ name: field.name,
pat: pat,
is_shorthand: false,
}
let def_variant = adt.variant_of_def(def);
if variant.did == def_variant.did {
Some(variant.fields.iter().map(|sf| {
- match pattern_fields.iter().find(|f| f.node.ident.name == sf.name) {
+ match pattern_fields.iter().find(|f| f.node.name == sf.name) {
Some(ref f) => &*f.node.pat,
_ => DUMMY_WILD_PAT
}