---

yaml
---
r: 272178
b: refs/heads/auto
c: 9a28d4e
h: refs/heads/master

Author: Amanieu

[refs]

@@ -8,7 +8,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 53498eca50e25d8a11f9dc5859770715fa906fa7
+refs/heads/auto: 9a28d4edc9375e5bf606c453d1e03a45ae8be0af
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336
 refs/tags/0.2: 1754d02027f2924bed83b0160ee340c7f41d5ea1

branches/auto/src/liballoc/arc.rs

@@ -223,7 +223,7 @@ impl<T> Arc<T> {
     #[stable(feature = "arc_unique", since = "1.4.0")]
     pub fn try_unwrap(this: Self) -> Result<T, Self> {
         // See `drop` for why all these atomics are like this
-        if this.inner().strong.compare_and_swap(1, 0, Release) != 1 {
+        if this.inner().strong.compare_exchange(1, 0, Release, Relaxed).is_err() {
             return Err(this);
         }
 
@@ -256,11 +256,11 @@ impl<T: ?Sized> Arc<T> {
     /// ```
     #[stable(feature = "arc_weak", since = "1.4.0")]
     pub fn downgrade(this: &Self) -> Weak<T> {
-        loop {
-            // This Relaxed is OK because we're checking the value in the CAS
-            // below.
-            let cur = this.inner().weak.load(Relaxed);
+        // This Relaxed is OK because we're checking the value in the CAS
+        // below.
+        let mut cur = this.inner().weak.load(Relaxed);
 
+        loop {
             // check if the weak counter is currently "locked"; if so, spin.
             if cur == usize::MAX {
                 continue;
@@ -273,8 +273,9 @@ impl<T: ?Sized> Arc<T> {
             // Unlike with Clone(), we need this to be an Acquire read to
             // synchronize with the write coming from `is_unique`, so that the
             // events prior to that write happen before this read.
-            if this.inner().weak.compare_and_swap(cur, cur + 1, Acquire) == cur {
-                return Weak { _ptr: this._ptr };
+            match this.inner().weak.compare_exchange_weak(cur, cur + 1, Acquire, Relaxed) {
+                Ok(_) => return Weak { _ptr: this._ptr },
+                Err(old) => cur = old,
             }
         }
     }
@@ -416,7 +417,7 @@ impl<T: Clone> Arc<T> {
         // before release writes (i.e., decrements) to `strong`. Since we hold a
         // weak count, there's no chance the ArcInner itself could be
         // deallocated.
-        if this.inner().strong.compare_and_swap(1, 0, Acquire) != 1 {
+        if this.inner().strong.compare_exchange(1, 0, Acquire, Relaxed).is_err() {
             // Another strong pointer exists; clone
             *this = Arc::new((**this).clone());
         } else if this.inner().weak.load(Relaxed) != 1 {
@@ -506,7 +507,7 @@ impl<T: ?Sized> Arc<T> {
         // The acquire label here ensures a happens-before relationship with any
         // writes to `strong` prior to decrements of the `weak` count (via drop,
         // which uses Release).
-        if self.inner().weak.compare_and_swap(1, usize::MAX, Acquire) == 1 {
+        if self.inner().weak.compare_exchange(1, usize::MAX, Acquire, Relaxed).is_ok() {
             // Due to the previous acquire read, this will observe any writes to
             // `strong` that were due to upgrading weak pointers; only strong
             // clones remain, which require that the strong count is > 1 anyway.
@@ -618,12 +619,14 @@ impl<T: ?Sized> Weak<T> {
         // We use a CAS loop to increment the strong count instead of a
         // fetch_add because once the count hits 0 it must never be above 0.
         let inner = self.inner();
+
+        // Relaxed load because any write of 0 that we can observe
+        // leaves the field in a permanently zero state (so a
+        // "stale" read of 0 is fine), and any other value is
+        // confirmed via the CAS below.
+        let mut n = inner.strong.load(Relaxed);
+
         loop {
-            // Relaxed load because any write of 0 that we can observe
-            // leaves the field in a permanently zero state (so a
-            // "stale" read of 0 is fine), and any other value is
-            // confirmed via the CAS below.
-            let n = inner.strong.load(Relaxed);
             if n == 0 {
                 return None;
             }
@@ -634,9 +637,9 @@ impl<T: ?Sized> Weak<T> {
             }
 
             // Relaxed is valid for the same reason it is on Arc's Clone impl
-            let old = inner.strong.compare_and_swap(n, n + 1, Relaxed);
-            if old == n {
-                return Some(Arc { _ptr: self._ptr });
+            match inner.strong.compare_exchange_weak(n, n + 1, Relaxed, Relaxed) {
+                Ok(_) => return Some(Arc { _ptr: self._ptr }),
+                Err(old) => n = old,
             }
         }
     }

branches/auto/src/liballoc/lib.rs

@@ -90,6 +90,7 @@
 #![feature(unique)]
 #![feature(unsafe_no_drop_flag, filling_drop)]
 #![feature(unsize)]
+#![feature(extended_compare_and_swap)]
 
 #![cfg_attr(not(test), feature(raw, fn_traits, placement_new_protocol))]
 #![cfg_attr(test, feature(test, box_heap))]

branches/auto/src/libcollections/lib.rs

@@ -48,7 +48,6 @@
 #![feature(placement_new_protocol)]
 #![feature(shared)]
 #![feature(slice_patterns)]
-#![feature(specialization)]
 #![feature(staged_api)]
 #![feature(step_by)]
 #![feature(str_char)]

branches/auto/src/libcollections/string.rs

@@ -1755,7 +1755,7 @@ pub trait ToString {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: fmt::Display + ?Sized> ToString for T {
     #[inline]
-    default fn to_string(&self) -> String {
+    fn to_string(&self) -> String {
         use core::fmt::Write;
         let mut buf = String::new();
         let _ = buf.write_fmt(format_args!("{}", self));
@@ -1764,14 +1764,6 @@ impl<T: fmt::Display + ?Sized> ToString for T {
     }
 }
 
-#[stable(feature = "str_to_string_specialization", since = "1.9.0")]
-impl ToString for str {
-    #[inline]
-    fn to_string(&self) -> String {
-        String::from(self)
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl AsRef<str> for String {
     #[inline]

branches/auto/src/libcore/cell.rs

@@ -216,6 +216,10 @@ impl<T:Copy> Cell<T> {
 
     /// Returns a reference to the underlying `UnsafeCell`.
     ///
+    /// # Safety
+    ///
+    /// This function is `unsafe` because `UnsafeCell`'s field is public.
+    ///
     /// # Examples
     ///
     /// ```
@@ -225,11 +229,11 @@ impl<T:Copy> Cell<T> {
     ///
     /// let c = Cell::new(5);
     ///
-    /// let uc = c.as_unsafe_cell();
+    /// let uc = unsafe { c.as_unsafe_cell() };
     /// ```
     #[inline]
     #[unstable(feature = "as_unsafe_cell", issue = "27708")]
-    pub fn as_unsafe_cell(&self) -> &UnsafeCell<T> {
+    pub unsafe fn as_unsafe_cell(&self) -> &UnsafeCell<T> {
         &self.value
     }
 }

branches/auto/src/librustc/front/map/mod.rs

@@ -581,6 +581,14 @@ impl<'ast> Map<'ast> {
         }
     }
 
+    pub fn get_foreign_vis(&self, id: NodeId) -> Visibility {
+        let vis = self.expect_foreign_item(id).vis; // read recorded by `expect_foreign_item`
+        match self.find(self.get_parent(id)) { // read recorded by `find`
+            Some(NodeItem(i)) => vis.inherit_from(i.vis),
+            _ => vis
+        }
+    }
+
     pub fn expect_item(&self, id: NodeId) -> &'ast Item {
         match self.find(id) { // read recorded by `find`
             Some(NodeItem(item)) => item,

branches/auto/src/librustc/middle/cstore.rs

@@ -32,7 +32,7 @@ use mir::repr::Mir;
 use mir::mir_map::MirMap;
 use session::Session;
 use session::search_paths::PathKind;
-use util::nodemap::{FnvHashMap, NodeMap, NodeSet, DefIdMap};
+use util::nodemap::{FnvHashMap, NodeMap, NodeSet};
 use std::any::Any;
 use std::cell::RefCell;
 use std::rc::Rc;
@@ -169,7 +169,6 @@ pub trait CrateStore<'tcx> : Any {
     fn item_type(&self, tcx: &TyCtxt<'tcx>, def: DefId)
                  -> ty::TypeScheme<'tcx>;
     fn relative_item_path(&self, def: DefId) -> Vec<hir_map::PathElem>;
-    fn visible_parent_map<'a>(&'a self) -> ::std::cell::RefMut<'a, DefIdMap<DefId>>;
     fn extern_item_path(&self, def: DefId) -> Vec<hir_map::PathElem>;
     fn item_name(&self, def: DefId) -> ast::Name;
     fn item_predicates(&self, tcx: &TyCtxt<'tcx>, def: DefId)
@@ -348,9 +347,6 @@ impl<'tcx> CrateStore<'tcx> for DummyCrateStore {
     fn item_type(&self, tcx: &TyCtxt<'tcx>, def: DefId)
                  -> ty::TypeScheme<'tcx> { unimplemented!() }
     fn relative_item_path(&self, def: DefId) -> Vec<hir_map::PathElem> { unimplemented!() }
-    fn visible_parent_map<'a>(&'a self) -> ::std::cell::RefMut<'a, DefIdMap<DefId>> {
-        unimplemented!()
-    }
     fn extern_item_path(&self, def: DefId) -> Vec<hir_map::PathElem> { unimplemented!() }
     fn item_name(&self, def: DefId) -> ast::Name { unimplemented!() }
     fn item_predicates(&self, tcx: &TyCtxt<'tcx>, def: DefId)

branches/auto/src/librustc/ty/item_path.rs

@@ -10,7 +10,7 @@
 
 use front::map::DefPathData;
 use middle::cstore::LOCAL_CRATE;
-use middle::def_id::{DefId, CRATE_DEF_INDEX};
+use middle::def_id::DefId;
 use ty::{self, Ty, TyCtxt};
 use syntax::ast;
 
@@ -75,51 +75,9 @@ impl<'tcx> TyCtxt<'tcx> {
         }
     }
 
-    /// If possible, this pushes a global path resolving to `external_def_id` that is visible
-    /// from at least one local module and returns true. If the crate defining `external_def_id` is
-    /// declared with an `extern crate`, the path is guarenteed to use the `extern crate`.
-    pub fn try_push_visible_item_path<T>(&self, buffer: &mut T, external_def_id: DefId) -> bool
-        where T: ItemPathBuffer
-    {
-        let visible_parent_map = self.sess.cstore.visible_parent_map();
-
-        let (mut cur_def, mut cur_path) = (external_def_id, Vec::<ast::Name>::new());
-        loop {
-            // If `cur_def` is a direct or injected extern crate, push the path to the crate
-            // followed by the path to the item within the crate and return.
-            if cur_def.index == CRATE_DEF_INDEX {
-                match self.sess.cstore.extern_crate(cur_def.krate) {
-                    Some(extern_crate) if extern_crate.direct => {
-                        self.push_item_path(buffer, extern_crate.def_id);
-                        cur_path.iter().rev().map(|segment| buffer.push(&segment.as_str())).count();
-                        return true;
-                    }
-                    None => {
-                        buffer.push(&self.crate_name(cur_def.krate));
-                        cur_path.iter().rev().map(|segment| buffer.push(&segment.as_str())).count();
-                        return true;
-                    }
-                    _ => {},
-                }
-            }
-
-            cur_path.push(self.sess.cstore.item_name(cur_def));
-            match visible_parent_map.get(&cur_def) {
-                Some(&def) => cur_def = def,
-                None => return false,
-            };
-        }
-    }
-
     pub fn push_item_path<T>(&self, buffer: &mut T, def_id: DefId)
         where T: ItemPathBuffer
     {
-        match *buffer.root_mode() {
-            RootMode::Local if !def_id.is_local() =>
-                if self.try_push_visible_item_path(buffer, def_id) { return },
-            _ => {}
-        }
-
         let key = self.def_key(def_id);
         match key.disambiguated_data.data {
             DefPathData::CrateRoot => {

branches/auto/src/librustc_metadata/csearch.rs

@@ -13,17 +13,17 @@ use decoder;
 use encoder;
 use loader;
 
-use middle::cstore::{CrateStore, CrateSource, ChildItem, ExternCrate, FoundAst, DefLike};
+use middle::cstore::{CrateStore, CrateSource, ChildItem, ExternCrate, FoundAst};
 use middle::cstore::{NativeLibraryKind, LinkMeta, LinkagePreference};
 use middle::def;
 use middle::lang_items;
 use rustc::ty::{self, Ty, TyCtxt, VariantKind};
-use middle::def_id::{DefId, DefIndex, CRATE_DEF_INDEX};
+use middle::def_id::{DefId, DefIndex};
 
 use rustc::front::map as hir_map;
 use rustc::mir::repr::Mir;
 use rustc::mir::mir_map::MirMap;
-use rustc::util::nodemap::{FnvHashMap, NodeMap, NodeSet, DefIdMap};
+use rustc::util::nodemap::{FnvHashMap, NodeMap, NodeSet};
 
 use std::cell::RefCell;
 use std::rc::Rc;
@@ -544,60 +544,4 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore {
     {
         encoder::metadata_encoding_version
     }
-
-    /// Returns a map from a sufficiently visible external item (i.e. an external item that is
-    /// visible from at least one local module) to a sufficiently visible parent (considering
-    /// modules that re-export the external item to be parents).
-    fn visible_parent_map<'a>(&'a self) -> ::std::cell::RefMut<'a, DefIdMap<DefId>> {
-        let mut visible_parent_map = self.visible_parent_map.borrow_mut();
-        if !visible_parent_map.is_empty() { return visible_parent_map; }
-
-        use rustc_front::hir;
-        use rustc::middle::cstore::{CrateStore, ChildItem};
-        use std::collections::vec_deque::VecDeque;
-        use std::collections::hash_map::Entry;
-        for cnum in 1 .. self.next_crate_num() {
-            let cdata = self.get_crate_data(cnum);
-
-            match cdata.extern_crate.get() {
-                // Ignore crates without a corresponding local `extern crate` item.
-                Some(extern_crate) if !extern_crate.direct => continue,
-                _ => {},
-            }
-
-            let mut bfs_queue = &mut VecDeque::new();
-            let mut add_child = |bfs_queue: &mut VecDeque<_>, child: ChildItem, parent: DefId| {
-                let child = match child.def {
-                    DefLike::DlDef(def) if child.vis == hir::Public => def.def_id(),
-                    _ => return,
-                };
-
-                match visible_parent_map.entry(child) {
-                    Entry::Occupied(mut entry) => {
-                        // If `child` is defined in crate `cnum`, ensure
-                        // that it is mapped to a parent in `cnum`.
-                        if child.krate == cnum && entry.get().krate != cnum {
-                            entry.insert(parent);
-                        }
-                    }
-                    Entry::Vacant(entry) => {
-                        entry.insert(parent);
-                        bfs_queue.push_back(child);
-                    }
-                }
-            };
-
-            let croot = DefId { krate: cnum, index: CRATE_DEF_INDEX };
-            for child in self.crate_top_level_items(cnum) {
-                add_child(bfs_queue, child, croot);
-            }
-            while let Some(def) = bfs_queue.pop_front() {
-                for child in self.item_children(def) {
-                    add_child(bfs_queue, child, def);
-                }
-            }
-        }
-
-        visible_parent_map
-    }
 }

branches/auto/src/librustc_metadata/cstore.rs

@@ -22,8 +22,7 @@ use loader;
 
 use rustc::back::svh::Svh;
 use rustc::middle::cstore::{ExternCrate};
-use rustc::util::nodemap::{FnvHashMap, NodeMap, NodeSet, DefIdMap};
-use rustc::middle::def_id::DefId;
+use rustc::util::nodemap::{FnvHashMap, NodeMap, NodeSet};
 
 use std::cell::{RefCell, Ref, Cell};
 use std::rc::Rc;
@@ -93,7 +92,6 @@ pub struct CStore {
     used_link_args: RefCell<Vec<String>>,
     statically_included_foreign_items: RefCell<NodeSet>,
     pub intr: Rc<IdentInterner>,
-    pub visible_parent_map: RefCell<DefIdMap<DefId>>,
 }
 
 impl CStore {
@@ -106,7 +104,6 @@ impl CStore {
             used_link_args: RefCell::new(Vec::new()),
             intr: intr,
             statically_included_foreign_items: RefCell::new(NodeSet()),
-            visible_parent_map: RefCell::new(FnvHashMap()),
         }
     }