intersection impls

Author: giannicic

src/librustc/traits/coherence.rs

@@ -8,15 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! 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
+//! See `README.md` for high-level documentation
 
 use hir::def_id::{DefId, LOCAL_CRATE};
 use syntax_pos::DUMMY_SP;
-use traits::{self, Normalized, SelectionContext, Obligation, ObligationCause};
+use traits::{self, Normalized, SelectionContext, Obligation, ObligationCause, Reveal};
 use traits::IntercrateMode;
 use traits::select::IntercrateAmbiguityCause;
 use ty::{self, Ty, TyCtxt};
@@ -123,7 +119,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();
+    let param_env = ty::ParamEnv::empty(Reveal::UserFacing);
 
     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);
@@ -140,7 +136,7 @@ fn overlap<'cx, 'gcx, 'tcx>(selcx: &mut SelectionContext<'cx, 'gcx, 'tcx>,
         Err(_) => return None
     };
 
-    debug!("overlap: unification check succeeded");
+    debug!("overlap: unification check succeeded {:?}", obligations);
 
     // Are any of the obligations unsatisfiable? If so, no overlap.
     let infcx = selcx.infcx();
@@ -281,7 +277,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 occurrence of `T` is not a subtree of *any* local type.
+///     the second occurence 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

@@ -42,6 +42,7 @@ pub struct OverlapError {
     pub trait_desc: String,
     pub self_desc: Option<String>,
     pub intercrate_ambiguity_causes: Vec<IntercrateAmbiguityCause>,
+    pub used_to_be_allowed: bool,
 }
 
 /// Given a subst for the requested impl, translate it to a subst
@@ -324,29 +325,48 @@ pub(super) fn specialization_graph_provider<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx
          def_id.index.as_array_index())
     });
 
+    let mut overlaps = Vec::new();
+
     for impl_def_id in trait_impls {
         if impl_def_id.is_local() {
-            // This is where impl overlap checking happens:
             let insert_result = sg.insert(tcx, impl_def_id);
-            // Report error if there was one.
-            let (overlap, used_to_be_allowed) = match insert_result {
-                Err(overlap) => (Some(overlap), false),
-                Ok(opt_overlap) => (opt_overlap, true)
+            match insert_result {
+                Ok(Some(mut opt_overlaps)) => {
+                    // record any overlap that occurs between two impl
+                    // later those recordings are processed to establish
+                    // if an intersection impl is present between two overlapping impls
+                    // if no an overlap error is emitted
+                    for opt_overlap in opt_overlaps {
+                        overlaps.push((impl_def_id, opt_overlap));
+                    }
+                },
+                _ => {},
             };
 
-            if let Some(overlap) = overlap {
+        } else {
+            let parent = tcx.impl_parent(impl_def_id).unwrap_or(trait_id);
+            sg.record_impl_from_cstore(tcx, parent, impl_def_id)
+        }
+    }
+
+    if overlaps.len() > 0 {
+        // 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 `{}`{}:{}",
                     overlap.trait_desc,
                     overlap.self_desc.clone().map_or(
                         String::new(), |ty| {
                             format!(" for type `{}`", ty)
                         }),
-                    if used_to_be_allowed { " (E0119)" } else { "" }
+                    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 used_to_be_allowed {
+                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(),
@@ -386,9 +406,6 @@ pub(super) fn specialization_graph_provider<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx
 
                 err.emit();
             }
-        } else {
-            let parent = tcx.impl_parent(impl_def_id).unwrap_or(trait_id);
-            sg.record_impl_from_cstore(tcx, parent, impl_def_id)
         }
     }