---

yaml
---
r: 211863
b: refs/heads/auto
c: a190394
h: refs/heads/master
i:
  211861: cd41602
  211859: d588472
  211855: 603d791
v: v3

Author: Manishearth

[refs]

@@ -10,7 +10,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: b936b1bd7cd28dd55f5ff4dfd47a808452da2b28
+refs/heads/auto: a190394ae8edbdded63062243400b3b9bda26eee
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/configure

@@ -849,13 +849,6 @@ then
     putvar CFG_LOCAL_RUST_ROOT
 fi
 
-# Force freebsd to build with clang; gcc doesn't like us there
-if [ $CFG_OSTYPE = unknown-freebsd ]
-then
-    step_msg "on FreeBSD, forcing use of clang"
-    CFG_ENABLE_CLANG=1
-fi
-
 # Force bitrig to build with clang; gcc doesn't like us there
 if [ $CFG_OSTYPE = unknown-bitrig ]
 then

branches/auto/src/doc/trpl/mutability.md

@@ -159,7 +159,7 @@ b.x = 10; // error: cannot assign to immutable field `b.x`
 
 [struct]: structs.html
 
-However, by using `Cell<T>`, you can emulate field-level mutability:
+However, by using [`Cell<T>`][cell], you can emulate field-level mutability:
 
 ```rust
 use std::cell::Cell;
@@ -176,4 +176,6 @@ point.y.set(7);
 println!("y: {:?}", point.y);
 ```
 
+[cell]: ../std/cell/struct.Cell.html
+
 This will print `y: Cell { value: 7 }`. We’ve successfully updated `y`.

branches/auto/src/libcollections/lib.rs

@@ -37,12 +37,11 @@
 #![feature(unsafe_no_drop_flag, filling_drop)]
 #![feature(step_by)]
 #![feature(str_char)]
-#![feature(str_words)]
 #![feature(slice_patterns)]
 #![feature(utf8_error)]
-#![cfg_attr(test, feature(rand, rustc_private, test, hash, collections,
-                          collections_drain, collections_range))]
+#![cfg_attr(test, feature(rand, test))]
 #![cfg_attr(test, allow(deprecated))] // rand
+#![cfg_attr(not(test), feature(str_words))]
 
 #![feature(no_std)]
 #![no_std]

branches/auto/src/libcollections/slice.rs

@@ -79,6 +79,10 @@
 #![doc(primitive = "slice")]
 #![stable(feature = "rust1", since = "1.0.0")]
 
+// Many of the usings in this module are only used in the test configuration.
+// It's cleaner to just turn off the unused_imports warning than to fix them.
+#![allow(unused_imports)]
+
 use alloc::boxed::Box;
 use core::clone::Clone;
 use core::cmp::Ordering::{self, Greater, Less};

branches/auto/src/libcollections/str.rs

@@ -47,6 +47,10 @@
 #![doc(primitive = "str")]
 #![stable(feature = "rust1", since = "1.0.0")]
 
+// Many of the usings in this module are only used in the test configuration.
+// It's cleaner to just turn off the unused_imports warning than to fix them.
+#![allow(unused_imports)]
+
 use self::RecompositionState::*;
 use self::DecompositionType::*;
 

branches/auto/src/libcollections/vec_deque.rs

