---

yaml
---
r: 178559
b: refs/heads/try
c: 9985991
h: refs/heads/master
i:
  178557: e5b1eaf
  178555: 0174582
  178551: 5c59882
  178543: 2c4bf25
  178527: b325358
  178495: baa8f55
  178431: ffdfc35
v: v3

Author: Gankra

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 336c8d2e9c6b276b162bdb3edd43706372e6eddd
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 474b324eda10440d6568ef872a7307d38e7de95b
-refs/heads/try: e8489d3cc7a44dc31030b17ec0faad795d3895df
+refs/heads/try: 998599187fa0d1341ffd051e8d54b7ba7fea0be5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/src/librustc/middle/traits/coherence.rs

@@ -15,7 +15,7 @@ use super::{Obligation, ObligationCause};
 use super::project;
 use super::util;
 
-use middle::subst::{Subst, TypeSpace};
+use middle::subst::{Subst};
 use middle::ty::{self, Ty};
 use middle::infer::InferCtxt;
 use std::collections::HashSet;
@@ -89,28 +89,16 @@ pub fn orphan_check<'tcx>(tcx: &ty::ctxt<'tcx>,
         return Ok(());
     }
 
-    // First, create an ordered iterator over all the type parameters to the trait, with the self
-    // type appearing first.
-    let input_tys = Some(trait_ref.self_ty());
-    let input_tys = input_tys.iter().chain(trait_ref.substs.types.get_slice(TypeSpace).iter());
-    let mut input_tys = input_tys;
-
-    // Find the first input type that either references a type parameter OR
-    // some local type.
-    match input_tys.find(|&&input_ty| references_local_or_type_parameter(tcx, input_ty)) {
-        Some(&input_ty) => {
-            // Within this first type, check that all type parameters are covered by a local
-            // type constructor. Note that if there is no local type constructor, then any
-            // type parameter at all will be an error.
-            let covered_params = type_parameters_covered_by_ty(tcx, input_ty);
-            let all_params = type_parameters_reachable_from_ty(input_ty);
-            for &param in all_params.difference(&covered_params) {
-                return Err(OrphanCheckErr::UncoveredTy(param));
-            }
-        }
-        None => {
-            return Err(OrphanCheckErr::NoLocalInputType);
-        }
+    // Otherwise, check that (1) all type parameters are covered.
+    let covered_params = type_parameters_covered_by_ty(tcx, trait_ref.self_ty());
+    let all_params = type_parameters_reachable_from_ty(trait_ref.self_ty());
+    for &param in all_params.difference(&covered_params) {
+        return Err(OrphanCheckErr::UncoveredTy(param));
+    }
+
+    // And (2) some local type appears.
+    if !trait_ref.self_ty().walk().any(|t| ty_is_local_constructor(tcx, t)) {
+        return Err(OrphanCheckErr::NoLocalInputType);
     }
 
     return Ok(());
@@ -174,17 +162,13 @@ fn type_parameters_covered_by_ty<'tcx>(tcx: &ty::ctxt<'tcx>,
 
 /// All type parameters reachable from `ty`
 fn type_parameters_reachable_from_ty<'tcx>(ty: Ty<'tcx>) -> HashSet<Ty<'tcx>> {
-    ty.walk().filter(|&t| is_type_parameter(t)).collect()
-}
-
-fn references_local_or_type_parameter<'tcx>(tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool {
-    ty.walk().any(|ty| is_type_parameter(ty) || ty_is_local_constructor(tcx, ty))
-}
-
-fn is_type_parameter<'tcx>(ty: Ty<'tcx>) -> bool {
-    match ty.sty {
-        // FIXME(#20590) straighten story about projection types
-        ty::ty_projection(..) | ty::ty_param(..) => true,
-        _ => false,
-    }
+    ty.walk()
+        .filter(|&t| {
+            match t.sty {
+                // FIXME(#20590) straighten story about projection types
+                ty::ty_projection(..) | ty::ty_param(..) => true,
+                _ => false,
+            }
+        })
+        .collect()
 }

