From 8978bf61a1e5c060fc101ef818f1811c277079f8 Mon Sep 17 00:00:00 2001
From: Sean Griffin <sean@seantheprogrammer.com>
Date: Sat, 25 Feb 2017 16:16:27 -0500
Subject: [PATCH 1/6] Implement RFC 1268

This patch allows overlap to occur between any two impls of a trait for
traits which have no associated items.

Several compile-fail tests around coherence had to be changed to add at
least one item to the trait they test against.

Ref #29864
---
 src/librustc/traits/specialize/mod.rs         |  5 ++++
 .../traits/specialize/specialization_graph.rs |  5 ++++
 src/librustc/ty/mod.rs                        | 10 ++++++++
 src/test/compile-fail/E0120.rs                |  2 +-
 ...herence-conflicting-negative-trait-impl.rs |  2 +-
 .../coherence-default-trait-impl.rs           |  2 +-
 src/test/compile-fail/coherence-impls-send.rs |  1 -
 .../coherence-no-direct-lifetime-dispatch.rs  |  2 +-
 .../coherence-overlap-all-t-and-tuple.rs      |  1 +
 .../coherence-overlap-messages.rs             |  8 +++----
 .../coherence-projection-conflict-orphan.rs   |  2 +-
 .../coherence-projection-conflict-ty-param.rs |  2 +-
 .../coherence-projection-conflict.rs          |  2 +-
 ...erence_copy_like_err_fundamental_struct.rs |  2 +-
 ...ce_copy_like_err_fundamental_struct_ref.rs |  2 +-
 ..._copy_like_err_fundamental_struct_tuple.rs |  2 +-
 .../coherence_copy_like_err_struct.rs         |  2 +-
 .../coherence_copy_like_err_tuple.rs          |  2 +-
 .../specialization/specialization-overlap.rs  |  8 +++----
 .../overlap-permitted-for-marker-traits.rs    | 23 +++++++++++++++++++
 20 files changed, 64 insertions(+), 21 deletions(-)
 create mode 100644 src/test/run-pass/overlap-permitted-for-marker-traits.rs

diff --git a/src/librustc/traits/specialize/mod.rs b/src/librustc/traits/specialize/mod.rs
index 50a4d982832ac..6455de48a299d 100644
--- a/src/librustc/traits/specialize/mod.rs
+++ b/src/librustc/traits/specialize/mod.rs
@@ -155,6 +155,11 @@ pub fn specializes<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         return r;
     }
 
+    if tcx.impl_always_allowed_to_overlap(impl1_def_id)
+        && tcx.impl_always_allowed_to_overlap(impl2_def_id) {
+        return true;
+    }
+
     // The feature gate should prevent introducing new specializations, but not
     // taking advantage of upstream ones.
     if !tcx.sess.features.borrow().specialization &&
diff --git a/src/librustc/traits/specialize/specialization_graph.rs b/src/librustc/traits/specialize/specialization_graph.rs
index 40eb69395678f..87abe681d3938 100644
--- a/src/librustc/traits/specialize/specialization_graph.rs
+++ b/src/librustc/traits/specialize/specialization_graph.rs
@@ -113,6 +113,11 @@ impl<'a, 'gcx, 'tcx> Children {
                                                         possible_sibling,
                                                         impl_def_id);
                 if let Some(impl_header) = overlap {
+                    if tcx.impl_always_allowed_to_overlap(impl_def_id)
+                        && tcx.impl_always_allowed_to_overlap(possible_sibling) {
+                        return Ok((true, true));
+                    }
+
                     let le = specializes(tcx, impl_def_id, possible_sibling);
                     let ge = specializes(tcx, possible_sibling, impl_def_id);
 
diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
index 6a4e7db21dd12..0901f3b70a399 100644
--- a/src/librustc/ty/mod.rs
+++ b/src/librustc/ty/mod.rs
@@ -2158,6 +2158,16 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         queries::impl_trait_ref::get(self, DUMMY_SP, id)
     }
 
+    /// Returns true if the impl is positive and is for a triat which contains
+    /// no items
+    pub fn impl_always_allowed_to_overlap(self, def_id: DefId) -> bool {
+        self.trait_impl_polarity(def_id) == hir::ImplPolarity::Positive
+            && self.impl_trait_ref(def_id)
+                .map_or(false, |trait_ref| {
+                    self.associated_item_def_ids(trait_ref.def_id).is_empty()
+                })
+    }
+
     // Returns `ty::VariantDef` if `def` refers to a struct,
     // or variant or their constructors, panics otherwise.
     pub fn expect_variant_def(self, def: Def) -> &'tcx VariantDef {
