#37653 support default impl for specialization

src/librustc/traits/select.rs

@@ -1710,22 +1710,44 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
     {
         debug!("assemble_candidates_from_impls(obligation={:?})", obligation);
 
+        // Check if default impls should be emitted.
+        // default impls are emitted if the param_env is refered to a default impl.
+        // The param_env should contain a Self: Trait<..> predicate in those cases
+        let self_trait_is_present:Vec<&ty::Predicate<'tcx>> =
+                    obligation.param_env
+                               .caller_bounds
+                               .iter()
+                               .filter(|predicate| {
+                                    match **predicate {
+                                         ty::Predicate::Trait(ref trait_predicate) => {
+                                             trait_predicate.def_id() ==
+                                                 obligation.predicate.def_id() &&
+                                             obligation.predicate.0.trait_ref.self_ty() ==
+                                                 trait_predicate.skip_binder().self_ty()
+                                         }
+                                         _ => false
+                                    }
+                               }).collect::<Vec<&ty::Predicate<'tcx>>>();
+
         self.tcx().for_each_relevant_impl(
             obligation.predicate.def_id(),
             obligation.predicate.0.trait_ref.self_ty(),
             |impl_def_id| {
-                self.probe(|this, snapshot| { /* [1] */
-                    match this.match_impl(impl_def_id, obligation, snapshot) {
-                        Ok(skol_map) => {
-                            candidates.vec.push(ImplCandidate(impl_def_id));
-
-                            // NB: we can safely drop the skol map
-                            // since we are in a probe [1]
-                            mem::drop(skol_map);
+                if self_trait_is_present.len() > 0 ||
+                   !self.tcx().impl_is_default(impl_def_id) {
+                    self.probe(|this, snapshot| { /* [1] */
+                        match this.match_impl(impl_def_id, obligation, snapshot) {
+                            Ok(skol_map) => {
+                                candidates.vec.push(ImplCandidate(impl_def_id));
+
+                                // NB: we can safely drop the skol map
+                                // since we are in a probe [1]
+                                mem::drop(skol_map);
+                            }
+                            Err(_) => { }
                         }
-                        Err(_) => { }
-                    }
-                });
+                    });
+                }
             }
         );
 

src/librustc/ty/mod.rs

@@ -2606,8 +2606,31 @@ fn param_env<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                        def_id: DefId)
                        -> ParamEnv<'tcx> {
     // Compute the bounds on Self and the type parameters.
+    let mut predicates = tcx.predicates_of(def_id);
+    match tcx.hir.as_local_node_id(def_id)
+           .and_then(|node_id| tcx.hir.find(node_id))
+           .and_then(|item| {
+        match item {
+            hir::map::NodeItem(..) => {
+                if tcx.impl_is_default(def_id) {
+                    tcx.impl_trait_ref(def_id)
+                } else {
+                    None
+                }
+            }
+            _ => None
+        }
+    }) {
+        Some(trait_ref) =>
+            predicates.predicates
+                      .push(
+                trait_ref.to_poly_trait_ref()
+                         .to_predicate()
+            ),
+        None => {}
+    }
 
-    let bounds = tcx.predicates_of(def_id).instantiate_identity(tcx);
+    let bounds = predicates.instantiate_identity(tcx);
     let predicates = bounds.predicates;
 
     // Finally, we have to normalize the bounds in the environment, in

src/librustc_typeck/check/mod.rs

@@ -1395,7 +1395,7 @@ fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
             .map(|node_item| !node_item.node.is_from_trait())
             .unwrap_or(false);
 
-        if !is_implemented {
+        if !is_implemented && !tcx.impl_is_default(impl_id) {
             if !trait_item.defaultness.has_value() {
                 missing_items.push(trait_item);
             } else if associated_type_overridden {

src/test/compile-fail/specialization/defaultimpl/specialization-trait-item-not-implemented.rs

@@ -0,0 +1,31 @@
+// 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(specialization)]
+
+trait Foo {
+    fn foo_one(&self) -> &'static str;
+    fn foo_two(&self) -> &'static str;
+}
+
+struct MyStruct;
+
+default impl<T> Foo for T {
+    fn foo_one(&self) -> &'static str {
+        "generic"
+    }
+}
+
+impl Foo for MyStruct {}
+//~^ ERROR not all trait items implemented, missing: `foo_two` [E0046]
+
+fn main() {
+    println!("{}", MyStruct.foo_one());
+}

src/test/compile-fail/specialization/defaultimpl/specialization-trait-not-implemented.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 <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(specialization)]
+
+trait Foo {
+    fn foo_one(&self) -> &'static str;
+    fn foo_two(&self) -> &'static str;
+}
+
+struct MyStruct;
+
+default impl<T> Foo for T {
+    fn foo_one(&self) -> &'static str {
+        "generic"
+    }
+}
+
+
+fn main() {
+    println!("{}", MyStruct.foo_one());
+    //~^ ERROR no method named `foo_one` found for type `MyStruct` in the current scope
+}

src/test/run-pass/specialization/defaultimpl/projection-alias.rs → src/test/compile-fail/specialization/defaultimpl/specialization-wfcheck.rs

@@ -1,4 +1,4 @@
-// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// 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.
 //
@@ -10,23 +10,9 @@
 
 #![feature(specialization)]
 
-// Regression test for ICE when combining specialized associated types and type
-// aliases
+trait Foo<'a, T: Eq + 'a> { }
 
-trait Id_ {
-    type Out;
-}
+default impl<U> Foo<'static, U> for () {}
+//~^ ERROR the trait bound `U: std::cmp::Eq` is not satisfied
 
-type Id<T> = <T as Id_>::Out;
-
-default impl<T> Id_ for T {
-    type Out = T;
-}
-
-fn test_proection() {
-    let x: Id<bool> = panic!();
-}
-
-fn main() {
-
-}
+fn main(){}