Check duplicated paramter bounds, refs rust-lang#2687

Author: fhahn

src/librustc/middle/lint.rs

@@ -102,6 +102,7 @@ pub enum Lint {
     DeadCode,
     VisiblePrivateTypes,
     UnnecessaryTypecast,
+    DuplicatedTypeBound,
 
     MissingDoc,
     UnreachableCode,
@@ -304,6 +305,13 @@ static lint_table: &'static [(&'static str, LintSpec)] = &[
         default: allow,
     }),
 
+    ("duplicated_type_bound",
+     LintSpec {
+        lint: DuplicatedTypeBound,
+        desc: "detects duplicated type bound",
+        default: warn
+    }),
+
     ("unused_mut",
      LintSpec {
         lint: UnusedMut,

src/librustc/middle/typeck/collect.rs

@@ -33,6 +33,7 @@ are represented as `ty_param()` instances.
 
 use metadata::csearch;
 use middle::resolve_lifetime;
+use middle::lint::DuplicatedTypeBound;
 use middle::ty::{ImplContainer, MethodContainer, TraitContainer, substs};
 use middle::ty::{ty_param_bounds_and_ty};
 use middle::ty;
@@ -45,6 +46,8 @@ use middle::typeck::{CrateCtxt, lookup_def_tcx, no_params, write_ty_to_tcx};
 use util::ppaux;
 use util::ppaux::Repr;
 
+use collections::HashSet;
+
 use std::rc::Rc;
 use std::vec_ng::Vec;
 use std::vec_ng;
@@ -1029,20 +1032,21 @@ pub fn ty_generics(ccx: &CrateCtxt,
             builtin_bounds: ty::EmptyBuiltinBounds(),
             trait_bounds: Vec::new()
         };
+
+        let mut added_bounds = HashSet::new();
         for ast_bound in ast_bounds.iter() {
             match *ast_bound {
                 TraitTyParamBound(ref b) => {
                     let ty = ty::mk_param(ccx.tcx, param_ty.idx, param_ty.def_id);
                     let trait_ref = instantiate_trait_ref(ccx, b, ty);
-                    if added_bounds.contains_key(&trait_ref.def_id) {
-                        ccx.tcx.sess.span_warn(
+                    if !added_bounds.insert(trait_ref.def_id) {
+                        ccx.tcx.sess.add_lint(
+                            DuplicatedTypeBound,
+                            0,
                             b.path.span,
                             format!("duplicated bound `{}`, ignoring it",
                                     trait_ref.repr(ccx.tcx)));
                         continue;
-
-                    } else {
-                        added_bounds.insert(trait_ref.def_id, ());
                     }
 
                     if !ty::try_add_builtin_trait(

src/test/compile-fail/typeck-duplicated-trait-bounds.rs

@@ -0,0 +1,36 @@
+// Copyright 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 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+//
+// Tests contravariant type parameters in implementations of traits, see #2687
+
+#[deny(duplicated_type_bound)];
+
+trait A {}
+
+trait Foo {
+    fn test_duplicated_builtin_bounds_fn<T: Eq+Ord+Eq>(&self);
+    //~^ ERROR duplicated bound `std::cmp::Eq`, ignoring it
+
+    fn test_duplicated_user_bounds_fn<T: A+A>(&self);
+    //~^ ERROR duplicated bound `A`, ignoring it
+}
+
+impl Foo for int {
+    fn test_duplicated_builtin_bounds_fn<T: Eq+Ord+Eq+Eq>(&self) {}
+    //~^ ERROR duplicated bound `std::cmp::Eq`, ignoring it
+    //~^^ ERROR duplicated bound `std::cmp::Eq`, ignoring it
+
+    fn test_duplicated_user_bounds_fn<T: A+A+A+A>(&self) {}
+    //~^ ERROR duplicated bound `A`, ignoring it
+    //~^^ ERROR duplicated bound `A`, ignoring it
+    //~^^^ ERROR duplicated bound `A`, ignoring it
+}
+
+fn main() {}

src/test/run-pass/typeck-contravariant-trait-bounds-impl.rs

@@ -39,7 +39,6 @@ impl B for u32 {
 trait Foo {
     fn test_fn<T: B>(&self, x: T) -> int;
     fn test_duplicated_bounds1_fn<T: B+B>(&self) -> int;
-    //~^ warn: duplicated bound `B`, ignoring it
     fn test_duplicated_bounds2_fn<T: B>(&self) -> int;
 }
 
@@ -49,12 +48,10 @@ impl Foo for int {
     }
 
     fn test_duplicated_bounds1_fn<T: B+B>(&self) -> int {
-        //~^ warn: duplicated bound `B`, ignoring it
         99
     }
 
     fn test_duplicated_bounds2_fn<T: B+B>(&self) -> int {
-        //~^ warn: duplicated bound `B`, ignoring it
         199
     }
 }