diff --git a/src/test/compile-fail/E0120.rs b/src/test/compile-fail/E0120.rs
index 3fdeb75317540..80cc0d2680f7c 100644
--- a/src/test/compile-fail/E0120.rs
+++ b/src/test/compile-fail/E0120.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-trait MyTrait {}
+trait MyTrait { fn foo() {} }
 
 impl Drop for MyTrait {
               //~^ ERROR E0120
diff --git a/src/test/compile-fail/coherence-conflicting-negative-trait-impl.rs b/src/test/compile-fail/coherence-conflicting-negative-trait-impl.rs
index 7fd1b17f2966c..d841e8c41d984 100644
--- a/src/test/compile-fail/coherence-conflicting-negative-trait-impl.rs
+++ b/src/test/compile-fail/coherence-conflicting-negative-trait-impl.rs
@@ -20,8 +20,8 @@ impl<T: MyTrait> !Send for TestType<T> {}
 //~^ ERROR conflicting implementations of trait `std::marker::Send`
 
 unsafe impl<T:'static> Send for TestType<T> {}
-//~^ ERROR conflicting implementations of trait `std::marker::Send`
 
 impl !Send for TestType<i32> {}
+//~^ ERROR conflicting implementations of trait `std::marker::Send`
 
 fn main() {}
diff --git a/src/test/compile-fail/coherence-default-trait-impl.rs b/src/test/compile-fail/coherence-default-trait-impl.rs
index 15a80c64f8b06..e6bf068156c2b 100644
--- a/src/test/compile-fail/coherence-default-trait-impl.rs
+++ b/src/test/compile-fail/coherence-default-trait-impl.rs
@@ -10,7 +10,7 @@
 
 #![feature(optin_builtin_traits)]
 
-trait MyTrait {}
+trait MyTrait { fn foo() {} }
 
 impl MyTrait for .. {}
 //~^ ERROR redundant default implementations of trait `MyTrait`
diff --git a/src/test/compile-fail/coherence-impls-send.rs b/src/test/compile-fail/coherence-impls-send.rs
index f130a9353516f..d0e6bc6a1c699 100644
--- a/src/test/compile-fail/coherence-impls-send.rs
+++ b/src/test/compile-fail/coherence-impls-send.rs
@@ -34,7 +34,6 @@ unsafe impl Send for [MyType] {}
 
 unsafe impl Send for &'static [NotSync] {}
 //~^ ERROR E0117
-//~| ERROR E0119
 
 fn main() {
 }
diff --git a/src/test/compile-fail/coherence-no-direct-lifetime-dispatch.rs b/src/test/compile-fail/coherence-no-direct-lifetime-dispatch.rs
index 6de338f1db0fa..47026cd32d411 100644
--- a/src/test/compile-fail/coherence-no-direct-lifetime-dispatch.rs
+++ b/src/test/compile-fail/coherence-no-direct-lifetime-dispatch.rs
@@ -10,7 +10,7 @@
 
 // Test that you cannot *directly* dispatch on lifetime requirements
 
-trait MyTrait {}
+trait MyTrait { fn foo() {} }
 
 impl<T> MyTrait for T {}
 impl<T: 'static> MyTrait for T {} //~ ERROR E0119
diff --git a/src/test/compile-fail/coherence-overlap-all-t-and-tuple.rs b/src/test/compile-fail/coherence-overlap-all-t-and-tuple.rs
index 928ba7a36db26..1fad608db6c3b 100644
--- a/src/test/compile-fail/coherence-overlap-all-t-and-tuple.rs
+++ b/src/test/compile-fail/coherence-overlap-all-t-and-tuple.rs
@@ -17,6 +17,7 @@
 // Seems pretty basic, but then there was issue #24241. :)
 
 trait From<U> {
+    fn foo() {}
 }
 
 impl <T> From<T> for T {
diff --git a/src/test/compile-fail/coherence-overlap-messages.rs b/src/test/compile-fail/coherence-overlap-messages.rs
index 0ae8135221c21..a10deeafbe67e 100644
--- a/src/test/compile-fail/coherence-overlap-messages.rs
+++ b/src/test/compile-fail/coherence-overlap-messages.rs
@@ -8,22 +8,22 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-trait Foo {}
+trait Foo { fn foo() {} }
 
 impl<T> Foo for T {}
 impl<U> Foo for U {} //~ ERROR conflicting implementations of trait `Foo`:
 
-trait Bar {}
+trait Bar { fn bar() {} }
 
 impl<T> Bar for (T, u8) {}
 impl<T> Bar for (u8, T) {} //~ ERROR conflicting implementations of trait `Bar` for type `(u8, u8)`:
 
-trait Baz<T> {}
+trait Baz<T> { fn baz() {} }
 
 impl<T> Baz<u8> for T {}
 impl<T> Baz<T> for u8 {} //~ ERROR conflicting implementations of trait `Baz<u8>` for type `u8`:
 
-trait Quux<U, V> {}
+trait Quux<U, V> { fn quux() {} }
 
 impl<T, U, V> Quux<U, V> for T {}
 impl<T, U> Quux<U, U> for T {} //~ ERROR conflicting implementations of trait `Quux<_, _>`:
diff --git a/src/test/compile-fail/coherence-projection-conflict-orphan.rs b/src/test/compile-fail/coherence-projection-conflict-orphan.rs
index 3ed3549de89aa..784ff0cd5e0aa 100644
--- a/src/test/compile-fail/coherence-projection-conflict-orphan.rs
+++ b/src/test/compile-fail/coherence-projection-conflict-orphan.rs
@@ -15,7 +15,7 @@
 // due to the orphan rules. Therefore, `A::Item` may yet turn out to
 // be `i32`.
 
-pub trait Foo<P> {}
+pub trait Foo<P> { fn foo() {} }
 
 pub trait Bar {
     type Output: 'static;
diff --git a/src/test/compile-fail/coherence-projection-conflict-ty-param.rs b/src/test/compile-fail/coherence-projection-conflict-ty-param.rs
index f04902a70f68c..120d9046389a1 100644
--- a/src/test/compile-fail/coherence-projection-conflict-ty-param.rs
+++ b/src/test/compile-fail/coherence-projection-conflict-ty-param.rs
@@ -13,7 +13,7 @@
 
 use std::marker::PhantomData;
 
-pub trait Foo<P> {}
+pub trait Foo<P> { fn foo() {} }
 
 impl <P, T: Foo<P>> Foo<P> for Option<T> {}
 
diff --git a/src/test/compile-fail/coherence-projection-conflict.rs b/src/test/compile-fail/coherence-projection-conflict.rs
index 6d3ab32f06f43..3c32ab38b93dc 100644
--- a/src/test/compile-fail/coherence-projection-conflict.rs
+++ b/src/test/compile-fail/coherence-projection-conflict.rs
@@ -10,7 +10,7 @@
 
 use std::marker::PhantomData;
 
-pub trait Foo<P> {}
+pub trait Foo<P> { fn foo() {} }
 
 pub trait Bar {
     type Output: 'static;
diff --git a/src/test/compile-fail/coherence_copy_like_err_fundamental_struct.rs b/src/test/compile-fail/coherence_copy_like_err_fundamental_struct.rs
index fcd6e5c495207..9fbb7aa4cb1a7 100644
--- a/src/test/compile-fail/coherence_copy_like_err_fundamental_struct.rs
+++ b/src/test/compile-fail/coherence_copy_like_err_fundamental_struct.rs
@@ -20,7 +20,7 @@ extern crate coherence_copy_like_lib as lib;
 
 struct MyType { x: i32 }
 
-trait MyTrait { }
+trait MyTrait { fn foo() {} }
 impl<T: lib::MyCopy> MyTrait for T { }
 
 // `MyFundamentalStruct` is declared fundamental, so we can test that
diff --git a/src/test/compile-fail/coherence_copy_like_err_fundamental_struct_ref.rs b/src/test/compile-fail/coherence_copy_like_err_fundamental_struct_ref.rs
index b5c0a7fb5f564..2f6dca4f3c271 100644
--- a/src/test/compile-fail/coherence_copy_like_err_fundamental_struct_ref.rs
+++ b/src/test/compile-fail/coherence_copy_like_err_fundamental_struct_ref.rs
@@ -20,7 +20,7 @@ extern crate coherence_copy_like_lib as lib;
 
 struct MyType { x: i32 }
 
-trait MyTrait { }
+trait MyTrait { fn foo() {} }
 impl<T: lib::MyCopy> MyTrait for T { }
 
 // `MyFundamentalStruct` is declared fundamental, so we can test that
diff --git a/src/test/compile-fail/coherence_copy_like_err_fundamental_struct_tuple.rs b/src/test/compile-fail/coherence_copy_like_err_fundamental_struct_tuple.rs
index 8e3e3f31cb5f1..f424e8872010f 100644
--- a/src/test/compile-fail/coherence_copy_like_err_fundamental_struct_tuple.rs
+++ b/src/test/compile-fail/coherence_copy_like_err_fundamental_struct_tuple.rs
@@ -19,7 +19,7 @@ extern crate coherence_copy_like_lib as lib;
 
 struct MyType { x: i32 }
 
-trait MyTrait { }
+trait MyTrait { fn foo() {} }
 
 impl<T: lib::MyCopy> MyTrait for T { }
 
diff --git a/src/test/compile-fail/coherence_copy_like_err_struct.rs b/src/test/compile-fail/coherence_copy_like_err_struct.rs
index 35bc17b8e8870..04262e65c5a2a 100644
--- a/src/test/compile-fail/coherence_copy_like_err_struct.rs
+++ b/src/test/compile-fail/coherence_copy_like_err_struct.rs
@@ -17,7 +17,7 @@ extern crate coherence_copy_like_lib as lib;
 
 struct MyType { x: i32 }
 
-trait MyTrait { }
+trait MyTrait { fn foo() {} }
 impl<T: lib::MyCopy> MyTrait for T { }
 
 // `MyStruct` is not declared fundamental, therefore this would
diff --git a/src/test/compile-fail/coherence_copy_like_err_tuple.rs b/src/test/compile-fail/coherence_copy_like_err_tuple.rs
index a70cc92955fb0..378a70864f0ee 100644
--- a/src/test/compile-fail/coherence_copy_like_err_tuple.rs
+++ b/src/test/compile-fail/coherence_copy_like_err_tuple.rs
@@ -17,7 +17,7 @@ extern crate coherence_copy_like_lib as lib;
 
 struct MyType { x: i32 }
 
-trait MyTrait { }
+trait MyTrait { fn foo() {} }
 impl<T: lib::MyCopy> MyTrait for T { }
 
 // Tuples are not fundamental, therefore this would require that
diff --git a/src/test/compile-fail/specialization/specialization-overlap.rs b/src/test/compile-fail/specialization/specialization-overlap.rs
index f579817100107..ff12a82db5b7d 100644
--- a/src/test/compile-fail/specialization/specialization-overlap.rs
+++ b/src/test/compile-fail/specialization/specialization-overlap.rs
@@ -10,19 +10,19 @@
 
 #![feature(specialization)]
 
-trait Foo {}
+trait Foo { fn foo() {} }
 impl<T: Clone> Foo for T {}
 impl<T> Foo for Vec<T> {} //~ ERROR E0119
 
-trait Bar {}
+trait Bar { fn bar() {} }
 impl<T> Bar for (T, u8) {}
 impl<T> Bar for (u8, T) {} //~ ERROR E0119
 
-trait Baz<U> {}
+trait Baz<U> { fn baz() {} }
 impl<T> Baz<T> for u8 {}
 impl<T> Baz<u8> for T {} //~ ERROR E0119
 
-trait Qux {}
+trait Qux { fn qux() {} }
 impl<T: Clone> Qux for T {}
 impl<T: Eq> Qux for T {} //~ ERROR E0119
 
diff --git a/src/test/run-pass/overlap-permitted-for-marker-traits.rs b/src/test/run-pass/overlap-permitted-for-marker-traits.rs
new file mode 100644
index 0000000000000..66c45e6718331
--- /dev/null
+++ b/src/test/run-pass/overlap-permitted-for-marker-traits.rs
@@ -0,0 +1,23 @@
+// Copyright 2017 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.
+
+trait MyMarker {}
+
+impl<T: Copy> MyMarker for T {}
+impl<T: Eq> MyMarker for T {}
+
+fn foo<T: MyMarker>(t: T) -> T {
+    t
+}
+
+fn main() {
+    assert_eq!(1, foo(1));
+    assert_eq!(vec![1], foo(vec![1]));
+}

From 333a1cd49780fe4a7ea1fa0e3e8371324678b88b Mon Sep 17 00:00:00 2001
From: Sean Griffin <sean@seantheprogrammer.com>
Date: Fri, 3 Mar 2017 09:09:09 -0500
Subject: [PATCH 2/6] Update with response to feedback

---
 src/librustc/ty/mod.rs                                   | 2 +-
 src/test/run-pass/overlap-permitted-for-marker-traits.rs | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
index 0901f3b70a399..70b187eedac04 100644
--- a/src/librustc/ty/mod.rs
+++ b/src/librustc/ty/mod.rs
@@ -2158,7 +2158,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         queries::impl_trait_ref::get(self, DUMMY_SP, id)
     }
 
-    /// Returns true if the impl is positive and is for a triat which contains
+    /// Returns true if the impl is positive and is for a trait which contains
     /// no items
     pub fn impl_always_allowed_to_overlap(self, def_id: DefId) -> bool {
         self.trait_impl_polarity(def_id) == hir::ImplPolarity::Positive
diff --git a/src/test/run-pass/overlap-permitted-for-marker-traits.rs b/src/test/run-pass/overlap-permitted-for-marker-traits.rs
index 66c45e6718331..b0b1930d274d6 100644
--- a/src/test/run-pass/overlap-permitted-for-marker-traits.rs
+++ b/src/test/run-pass/overlap-permitted-for-marker-traits.rs
@@ -19,5 +19,6 @@ fn foo<T: MyMarker>(t: T) -> T {
 
 fn main() {
     assert_eq!(1, foo(1));
+    assert_eq!(2.0, foo(2.0));
     assert_eq!(vec![1], foo(vec![1]));
 }

From c3d49c986a82f8436dab2d63b4aa5984f25ef31b Mon Sep 17 00:00:00 2001
From: Sean Griffin <sean@seantheprogrammer.com>
Date: Fri, 17 Mar 2017 12:43:15 -0400
Subject: [PATCH 3/6] Further update with response to feedback

---
 src/librustc/traits/select.rs                 |  3 ++-
 src/librustc/traits/specialize/mod.rs         |  5 -----
 .../traits/specialize/specialization_graph.rs |  5 ++---
 src/librustc/ty/mod.rs                        | 22 ++++++++++++-------
 .../auxiliary/trait_impl_conflict.rs          |  1 +
 5 files changed, 19 insertions(+), 17 deletions(-)

diff --git a/src/librustc/traits/select.rs b/src/librustc/traits/select.rs
index 38ea1e4a19b91..b54b9edc78dde 100644
--- a/src/librustc/traits/select.rs
+++ b/src/librustc/traits/select.rs
@@ -1724,7 +1724,8 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
                 if other.evaluation == EvaluatedToOk {
                     if let ImplCandidate(victim_def) = victim.candidate {
                         let tcx = self.tcx().global_tcx();
-                        return traits::specializes(tcx, other_def, victim_def);
+                        return traits::specializes(tcx, other_def, victim_def) ||
+                            tcx.impls_are_allowed_to_overlap(other_def, victim_def);
                     }
                 }
 
diff --git a/src/librustc/traits/specialize/mod.rs b/src/librustc/traits/specialize/mod.rs
index 6455de48a299d..50a4d982832ac 100644
--- a/src/librustc/traits/specialize/mod.rs
+++ b/src/librustc/traits/specialize/mod.rs
@@ -155,11 +155,6 @@ pub fn specializes<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         return r;
     }
 
-    if tcx.impl_always_allowed_to_overlap(impl1_def_id)
-        && tcx.impl_always_allowed_to_overlap(impl2_def_id) {
-        return true;
-    }
-
     // The feature gate should prevent introducing new specializations, but not
     // taking advantage of upstream ones.
     if !tcx.sess.features.borrow().specialization &&
diff --git a/src/librustc/traits/specialize/specialization_graph.rs b/src/librustc/traits/specialize/specialization_graph.rs
index 87abe681d3938..6e2c16c82aeb4 100644
--- a/src/librustc/traits/specialize/specialization_graph.rs
+++ b/src/librustc/traits/specialize/specialization_graph.rs
@@ -113,9 +113,8 @@ impl<'a, 'gcx, 'tcx> Children {
                                                         possible_sibling,
                                                         impl_def_id);
                 if let Some(impl_header) = overlap {
-                    if tcx.impl_always_allowed_to_overlap(impl_def_id)
-                        && tcx.impl_always_allowed_to_overlap(possible_sibling) {
-                        return Ok((true, true));
+                    if tcx.impls_are_allowed_to_overlap(impl_def_id, possible_sibling) {
+                        return Ok((false, false));
                     }
 
                     let le = specializes(tcx, impl_def_id, possible_sibling);
diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
index 70b187eedac04..bbb979067cd56 100644
--- a/src/librustc/ty/mod.rs
+++ b/src/librustc/ty/mod.rs
@@ -2158,14 +2158,20 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         queries::impl_trait_ref::get(self, DUMMY_SP, id)
     }
 
-    /// Returns true if the impl is positive and is for a trait which contains
-    /// no items
-    pub fn impl_always_allowed_to_overlap(self, def_id: DefId) -> bool {
-        self.trait_impl_polarity(def_id) == hir::ImplPolarity::Positive
-            && self.impl_trait_ref(def_id)
-                .map_or(false, |trait_ref| {
-                    self.associated_item_def_ids(trait_ref.def_id).is_empty()
-                })
+    /// Returns true if the impls are the same polarity and are implementing
+    /// a trait which contains no items
+    pub fn impls_are_allowed_to_overlap(self, def_id1: DefId, def_id2: DefId) -> bool {
+        let trait1_is_empty = self.impl_trait_ref(def_id1)
+            .map_or(false, |trait_ref| {
+                self.associated_item_def_ids(trait_ref.def_id).is_empty()
+            });
+        let trait2_is_empty = self.impl_trait_ref(def_id2)
+            .map_or(false, |trait_ref| {
+                self.associated_item_def_ids(trait_ref.def_id).is_empty()
+            });
+        self.trait_impl_polarity(def_id1) == self.trait_impl_polarity(def_id2)
+            && trait1_is_empty
+            && trait2_is_empty
     }
 
     // Returns `ty::VariantDef` if `def` refers to a struct,
diff --git a/src/test/compile-fail/auxiliary/trait_impl_conflict.rs b/src/test/compile-fail/auxiliary/trait_impl_conflict.rs
index c3ecbb014dc6b..3190ce430ad67 100644
--- a/src/test/compile-fail/auxiliary/trait_impl_conflict.rs
+++ b/src/test/compile-fail/auxiliary/trait_impl_conflict.rs
@@ -9,6 +9,7 @@
 // except according to those terms.
 
 pub trait Foo {
+    fn foo() {}
 }
 
 impl Foo for isize {

From e5f444da6f92ecb025cfa0f6b6998eab32fc6328 Mon Sep 17 00:00:00 2001
From: Sean Griffin <sean@seantheprogrammer.com>
Date: Fri, 17 Mar 2017 14:16:29 -0400
Subject: [PATCH 4/6] Put overlapping impls behind feature gate, add tests

I've added some explicit tests that negative impls are allowed to
overlap, and also to make sure that the feature doesn't interfere with
specialization. I've not added an explicit test for positive overlapping
with negative, as that's already tested elsewhere.
---
 src/librustc/ty/mod.rs                        |  3 +++
 src/libsyntax/feature_gate.rs                 |  3 +++
 ...herence-conflicting-negative-trait-impl.rs |  1 +
 src/test/compile-fail/coherence-impls-send.rs |  1 +
 ...overlapping-impls-requires-feature-gate.rs | 17 ++++++++++++
 ...lap-doesnt-conflict-with-specialization.rs | 27 +++++++++++++++++++
 .../overlap-permitted-for-marker-traits.rs    |  7 +++++
 7 files changed, 59 insertions(+)
 create mode 100644 src/test/compile-fail/overlapping-impls-requires-feature-gate.rs
 create mode 100644 src/test/run-pass/overlap-doesnt-conflict-with-specialization.rs

diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
index bbb979067cd56..e9f35a5808b7d 100644
--- a/src/librustc/ty/mod.rs
+++ b/src/librustc/ty/mod.rs
@@ -2161,6 +2161,9 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
     /// Returns true if the impls are the same polarity and are implementing
     /// a trait which contains no items
     pub fn impls_are_allowed_to_overlap(self, def_id1: DefId, def_id2: DefId) -> bool {
+        if !self.sess.features.borrow().overlapping_marker_traits {
+            return false;
+        }
         let trait1_is_empty = self.impl_trait_ref(def_id1)
             .map_or(false, |trait_ref| {
                 self.associated_item_def_ids(trait_ref.def_id).is_empty()
diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs
index 12d25ca4274fe..690cf03513c89 100644
--- a/src/libsyntax/feature_gate.rs
+++ b/src/libsyntax/feature_gate.rs
@@ -342,6 +342,9 @@ declare_features! (
 
     // See rust-lang/rfcs#1414. Allows code like `let x: &'static u32 = &42` to work.
     (active, rvalue_static_promotion, "1.15.1", Some(38865)),
+
+    // Allows overlapping impls of marker traits
+    (active, overlapping_marker_traits, "1.18.0", Some(29864)),
 );
 
 declare_features! (
diff --git a/src/test/compile-fail/coherence-conflicting-negative-trait-impl.rs b/src/test/compile-fail/coherence-conflicting-negative-trait-impl.rs
index d841e8c41d984..8e9d1eff34580 100644
--- a/src/test/compile-fail/coherence-conflicting-negative-trait-impl.rs
+++ b/src/test/compile-fail/coherence-conflicting-negative-trait-impl.rs
@@ -9,6 +9,7 @@
 // except according to those terms.
 
 #![feature(optin_builtin_traits)]
+#![feature(overlapping_marker_traits)]
 
 trait MyTrait {}
 
diff --git a/src/test/compile-fail/coherence-impls-send.rs b/src/test/compile-fail/coherence-impls-send.rs
index d0e6bc6a1c699..9caaee41aeb1d 100644
--- a/src/test/compile-fail/coherence-impls-send.rs
+++ b/src/test/compile-fail/coherence-impls-send.rs
@@ -9,6 +9,7 @@
 // except according to those terms.
 
 #![feature(optin_builtin_traits)]
+#![feature(overlapping_marker_traits)]
 
 use std::marker::Copy;
 
diff --git a/src/test/compile-fail/overlapping-impls-requires-feature-gate.rs b/src/test/compile-fail/overlapping-impls-requires-feature-gate.rs
new file mode 100644
index 0000000000000..bf2b06dd8ba0c
--- /dev/null
+++ b/src/test/compile-fail/overlapping-impls-requires-feature-gate.rs
@@ -0,0 +1,17 @@
+// Copyright 2017 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.
+
+trait MyMarker {}
+
+impl<T> MyMarker for T {}
+impl<T> MyMarker for Vec<T> {}
+//~^ ERROR E0119
+
+fn main() {}
diff --git a/src/test/run-pass/overlap-doesnt-conflict-with-specialization.rs b/src/test/run-pass/overlap-doesnt-conflict-with-specialization.rs
new file mode 100644
index 0000000000000..ed45d81c0d6a1
--- /dev/null
+++ b/src/test/run-pass/overlap-doesnt-conflict-with-specialization.rs
@@ -0,0 +1,27 @@
+// Copyright 2017 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(overlapping_marker_traits)]
+#![feature(specialization)]
+
+trait MyMarker {}
+
+impl<T> MyMarker for T {}
+impl<T> MyMarker for Vec<T> {}
+
+fn foo<T: MyMarker>(t: T) -> T {
+    t
+}
+
+fn main() {
+    assert_eq!(1, foo(1));
+    assert_eq!(2.0, foo(2.0));
+    assert_eq!(vec![1], foo(vec![1]));
+}
diff --git a/src/test/run-pass/overlap-permitted-for-marker-traits.rs b/src/test/run-pass/overlap-permitted-for-marker-traits.rs
index b0b1930d274d6..45085c093fc98 100644
--- a/src/test/run-pass/overlap-permitted-for-marker-traits.rs
+++ b/src/test/run-pass/overlap-permitted-for-marker-traits.rs
@@ -8,11 +8,18 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(overlapping_marker_traits)]
+#![feature(optin_builtin_traits)]
+
 trait MyMarker {}
 
 impl<T: Copy> MyMarker for T {}
 impl<T: Eq> MyMarker for T {}
 
+struct MyStruct;
+impl !Send for MyStruct {}
+impl !Send for MyStruct {}
+
 fn foo<T: MyMarker>(t: T) -> T {
     t
 }

From ac38627a309ec9d4b96f596bd57df236e307686c Mon Sep 17 00:00:00 2001
From: Sean Griffin <sean@seantheprogrammer.com>
Date: Fri, 17 Mar 2017 19:20:18 -0400
Subject: [PATCH 5/6] Name files what tidy wants them to be namd

---
 ...-feature-gate.rs => feature-gate-overlapping_marker_traits.rs} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename src/test/compile-fail/{overlapping-impls-requires-feature-gate.rs => feature-gate-overlapping_marker_traits.rs} (100%)

diff --git a/src/test/compile-fail/overlapping-impls-requires-feature-gate.rs b/src/test/compile-fail/feature-gate-overlapping_marker_traits.rs
similarity index 100%
rename from src/test/compile-fail/overlapping-impls-requires-feature-gate.rs
rename to src/test/compile-fail/feature-gate-overlapping_marker_traits.rs

From 665f852ea80dbd6f857fd12bfee251d54d0b55e4 Mon Sep 17 00:00:00 2001
From: Niko Matsakis <niko@alum.mit.edu>
Date: Thu, 30 Mar 2017 08:54:28 -0400
Subject: [PATCH 6/6] update tests slightly

---
 .../feature-gate-overlapping_marker_traits.rs |  6 ++-
 src/test/compile-fail/overlap-marker-trait.rs | 41 +++++++++++++++++++
 ...overlap-permitted-for-marker-traits-neg.rs | 20 +++++++++
 .../overlap-permitted-for-marker-traits.rs    | 17 +++++---
 4 files changed, 76 insertions(+), 8 deletions(-)
 create mode 100644 src/test/compile-fail/overlap-marker-trait.rs
 create mode 100644 src/test/run-pass/overlap-permitted-for-marker-traits-neg.rs

diff --git a/src/test/compile-fail/feature-gate-overlapping_marker_traits.rs b/src/test/compile-fail/feature-gate-overlapping_marker_traits.rs
index bf2b06dd8ba0c..d2aa4e59b5ba9 100644
--- a/src/test/compile-fail/feature-gate-overlapping_marker_traits.rs
+++ b/src/test/compile-fail/feature-gate-overlapping_marker_traits.rs
@@ -8,10 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use std::fmt::{Debug, Display};
+
 trait MyMarker {}
 
-impl<T> MyMarker for T {}
-impl<T> MyMarker for Vec<T> {}
+impl<T: Display> MyMarker for T {}
+impl<T: Debug> MyMarker for T {}
 //~^ ERROR E0119
 
 fn main() {}
diff --git a/src/test/compile-fail/overlap-marker-trait.rs b/src/test/compile-fail/overlap-marker-trait.rs
new file mode 100644
index 0000000000000..a649ae25f34ea
--- /dev/null
+++ b/src/test/compile-fail/overlap-marker-trait.rs
@@ -0,0 +1,41 @@
+// Copyright 2017 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.
+
+// Test for RFC 1268: we allow overlapping impls of marker traits,
+// that is, traits without items. In this case, a type `T` is
+// `MyMarker` if it is either `Debug` or `Display`. This test just
+// checks that we don't consider **all** types to be `MyMarker`.  See
+// also the companion test in
+// `run-pass/overlap-permitted-for-marker-traits.rs`.
+
+#![feature(overlapping_marker_traits)]
+#![feature(optin_builtin_traits)]
+
+use std::fmt::{Debug, Display};
+
+trait Marker {}
+
+impl<T: Debug> Marker for T {}
+impl<T: Display> Marker for T {}
+
+fn is_marker<T: Marker>() { }
+
+struct NotDebugOrDisplay;
+
+fn main() {
+    // Debug && Display:
+    is_marker::<i32>();
+
+    // Debug && !Display:
+    is_marker::<Vec<i32>>();
+
+    // !Debug && !Display
+    is_marker::<NotDebugOrDisplay>(); //~ ERROR
+}
diff --git a/src/test/run-pass/overlap-permitted-for-marker-traits-neg.rs b/src/test/run-pass/overlap-permitted-for-marker-traits-neg.rs
new file mode 100644
index 0000000000000..740d5d22ab507
--- /dev/null
+++ b/src/test/run-pass/overlap-permitted-for-marker-traits-neg.rs
@@ -0,0 +1,20 @@
+// Copyright 2017 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(overlapping_marker_traits)]
+#![feature(optin_builtin_traits)]
+
+// Overlapping negative impls for `MyStruct` are permitted:
+struct MyStruct;
+impl !Send for MyStruct {}
+impl !Send for MyStruct {}
+
+fn main() {
+}
diff --git a/src/test/run-pass/overlap-permitted-for-marker-traits.rs b/src/test/run-pass/overlap-permitted-for-marker-traits.rs
index 45085c093fc98..11a46299d8c83 100644
--- a/src/test/run-pass/overlap-permitted-for-marker-traits.rs
+++ b/src/test/run-pass/overlap-permitted-for-marker-traits.rs
@@ -8,24 +8,29 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// Tests for RFC 1268: we allow overlapping impls of marker traits,
+// that is, traits without items. In this case, a type `T` is
+// `MyMarker` if it is either `Debug` or `Display`.
+
 #![feature(overlapping_marker_traits)]
 #![feature(optin_builtin_traits)]
 
-trait MyMarker {}
+use std::fmt::{Debug, Display};
 
-impl<T: Copy> MyMarker for T {}
-impl<T: Eq> MyMarker for T {}
+trait MyMarker {}
 
-struct MyStruct;
-impl !Send for MyStruct {}
-impl !Send for MyStruct {}
+impl<T: Debug> MyMarker for T {}
+impl<T: Display> MyMarker for T {}
 
 fn foo<T: MyMarker>(t: T) -> T {
     t
 }
 
 fn main() {
+    // Debug && Display:
     assert_eq!(1, foo(1));
     assert_eq!(2.0, foo(2.0));
+
+    // Debug && !Display:
     assert_eq!(vec![1], foo(vec![1]));
 }