src/librustc_typeck/check/demand.rs

   1 // Copyright 2012 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
  12 use check::{coercion, FnCtxt};
  13 use middle::ty::{self, Ty};
  14 use middle::infer;
  15
  16 use std::result::Result::{Err, Ok};
  17 use syntax::ast;
  18 use syntax::codemap::Span;
  19 use util::ppaux::Repr;
  20
  21 // Requires that the two types unify, and prints an error message if
  22 // they don't.
  23 pub fn suptype<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, sp: Span,
  24                          ty_expected: Ty<'tcx>, ty_actual: Ty<'tcx>) {
  25     suptype_with_fn(fcx, sp, false, ty_expected, ty_actual,
  26         |sp, e, a, s| { fcx.report_mismatched_types(sp, e, a, s) })
  27 }
  28
  29 /// As `suptype`, but call `handle_err` if unification for subtyping fails.
  30 pub fn suptype_with_fn<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
  31                                     sp: Span,
  32                                     b_is_expected: bool,
  33                                     ty_a: Ty<'tcx>,
  34                                     ty_b: Ty<'tcx>,
  35                                     handle_err: F) where
  36     F: FnOnce(Span, Ty<'tcx>, Ty<'tcx>, &ty::type_err<'tcx>),
  37 {
  38     // n.b.: order of actual, expected is reversed
  39     match infer::mk_subty(fcx.infcx(), b_is_expected, infer::Misc(sp),
  40                           ty_b, ty_a) {
  41       Ok(()) => { /* ok */ }
  42       Err(ref err) => {
  43           handle_err(sp, ty_a, ty_b, err);
  44       }
  45     }
  46 }
  47
  48 pub fn eqtype<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, sp: Span,
  49                         expected: Ty<'tcx>, actual: Ty<'tcx>) {
  50     match infer::mk_eqty(fcx.infcx(), false, infer::Misc(sp), actual, expected) {
  51         Ok(()) => { /* ok */ }
  52         Err(ref err) => { fcx.report_mismatched_types(sp, expected, actual, err); }
  53     }
  54 }
  55
  56 // Checks that the type of `expr` can be coerced to `expected`.
  57 pub fn coerce<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
  58                         sp: Span,
  59                         expected: Ty<'tcx>,
  60                         expr: &ast::Expr) {
  61     let expr_ty = fcx.expr_ty(expr);
  62     debug!("demand::coerce(expected = {}, expr_ty = {})",
  63            expected.repr(fcx.ccx.tcx),
  64            expr_ty.repr(fcx.ccx.tcx));
  65     let expr_ty = fcx.resolve_type_vars_if_possible(expr_ty);
  66     let expected = fcx.resolve_type_vars_if_possible(expected);
  67     match coercion::mk_assignty(fcx, expr, expr_ty, expected) {
  68       Ok(()) => { /* ok */ }
  69       Err(ref err) => {
  70         fcx.report_mismatched_types(sp, expected, expr_ty, err);
  71       }
  72     }
  73 }