Remove duplicated errors for closure type mismatch

Author: estebank

src/librustc/infer/mod.rs

@@ -169,9 +169,11 @@ pub struct InferCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
     /// Caches the results of trait evaluation.
     pub evaluation_cache: traits::EvaluationCache<'tcx>,
 
-    // the set of predicates on which errors have been reported, to
-    // avoid reporting the same error twice.
+    /// Set of predicates on which errors have been reported, to
+    /// avoid reporting the same error twice.
     pub reported_trait_errors: RefCell<FxHashSet<traits::TraitErrorKey<'tcx>>>,
+    /// Set of selection errors have been reported, to avoid reporting them twice.
+    pub reported_selection_errors: RefCell<FxHashSet<(Span, traits::SelectionError<'tcx>)>>,
 
     // Sadly, the behavior of projection varies a bit depending on the
     // stage of compilation. The specifics are given in the
@@ -502,6 +504,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'gcx> {
             evaluation_cache: traits::EvaluationCache::new(),
             projection_cache: RefCell::new(traits::ProjectionCache::new()),
             reported_trait_errors: RefCell::new(FxHashSet()),
+            reported_selection_errors: RefCell::new(FxHashSet()),
             projection_mode: Reveal::UserFacing,
             tainted_by_errors_flag: Cell::new(false),
             err_count_on_creation: self.sess.err_count(),
@@ -540,6 +543,7 @@ impl<'a, 'gcx, 'tcx> InferCtxtBuilder<'a, 'gcx, 'tcx> {
             selection_cache: traits::SelectionCache::new(),
             evaluation_cache: traits::EvaluationCache::new(),
             reported_trait_errors: RefCell::new(FxHashSet()),
+            reported_selection_errors: RefCell::new(FxHashSet()),
             projection_mode: projection_mode,
             tainted_by_errors_flag: Cell::new(false),
             err_count_on_creation: tcx.sess.err_count(),

src/librustc/traits/error_reporting.rs

@@ -15,6 +15,7 @@ use super::{
     Obligation,
     ObligationCause,
     ObligationCauseCode,
+    ParameterCountMismatch,
     OutputTypeParameterMismatch,
     TraitNotObjectSafe,
     PredicateObligation,
@@ -54,11 +55,11 @@ pub struct TraitErrorKey<'tcx> {
 impl<'a, 'gcx, 'tcx> TraitErrorKey<'tcx> {
     fn from_error(infcx: &InferCtxt<'a, 'gcx, 'tcx>,
                   e: &FulfillmentError<'tcx>) -> Self {
-        let predicate =
-            infcx.resolve_type_vars_if_possible(&e.obligation.predicate);
+        let predicate = infcx.resolve_type_vars_if_possible(&e.obligation.predicate);
+        let predicate = infcx.tcx.erase_regions(&predicate);
         TraitErrorKey {
             span: e.obligation.cause.span,
-            predicate: infcx.tcx.erase_regions(&predicate)
+            predicate: predicate,
         }
     }
 }
@@ -523,6 +524,11 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
     {
         let span = obligation.cause.span;
 
+        if !self.reported_selection_errors.borrow_mut().insert((span, error.clone())) {
+            debug!("report_selection_error: skipping duplicate {:?}", error);
+            return;
+        }
+
         let mut err = match *error {
             SelectionError::Unimplemented => {
                 if let ObligationCauseCode::CompareImplMethodObligation {
@@ -657,6 +663,14 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                 }
             }
 
+            ParameterCountMismatch(expected_found, ty, def_id) => {
+                let found_span = self.tcx.hir.span_if_local(def_id);
+                self.report_arg_count_mismatch(span,
+                                               found_span,
+                                               expected_found.expected,
+                                               expected_found.found,
+                                               ty.is_closure())
+            }
             OutputTypeParameterMismatch(ref expected_trait_ref, ref actual_trait_ref, ref e) => {
                 let expected_trait_ref = self.resolve_type_vars_if_possible(&*expected_trait_ref);
                 let actual_trait_ref = self.resolve_type_vars_if_possible(&*actual_trait_ref);
@@ -668,49 +682,12 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                     self.tcx.hir.span_if_local(did)
                 });
 
-                if let &TypeError::TupleSize(ref expected_found) = e {
-                    // Expected `|x| { }`, found `|x, y| { }`
-                    self.report_arg_count_mismatch(span,
-                                                   found_span,
-                                                   expected_found.expected,
-                                                   expected_found.found,
-                                                   expected_trait_ty.is_closure())
-                } else if let &TypeError::Sorts(ref expected_found) = e {
-                    let expected = if let ty::TyTuple(tys, _) = expected_found.expected.sty {
-                        tys.len()
-                    } else {
-                        1
-                    };
-                    let found = if let ty::TyTuple(tys, _) = expected_found.found.sty {
-                        tys.len()
-                    } else {
-                        1
-                    };
-
-                    if expected != found {
-                        // Expected `|| { }`, found `|x, y| { }`
-                        // Expected `fn(x) -> ()`, found `|| { }`
-                        self.report_arg_count_mismatch(span,
-                                                       found_span,
-                                                       expected,
-                                                       found,
-                                                       expected_trait_ty.is_closure())
-                    } else {
-                        self.report_type_argument_mismatch(span,
-                                                            found_span,
-                                                            expected_trait_ty,
-                                                            expected_trait_ref,
-                                                            actual_trait_ref,
-                                                            e)
-                    }
-                } else {
-                    self.report_type_argument_mismatch(span,
-                                                        found_span,
-                                                        expected_trait_ty,
-                                                        expected_trait_ref,
-                                                        actual_trait_ref,
-                                                        e)
-                }
+                self.report_type_argument_mismatch(span,
+                                                    found_span,
+                                                    expected_trait_ty,
+                                                    expected_trait_ref,
+                                                    actual_trait_ref,
+                                                    e)
             }
 
             TraitNotObjectSafe(did) => {

src/librustc/traits/mod.rs

@@ -196,12 +196,13 @@ pub type TraitObligations<'tcx> = Vec<TraitObligation<'tcx>>;
 
 pub type Selection<'tcx> = Vtable<'tcx, PredicateObligation<'tcx>>;
 
-#[derive(Clone,Debug)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum SelectionError<'tcx> {
     Unimplemented,
     OutputTypeParameterMismatch(ty::PolyTraitRef<'tcx>,
                                 ty::PolyTraitRef<'tcx>,
                                 ty::error::TypeError<'tcx>),
+    ParameterCountMismatch(ExpectedFound<usize>, Ty<'tcx>, DefId),
     TraitNotObjectSafe(DefId),
 }
 

src/librustc/traits/select.rs

@@ -19,7 +19,7 @@ use super::project;
 use super::project::{normalize_with_depth, Normalized};
 use super::{PredicateObligation, TraitObligation, ObligationCause};
 use super::{ObligationCauseCode, BuiltinDerivedObligation, ImplDerivedObligation};
-use super::{SelectionError, Unimplemented, OutputTypeParameterMismatch};
+use super::{SelectionError, Unimplemented, ParameterCountMismatch, OutputTypeParameterMismatch};
 use super::{ObjectCastObligation, Obligation};
 use super::Reveal;
 use super::TraitNotObjectSafe;
@@ -39,6 +39,7 @@ use ty::{self, ToPredicate, ToPolyTraitRef, Ty, TyCtxt, TypeFoldable};
 use traits;
 use ty::fast_reject;
 use ty::relate::TypeRelation;
+use ty::error::TypeError::{TupleSize, Sorts};
 use middle::lang_items;
 
 use rustc_data_structures::bitvec::BitVector;
@@ -2425,7 +2426,42 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
                                        expected_trait_ref.clone(),
                                        obligation_trait_ref.clone())
             .map(|InferOk { obligations, .. }| self.inferred_obligations.extend(obligations))
-            .map_err(|e| OutputTypeParameterMismatch(expected_trait_ref, obligation_trait_ref, e))
+            .map_err(|e| {
+                let self_ty = expected_trait_ref.self_ty();
+                match (&self_ty.sty, &e) {
+                    (&ty::TyClosure(def_id, ..), &TupleSize(expected_found)) |
+                    (&ty::TyFnDef(def_id, ..), &TupleSize(expected_found)) => {
+                        // Expected `fn(x)`/`|x| { }`, found `fn(x, y)`/`|x, y| { }`
+                        ParameterCountMismatch(expected_found, self_ty, def_id)
+                    }
+                    (&ty::TyClosure(def_id, ..), &Sorts(expected_found)) |
+                    (&ty::TyFnDef(def_id, ..), &Sorts(expected_found)) => {
+                        // Expected `|| { }`, found `|x, y| { }`
+                        // Expected `fn(x)`, found `|| { }`
+                        let expected = if let ty::TyTuple(tys, _) = expected_found.expected.sty {
+                            tys.len()
+                        } else {
+                            1
+                        };
+                        let found = if let ty::TyTuple(tys, _) = expected_found.found.sty {
+                            tys.len()
+                        } else {
+                            1
+                        };
+
+                        if expected != found {
+                            let expected_found = ty::error::ExpectedFound {
+                                expected: expected,
+                                found: found,
+                            };
+                            ParameterCountMismatch(expected_found, self_ty, def_id)
+                        } else {
+                            OutputTypeParameterMismatch(expected_trait_ref, obligation_trait_ref, e)
+                        }
+                    }
+                    _ => OutputTypeParameterMismatch(expected_trait_ref, obligation_trait_ref, e),
+                }
+            })
     }
 
     fn confirm_builtin_unsize_candidate(&mut self,

src/librustc/traits/structural_impls.rs

@@ -151,6 +151,11 @@ impl<'a, 'tcx> Lift<'tcx> for traits::SelectionError<'a> {
     fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<Self::Lifted> {
         match *self {
             super::Unimplemented => Some(super::Unimplemented),
+            super::ParameterCountMismatch(expected_found, ref ty, def_id) => {
+                tcx.lift(ty).map(|ty| {
+                    super::ParameterCountMismatch(expected_found, ty, def_id)
+                })
+            }
             super::OutputTypeParameterMismatch(a, b, ref err) => {
                 tcx.lift(&(a, b)).and_then(|(a, b)| {
                     tcx.lift(err).map(|err| {

src/librustc/ty/error.rs

@@ -20,14 +20,14 @@ use syntax_pos::Span;
 
 use hir;
 
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct ExpectedFound<T> {
     pub expected: T,
     pub found: T,
 }
 
 // Data structures used in type unification
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum TypeError<'tcx> {
     Mismatch,
     UnsafetyMismatch(ExpectedFound<hir::Unsafety>),

src/librustc/ty/mod.rs

@@ -613,7 +613,7 @@ pub struct ClosureUpvar<'tcx> {
     pub ty: Ty<'tcx>,
 }
 
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
 pub enum IntVarValue {
     IntType(ast::IntTy),
     UintType(ast::UintTy),

src/librustc_data_structures/obligation_forest/mod.rs

@@ -261,7 +261,7 @@ impl<O: ForestObligation> ObligationForest<O> {
     /// Convert all remaining obligations to the given error.
     ///
     /// This cannot be done during a snapshot.
-    pub fn to_errors<E: Clone>(&mut self, error: E) -> Vec<Error<O, E>> {
+    pub fn to_errors<E: Clone + Debug>(&mut self, error: E) -> Vec<Error<O, E>> {
         assert!(!self.in_snapshot());
         let mut errors = vec![];
         for index in 0..self.nodes.len() {

src/test/compile-fail/extern-wrong-value-type.rs

@@ -18,5 +18,4 @@ fn main() {
     let _x: extern "C" fn() = f; // OK
     is_fn(f);
     //~^ ERROR `extern "C" fn() {f}: std::ops::Fn<()>` is not satisfied
-    //~| ERROR `extern "C" fn() {f}: std::ops::FnOnce<()>` is not satisfied
 }

src/test/compile-fail/fn-trait-formatting.rs

@@ -28,5 +28,4 @@ fn main() {
 
     needs_fn(1);
     //~^ ERROR : std::ops::Fn<(isize,)>`
-    //~| ERROR : std::ops::FnOnce<(isize,)>`
 }