branches/try/src/librustc_typeck/coherence/orphan.rs

@@ -77,12 +77,14 @@ impl<'cx, 'tcx,'v> visit::Visitor<'v> for OrphanChecker<'cx, 'tcx> {
                     Ok(()) => { }
                     Err(traits::OrphanCheckErr::NoLocalInputType) => {
                         if !ty::has_attr(self.tcx, trait_def_id, "old_orphan_check") {
+                            let self_ty = ty::lookup_item_type(self.tcx, def_id).ty;
                             span_err!(
                                 self.tcx.sess, item.span, E0117,
-                                "the impl does not reference any \
+                                "the type `{}` does not reference any \
                                  types defined in this crate; \
                                  only traits defined in the current crate can be \
-                                 implemented for arbitrary types");
+                                 implemented for arbitrary types",
+                                self_ty.user_string(self.tcx));
                         }
                     }
                     Err(traits::OrphanCheckErr::UncoveredTy(param_ty)) => {

branches/try/src/libstd/collections/hash/table.rs

@@ -16,15 +16,14 @@ use clone::Clone;
 use cmp;
 use hash::{Hash, Hasher};
 use iter::{Iterator, IteratorExt, ExactSizeIterator, count};
-use marker::{Copy, Sized, self};
+use marker::{Copy, Send, Sync, Sized, self};
 use mem::{min_align_of, size_of};
 use mem;
 use num::{Int, UnsignedInt};
 use ops::{Deref, DerefMut, Drop};
 use option::Option;
 use option::Option::{Some, None};
-use ptr::{Unique, PtrExt, copy_nonoverlapping_memory, zero_memory};
-use ptr;
+use ptr::{self, PtrExt, copy_nonoverlapping_memory, zero_memory};
 use rt::heap::{allocate, deallocate};
 use collections::hash_state::HashState;
 
@@ -70,12 +69,15 @@ const EMPTY_BUCKET: u64 = 0u64;
 pub struct RawTable<K, V> {
     capacity: uint,
     size:     uint,
-    hashes:   Unique<u64>,
+    hashes:   *mut u64,
     // Because K/V do not appear directly in any of the types in the struct,
     // inform rustc that in fact instances of K and V are reachable from here.
     marker:   marker::CovariantType<(K,V)>,
 }
 
+unsafe impl<K: Send, V: Send> Send for RawTable<K, V> {}
+unsafe impl<K: Sync, V: Sync> Sync for RawTable<K, V> {}
+
 struct RawBucket<K, V> {
     hash: *mut u64,
     key:  *mut K,
@@ -565,7 +567,7 @@ impl<K, V> RawTable<K, V> {
             return RawTable {
                 size: 0,
                 capacity: 0,
-                hashes: Unique::null(),
+                hashes: ptr::null_mut(),
                 marker: marker::CovariantType,
             };
         }
@@ -604,7 +606,7 @@ impl<K, V> RawTable<K, V> {
         RawTable {
             capacity: capacity,
             size:     0,
-            hashes:   Unique(hashes),
+            hashes:   hashes,
             marker:   marker::CovariantType,
         }
     }
@@ -613,14 +615,14 @@ impl<K, V> RawTable<K, V> {
         let hashes_size = self.capacity * size_of::<u64>();
         let keys_size = self.capacity * size_of::<K>();
 
-        let buffer = self.hashes.0 as *mut u8;
+        let buffer = self.hashes as *mut u8;
         let (keys_offset, vals_offset) = calculate_offsets(hashes_size,
                                                            keys_size, min_align_of::<K>(),
                                                            min_align_of::<V>());
 
         unsafe {
             RawBucket {
-                hash: self.hashes.0,
+                hash: self.hashes,
                 key:  buffer.offset(keys_offset as int) as *mut K,
                 val:  buffer.offset(vals_offset as int) as *mut V
             }
@@ -632,7 +634,7 @@ impl<K, V> RawTable<K, V> {
     pub fn new(capacity: uint) -> RawTable<K, V> {
         unsafe {
             let ret = RawTable::new_uninitialized(capacity);
-            zero_memory(ret.hashes.0, capacity);
+            zero_memory(ret.hashes, capacity);
             ret
         }
     }
@@ -652,7 +654,7 @@ impl<K, V> RawTable<K, V> {
         RawBuckets {
             raw: self.first_bucket_raw(),
             hashes_end: unsafe {
-                self.hashes.0.offset(self.capacity as int)
+                self.hashes.offset(self.capacity as int)
             },
             marker: marker::ContravariantLifetime,
         }
@@ -964,7 +966,7 @@ impl<K: Clone, V: Clone> Clone for RawTable<K, V> {
 #[unsafe_destructor]
 impl<K, V> Drop for RawTable<K, V> {
     fn drop(&mut self) {
-        if self.hashes.0.is_null() {
+        if self.hashes.is_null() {
             return;
         }
         // This is done in reverse because we've likely partially taken
@@ -984,7 +986,7 @@ impl<K, V> Drop for RawTable<K, V> {
                                                     vals_size, min_align_of::<V>());
 
         unsafe {
-            deallocate(self.hashes.0 as *mut u8, size, align);
+            deallocate(self.hashes as *mut u8, size, align);
             // Remember how everything was allocated out of one buffer
             // during initialization? We only need one call to free here.
         }

branches/try/src/test/compile-fail/coherence-all-remote.rs

@@ -14,6 +14,6 @@ extern crate "coherence-lib" as lib;
 use lib::Remote1;
 
 impl<T> Remote1<T> for isize { }
-//~^ ERROR E0210
+//~^ ERROR E0117
 
 fn main() { }

branches/try/src/test/run-pass/coherence-bigint-int.rs renamed to branches/try/src/test/compile-fail/coherence-bigint-int.rs

@@ -15,6 +15,6 @@ use lib::Remote1;
 
 pub struct BigInt;
 
-impl Remote1<BigInt> for isize { }
+impl Remote1<BigInt> for isize { } //~ ERROR E0117
 
 fn main() { }

branches/try/src/test/run-pass/coherence-bigint-vecint.rs renamed to branches/try/src/test/compile-fail/coherence-bigint-vecint.rs

@@ -15,6 +15,6 @@ use lib::Remote1;
 
 pub struct BigInt;
 
-impl Remote1<BigInt> for Vec<isize> { }
+impl Remote1<BigInt> for Vec<isize> { } //~ ERROR E0117
 
 fn main() { }

branches/try/src/test/compile-fail/coherence-orphan.rs

@@ -21,7 +21,7 @@ struct TheType;
 
 impl TheTrait<usize> for isize { } //~ ERROR E0117
 
-impl TheTrait<TheType> for isize { }
+impl TheTrait<TheType> for isize { } //~ ERROR E0117
 
 impl TheTrait<isize> for TheType { }
 

branches/try/src/test/compile-fail/coherence-pair-covered-uncovered-1.rs

@@ -8,16 +8,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// aux-build:coherence-lib.rs
+// Regression test for HashMap only impl'ing Send/Sync if its contents do
 
-// Test that it's not ok for U to appear uncovered
+use std::collections::HashMap;
+use std::rc::Rc;
 
-extern crate "coherence-lib" as lib;
-use lib::{Remote,Pair};
+fn foo<T: Send>() {}
 
-pub struct Cover<T>(T);
-
-impl<T,U> Remote for Pair<Cover<T>,U> { }
-//~^ ERROR type parameter `U` is not constrained by any local type
-
-fn main() { }
+fn main() {
+    foo::<HashMap<Rc<()>, Rc<()>>>();
+    //~^ ERROR: the trait `core::marker::Send` is not implemented for the type `alloc::rc::Rc<()>`
+}