src/librustc_typeck/check/_match.rs

   1 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use middle::def;
  12 use middle::infer;
  13 use middle::pat_util::{PatIdMap, pat_id_map, pat_is_binding};
  14 use middle::pat_util::pat_is_resolved_const;
  15 use middle::privacy::{AllPublic, LastMod};
  16 use middle::subst::Substs;
  17 use middle::ty::{self, Ty, HasTypeFlags, LvaluePreference};
  18 use check::{check_expr, check_expr_has_type, check_expr_with_expectation};
  19 use check::{check_expr_coercable_to_type, demand, FnCtxt, Expectation};
  20 use check::{check_expr_with_lvalue_pref};
  21 use check::{instantiate_path, resolve_ty_and_def_ufcs, structurally_resolved_type};
  22 use require_same_types;
  23 use util::nodemap::FnvHashMap;
  24
  25 use std::cmp;
  26 use std::collections::hash_map::Entry::{Occupied, Vacant};
  27 use syntax::ast;
  28 use syntax::codemap::{Span, Spanned};
  29 use syntax::ptr::P;
  30
  31 use rustc_front::hir;
  32 use rustc_front::print::pprust;
  33 use rustc_front::util as hir_util;
  34
  35 pub fn check_pat<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>,
  36                            pat: &'tcx hir::Pat,
  37                            expected: Ty<'tcx>)
  38 {
  39     let fcx = pcx.fcx;
  40     let tcx = pcx.fcx.ccx.tcx;
  41
  42     debug!("check_pat(pat={:?},expected={:?})",
  43            pat,
  44            expected);
  45
  46     match pat.node {
  47         hir::PatWild(_) => {
  48             fcx.write_ty(pat.id, expected);
  49         }
  50         hir::PatLit(ref lt) => {
  51             check_expr(fcx, &**lt);
  52             let expr_ty = fcx.expr_ty(&**lt);
  53
  54             // Byte string patterns behave the same way as array patterns
  55             // They can denote both statically and dynamically sized byte arrays
  56             let mut pat_ty = expr_ty;
  57             if let hir::ExprLit(ref lt) = lt.node {
  58                 if let ast::LitByteStr(_) = lt.node {
  59                     let expected_ty = structurally_resolved_type(fcx, pat.span, expected);
  60                     if let ty::TyRef(_, mt) = expected_ty.sty {
  61                         if let ty::TySlice(_) = mt.ty.sty {
  62                             pat_ty = tcx.mk_imm_ref(tcx.mk_region(ty::ReStatic),
  63                                                      tcx.mk_slice(tcx.types.u8))
  64                         }
  65                     }
  66                 }
  67             }
  68
  69             fcx.write_ty(pat.id, pat_ty);
  70
  71             // somewhat surprising: in this case, the subtyping
  72             // relation goes the opposite way as the other
  73             // cases. Actually what we really want is not a subtyping
  74             // relation at all but rather that there exists a LUB (so
  75             // that they can be compared). However, in practice,
  76             // constants are always scalars or strings.  For scalars
  77             // subtyping is irrelevant, and for strings `expr_ty` is
  78             // type is `&'static str`, so if we say that
  79             //
  80             //     &'static str <: expected
  81             //
  82             // that's equivalent to there existing a LUB.
  83             demand::suptype(fcx, pat.span, expected, pat_ty);
  84         }
  85         hir::PatRange(ref begin, ref end) => {
  86             check_expr(fcx, begin);
  87             check_expr(fcx, end);
  88
  89             let lhs_ty = fcx.expr_ty(begin);
  90             let rhs_ty = fcx.expr_ty(end);
  91
  92             // Check that both end-points are of numeric or char type.
  93             let numeric_or_char = |ty: Ty| ty.is_numeric() || ty.is_char();
  94             let lhs_compat = numeric_or_char(lhs_ty);
  95             let rhs_compat = numeric_or_char(rhs_ty);
  96
  97             if !lhs_compat || !rhs_compat {
  98                 let span = if !lhs_compat && !rhs_compat {
  99                     pat.span
 100                 } else if !lhs_compat {
 101                     begin.span
 102                 } else {
 103                     end.span
 104                 };
 105
 106                 // Note: spacing here is intentional, we want a space before "start" and "end".
 107                 span_err!(tcx.sess, span, E0029,
 108                           "only char and numeric types are allowed in range patterns\n \
 109                            start type: {}\n end type: {}",
 110                           fcx.infcx().ty_to_string(lhs_ty),
 111                           fcx.infcx().ty_to_string(rhs_ty)
 112                 );
 113                 return;
 114             }
 115
 116             // Check that the types of the end-points can be unified.
 117             let types_unify = require_same_types(
 118                     tcx, Some(fcx.infcx()), false, pat.span, rhs_ty, lhs_ty,
 119                     || "mismatched types in range".to_string()
 120             );
 121
 122             // It's ok to return without a message as `require_same_types` prints an error.
 123             if !types_unify {
 124                 return;
 125             }
 126
 127             // Now that we know the types can be unified we find the unified type and use
 128             // it to type the entire expression.
 129             let common_type = fcx.infcx().resolve_type_vars_if_possible(&lhs_ty);
 130
 131             fcx.write_ty(pat.id, common_type);
 132
 133             // subtyping doesn't matter here, as the value is some kind of scalar
 134             demand::eqtype(fcx, pat.span, expected, lhs_ty);
 135         }
 136         hir::PatEnum(..) | hir::PatIdent(..) if pat_is_resolved_const(&tcx.def_map, pat) => {
 137             let const_did = tcx.def_map.borrow().get(&pat.id).unwrap().def_id();
 138             let const_scheme = tcx.lookup_item_type(const_did);
 139             assert!(const_scheme.generics.is_empty());
 140             let const_ty = pcx.fcx.instantiate_type_scheme(pat.span,
 141                                                            &Substs::empty(),
 142                                                            &const_scheme.ty);
 143             fcx.write_ty(pat.id, const_ty);
 144
 145             // FIXME(#20489) -- we should limit the types here to scalars or something!
 146
 147             // As with PatLit, what we really want here is that there
 148             // exist a LUB, but for the cases that can occur, subtype
 149             // is good enough.
 150             demand::suptype(fcx, pat.span, expected, const_ty);
 151         }
 152         hir::PatIdent(bm, ref path, ref sub) if pat_is_binding(&tcx.def_map, pat) => {
 153             let typ = fcx.local_ty(pat.span, pat.id);
 154             match bm {
 155                 hir::BindByRef(mutbl) => {
 156                     // if the binding is like
 157                     //    ref x | ref const x | ref mut x
 158                     // then `x` is assigned a value of type `&M T` where M is the mutability
 159                     // and T is the expected type.
 160                     let region_var = fcx.infcx().next_region_var(infer::PatternRegion(pat.span));
 161                     let mt = ty::TypeAndMut { ty: expected, mutbl: mutbl };
 162                     let region_ty = tcx.mk_ref(tcx.mk_region(region_var), mt);
 163
 164                     // `x` is assigned a value of type `&M T`, hence `&M T <: typeof(x)` is
 165                     // required. However, we use equality, which is stronger. See (*) for
 166                     // an explanation.
 167                     demand::eqtype(fcx, pat.span, region_ty, typ);
 168                 }
 169                 // otherwise the type of x is the expected type T
 170                 hir::BindByValue(_) => {
 171                     // As above, `T <: typeof(x)` is required but we
 172                     // use equality, see (*) below.
 173                     demand::eqtype(fcx, pat.span, expected, typ);
 174                 }
 175             }
 176
 177             fcx.write_ty(pat.id, typ);
 178
 179             // if there are multiple arms, make sure they all agree on
 180             // what the type of the binding `x` ought to be
 181             let canon_id = *pcx.map.get(&path.node.name).unwrap();
 182             if canon_id != pat.id {
 183                 let ct = fcx.local_ty(pat.span, canon_id);
 184                 demand::eqtype(fcx, pat.span, ct, typ);
 185             }
 186
 187             if let Some(ref p) = *sub {
 188                 check_pat(pcx, &**p, expected);
 189             }
 190         }
 191         hir::PatIdent(_, ref path, _) => {
 192             let path = hir_util::ident_to_path(path.span, path.node);
 193             check_pat_enum(pcx, pat, &path, Some(&[]), expected);
 194         }
 195         hir::PatEnum(ref path, ref subpats) => {
 196             let subpats = subpats.as_ref().map(|v| &v[..]);
 197             check_pat_enum(pcx, pat, path, subpats, expected);
 198         }
 199         hir::PatQPath(ref qself, ref path) => {
 200             let self_ty = fcx.to_ty(&qself.ty);
 201             let path_res = if let Some(&d) = tcx.def_map.borrow().get(&pat.id) {
 202                 d
 203             } else if qself.position == 0 {
 204                 // This is just a sentinel for finish_resolving_def_to_ty.
 205                 let sentinel = fcx.tcx().map.local_def_id(ast::CRATE_NODE_ID);
 206                 def::PathResolution {
 207                     base_def: def::DefMod(sentinel),
 208                     last_private: LastMod(AllPublic),
 209                     depth: path.segments.len()
 210                 }
 211             } else {
 212                 tcx.sess.span_bug(pat.span,
 213                                   &format!("unbound path {:?}", pat))
 214             };
 215             if let Some((opt_ty, segments, def)) =
 216                     resolve_ty_and_def_ufcs(fcx, path_res, Some(self_ty),
 217                                             path, pat.span, pat.id) {
 218                 if check_assoc_item_is_const(pcx, def, pat.span) {
 219                     let scheme = tcx.lookup_item_type(def.def_id());
 220                     let predicates = tcx.lookup_predicates(def.def_id());
 221                     instantiate_path(fcx, segments,
 222                                      scheme, &predicates,
 223                                      opt_ty, def, pat.span, pat.id);
 224                     let const_ty = fcx.node_ty(pat.id);
 225                     demand::suptype(fcx, pat.span, expected, const_ty);
 226                 } else {
 227                     fcx.write_error(pat.id)
 228                 }
 229             }
 230         }
 231         hir::PatStruct(ref path, ref fields, etc) => {
 232             check_pat_struct(pcx, pat, path, fields, etc, expected);
 233         }
 234         hir::PatTup(ref elements) => {
 235             let element_tys: Vec<_> =
 236                 (0..elements.len()).map(|_| fcx.infcx().next_ty_var())
 237                                         .collect();
 238             let pat_ty = tcx.mk_tup(element_tys.clone());
 239             fcx.write_ty(pat.id, pat_ty);
 240             demand::eqtype(fcx, pat.span, expected, pat_ty);
 241             for (element_pat, element_ty) in elements.iter().zip(element_tys) {
 242                 check_pat(pcx, &**element_pat, element_ty);
 243             }
 244         }
 245         hir::PatBox(ref inner) => {
 246             let inner_ty = fcx.infcx().next_ty_var();
 247             let uniq_ty = tcx.mk_box(inner_ty);
 248
 249             if check_dereferencable(pcx, pat.span, expected, &**inner) {
 250                 // Here, `demand::subtype` is good enough, but I don't
 251                 // think any errors can be introduced by using
 252                 // `demand::eqtype`.
 253                 demand::eqtype(fcx, pat.span, expected, uniq_ty);
 254                 fcx.write_ty(pat.id, uniq_ty);
 255                 check_pat(pcx, &**inner, inner_ty);
 256             } else {
 257                 fcx.write_error(pat.id);
 258                 check_pat(pcx, &**inner, tcx.types.err);
 259             }
 260         }
 261         hir::PatRegion(ref inner, mutbl) => {
 262             let inner_ty = fcx.infcx().next_ty_var();
 263
 264             let mt = ty::TypeAndMut { ty: inner_ty, mutbl: mutbl };
 265             let region = fcx.infcx().next_region_var(infer::PatternRegion(pat.span));
 266             let rptr_ty = tcx.mk_ref(tcx.mk_region(region), mt);
 267
 268             if check_dereferencable(pcx, pat.span, expected, &**inner) {
 269                 // `demand::subtype` would be good enough, but using
 270                 // `eqtype` turns out to be equally general. See (*)
 271                 // below for details.
 272                 demand::eqtype(fcx, pat.span, expected, rptr_ty);
 273                 fcx.write_ty(pat.id, rptr_ty);
 274                 check_pat(pcx, &**inner, inner_ty);
 275             } else {
 276                 fcx.write_error(pat.id);
 277                 check_pat(pcx, &**inner, tcx.types.err);
 278             }
 279         }
 280         hir::PatVec(ref before, ref slice, ref after) => {
 281             let expected_ty = structurally_resolved_type(fcx, pat.span, expected);
 282             let inner_ty = fcx.infcx().next_ty_var();
 283             let pat_ty = match expected_ty.sty {
 284                 ty::TyArray(_, size) => tcx.mk_array(inner_ty, {
 285                     let min_len = before.len() + after.len();
 286                     match *slice {
 287                         Some(_) => cmp::max(min_len, size),
 288                         None => min_len
 289                     }
 290                 }),
 291                 _ => {
 292                     let region = fcx.infcx().next_region_var(infer::PatternRegion(pat.span));
 293                     tcx.mk_ref(tcx.mk_region(region), ty::TypeAndMut {
 294                         ty: tcx.mk_slice(inner_ty),
 295                         mutbl: expected_ty.builtin_deref(true, ty::NoPreference).map(|mt| mt.mutbl)
 296                                                               .unwrap_or(hir::MutImmutable)
 297                     })
 298                 }
 299             };
 300
 301             fcx.write_ty(pat.id, pat_ty);
 302
 303             // `demand::subtype` would be good enough, but using
 304             // `eqtype` turns out to be equally general. See (*)
 305             // below for details.
 306             demand::eqtype(fcx, pat.span, expected, pat_ty);
 307
 308             for elt in before {
 309                 check_pat(pcx, &**elt, inner_ty);
 310             }
 311             if let Some(ref slice) = *slice {
 312                 let region = fcx.infcx().next_region_var(infer::PatternRegion(pat.span));
 313                 let mutbl = expected_ty.builtin_deref(true, ty::NoPreference)
 314                     .map_or(hir::MutImmutable, |mt| mt.mutbl);
 315
 316                 let slice_ty = tcx.mk_ref(tcx.mk_region(region), ty::TypeAndMut {
 317                     ty: tcx.mk_slice(inner_ty),
 318                     mutbl: mutbl
 319                 });
 320                 check_pat(pcx, &**slice, slice_ty);
 321             }
 322             for elt in after {
 323                 check_pat(pcx, &**elt, inner_ty);
 324             }
 325         }
 326     }
 327
 328
 329     // (*) In most of the cases above (literals and constants being
 330     // the exception), we relate types using strict equality, evewn
 331     // though subtyping would be sufficient. There are a few reasons
 332     // for this, some of which are fairly subtle and which cost me
 333     // (nmatsakis) an hour or two debugging to remember, so I thought
 334     // I'd write them down this time.
 335     //
 336     // 1. There is no loss of expressiveness here, though it does
 337     // cause some inconvenience. What we are saying is that the type
 338     // of `x` becomes *exactly* what is expected. This can cause unnecessary
 339     // errors in some cases, such as this one:
 340     // it will cause errors in a case like this:
 341     //
 342     // ```
 343     // fn foo<'x>(x: &'x int) {
 344     //    let a = 1;
 345     //    let mut z = x;
 346     //    z = &a;
 347     // }
 348     // ```
 349     //
 350     // The reason we might get an error is that `z` might be
 351     // assigned a type like `&'x int`, and then we would have
 352     // a problem when we try to assign `&a` to `z`, because
 353     // the lifetime of `&a` (i.e., the enclosing block) is
 354     // shorter than `'x`.
 355     //
 356     // HOWEVER, this code works fine. The reason is that the
 357     // expected type here is whatever type the user wrote, not
 358     // the initializer's type. In this case the user wrote
 359     // nothing, so we are going to create a type variable `Z`.
 360     // Then we will assign the type of the initializer (`&'x
 361     // int`) as a subtype of `Z`: `&'x int <: Z`. And hence we
 362     // will instantiate `Z` as a type `&'0 int` where `'0` is
 363     // a fresh region variable, with the constraint that `'x :
 364     // '0`.  So basically we're all set.
 365     //
 366     // Note that there are two tests to check that this remains true
 367     // (`regions-reassign-{match,let}-bound-pointer.rs`).
 368     //
 369     // 2. Things go horribly wrong if we use subtype. The reason for
 370     // THIS is a fairly subtle case involving bound regions. See the
 371     // `givens` field in `region_inference`, as well as the test
 372     // `regions-relate-bound-regions-on-closures-to-inference-variables.rs`,
 373     // for details. Short version is that we must sometimes detect
 374     // relationships between specific region variables and regions
 375     // bound in a closure signature, and that detection gets thrown
 376     // off when we substitute fresh region variables here to enable
 377     // subtyping.
 378 }
 379
 380 fn check_assoc_item_is_const(pcx: &pat_ctxt, def: def::Def, span: Span) -> bool {
 381     match def {
 382         def::DefAssociatedConst(..) => true,
 383         def::DefMethod(..) => {
 384             span_err!(pcx.fcx.ccx.tcx.sess, span, E0327,
 385                       "associated items in match patterns must be constants");
 386             false
 387         }
 388         _ => {
 389             pcx.fcx.ccx.tcx.sess.span_bug(span, "non-associated item in
 390                                                  check_assoc_item_is_const");
 391         }
 392     }
 393 }
 394
 395 pub fn check_dereferencable<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>,
 396                                       span: Span, expected: Ty<'tcx>,
 397                                       inner: &hir::Pat) -> bool {
 398     let fcx = pcx.fcx;
 399     let tcx = pcx.fcx.ccx.tcx;
 400     if pat_is_binding(&tcx.def_map, inner) {
 401         let expected = fcx.infcx().shallow_resolve(expected);
 402         expected.builtin_deref(true, ty::NoPreference).map_or(true, |mt| match mt.ty.sty {
 403             ty::TyTrait(_) => {
 404                 // This is "x = SomeTrait" being reduced from
 405                 // "let &x = &SomeTrait" or "let box x = Box<SomeTrait>", an error.
 406                 span_err!(tcx.sess, span, E0033,
 407                           "type `{}` cannot be dereferenced",
 408                           fcx.infcx().ty_to_string(expected));
 409                 false
 410             }
 411             _ => true
 412         })
 413     } else {
 414         true
 415     }
 416 }
 417
 418 pub fn check_match<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
 419                              expr: &'tcx hir::Expr,
 420                              discrim: &'tcx hir::Expr,
 421                              arms: &'tcx [hir::Arm],
 422                              expected: Expectation<'tcx>,
 423                              match_src: hir::MatchSource) {
 424     let tcx = fcx.ccx.tcx;
 425
 426     // Not entirely obvious: if matches may create ref bindings, we
 427     // want to use the *precise* type of the discriminant, *not* some
 428     // supertype, as the "discriminant type" (issue #23116).
 429     let contains_ref_bindings = arms.iter()
 430                                     .filter_map(|a| tcx.arm_contains_ref_binding(a))
 431                                     .max_by(|m| match *m {
 432                                         hir::MutMutable => 1,
 433                                         hir::MutImmutable => 0,
 434                                     });
 435     let discrim_ty;
 436     if let Some(m) = contains_ref_bindings {
 437         check_expr_with_lvalue_pref(fcx, discrim, LvaluePreference::from_mutbl(m));
 438         discrim_ty = fcx.expr_ty(discrim);
 439     } else {
 440         // ...but otherwise we want to use any supertype of the
 441         // discriminant. This is sort of a workaround, see note (*) in
 442         // `check_pat` for some details.
 443         discrim_ty = fcx.infcx().next_ty_var();
 444         check_expr_has_type(fcx, discrim, discrim_ty);
 445     };
 446
 447     // Typecheck the patterns first, so that we get types for all the
 448     // bindings.
 449     for arm in arms {
 450         let mut pcx = pat_ctxt {
 451             fcx: fcx,
 452             map: pat_id_map(&tcx.def_map, &*arm.pats[0]),
 453         };
 454         for p in &arm.pats {
 455             check_pat(&mut pcx, &**p, discrim_ty);
 456         }
 457     }
 458
 459     // Now typecheck the blocks.
 460     //
 461     // The result of the match is the common supertype of all the
 462     // arms. Start out the value as bottom, since it's the, well,
 463     // bottom the type lattice, and we'll be moving up the lattice as
 464     // we process each arm. (Note that any match with 0 arms is matching
 465     // on any empty type and is therefore unreachable; should the flow
 466     // of execution reach it, we will panic, so bottom is an appropriate
 467     // type in that case)
 468     let expected = expected.adjust_for_branches(fcx);
 469     let result_ty = arms.iter().fold(fcx.infcx().next_diverging_ty_var(), |result_ty, arm| {
 470         let bty = match expected {
 471             // We don't coerce to `()` so that if the match expression is a
 472             // statement it's branches can have any consistent type. That allows
 473             // us to give better error messages (pointing to a usually better
 474             // arm for inconsistent arms or to the whole match when a `()` type
 475             // is required).
 476             Expectation::ExpectHasType(ety) if ety != fcx.tcx().mk_nil() => {
 477                 check_expr_coercable_to_type(fcx, &*arm.body, ety);
 478                 ety
 479             }
 480             _ => {
 481                 check_expr_with_expectation(fcx, &*arm.body, expected);
 482                 fcx.node_ty(arm.body.id)
 483             }
 484         };
 485
 486         if let Some(ref e) = arm.guard {
 487             check_expr_has_type(fcx, &**e, tcx.types.bool);
 488         }
 489
 490         if result_ty.references_error() || bty.references_error() {
 491             tcx.types.err
 492         } else {
 493             let (origin, expected, found) = match match_src {
 494                 /* if-let construct without an else block */
 495                 hir::MatchSource::IfLetDesugar { contains_else_clause }
 496                 if !contains_else_clause => (
 497                     infer::IfExpressionWithNoElse(expr.span),
 498                     bty,
 499                     result_ty,
 500                 ),
 501                 _ => (
 502                     infer::MatchExpressionArm(expr.span, arm.body.span, match_src),
 503                     result_ty,
 504                     bty,
 505                 ),
 506             };
 507
 508             infer::common_supertype(
 509                 fcx.infcx(),
 510                 origin,
 511                 true,
 512                 expected,
 513                 found,
 514             )
 515         }
 516     });
 517
 518     fcx.write_ty(expr.id, result_ty);
 519 }
 520
 521 pub struct pat_ctxt<'a, 'tcx: 'a> {
 522     pub fcx: &'a FnCtxt<'a, 'tcx>,
 523     pub map: PatIdMap,
 524 }
 525
 526 pub fn check_pat_struct<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, pat: &'tcx hir::Pat,
 527                                   path: &hir::Path, fields: &'tcx [Spanned<hir::FieldPat>],
 528                                   etc: bool, expected: Ty<'tcx>) {
 529     let fcx = pcx.fcx;
 530     let tcx = pcx.fcx.ccx.tcx;
 531
 532     let def = tcx.def_map.borrow().get(&pat.id).unwrap().full_def();
 533     let variant = match fcx.def_struct_variant(def, path.span) {
 534         Some((_, variant)) => variant,
 535         None => {
 536             let name = pprust::path_to_string(path);
 537             span_err!(tcx.sess, pat.span, E0163,
 538                       "`{}` does not name a struct or a struct variant", name);
 539             fcx.write_error(pat.id);
 540
 541             for field in fields {
 542                 check_pat(pcx, &field.node.pat, tcx.types.err);
 543             }
 544             return;
 545         }
 546     };
 547
 548     let pat_ty = pcx.fcx.instantiate_type(def.def_id(), path);
 549     let item_substs = match pat_ty.sty {
 550         ty::TyStruct(_, substs) | ty::TyEnum(_, substs) => substs,
 551         _ => tcx.sess.span_bug(pat.span, "struct variant is not an ADT")
 552     };
 553     demand::eqtype(fcx, pat.span, expected, pat_ty);
 554     check_struct_pat_fields(pcx, pat.span, fields, variant, &item_substs, etc);
 555
 556     fcx.write_ty(pat.id, pat_ty);
 557     fcx.write_substs(pat.id, ty::ItemSubsts { substs: item_substs.clone() });
 558 }
 559
 560 pub fn check_pat_enum<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>,
 561                                 pat: &hir::Pat,
 562                                 path: &hir::Path,
 563                                 subpats: Option<&'tcx [P<hir::Pat>]>,
 564                                 expected: Ty<'tcx>)
 565 {
 566     // Typecheck the path.
 567     let fcx = pcx.fcx;
 568     let tcx = pcx.fcx.ccx.tcx;
 569
 570     let path_res = *tcx.def_map.borrow().get(&pat.id).unwrap();
 571
 572     let (opt_ty, segments, def) = match resolve_ty_and_def_ufcs(fcx, path_res,
 573                                                                 None, path,
 574                                                                 pat.span, pat.id) {
 575         Some(resolution) => resolution,
 576         // Error handling done inside resolve_ty_and_def_ufcs, so if
 577         // resolution fails just return.
 578         None => {return;}
 579     };
 580
 581     // Items that were partially resolved before should have been resolved to
 582     // associated constants (i.e. not methods).
 583     if path_res.depth != 0 && !check_assoc_item_is_const(pcx, def, pat.span) {
 584         fcx.write_error(pat.id);
 585         return;
 586     }
 587
 588     let enum_def = def.variant_def_ids()
 589         .map_or_else(|| def.def_id(), |(enum_def, _)| enum_def);
 590
 591     let ctor_scheme = tcx.lookup_item_type(enum_def);
 592     let ctor_predicates = tcx.lookup_predicates(enum_def);
 593     let path_scheme = if ctor_scheme.ty.is_fn() {
 594         let fn_ret = tcx.no_late_bound_regions(&ctor_scheme.ty.fn_ret()).unwrap();
 595         ty::TypeScheme {
 596             ty: fn_ret.unwrap(),
 597             generics: ctor_scheme.generics,
 598         }
 599     } else {
 600         ctor_scheme
 601     };
 602     instantiate_path(pcx.fcx, segments,
 603                      path_scheme, &ctor_predicates,
 604                      opt_ty, def, pat.span, pat.id);
 605
 606     // If we didn't have a fully resolved path to start with, we had an
 607     // associated const, and we should quit now, since the rest of this
 608     // function uses checks specific to structs and enums.
 609     if path_res.depth != 0 {
 610         let pat_ty = fcx.node_ty(pat.id);
 611         demand::suptype(fcx, pat.span, expected, pat_ty);
 612         return;
 613     }
 614
 615     let pat_ty = fcx.node_ty(pat.id);
 616     demand::eqtype(fcx, pat.span, expected, pat_ty);
 617
 618
 619     let real_path_ty = fcx.node_ty(pat.id);
 620     let (arg_tys, kind_name): (Vec<_>, &'static str) = match real_path_ty.sty {
 621         ty::TyEnum(enum_def, expected_substs)
 622             if def == def::DefVariant(enum_def.did, def.def_id(), false) =>
 623         {
 624             let variant = enum_def.variant_of_def(def);
 625             (variant.fields
 626                     .iter()
 627                     .map(|f| fcx.instantiate_type_scheme(pat.span,
 628                                                          expected_substs,
 629                                                          &f.unsubst_ty()))
 630                     .collect(),
 631              "variant")
 632         }
 633         ty::TyStruct(struct_def, expected_substs) => {
 634             (struct_def.struct_variant()
 635                        .fields
 636                        .iter()
 637                        .map(|f| fcx.instantiate_type_scheme(pat.span,
 638                                                             expected_substs,
 639                                                             &f.unsubst_ty()))
 640                        .collect(),
 641              "struct")
 642         }
 643         _ => {
 644             let name = pprust::path_to_string(path);
 645             span_err!(tcx.sess, pat.span, E0164,
 646                 "`{}` does not name a non-struct variant or a tuple struct", name);
 647             fcx.write_error(pat.id);
 648
 649             if let Some(subpats) = subpats {
 650                 for pat in subpats {
 651                     check_pat(pcx, &**pat, tcx.types.err);
 652                 }
 653             }
 654             return;
 655         }
 656     };
 657
 658     if let Some(subpats) = subpats {
 659         if subpats.len() == arg_tys.len() {
 660             for (subpat, arg_ty) in subpats.iter().zip(arg_tys) {
 661                 check_pat(pcx, &**subpat, arg_ty);
 662             }
 663         } else if arg_tys.is_empty() {
 664             span_err!(tcx.sess, pat.span, E0024,
 665                       "this pattern has {} field{}, but the corresponding {} has no fields",
 666                       subpats.len(), if subpats.len() == 1 {""} else {"s"}, kind_name);
 667
 668             for pat in subpats {
 669                 check_pat(pcx, &**pat, tcx.types.err);
 670             }
 671         } else {
 672             span_err!(tcx.sess, pat.span, E0023,
 673                       "this pattern has {} field{}, but the corresponding {} has {} field{}",
 674                       subpats.len(), if subpats.len() == 1 {""} else {"s"},
 675                       kind_name,
 676                       arg_tys.len(), if arg_tys.len() == 1 {""} else {"s"});
 677
 678             for pat in subpats {
 679                 check_pat(pcx, &**pat, tcx.types.err);
 680             }
 681         }
 682     }
 683 }
 684
 685 /// `path` is the AST path item naming the type of this struct.
 686 /// `fields` is the field patterns of the struct pattern.
 687 /// `struct_fields` describes the type of each field of the struct.
 688 /// `struct_id` is the ID of the struct.
 689 /// `etc` is true if the pattern said '...' and false otherwise.
 690 pub fn check_struct_pat_fields<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>,
 691                                          span: Span,
 692                                          fields: &'tcx [Spanned<hir::FieldPat>],
 693                                          variant: ty::VariantDef<'tcx>,
 694                                          substs: &Substs<'tcx>,
 695                                          etc: bool) {
 696     let tcx = pcx.fcx.ccx.tcx;
 697
 698     // Index the struct fields' types.
 699     let field_map = variant.fields
 700         .iter()
 701         .map(|field| (field.name, field))
 702         .collect::<FnvHashMap<_, _>>();
 703
 704     // Keep track of which fields have already appeared in the pattern.
 705     let mut used_fields = FnvHashMap();
 706
 707     // Typecheck each field.
 708     for &Spanned { node: ref field, span } in fields {
 709         let field_ty = match used_fields.entry(field.name) {
 710             Occupied(occupied) => {
 711                 span_err!(tcx.sess, span, E0025,
 712                     "field `{}` bound multiple times in the pattern",
 713                     field.name);
 714                 span_note!(tcx.sess, *occupied.get(),
 715                     "field `{}` previously bound here",
 716                     field.name);
 717                 tcx.types.err
 718             }
 719             Vacant(vacant) => {
 720                 vacant.insert(span);
 721                 field_map.get(&field.name)
 722                     .map(|f| pcx.fcx.field_ty(span, f, substs))
 723                     .unwrap_or_else(|| {
 724                         span_err!(tcx.sess, span, E0026,
 725                             "struct `{}` does not have a field named `{}`",
 726                             tcx.item_path_str(variant.did),
 727                             field.name);
 728                         tcx.types.err
 729                     })
 730             }
 731         };
 732
 733         check_pat(pcx, &*field.pat, field_ty);
 734     }
 735
 736     // Report an error if not all the fields were specified.
 737     if !etc {
 738         for field in variant.fields
 739             .iter()
 740             .filter(|field| !used_fields.contains_key(&field.name)) {
 741             span_err!(tcx.sess, span, E0027,
 742                 "pattern does not mention field `{}`",
 743                 field.name);
 744         }
 745     }
 746 }