Intersection impls

check if the intersection impl is complete

Author: giannicic

src/librustc/traits/coherence.rs

@@ -8,11 +8,15 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! See `README.md` for high-level documentation
+//! See rustc guide chapters on [trait-resolution] and [trait-specialization] for more info on how
+//! this works.
+//!
+//! [trait-resolution]: https://rust-lang-nursery.github.io/rustc-guide/trait-resolution.html
+//! [trait-specialization]: https://rust-lang-nursery.github.io/rustc-guide/trait-specialization.html
 
 use hir::def_id::{DefId, LOCAL_CRATE};
 use syntax_pos::DUMMY_SP;
-use traits::{self, Normalized, SelectionContext, Obligation, ObligationCause, Reveal};
+use traits::{self, Normalized, SelectionContext, Obligation, ObligationCause};
 use traits::IntercrateMode;
 use traits::select::IntercrateAmbiguityCause;
 use ty::{self, Ty, TyCtxt};
@@ -119,7 +123,7 @@ fn overlap<'cx, 'gcx, 'tcx>(selcx: &mut SelectionContext<'cx, 'gcx, 'tcx>,
     // types into scope; instead, we replace the generic types with
     // fresh type variables, and hence we do our evaluations in an
     // empty environment.
-    let param_env = ty::ParamEnv::empty(Reveal::UserFacing);
+    let param_env = ty::ParamEnv::empty();
 
     let a_impl_header = with_fresh_ty_vars(selcx, param_env, a_def_id);
     let b_impl_header = with_fresh_ty_vars(selcx, param_env, b_def_id);
@@ -136,7 +140,7 @@ fn overlap<'cx, 'gcx, 'tcx>(selcx: &mut SelectionContext<'cx, 'gcx, 'tcx>,
         Err(_) => return None
     };
 
-    debug!("overlap: unification check succeeded {:?}", obligations);
+    debug!("overlap: unification check succeeded");
 
     // Are any of the obligations unsatisfiable? If so, no overlap.
     let infcx = selcx.infcx();
@@ -277,7 +281,7 @@ pub fn orphan_check<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
 ///     is bad, because the only local type with `T` as a subtree is
 ///     `LocalType<T>`, and `Vec<->` is between it and the type parameter.
 ///     - similarly, `FundamentalPair<LocalType<T>, T>` is bad, because
-///     the second occurence of `T` is not a subtree of *any* local type.
+///     the second occurrence of `T` is not a subtree of *any* local type.
 ///     - however, `LocalType<Vec<T>>` is OK, because `T` is a subtree of
 ///     `LocalType<Vec<T>>`, which is local and has no types between it and
 ///     the type parameter.

src/librustc/traits/specialize/mod.rs

@@ -339,10 +339,9 @@ pub(super) fn specialization_graph_provider<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx
                     for opt_overlap in opt_overlaps {
                         overlaps.push((impl_def_id, opt_overlap));
                     }
-                },
-                _ => {},
+                }
+                _ => {}
             };
-
         } else {
             let parent = tcx.impl_parent(impl_def_id).unwrap_or(trait_id);
             sg.record_impl_from_cstore(tcx, parent, impl_def_id)
@@ -353,47 +352,55 @@ pub(super) fn specialization_graph_provider<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx
         // Build the graph only if there is at least an overlap
         let (graph, nodes_idx) = sg.build_graph();
         for (impl_def_id, overlap) in overlaps {
-            if !sg.check_overlap(&graph, &nodes_idx, impl_def_id, overlap.with_impl) {
-
-                let msg = format!("conflicting implementations of trait `{}`{}:{}",
+            if !sg.check_overlap(&graph, &nodes_idx, impl_def_id, overlap.with_impl, tcx) {
+                let msg = format!(
+                    "conflicting implementations of trait `{}`{}:{}",
                     overlap.trait_desc,
-                    overlap.self_desc.clone().map_or(
-                        String::new(), |ty| {
-                            format!(" for type `{}`", ty)
-                        }),
-                    if overlap.used_to_be_allowed { " (E0119)" } else { "" }
-                );
-                let impl_span = tcx.sess.codemap().def_span(
-                    tcx.span_of_impl(impl_def_id).unwrap()
+                    overlap
+                        .self_desc
+                        .clone()
+                        .map_or(String::new(), |ty| format!(" for type `{}`", ty)),
+                    if overlap.used_to_be_allowed {
+                        " (E0119)"
+                    } else {
+                        ""
+                    }
                 );
+                let impl_span = tcx.sess
+                    .codemap()
+                    .def_span(tcx.span_of_impl(impl_def_id).unwrap());
                 let mut err = if overlap.used_to_be_allowed {
                     tcx.struct_span_lint_node(
                         lint::builtin::INCOHERENT_FUNDAMENTAL_IMPLS,
                         tcx.hir.as_local_node_id(impl_def_id).unwrap(),
                         impl_span,
-                        &msg)
+                        &msg,
+                    )
                 } else {
-                    struct_span_err!(tcx.sess,
-                                     impl_span,
-                                     E0119,
-                                     "{}",
-                                     msg)
+                    struct_span_err!(tcx.sess, impl_span, E0119, "{}", msg)
                 };
 
                 match tcx.span_of_impl(overlap.with_impl) {
                     Ok(span) => {
-                        err.span_label(tcx.sess.codemap().def_span(span),
-                                       format!("first implementation here"));
-                        err.span_label(impl_span,
-                                       format!("conflicting implementation{}",
-                                                overlap.self_desc
-                                                    .map_or(String::new(),
-                                                            |ty| format!(" for `{}`", ty))));
+                        err.span_label(
+                            tcx.sess.codemap().def_span(span),
+                            format!("first implementation here"),
+                        );
+                        err.span_label(
+                            impl_span,
+                            format!(
+                                "conflicting implementation{}",
+                                overlap
+                                    .self_desc
+                                    .map_or(String::new(), |ty| format!(" for `{}`", ty))
+                            ),
+                        );
                     }
                     Err(cname) => {
                         let msg = match to_pretty_impl_header(tcx, overlap.with_impl) {
-                            Some(s) => format!(
-                                "conflicting implementation in crate `{}`:\n- {}", cname, s),
+                            Some(s) => {
+                                format!("conflicting implementation in crate `{}`:\n- {}", cname, s)
+                            }
                             None => format!("conflicting implementation in crate `{}`", cname),
                         };
                         err.note(&msg);