---

yaml
---
r: 272191
b: refs/heads/auto
c: 10caca2
h: refs/heads/master
i:
  272189: aa24f46
  272187: 9377726
  272183: a8a9f7e
  272175: 1cdbda6
  272159: ad28d03
  272127: 1f8791f

Author: tbu-

[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: d611cc080c4f7a5e078990e6cf74083a1d8c4823
+refs/heads/auto: 10caca24f0052a033cac648884d2393125bc24a3
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336
 refs/tags/0.2: 1754d02027f2924bed83b0160ee340c7f41d5ea1

branches/auto/README.md

@@ -177,11 +177,10 @@ To contribute to Rust, please see [CONTRIBUTING](CONTRIBUTING.md).
 Rust has an [IRC] culture and most real-time collaboration happens in a
 variety of channels on Mozilla's IRC network, irc.mozilla.org. The
 most popular channel is [#rust], a venue for general discussion about
-Rust. And a good place to ask for help would be [#rust-beginners].
+Rust, and a good place to ask for help.
 
 [IRC]: https://en.wikipedia.org/wiki/Internet_Relay_Chat
 [#rust]: irc://irc.mozilla.org/rust
-[#rust-beginners]: irc://irc.mozilla.org/rust-beginners
 
 ## License
 

branches/auto/src/doc/book/getting-started.md

@@ -164,15 +164,13 @@ installed. Doing so will depend on your specific system, consult its
 documentation for more details.
 
 If not, there are a number of places where we can get help. The easiest is
-[the #rust-beginners IRC channel on irc.mozilla.org][irc-beginners] and for
-general discussion [the #rust IRC channel on irc.mozilla.org][irc], which we
-can access through [Mibbit][mibbit]. Then we'll be chatting with other
-Rustaceans (a silly nickname we call ourselves) who can help us out. Other great
-resources include [the user’s forum][users] and [Stack Overflow][stackoverflow].
+[the #rust IRC channel on irc.mozilla.org][irc], which we can access through
+[Mibbit][mibbit]. Click that link, and we'll be chatting with other Rustaceans
+(a silly nickname we call ourselves) who can help us out. Other great resources
+include [the user’s forum][users], and [Stack Overflow][stackoverflow].
 
-[irc-beginners]: irc://irc.mozilla.org/#rust-beginners
 [irc]: irc://irc.mozilla.org/#rust
-[mibbit]: http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-beginners,%23rust
+[mibbit]: http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust
 [users]: https://users.rust-lang.org/
 [stackoverflow]: http://stackoverflow.com/questions/tagged/rust
 

branches/auto/src/doc/nomicon/vec.md

@@ -2,7 +2,7 @@
 
 To bring everything together, we're going to write `std::Vec` from scratch.
 Because all the best tools for writing unsafe code are unstable, this
-project will only work on nightly (as of Rust 1.9.0). With the exception of the
+project will only work on nightly (as of Rust 1.2.0). With the exception of the
 allocator API, much of the unstable code we'll use is expected to be stabilized
 in a similar form as it is today.
 

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/diagnostics.rs

@@ -1033,6 +1033,47 @@ fn main() {
     some_func(5i32); // ok!
 }
 ```
+
+Or in a generic context, an erroneous code example would look like:
+```compile_fail
+fn some_func<T>(foo: T) {
+    println!("{:?}", foo); // error: the trait `core::fmt::Debug` is not
+                           //        implemented for the type `T`
+}
+
+fn main() {
+    // We now call the method with the i32 type,
+    // which *does* implement the Debug trait.
+    some_func(5i32);
+}
+```
+
+Note that the error here is in the definition of the generic function: Although
+we only call it with a parameter that does implement `Debug`, the compiler
+still rejects the function: It must work with all possible input types. In
+order to make this example compile, we need to restrict the generic type we're
+accepting:
+```
+use std::fmt;
+
+// Restrict the input type to types that implement Debug.
+fn some_func<T: fmt::Debug>(foo: T) {
+    println!("{:?}", foo);
+}
+
+fn main() {
+    // Calling the method is still fine, as i32 implements Debug.
+    some_func(5i32);
+
+    // This would fail to compile now:
+    // struct WithoutDebug;
+    // some_func(WithoutDebug);
+}
+
+Rust only looks at the signature of the called function, as such it must
+already specify all requirements that will be used for every type parameter.
+```
+
 "##,
 
 E0281: r##"

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()),
         }
     }