@@ -1801,7 +1801,7 @@ impl<T: fmt::Debug> fmt::Debug for VecDeque<T> {
 
 #[cfg(test)]
 mod tests {
-    use core::iter::{Iterator, self};
+    use core::iter::Iterator;
     use core::option::Option::Some;
 
     use test;

branches/auto/src/libcore/cell.rs

@@ -795,6 +795,8 @@ pub struct UnsafeCell<T: ?Sized> {
     ///
     /// This field should not be accessed directly, it is made public for static
     /// initializers.
+    #[deprecated(since = "1.2.0", reason = "use `get` to access the wrapped \
+        value or `new` to initialize `UnsafeCell` in statics")]
     #[unstable(feature = "core")]
     pub value: T,
 }
@@ -818,6 +820,7 @@ impl<T> UnsafeCell<T> {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub const fn new(value: T) -> UnsafeCell<T> {
+        #![allow(deprecated)]
         UnsafeCell { value: value }
     }
 
@@ -839,7 +842,10 @@ impl<T> UnsafeCell<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub unsafe fn into_inner(self) -> T { self.value }
+    pub unsafe fn into_inner(self) -> T {
+        #![allow(deprecated)]
+        self.value
+    }
 }
 
 impl<T: ?Sized> UnsafeCell<T> {
@@ -859,6 +865,7 @@ impl<T: ?Sized> UnsafeCell<T> {
     pub fn get(&self) -> *mut T {
         // FIXME(#23542) Replace with type ascription.
         #![allow(trivial_casts)]
+        #![allow(deprecated)]
         &self.value as *const T as *mut T
     }
 }

branches/auto/src/librustc/metadata/decoder.rs

@@ -268,10 +268,28 @@ fn item_trait_ref<'tcx>(doc: rbml::Doc, tcx: &ty::ctxt<'tcx>, cdata: Cmd)
     doc_trait_ref(tp, tcx, cdata)
 }
 
-fn enum_variant_ids(item: rbml::Doc, cdata: Cmd) -> Vec<ast::DefId> {
-    reader::tagged_docs(item, tag_items_data_item_variant)
-        .map(|p| translated_def_id(cdata, p))
-        .collect()
+struct EnumVariantIds<'a> {
+    iter: reader::TaggedDocsIterator<'a>,
+    cdata: Cmd<'a>,
+}
+
+impl<'a> Iterator for EnumVariantIds<'a> {
+    type Item = ast::DefId;
+
+    fn next(&mut self) -> Option<ast::DefId> {
+        self.iter.next().map(|p| translated_def_id(self.cdata, p))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.iter.size_hint()
+    }
+}
+
+fn enum_variant_ids<'a>(item: rbml::Doc<'a>, cdata: Cmd<'a>) -> EnumVariantIds<'a> {
+    EnumVariantIds {
+        iter: reader::tagged_docs(item, tag_items_data_item_variant),
+        cdata: cdata,
+    }
 }
 
 fn item_path(item_doc: rbml::Doc) -> Vec<ast_map::PathElem> {
@@ -719,11 +737,11 @@ pub fn get_enum_variant_defs(intr: &IdentInterner,
     let data = cdata.data();
     let items = reader::get_doc(rbml::Doc::new(data), tag_items);
     let item = find_item(id, items);
-    enum_variant_ids(item, cdata).iter().map(|did| {
+    enum_variant_ids(item, cdata).map(|did| {
         let item = find_item(did.node, items);
         let name = item_name(intr, item);
         let visibility = item_visibility(item);
-        match item_to_def_like(cdata, item, *did) {
+        match item_to_def_like(cdata, item, did) {
             DlDef(def @ def::DefVariant(..)) => (def, name, visibility),
             _ => unreachable!()
         }
@@ -736,7 +754,7 @@ pub fn get_enum_variants<'tcx>(intr: Rc<IdentInterner>, cdata: Cmd, id: ast::Nod
     let items = reader::get_doc(rbml::Doc::new(data), tag_items);
     let item = find_item(id, items);
     let mut disr_val = 0;
-    enum_variant_ids(item, cdata).iter().map(|did| {
+    enum_variant_ids(item, cdata).map(|did| {
         let item = find_item(did.node, items);
         let ctor_ty = item_type(ast::DefId { krate: cdata.cnum, node: id},
                                 item, tcx, cdata);
@@ -771,7 +789,7 @@ pub fn get_enum_variants<'tcx>(intr: Rc<IdentInterner>, cdata: Cmd, id: ast::Nod
             name: name,
             // I'm not even sure if we encode visibility
             // for variants -- TEST -- tjc
-            id: *did,
+            id: did,
             disr_val: old_disr_val,
             vis: ast::Inherited
         })

branches/auto/src/librustc/util/fs.rs

@@ -11,14 +11,22 @@
 use std::path::{self, Path, PathBuf};
 use std::ffi::OsString;
 
-// Unfortunately, on windows, gcc cannot accept paths of the form `\\?\C:\...`
-// (a verbatim path). This form of path is generally pretty rare, but the
-// implementation of `fs::canonicalize` currently generates paths of this form,
-// meaning that we're going to be passing quite a few of these down to gcc.
+// Unfortunately, on windows, it looks like msvcrt.dll is silently translating
+// verbatim paths under the hood to non-verbatim paths! This manifests itself as
+// gcc looking like it cannot accept paths of the form `\\?\C:\...`, but the
+// real bug seems to lie in msvcrt.dll.
+//
+// Verbatim paths are generally pretty rare, but the implementation of
+// `fs::canonicalize` currently generates paths of this form, meaning that we're
+// going to be passing quite a few of these down to gcc, so we need to deal with
+// this case.
 //
 // For now we just strip the "verbatim prefix" of `\\?\` from the path. This
 // will probably lose information in some cases, but there's not a whole lot
-// more we can do with a buggy gcc...
+// more we can do with a buggy msvcrt...
+//
+// For some more information, see this comment:
+//   https://github.com/rust-lang/rust/issues/25505#issuecomment-102876737
 pub fn fix_windows_verbatim_for_gcc(p: &Path) -> PathBuf {
     if !cfg!(windows) {
         return p.to_path_buf()
@@ -28,11 +36,20 @@ pub fn fix_windows_verbatim_for_gcc(p: &Path) -> PathBuf {
         Some(path::Component::Prefix(p)) => p,
         _ => return p.to_path_buf(),
     };
-    let disk = match prefix.kind() {
-        path::Prefix::VerbatimDisk(disk) => disk,
-        _ => return p.to_path_buf(),
-    };
-    let mut base = OsString::from(format!("{}:", disk as char));
-    base.push(components.as_path());
-    PathBuf::from(base)
+    match prefix.kind() {
+        path::Prefix::VerbatimDisk(disk) => {
+            let mut base = OsString::from(format!("{}:", disk as char));
+            base.push(components.as_path());
+            PathBuf::from(base)
+        }
+        path::Prefix::VerbatimUNC(server, share) => {
+            let mut base = OsString::from(r"\\");
+            base.push(server);
+            base.push(r"\");
+            base.push(share);
+            base.push(components.as_path());
+            PathBuf::from(base)
+        }
+        _ => p.to_path_buf(),
+    }
 }

branches/auto/src/librustc_back/target/freebsd_base.rs

@@ -18,11 +18,6 @@ pub fn opts() -> TargetOptions {
         executables: true,
         morestack: true,
         has_rpath: true,
-        pre_link_args: vec!(
-            "-L/usr/local/lib".to_string(),
-            "-L/usr/local/lib/gcc46".to_string(),
-            "-L/usr/local/lib/gcc44".to_string(),
-        ),
 
         .. Default::default()
     }