From 560bb0af6d0dda06b856a80cc5095b7d552b8406 Mon Sep 17 00:00:00 2001 From: Nick Hamann Date: Wed, 3 Jun 2015 00:47:41 -0500 Subject: [PATCH 1/3] Better detection of duplicate associated items. Expands E0201 to be used for any duplicate associated items, not just duplicate methods/functions. It also correctly detects when two different kinds of items (like a constant and a method) have the same name. Fixes #23969. --- src/librustc_typeck/collect.rs | 35 +++++++++++++------ src/librustc_typeck/diagnostics.rs | 13 ++++--- .../associated-item-duplicate-names-2.rs | 20 +++++++++++ .../associated-item-duplicate-names-3.rs | 28 +++++++++++++++ .../associated-item-duplicate-names.rs | 30 ++++++++++++++++ 5 files changed, 111 insertions(+), 15 deletions(-) create mode 100644 src/test/compile-fail/associated-item-duplicate-names-2.rs create mode 100644 src/test/compile-fail/associated-item-duplicate-names-3.rs create mode 100644 src/test/compile-fail/associated-item-duplicate-names.rs diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index aabd33d9c1d3a..82449296eae1e 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -748,17 +748,7 @@ fn convert_methods<'a,'tcx,'i,I>(ccx: &CrateCtxt<'a, 'tcx>, rcvr_ty_generics.repr(ccx.tcx), rcvr_ty_predicates.repr(ccx.tcx)); - let tcx = ccx.tcx; - let mut seen_methods = FnvHashSet(); - for (sig, id, ident, vis, span) in methods { - if !seen_methods.insert(ident.name) { - let fn_desc = match sig.explicit_self.node { - ast::SelfStatic => "associated function", - _ => "method", - }; - span_err!(tcx.sess, span, E0201, "duplicate {}", fn_desc); - } - + for (sig, id, ident, vis, _span) in methods { convert_method(ccx, container, sig, @@ -860,7 +850,30 @@ fn convert_item(ccx: &CrateCtxt, it: &ast::Item) { }; // Convert all the associated consts. + // Also, check if there are any duplicate associated items + let mut seen_type_items = FnvHashSet(); + let mut seen_value_items = FnvHashSet(); + for impl_item in impl_items { + let seen_items = match impl_item.node { + ast::TypeImplItem(_) => &mut seen_type_items, + _ => &mut seen_value_items, + }; + if !seen_items.insert(impl_item.ident.name) { + let desc = match impl_item.node { + ast::ConstImplItem(_, _) => "associated constant", + ast::TypeImplItem(_) => "associated type", + ast::MethodImplItem(ref sig, _) => + match sig.explicit_self.node { + ast::SelfStatic => "associated function", + _ => "method", + }, + _ => "associated item", + }; + + span_err!(tcx.sess, impl_item.span, E0201, "duplicate {}", desc); + } + if let ast::ConstImplItem(ref ty, ref expr) = impl_item.node { let ty = ccx.icx(&ty_predicates) .to_ty(&ExplicitRscope, &*ty); diff --git a/src/librustc_typeck/diagnostics.rs b/src/librustc_typeck/diagnostics.rs index d89174295a892..c9ff6e36e66ed 100644 --- a/src/librustc_typeck/diagnostics.rs +++ b/src/librustc_typeck/diagnostics.rs @@ -1036,7 +1036,8 @@ unsafe impl Bar for Foo { } "##, E0201: r##" -It is an error to define an associated function more than once. +It is an error to define two associated items (like methods, associated types, +associated functions, etc.) with the same identifier. For example: @@ -1045,20 +1046,24 @@ struct Foo(u8); impl Foo { fn bar(&self) -> bool { self.0 > 5 } - - // error: duplicate associated function - fn bar() {} + fn bar() {} // error: duplicate associated function } trait Baz { + type Quux; fn baz(&self) -> bool; } impl Baz for Foo { + type Quux = u32; + fn baz(&self) -> bool { true } // error: duplicate method fn baz(&self) -> bool { self.0 > 5 } + + // error: duplicate associated type + type Quux = u32; } ``` "##, diff --git a/src/test/compile-fail/associated-item-duplicate-names-2.rs b/src/test/compile-fail/associated-item-duplicate-names-2.rs new file mode 100644 index 0000000000000..6a7eaecae7f42 --- /dev/null +++ b/src/test/compile-fail/associated-item-duplicate-names-2.rs @@ -0,0 +1,20 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![feature(associated_consts)] + +struct Foo; + +impl Foo { + const bar: bool = true; + fn bar() {} //~ ERROR duplicate associated function +} + +fn main() {} diff --git a/src/test/compile-fail/associated-item-duplicate-names-3.rs b/src/test/compile-fail/associated-item-duplicate-names-3.rs new file mode 100644 index 0000000000000..7c4c5ca6b4eab --- /dev/null +++ b/src/test/compile-fail/associated-item-duplicate-names-3.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 or the MIT license +// , 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; +} diff --git a/src/test/compile-fail/associated-item-duplicate-names.rs b/src/test/compile-fail/associated-item-duplicate-names.rs new file mode 100644 index 0000000000000..4c484b49024ef --- /dev/null +++ b/src/test/compile-fail/associated-item-duplicate-names.rs @@ -0,0 +1,30 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Test for issue #23969 + +#![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; +} From 4ec64453ae8a84099c83663344ccd2d3b2ce7f94 Mon Sep 17 00:00:00 2001 From: Lee Jeffery Date: Thu, 16 Jul 2015 14:36:05 +0100 Subject: [PATCH 2/3] Fix typo in stability attribute. --- src/libstd/sys/windows/ext/raw.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libstd/sys/windows/ext/raw.rs b/src/libstd/sys/windows/ext/raw.rs index e1796d4b5f073..92d53e2e42884 100644 --- a/src/libstd/sys/windows/ext/raw.rs +++ b/src/libstd/sys/windows/ext/raw.rs @@ -10,7 +10,7 @@ //! Windows-specific primitives -#[stable(feature = "raw_ext", since = "1.1.0")] +#![stable(feature = "raw_ext", since = "1.1.0")] use os::raw::c_void; From 2d32a15667c6d04db96938d1e3e56db34c0a9415 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20S=C3=B6derstr=C3=B6m?= Date: Thu, 16 Jul 2015 20:43:36 -0700 Subject: [PATCH 3/3] Fixed typo --- src/libstd/env.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libstd/env.rs b/src/libstd/env.rs index b65e065fe9148..6842de56d215d 100644 --- a/src/libstd/env.rs +++ b/src/libstd/env.rs @@ -11,7 +11,7 @@ //! Inspection and manipulation of the process's environment. //! //! This module contains methods to inspect various aspects such as -//! environment varibles, process arguments, the current directory, and various +//! environment variables, process arguments, the current directory, and various //! other important directories. #![stable(feature = "env", since = "1.0.0")]