// Copyright 2012-2014 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 or the MIT license // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. use middle::const_eval::{compare_const_vals, const_bool, const_float, const_nil, const_val}; use middle::const_eval::{eval_const_expr, lookup_const_by_id}; use middle::def::*; use middle::pat_util::*; use middle::ty::*; use middle::ty; use std::fmt; use std::gc::{Gc, GC}; use std::iter::AdditiveIterator; use std::iter::range_inclusive; use syntax::ast::*; use syntax::ast_util::{is_unguarded, walk_pat}; use syntax::codemap::{Span, Spanned, DUMMY_SP}; use syntax::owned_slice::OwnedSlice; use syntax::print::pprust::pat_to_string; use syntax::visit; use syntax::visit::{Visitor, FnKind}; use util::ppaux::ty_to_string; struct Matrix(Vec>>); /// Pretty-printer for matrices of patterns, example: /// ++++++++++++++++++++++++++ /// + _ + [] + /// ++++++++++++++++++++++++++ /// + true + [First] + /// ++++++++++++++++++++++++++ /// + true + [Second(true)] + /// ++++++++++++++++++++++++++ /// + false + [_] + /// ++++++++++++++++++++++++++ /// + _ + [_, _, ..tail] + /// ++++++++++++++++++++++++++ impl fmt::Show for Matrix { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { try!(write!(f, "\n")); let &Matrix(ref m) = self; let pretty_printed_matrix: Vec> = m.iter().map(|row| { row.iter().map(|&pat| pat_to_string(pat)).collect::>() }).collect(); let column_count = m.iter().map(|row| row.len()).max().unwrap_or(0u); assert!(m.iter().all(|row| row.len() == column_count)); let column_widths: Vec = range(0, column_count).map(|col| { pretty_printed_matrix.iter().map(|row| row.get(col).len()).max().unwrap_or(0u) }).collect(); let total_width = column_widths.iter().map(|n| *n).sum() + column_count * 3 + 1; let br = String::from_char(total_width, '+'); try!(write!(f, "{}\n", br)); for row in pretty_printed_matrix.move_iter() { try!(write!(f, "+")); for (column, pat_str) in row.move_iter().enumerate() { try!(write!(f, " ")); f.width = Some(*column_widths.get(column)); try!(f.pad(pat_str.as_slice())); try!(write!(f, " +")); } try!(write!(f, "\n")); try!(write!(f, "{}\n", br)); } Ok(()) } } pub struct MatchCheckCtxt<'a> { pub tcx: &'a ty::ctxt } #[deriving(Clone, PartialEq)] pub enum Constructor { /// The constructor of all patterns that don't vary by constructor, /// e.g. struct patterns and fixed-length arrays. Single, /// Enum variants. Variant(DefId), /// Literal values. ConstantValue(const_val), /// Ranges of literal values (2..5). ConstantRange(const_val, const_val), /// Array patterns of length n. Slice(uint) } #[deriving(Clone, PartialEq)] enum Usefulness { Useful, UsefulWithWitness(Vec>), NotUseful } enum WitnessPreference { ConstructWitness, LeaveOutWitness } impl<'a> Visitor<()> for MatchCheckCtxt<'a> { fn visit_expr(&mut self, ex: &Expr, _: ()) { check_expr(self, ex); } fn visit_local(&mut self, l: &Local, _: ()) { check_local(self, l); } fn visit_fn(&mut self, fk: &FnKind, fd: &FnDecl, b: &Block, s: Span, _: NodeId, _: ()) { check_fn(self, fk, fd, b, s); } } pub fn check_crate(tcx: &ty::ctxt, krate: &Crate) { let mut cx = MatchCheckCtxt { tcx: tcx, }; visit::walk_crate(&mut cx, krate, ()); tcx.sess.abort_if_errors(); } fn check_expr(cx: &mut MatchCheckCtxt, ex: &Expr) { visit::walk_expr(cx, ex, ()); match ex.node { ExprMatch(scrut, ref arms) => { // First, check legality of move bindings. for arm in arms.iter() { check_legality_of_move_bindings(cx, arm.guard.is_some(), arm.pats.as_slice()); } // Second, check for unreachable arms. check_arms(cx, arms.as_slice()); // Finally, check if the whole match expression is exhaustive. // Check for empty enum, because is_useful only works on inhabited types. let pat_ty = node_id_to_type(cx.tcx, scrut.id); if (*arms).is_empty() { if !type_is_empty(cx.tcx, pat_ty) { // We know the type is inhabited, so this must be wrong cx.tcx.sess.span_err(ex.span, format!("non-exhaustive patterns: \ type {} is non-empty", ty_to_string(cx.tcx, pat_ty)).as_slice()); } // If the type *is* empty, it's vacuously exhaustive return; } let m: Matrix = Matrix(arms .iter() .filter(|&arm| is_unguarded(arm)) .flat_map(|arm| arm.pats.iter()) .map(|pat| vec!(pat.clone())) .collect()); check_exhaustive(cx, ex.span, &m); }, _ => () } } // Check for unreachable patterns fn check_arms(cx: &MatchCheckCtxt, arms: &[Arm]) { let mut seen = Matrix(vec!()); for arm in arms.iter() { for pat in arm.pats.iter() { // Check that we do not match against a static NaN (#6804) let pat_matches_nan: |&Pat| -> bool = |p| { let opt_def = cx.tcx.def_map.borrow().find_copy(&p.id); match opt_def { Some(DefStatic(did, false)) => { let const_expr = lookup_const_by_id(cx.tcx, did).unwrap(); match eval_const_expr(cx.tcx, &*const_expr) { const_float(f) if f.is_nan() => true, _ => false } } _ => false } }; walk_pat(&**pat, |p| { if pat_matches_nan(p) { cx.tcx.sess.span_warn(p.span, "unmatchable NaN in pattern, \ use the is_nan method in a guard instead"); } true }); let v = vec!(*pat); match is_useful(cx, &seen, v.as_slice(), LeaveOutWitness) { NotUseful => span_err!(cx.tcx.sess, pat.span, E0001, "unreachable pattern"), Useful => (), UsefulWithWitness(_) => unreachable!() } if arm.guard.is_none() { let Matrix(mut rows) = seen; rows.push(v); seen = Matrix(rows); } } } } fn raw_pat(p: Gc) -> Gc { match p.node { PatIdent(_, _, Some(s)) => { raw_pat(s) } _ => { p } } } fn check_exhaustive(cx: &MatchCheckCtxt, sp: Span, m: &Matrix) { match is_useful(cx, m, [wild()], ConstructWitness) { UsefulWithWitness(pats) => { let witness = match pats.as_slice() { [witness] => witness, [] => wild(), _ => unreachable!() }; let msg = format!("non-exhaustive patterns: `{0}` not covered", pat_to_string(&*witness)); cx.tcx.sess.span_err(sp, msg.as_slice()); } NotUseful => { // This is good, wildcard pattern isn't reachable }, _ => unreachable!() } } fn const_val_to_expr(value: &const_val) -> Gc { let node = match value { &const_bool(b) => LitBool(b), &const_nil => LitNil, _ => unreachable!() }; box (GC) Expr { id: 0, node: ExprLit(box(GC) Spanned { node: node, span: DUMMY_SP }), span: DUMMY_SP } } fn def_to_path(tcx: &ty::ctxt, id: DefId) -> Path { ty::with_path(tcx, id, |mut path| Path { global: false, segments: path.last().map(|elem| PathSegment { identifier: Ident::new(elem.name()), lifetimes: vec!(), types: OwnedSlice::empty() }).move_iter().collect(), span: DUMMY_SP, }) } /// Constructs a partial witness for a pattern given a list of /// patterns expanded by the specialization step. /// /// When a pattern P is discovered to be useful, this function is used bottom-up /// to reconstruct a complete witness, e.g. a pattern P' that covers a subset /// of values, V, where each value in that set is not covered by any previously /// used patterns and is covered by the pattern P'. Examples: /// /// left_ty: tuple of 3 elements /// pats: [10, 20, _] => (10, 20, _) /// /// left_ty: struct X { a: (bool, &'static str), b: uint} /// pats: [(false, "foo"), 42] => X { a: (false, "foo"), b: 42 } fn construct_witness(cx: &MatchCheckCtxt, ctor: &Constructor, pats: Vec>, left_ty: ty::t) -> Gc { let pat = match ty::get(left_ty).sty { ty::ty_tup(_) => PatTup(pats), ty::ty_enum(cid, _) | ty::ty_struct(cid, _) => { let (vid, is_structure) = match ctor { &Variant(vid) => (vid, ty::enum_variant_with_id(cx.tcx, cid, vid).arg_names.is_some()), _ => (cid, true) }; if is_structure { let fields = ty::lookup_struct_fields(cx.tcx, vid); let field_pats: Vec = fields.move_iter() .zip(pats.iter()) .filter(|&(_, pat)| pat.node != PatWild) .map(|(field, pat)| FieldPat { ident: Ident::new(field.name), pat: pat.clone() }).collect(); let has_more_fields = field_pats.len() < pats.len(); PatStruct(def_to_path(cx.tcx, vid), field_pats, has_more_fields) } else { PatEnum(def_to_path(cx.tcx, vid), Some(pats)) } } ty::ty_rptr(_, ty::mt { ty: ty, .. }) => { match ty::get(ty).sty { ty::ty_vec(_, Some(n)) => match ctor { &Single => { assert_eq!(pats.len(), n); PatVec(pats, None, vec!()) }, _ => unreachable!() }, ty::ty_vec(_, None) => match ctor { &Slice(n) => { assert_eq!(pats.len(), n); PatVec(pats, None, vec!()) }, _ => unreachable!() }, ty::ty_str => PatWild, _ => { assert_eq!(pats.len(), 1); PatRegion(pats.get(0).clone()) } } } ty::ty_box(_) => { assert_eq!(pats.len(), 1); PatBox(pats.get(0).clone()) } ty::ty_vec(_, Some(len)) => { assert_eq!(pats.len(), len); PatVec(pats, None, vec!()) } _ => { match *ctor { ConstantValue(ref v) => PatLit(const_val_to_expr(v)), _ => PatWild } } }; box (GC) Pat { id: 0, node: pat, span: DUMMY_SP } } fn missing_constructor(cx: &MatchCheckCtxt, &Matrix(ref rows): &Matrix, left_ty: ty::t, max_slice_length: uint) -> Option { let used_constructors: Vec = rows.iter() .flat_map(|row| pat_constructors(cx, *row.get(0), left_ty, max_slice_length).move_iter()) .collect(); all_constructors(cx, left_ty, max_slice_length) .move_iter() .find(|c| !used_constructors.contains(c)) } /// This determines the set of all possible constructors of a pattern matching /// values of type `left_ty`. For vectors, this would normally be an infinite set /// but is instead bounded by the maximum fixed length of slice patterns in /// the column of patterns being analyzed. fn all_constructors(cx: &MatchCheckCtxt, left_ty: ty::t, max_slice_length: uint) -> Vec { match ty::get(left_ty).sty { ty::ty_bool => [true, false].iter().map(|b| ConstantValue(const_bool(*b))).collect(), ty::ty_nil => vec!(ConstantValue(const_nil)), ty::ty_rptr(_, ty::mt { ty: ty, .. }) => match ty::get(ty).sty { ty::ty_vec(_, None) => range_inclusive(0, max_slice_length).map(|length| Slice(length)).collect(), _ => vec!(Single) }, ty::ty_enum(eid, _) => ty::enum_variants(cx.tcx, eid) .iter() .map(|va| Variant(va.id)) .collect(), _ => vec!(Single) } } // Algorithm from http://moscova.inria.fr/~maranget/papers/warn/index.html // // Whether a vector `v` of patterns is 'useful' in relation to a set of such // vectors `m` is defined as there being a set of inputs that will match `v` // but not any of the sets in `m`. // // This is used both for reachability checking (if a pattern isn't useful in // relation to preceding patterns, it is not reachable) and exhaustiveness // checking (if a wildcard pattern is useful in relation to a matrix, the // matrix isn't exhaustive). // Note: is_useful doesn't work on empty types, as the paper notes. // So it assumes that v is non-empty. fn is_useful(cx: &MatchCheckCtxt, matrix @ &Matrix(ref rows): &Matrix, v: &[Gc], witness: WitnessPreference) -> Usefulness { debug!("{:}", matrix); if rows.len() == 0u { return match witness { ConstructWitness => UsefulWithWitness(vec!()), LeaveOutWitness => Useful }; } if rows.get(0).len() == 0u { return NotUseful; } let real_pat = match rows.iter().find(|r| r.get(0).id != 0) { Some(r) => raw_pat(*r.get(0)), None if v.len() == 0 => return NotUseful, None => v[0] }; let left_ty = if real_pat.id == 0 { ty::mk_nil() } else { ty::pat_ty(cx.tcx, &*real_pat) }; let max_slice_length = rows.iter().filter_map(|row| match row.get(0).node { PatVec(ref before, _, ref after) => Some(before.len() + after.len()), _ => None }).max().map_or(0, |v| v + 1); let constructors = pat_constructors(cx, v[0], left_ty, max_slice_length); if constructors.is_empty() { match missing_constructor(cx, matrix, left_ty, max_slice_length) { None => { all_constructors(cx, left_ty, max_slice_length).move_iter().map(|c| { match is_useful_specialized(cx, matrix, v, c.clone(), left_ty, witness) { UsefulWithWitness(pats) => UsefulWithWitness({ let arity = constructor_arity(cx, &c, left_ty); let subpats = { let pat_slice = pats.as_slice(); Vec::from_fn(arity, |i| { pat_slice.get(i).map(|p| p.clone()) .unwrap_or_else(|| wild()) }) }; let mut result = vec!(construct_witness(cx, &c, subpats, left_ty)); result.extend(pats.move_iter().skip(arity)); result }), result => result } }).find(|result| result != &NotUseful).unwrap_or(NotUseful) }, Some(constructor) => { let matrix = Matrix(rows.iter().filter_map(|r| default(cx, r.as_slice())).collect()); match is_useful(cx, &matrix, v.tail(), witness) { UsefulWithWitness(pats) => { let arity = constructor_arity(cx, &constructor, left_ty); let wild_pats = Vec::from_elem(arity, wild()); let enum_pat = construct_witness(cx, &constructor, wild_pats, left_ty); UsefulWithWitness(vec!(enum_pat).append(pats.as_slice())) }, result => result } } } } else { constructors.move_iter().map(|c| is_useful_specialized(cx, matrix, v, c.clone(), left_ty, witness) ).find(|result| result != &NotUseful).unwrap_or(NotUseful) } } fn is_useful_specialized(cx: &MatchCheckCtxt, &Matrix(ref m): &Matrix, v: &[Gc], ctor: Constructor, lty: ty::t, witness: WitnessPreference) -> Usefulness { let arity = constructor_arity(cx, &ctor, lty); let matrix = Matrix(m.iter().filter_map(|r| { specialize(cx, r.as_slice(), &ctor, 0u, arity) }).collect()); match specialize(cx, v, &ctor, 0u, arity) { Some(v) => is_useful(cx, &matrix, v.as_slice(), witness), None => NotUseful } } /// Determines the constructors that the given pattern can be specialized to. /// /// In most cases, there's only one constructor that a specific pattern /// represents, such as a specific enum variant or a specific literal value. /// Slice patterns, however, can match slices of different lengths. For instance, /// `[a, b, ..tail]` can match a slice of length 2, 3, 4 and so on. /// /// On the other hand, a wild pattern and an identifier pattern cannot be /// specialized in any way. fn pat_constructors(cx: &MatchCheckCtxt, p: Gc, left_ty: ty::t, max_slice_length: uint) -> Vec { let pat = raw_pat(p); match pat.node { PatIdent(..) => match cx.tcx.def_map.borrow().find(&pat.id) { Some(&DefStatic(did, false)) => { let const_expr = lookup_const_by_id(cx.tcx, did).unwrap(); vec!(ConstantValue(eval_const_expr(cx.tcx, &*const_expr))) }, Some(&DefStruct(_)) => vec!(Single), Some(&DefVariant(_, id, _)) => vec!(Variant(id)), _ => vec!() }, PatEnum(..) => match cx.tcx.def_map.borrow().find(&pat.id) { Some(&DefStatic(did, false)) => { let const_expr = lookup_const_by_id(cx.tcx, did).unwrap(); vec!(ConstantValue(eval_const_expr(cx.tcx, &*const_expr))) }, Some(&DefVariant(_, id, _)) => vec!(Variant(id)), _ => vec!(Single) }, PatStruct(..) => match cx.tcx.def_map.borrow().find(&pat.id) { Some(&DefVariant(_, id, _)) => vec!(Variant(id)), _ => vec!(Single) }, PatLit(expr) => vec!(ConstantValue(eval_const_expr(cx.tcx, &*expr))), PatRange(lo, hi) => vec!(ConstantRange(eval_const_expr(cx.tcx, &*lo), eval_const_expr(cx.tcx, &*hi))), PatVec(ref before, ref slice, ref after) => match ty::get(left_ty).sty { ty::ty_vec(_, Some(_)) => vec!(Single), _ => if slice.is_some() { range_inclusive(before.len() + after.len(), max_slice_length) .map(|length| Slice(length)) .collect() } else { vec!(Slice(before.len() + after.len())) } }, PatBox(_) | PatTup(_) | PatRegion(..) => vec!(Single), PatWild | PatWildMulti => vec!(), PatMac(_) => cx.tcx.sess.bug("unexpanded macro") } } /// This computes the arity of a constructor. The arity of a constructor /// is how many subpattern patterns of that constructor should be expanded to. /// /// For instance, a tuple pattern (_, 42u, Some([])) has the arity of 3. /// A struct pattern's arity is the number of fields it contains, etc. pub fn constructor_arity(cx: &MatchCheckCtxt, ctor: &Constructor, ty: ty::t) -> uint { match ty::get(ty).sty { ty::ty_tup(ref fs) => fs.len(), ty::ty_box(_) | ty::ty_uniq(_) => 1u, ty::ty_rptr(_, ty::mt { ty: ty, .. }) => match ty::get(ty).sty { ty::ty_vec(_, None) => match *ctor { Slice(length) => length, ConstantValue(_) => 0u, _ => unreachable!() }, ty::ty_str => 0u, _ => 1u }, ty::ty_enum(eid, _) => { match *ctor { Variant(id) => enum_variant_with_id(cx.tcx, eid, id).args.len(), _ => unreachable!() } } ty::ty_struct(cid, _) => ty::lookup_struct_fields(cx.tcx, cid).len(), ty::ty_vec(_, Some(n)) => n, _ => 0u } } fn range_covered_by_constructor(ctor: &Constructor, from: &const_val,to: &const_val) -> Option { let (c_from, c_to) = match *ctor { ConstantValue(ref value) => (value, value), ConstantRange(ref from, ref to) => (from, to), Single => return Some(true), _ => unreachable!() }; let cmp_from = compare_const_vals(c_from, from); let cmp_to = compare_const_vals(c_to, to); match (cmp_from, cmp_to) { (Some(val1), Some(val2)) => Some(val1 >= 0 && val2 <= 0), _ => None } } /// This is the main specialization step. It expands the first pattern in the given row /// into `arity` patterns based on the constructor. For most patterns, the step is trivial, /// for instance tuple patterns are flattened and box patterns expand into their inner pattern. /// /// OTOH, slice patterns with a subslice pattern (..tail) can be expanded into multiple /// different patterns. /// Structure patterns with a partial wild pattern (Foo { a: 42, .. }) have their missing /// fields filled with wild patterns. pub fn specialize(cx: &MatchCheckCtxt, r: &[Gc], constructor: &Constructor, col: uint, arity: uint) -> Option>> { let &Pat { id: pat_id, node: ref node, span: pat_span } = &(*raw_pat(r[col])); let head: Option>> = match node { &PatWild => Some(Vec::from_elem(arity, wild())), &PatWildMulti => Some(Vec::from_elem(arity, wild())), &PatIdent(_, _, _) => { let opt_def = cx.tcx.def_map.borrow().find_copy(&pat_id); match opt_def { Some(DefVariant(_, id, _)) => if *constructor == Variant(id) { Some(vec!()) } else { None }, Some(DefStatic(did, _)) => { let const_expr = lookup_const_by_id(cx.tcx, did).unwrap(); let e_v = eval_const_expr(cx.tcx, &*const_expr); match range_covered_by_constructor(constructor, &e_v, &e_v) { Some(true) => Some(vec!()), Some(false) => None, None => { cx.tcx.sess.span_err(pat_span, "mismatched types between arms"); None } } } _ => { Some(Vec::from_elem(arity, wild())) } } } &PatEnum(_, ref args) => { let def = cx.tcx.def_map.borrow().get_copy(&pat_id); match def { DefStatic(did, _) => { let const_expr = lookup_const_by_id(cx.tcx, did).unwrap(); let e_v = eval_const_expr(cx.tcx, &*const_expr); match range_covered_by_constructor(constructor, &e_v, &e_v) { Some(true) => Some(vec!()), Some(false) => None, None => { cx.tcx.sess.span_err(pat_span, "mismatched types between arms"); None } } } DefVariant(_, id, _) if *constructor != Variant(id) => None, DefVariant(..) | DefFn(..) | DefStruct(..) => { Some(match args { &Some(ref args) => args.clone(), &None => Vec::from_elem(arity, wild()) }) } _ => None } } &PatStruct(_, ref pattern_fields, _) => { // Is this a struct or an enum variant? let def = cx.tcx.def_map.borrow().get_copy(&pat_id); let class_id = match def { DefVariant(_, variant_id, _) => if *constructor == Variant(variant_id) { Some(variant_id) } else { None }, _ => { // Assume this is a struct. match ty::ty_to_def_id(node_id_to_type(cx.tcx, pat_id)) { None => { cx.tcx.sess.span_bug(pat_span, "struct pattern wasn't of a \ type with a def ID?!") } Some(def_id) => Some(def_id), } } }; class_id.map(|variant_id| { let struct_fields = ty::lookup_struct_fields(cx.tcx, variant_id); let args = struct_fields.iter().map(|sf| { match pattern_fields.iter().find(|f| f.ident.name == sf.name) { Some(f) => f.pat, _ => wild() } }).collect(); args }) } &PatTup(ref args) => Some(args.clone()), &PatBox(ref inner) | &PatRegion(ref inner) => Some(vec!(inner.clone())), &PatLit(ref expr) => { let expr_value = eval_const_expr(cx.tcx, &**expr); match range_covered_by_constructor(constructor, &expr_value, &expr_value) { Some(true) => Some(vec!()), Some(false) => None, None => { cx.tcx.sess.span_err(pat_span, "mismatched types between arms"); None } } } &PatRange(ref from, ref to) => { let from_value = eval_const_expr(cx.tcx, &**from); let to_value = eval_const_expr(cx.tcx, &**to); match range_covered_by_constructor(constructor, &from_value, &to_value) { Some(true) => Some(vec!()), Some(false) => None, None => { cx.tcx.sess.span_err(pat_span, "mismatched types between arms"); None } } } &PatVec(ref before, ref slice, ref after) => { match *constructor { // Fixed-length vectors. Single => { let mut pats = before.clone(); pats.grow_fn(arity - before.len() - after.len(), |_| wild()); pats.push_all(after.as_slice()); Some(pats) }, Slice(length) if before.len() + after.len() <= length && slice.is_some() => { let mut pats = before.clone(); pats.grow_fn(arity - before.len() - after.len(), |_| wild()); pats.push_all(after.as_slice()); Some(pats) }, Slice(length) if before.len() + after.len() == length => { let mut pats = before.clone(); pats.push_all(after.as_slice()); Some(pats) }, _ => None } } &PatMac(_) => { cx.tcx.sess.span_err(pat_span, "unexpanded macro"); None } }; head.map(|head| head.append(r.slice_to(col)).append(r.slice_from(col + 1))) } fn default(cx: &MatchCheckCtxt, r: &[Gc]) -> Option>> { if pat_is_binding_or_wild(&cx.tcx.def_map, &*raw_pat(r[0])) { Some(Vec::from_slice(r.tail())) } else { None } } fn check_local(cx: &mut MatchCheckCtxt, loc: &Local) { visit::walk_local(cx, loc, ()); let name = match loc.source { LocalLet => "local", LocalFor => "`for` loop" }; match is_refutable(cx, loc.pat) { Some(pat) => { let msg = format!( "refutable pattern in {} binding: `{}` not covered", name, pat_to_string(&*pat) ); cx.tcx.sess.span_err(loc.pat.span, msg.as_slice()); }, None => () } // Check legality of move bindings. check_legality_of_move_bindings(cx, false, [ loc.pat ]); } fn check_fn(cx: &mut MatchCheckCtxt, kind: &FnKind, decl: &FnDecl, body: &Block, sp: Span) { visit::walk_fn(cx, kind, decl, body, sp, ()); for input in decl.inputs.iter() { match is_refutable(cx, input.pat) { Some(pat) => { let msg = format!( "refutable pattern in function argument: `{}` not covered", pat_to_string(&*pat) ); cx.tcx.sess.span_err(input.pat.span, msg.as_slice()); }, None => () } check_legality_of_move_bindings(cx, false, [input.pat]); } } fn is_refutable(cx: &MatchCheckCtxt, pat: Gc) -> Option> { let pats = Matrix(vec!(vec!(pat))); match is_useful(cx, &pats, [wild()], ConstructWitness) { UsefulWithWitness(pats) => { assert_eq!(pats.len(), 1); Some(pats.get(0).clone()) }, NotUseful => None, Useful => unreachable!() } } // Legality of move bindings checking fn check_legality_of_move_bindings(cx: &MatchCheckCtxt, has_guard: bool, pats: &[Gc]) { let tcx = cx.tcx; let def_map = &tcx.def_map; let mut by_ref_span = None; for pat in pats.iter() { pat_bindings(def_map, &**pat, |bm, _, span, _path| { match bm { BindByRef(_) => { by_ref_span = Some(span); } BindByValue(_) => { } } }) } let check_move: |&Pat, Option>| = |p, sub| { // check legality of moving out of the enum // x @ Foo(..) is legal, but x @ Foo(y) isn't. if sub.map_or(false, |p| pat_contains_bindings(def_map, &*p)) { tcx.sess.span_err( p.span, "cannot bind by-move with sub-bindings"); } else if has_guard { tcx.sess.span_err( p.span, "cannot bind by-move into a pattern guard"); } else if by_ref_span.is_some() { tcx.sess.span_err( p.span, "cannot bind by-move and by-ref \ in the same pattern"); tcx.sess.span_note( by_ref_span.unwrap(), "by-ref binding occurs here"); } }; for pat in pats.iter() { walk_pat(&**pat, |p| { if pat_is_binding(def_map, &*p) { match p.node { PatIdent(BindByValue(_), _, sub) => { let pat_ty = ty::node_id_to_type(tcx, p.id); if ty::type_moves_by_default(tcx, pat_ty) { check_move(p, sub); } } PatIdent(BindByRef(_), _, _) => { } _ => { cx.tcx.sess.span_bug( p.span, format!("binding pattern {} is not an \ identifier: {:?}", p.id, p.node).as_slice()); } } } true }); } }