From dc37664c94d2c53d68e9cbb7175ccb8551d237e3 Mon Sep 17 00:00:00 2001 From: Eduard Burtescu Date: Sun, 21 Feb 2016 18:57:30 +0200 Subject: [PATCH] infer: Take the origin in report_mismatched_types. --- src/librustc/middle/infer/mod.rs | 8 ++--- src/librustc_typeck/check/demand.rs | 44 ++++++++-------------------- src/librustc_typeck/check/mod.rs | 8 ----- src/librustc_typeck/coherence/mod.rs | 6 ++-- 4 files changed, 19 insertions(+), 47 deletions(-) diff --git a/src/librustc/middle/infer/mod.rs b/src/librustc/middle/infer/mod.rs index 0ea11884637..1e3546269db 100644 --- a/src/librustc/middle/infer/mod.rs +++ b/src/librustc/middle/infer/mod.rs @@ -1351,18 +1351,18 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { } pub fn report_mismatched_types(&self, - span: Span, + origin: TypeOrigin, expected: Ty<'tcx>, actual: Ty<'tcx>, - err: &TypeError<'tcx>) { + err: TypeError<'tcx>) { let trace = TypeTrace { - origin: TypeOrigin::Misc(span), + origin: origin, values: Types(ExpectedFound { expected: expected, found: actual }) }; - self.report_and_explain_type_error(trace, err); + self.report_and_explain_type_error(trace, &err); } pub fn report_conflicting_default_types(&self, diff --git a/src/librustc_typeck/check/demand.rs b/src/librustc_typeck/check/demand.rs index 63dac49b384..4dd5a6f5909 100644 --- a/src/librustc_typeck/check/demand.rs +++ b/src/librustc_typeck/check/demand.rs @@ -10,45 +10,27 @@ use check::{coercion, FnCtxt}; -use middle::ty::{self, Ty}; -use middle::infer::{self, TypeOrigin}; +use middle::ty::Ty; +use middle::infer::TypeOrigin; -use std::result::Result::{Err, Ok}; use syntax::codemap::Span; use rustc_front::hir; // Requires that the two types unify, and prints an error message if // they don't. pub fn suptype<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, sp: Span, - ty_expected: Ty<'tcx>, ty_actual: Ty<'tcx>) { - suptype_with_fn(fcx, sp, false, ty_expected, ty_actual, - |sp, e, a, s| { fcx.report_mismatched_types(sp, e, a, s) }) -} - -/// As `suptype`, but call `handle_err` if unification for subtyping fails. -pub fn suptype_with_fn<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, - sp: Span, - b_is_expected: bool, - ty_a: Ty<'tcx>, - ty_b: Ty<'tcx>, - handle_err: F) where - F: FnOnce(Span, Ty<'tcx>, Ty<'tcx>, &ty::error::TypeError<'tcx>), -{ - // n.b.: order of actual, expected is reversed - match infer::mk_subty(fcx.infcx(), b_is_expected, TypeOrigin::Misc(sp), - ty_b, ty_a) { - Ok(()) => { /* ok */ } - Err(ref err) => { - handle_err(sp, ty_a, ty_b, err); - } + expected: Ty<'tcx>, actual: Ty<'tcx>) { + let origin = TypeOrigin::Misc(sp); + if let Err(e) = fcx.infcx().sub_types(false, origin, actual, expected) { + fcx.infcx().report_mismatched_types(origin, expected, actual, e); } } pub fn eqtype<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, sp: Span, expected: Ty<'tcx>, actual: Ty<'tcx>) { - match infer::mk_eqty(fcx.infcx(), false, TypeOrigin::Misc(sp), actual, expected) { - Ok(()) => { /* ok */ } - Err(ref err) => { fcx.report_mismatched_types(sp, expected, actual, err); } + let origin = TypeOrigin::Misc(sp); + if let Err(e) = fcx.infcx().eq_types(false, origin, actual, expected) { + fcx.infcx().report_mismatched_types(origin, expected, actual, e); } } @@ -63,10 +45,8 @@ pub fn coerce<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, expr_ty); let expr_ty = fcx.resolve_type_vars_if_possible(expr_ty); let expected = fcx.resolve_type_vars_if_possible(expected); - match coercion::mk_assignty(fcx, expr, expr_ty, expected) { - Ok(()) => { /* ok */ } - Err(ref err) => { - fcx.report_mismatched_types(sp, expected, expr_ty, err); - } + let origin = TypeOrigin::Misc(sp); + if let Err(e) = coercion::try(fcx, expr, expr_ty, expected) { + fcx.infcx().report_mismatched_types(origin, expected, expr_ty, e); } } diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 6865e173d32..e3578559c9b 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -1622,14 +1622,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { self.infcx().type_error_struct(sp, mk_msg, actual_ty, err) } - pub fn report_mismatched_types(&self, - sp: Span, - e: Ty<'tcx>, - a: Ty<'tcx>, - err: &TypeError<'tcx>) { - self.infcx().report_mismatched_types(sp, e, a, err) - } - /// Registers an obligation for checking later, during regionck, that the type `ty` must /// outlive the region `r`. pub fn register_region_obligation(&self, diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs index 28fbaf21367..cad321c0b23 100644 --- a/src/librustc_typeck/coherence/mod.rs +++ b/src/librustc_typeck/coherence/mod.rs @@ -385,11 +385,12 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { let infcx = new_infer_ctxt(tcx, &tcx.tables, Some(param_env)); + let origin = TypeOrigin::Misc(span); let check_mutbl = |mt_a: ty::TypeAndMut<'tcx>, mt_b: ty::TypeAndMut<'tcx>, mk_ptr: &Fn(Ty<'tcx>) -> Ty<'tcx>| { if (mt_a.mutbl, mt_b.mutbl) == (hir::MutImmutable, hir::MutMutable) { - infcx.report_mismatched_types(span, mk_ptr(mt_b.ty), - target, &ty::error::TypeError::Mutability); + infcx.report_mismatched_types(origin, mk_ptr(mt_b.ty), + target, ty::error::TypeError::Mutability); } (mt_a.ty, mt_b.ty, unsize_trait, None) }; @@ -418,7 +419,6 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { return; } - let origin = TypeOrigin::Misc(span); let fields = &def_a.struct_variant().fields; let diff_fields = fields.iter().enumerate().filter_map(|(i, f)| { let (a, b) = (f.ty(tcx, substs_a), f.ty(tcx, substs_b));