Detect duplicate implementations of assoc. types and constants.

Adds error codes E0398 and E0399.

Fixes rust-lang#23969.

src/librustc_typeck/collect.rs

@@ -856,8 +856,14 @@ fn convert_item(ccx: &CrateCtxt, it: &ast::Item) {
             };
 
             // Convert all the associated consts.
+            let mut seen_consts = FnvHashSet();
             for impl_item in impl_items {
                 if let ast::ConstImplItem(ref ty, ref expr) = impl_item.node {
+                    if !seen_consts.insert(impl_item.ident.name) {
+                        span_err!(tcx.sess, impl_item.span, E0398,
+                                  "duplicate associated constant");
+                    }
+
                     let ty = ccx.icx(&ty_predicates)
                                 .to_ty(&ExplicitRscope, &*ty);
                     tcx.tcache.borrow_mut().insert(local_def(impl_item.id),
@@ -873,8 +879,13 @@ fn convert_item(ccx: &CrateCtxt, it: &ast::Item) {
             }
 
             // Convert all the associated types.
+            let mut seen_types = FnvHashSet();
             for impl_item in impl_items {
                 if let ast::TypeImplItem(ref ty) = impl_item.node {
+                    if !seen_types.insert(impl_item.ident.name) {
+                        span_err!(tcx.sess, impl_item.span, E0399,
+                                  "duplicate associated type");
+                    }
                     if opt_trait_ref.is_none() {
                         span_err!(tcx.sess, impl_item.span, E0202,
                                   "associated types are not allowed in inherent impls");

src/librustc_typeck/diagnostics.rs

@@ -1284,6 +1284,8 @@ register_diagnostics! {
            // `#[lang = \"{}\"]` is allowed for the `{}` primitive
     E0391, // unsupported cyclic reference between types/traits detected
     E0392, // parameter `{}` is never used
-    E0393  // the type parameter `{}` must be explicitly specified in an object
+    E0393, // the type parameter `{}` must be explicitly specified in an object
            // type because its default value `{}` references the type `Self`"
+    E0398, // duplicate associated constant
+    E0399  // duplicate associated type
 }

src/test/compile-fail/duplicate-assoc-type.rs

@@ -0,0 +1,28 @@
+// Copyright 2015 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.
+//
+// Before the introduction of the "duplicate associated type" error, the
+// program below used to result in the "ambiguous associated type" error E0223,
+// which is unexpected.
+
+trait Foo {
+    type Bar;
+}
+
+struct Baz;
+
+impl Foo for Baz {
+    type Bar = i16;
+    type Bar = u16; //~ ERROR duplicate associated type
+}
+
+fn main() {
+    let x: Baz::Bar = 5;
+}

src/test/compile-fail/issue-23969.rs

@@ -0,0 +1,28 @@
+// Copyright 2015 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.
+
+#![feature(associated_consts)]
+
+trait Foo {
+    type Ty;
+    const BAR: u32;
+}
+
+impl Foo for () {
+    type Ty = ();
+    type Ty = usize; //~ ERROR duplicate associated type
+    const BAR: u32 = 7;
+    const BAR: u32 = 8; //~ ERROR duplicate associated constant
+}
+
+fn main() {
+    let _: <() as Foo>::Ty = ();
+    let _: u32 = <() as Foo>::BAR;
+}