---

yaml
---
r: 165403
b: refs/heads/master
c: 98af642
h: refs/heads/master
i:
  165401: 136d857
  165399: d03a1e6
v: v3

Author: frewsxcv

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: bc99ced5708599c5644a189eca8834453691965e
+refs/heads/master: 98af642f5c8f60ae141a5d3ff92e8cc4e4317342
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 658529467d9d69ac9e09cacf98a6d61d781c2c76
 refs/heads/try: aee614fc4973262a5a68efc643026e2b1458d65b

trunk/src/compiletest/runtest.rs

@@ -1609,7 +1609,7 @@ fn _arm_exec_compiled_test(config: &Config,
                 stderr_out.as_slice());
 
     ProcRes {
-        status: process::ExitStatus(exitcode),
+        status: process::ProcessExit::ExitStatus(exitcode),
         stdout: stdout_out,
         stderr: stderr_out,
         cmdline: cmdline

trunk/src/doc/guide.md

@@ -1,5 +1,5 @@
 /**
- * Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
+ * Copyright 2013 The Rust Project Developers. See the COPYRIGHT
  * file at the top-level directory of this distribution and at
  * http://rust-lang.org/COPYRIGHT.
  * With elements taken from Bootstrap v3.0.2 (MIT licensed).
@@ -209,6 +209,7 @@ pre {
 code {
     padding: 0 2px;
     color: #8D1A38;
+    white-space: pre-wrap;
 }
 pre code {
     padding: 0;

trunk/src/doc/rust.css

@@ -51,7 +51,7 @@
 
 #![doc(primitive = "str")]
 
-pub use self::MaybeOwned::*;
+use self::MaybeOwned::*;
 use self::RecompositionState::*;
 use self::DecompositionType::*;
 
@@ -842,7 +842,7 @@ mod tests {
     use core::iter::AdditiveIterator;
     use super::{eq_slice, from_utf8, is_utf8, is_utf16, raw};
     use super::truncate_utf16_at_nul;
-    use super::{Owned, Slice};
+    use super::MaybeOwned::{Owned, Slice};
 
     #[test]
     fn test_eq_slice() {

trunk/src/libcollections/str.rs

@@ -26,7 +26,8 @@ use core::raw::Slice as RawSlice;
 
 use slice::CloneSliceExt;
 use str;
-use str::{CharRange, CowString, FromStr, StrAllocating, Owned};
+use str::{CharRange, CowString, FromStr, StrAllocating};
+use str::MaybeOwned::Owned;
 use vec::{DerefVec, Vec, as_vec};
 
 /// A growable string stored as a UTF-8 encoded buffer.

trunk/src/libcollections/string.rs

@@ -222,7 +222,7 @@ extern "rust-intrinsic" {
     /// Both types must have the same size and alignment, and this guarantee
     /// is enforced at compile-time.
     ///
-    /// # Examples
+    /// # Example
     ///
     /// ```rust
     /// use std::mem;
@@ -253,20 +253,14 @@ extern "rust-intrinsic" {
     /// integer, since the conversion would throw away aliasing information.
     pub fn offset<T>(dst: *const T, offset: int) -> *const T;
 
-    /// Copies `count * size_of<T>` bytes from `src` to `dst`. The source
+    /// Copies data from one location to another.
+    ///
+    /// Copies `count` elements (not bytes) from `src` to `dst`. The source
     /// and destination may *not* overlap.
     ///
     /// `copy_nonoverlapping_memory` is semantically equivalent to C's `memcpy`.
     ///
-    /// # Safety
-    ///
-    /// Beyond requiring that both regions of memory be allocated, it is Undefined Behaviour
-    /// for source and destination to overlap. Care must also be taken with the ownership of
-    /// `src` and `dst`. This method semantically moves the values of `src` into `dst`.
-    /// However it does not drop the contents of `dst`, or prevent the contents of `src`
-    /// from being dropped or used.
-    ///
-    /// # Examples
+    /// # Example
     ///
     /// A safe swap function:
     ///
@@ -290,22 +284,22 @@ extern "rust-intrinsic" {
     ///     }
     /// }
     /// ```
+    ///
+    /// # Safety Note
+    ///
+    /// If the source and destination overlap then the behavior of this
+    /// function is undefined.
     #[unstable]
     pub fn copy_nonoverlapping_memory<T>(dst: *mut T, src: *const T, count: uint);
 
-    /// Copies `count * size_of<T>` bytes from `src` to `dst`. The source
+    /// Copies data from one location to another.
+    ///
+    /// Copies `count` elements (not bytes) from `src` to `dst`. The source
     /// and destination may overlap.
     ///
     /// `copy_memory` is semantically equivalent to C's `memmove`.
     ///
-    /// # Safety
-    ///
-    /// Care must be taken with the ownership of `src` and `dst`.
-    /// This method semantically moves the values of `src` into `dst`.
-    /// However it does not drop the contents of `dst`, or prevent the contents of `src`
-    /// from being dropped or used.
-    ///
-    /// # Examples
+    /// # Example
     ///
     /// Efficiently create a Rust vector from an unsafe buffer:
     ///

trunk/src/libcore/intrinsics.rs

@@ -252,9 +252,11 @@ pub mod marker {
     /// and this pointer is itself stored in an inherently mutable
     /// location (such as a `Cell`).
     #[lang="invariant_lifetime"]
-    #[deriving(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+    #[deriving(Clone, PartialEq, Eq, PartialOrd, Ord)]
     pub struct InvariantLifetime<'a>;
 
+    impl<'a> Copy for InvariantLifetime<'a> {}
+
     /// A type which is considered "not sendable", meaning that it cannot
     /// be safely sent between tasks, even if it is owned. This is
     /// typically embedded in other types, such as `Gc`, to ensure that

trunk/src/libcore/kinds.rs

@@ -97,20 +97,13 @@ use cmp::{PartialEq, Eq, Ord, PartialOrd, Equiv};
 use cmp::Ordering;
 use cmp::Ordering::{Less, Equal, Greater};
 
-// FIXME #19649: instrinsic docs don't render, so these have no docs :(
-
-#[unstable]
-pub use intrinsics::copy_nonoverlapping_memory;
-
-#[unstable]
 pub use intrinsics::copy_memory;
-
-#[experimental = "uncertain about naming and semantics"]
+pub use intrinsics::copy_nonoverlapping_memory;
 pub use intrinsics::set_memory;
 
-/// Creates a null raw pointer.
+/// Create a null pointer.
 ///
-/// # Examples
+/// # Example
 ///
 /// ```
 /// use std::ptr;
@@ -122,9 +115,9 @@ pub use intrinsics::set_memory;
 #[unstable = "may need a different name after pending changes to pointer types"]
 pub fn null<T>() -> *const T { 0 as *const T }
 
-/// Creates a null mutable raw pointer.
+/// Create an unsafe mutable null pointer.
 ///
-/// # Examples
+/// # Example
 ///
 /// ```
 /// use std::ptr;
@@ -136,26 +129,16 @@ pub fn null<T>() -> *const T { 0 as *const T }
 #[unstable = "may need a different name after pending changes to pointer types"]
 pub fn null_mut<T>() -> *mut T { 0 as *mut T }
 
-/// Zeroes out `count * size_of::<T>` bytes of memory at `dst`. `count` may be `0`.
-///
-/// # Safety
-///
-/// Beyond accepting a raw pointer, this is unsafe because it will not drop the contents of `dst`,
-/// and may be used to create invalid instances of `T`.
+/// Zeroes out `count * size_of::<T>` bytes of memory at `dst`
 #[inline]
 #[experimental = "uncertain about naming and semantics"]
 #[allow(experimental)]
 pub unsafe fn zero_memory<T>(dst: *mut T, count: uint) {
     set_memory(dst, 0, count);
 }
 
-/// Swaps the values at two mutable locations of the same type, without
-/// deinitialising either. They may overlap, unlike `mem::swap` which is otherwise
-/// equivalent.
-///
-/// # Safety
-///
-/// This is only unsafe because it accepts a raw pointer.
+/// Swap the values at two mutable locations of the same type, without
+/// deinitialising either. They may overlap.
 #[inline]
 #[unstable]
 pub unsafe fn swap<T>(x: *mut T, y: *mut T) {
@@ -173,31 +156,16 @@ pub unsafe fn swap<T>(x: *mut T, y: *mut T) {
     mem::forget(tmp);
 }
 
-/// Replaces the value at `dest` with `src`, returning the old
-/// value, without dropping either.
-///
-/// # Safety
-///
-/// This is only unsafe because it accepts a raw pointer.
-/// Otherwise, this operation is identical to `mem::replace`.
+/// Replace the value at a mutable location with a new one, returning the old
+/// value, without deinitialising either.
 #[inline]
 #[unstable]
 pub unsafe fn replace<T>(dest: *mut T, mut src: T) -> T {
     mem::swap(mem::transmute(dest), &mut src); // cannot overlap
     src
 }
 
-/// Reads the value from `src` without dropping it. This leaves the
-/// memory in `src` unchanged.
-///
-/// # Safety
-///
-/// Beyond accepting a raw pointer, this is unsafe because it semantically
-/// moves the value out of `src` without preventing further usage of `src`.
-/// If `T` is not `Copy`, then care must be taken to ensure that the value at
-/// `src` is not used before the data is overwritten again (e.g. with `write`,
-/// `zero_memory`, or `copy_memory`). Note that `*src = foo` counts as a use
-/// because it will attempt to drop the value previously at `*src`.
+/// Reads the value from `*src` and returns it.
 #[inline(always)]
 #[unstable]
 pub unsafe fn read<T>(src: *const T) -> T {
@@ -206,11 +174,8 @@ pub unsafe fn read<T>(src: *const T) -> T {
     tmp
 }
 
-/// Reads the value from `src` and nulls it out without dropping it.
-///
-/// # Safety
-///
-/// This is unsafe for the same reasons that `read` is unsafe.
+/// Reads the value from `*src` and nulls it out.
+/// This currently prevents destructors from executing.
 #[inline(always)]
 #[experimental]
 #[allow(experimental)]
@@ -224,17 +189,12 @@ pub unsafe fn read_and_zero<T>(dest: *mut T) -> T {
     tmp
 }
 
-/// Overwrites a memory location with the given value without reading or dropping
+/// Unsafely overwrite a memory location with the given value without destroying
 /// the old value.
 ///
-/// # Safety
-///
-/// Beyond accepting a raw pointer, this operation is unsafe because it does
-/// not drop the contents of `dst`. This could leak allocations or resources,
-/// so care must be taken not to overwrite an object that should be dropped.
-///
-/// This is appropriate for initializing uninitialized memory, or overwritting memory
-/// that has previously been `read` from.
+/// This operation is unsafe because it does not destroy the previous value
+/// contained at the location `dst`. This could leak allocations or resources,
+/// so care must be taken to previously deallocate the value at `dst`.
 #[inline]
 #[unstable]
 pub unsafe fn write<T>(dst: *mut T, src: T) {
@@ -243,47 +203,39 @@ pub unsafe fn write<T>(dst: *mut T, src: T) {
 
 /// Methods on raw pointers
 pub trait RawPtr<T> {
-    /// Returns a null raw pointer.
+    /// Returns the null pointer.
     fn null() -> Self;
 
-    /// Returns true if the pointer is null.
+    /// Returns true if the pointer is equal to the null pointer.
     fn is_null(&self) -> bool;
 
-    /// Returns true if the pointer is not null.
+    /// Returns true if the pointer is not equal to the null pointer.
     fn is_not_null(&self) -> bool { !self.is_null() }
 
-    /// Returns the address of the pointer.
+    /// Returns the value of this pointer (ie, the address it points to)
     fn to_uint(&self) -> uint;
 
     /// Returns `None` if the pointer is null, or else returns a reference to the
     /// value wrapped in `Some`.
     ///
-    /// # Safety
+    /// # Safety Notes
     ///
     /// While this method and its mutable counterpart are useful for null-safety,
     /// it is important to note that this is still an unsafe operation because
     /// the returned value could be pointing to invalid memory.
     unsafe fn as_ref<'a>(&self) -> Option<&'a T>;
 
-    /// Calculates the offset from a pointer. `count` is in units of T; e.g. a
+    /// Calculates the offset from a pointer. The offset *must* be in-bounds of
+    /// the object, or one-byte-past-the-end.  `count` is in units of T; e.g. a
     /// `count` of 3 represents a pointer offset of `3 * sizeof::<T>()` bytes.
-    ///
-    /// # Safety
-    ///
-    /// The offset must be in-bounds of the object, or one-byte-past-the-end. Otherwise
-    /// `offset` invokes Undefined Behaviour, regardless of whether the pointer is used.
     unsafe fn offset(self, count: int) -> Self;
 }
 
 /// Methods on mutable raw pointers
 pub trait RawMutPtr<T>{
     /// Returns `None` if the pointer is null, or else returns a mutable reference
-    /// to the value wrapped in `Some`.
-    ///
-    /// # Safety
-    ///
-    /// As with `as_ref`, this is unsafe because it cannot verify the validity
-    /// of the returned pointer.
+    /// to the value wrapped in `Some`. As with `as_ref`, this is unsafe because
+    /// it cannot verify the validity of the returned pointer.
     unsafe fn as_mut<'a>(&self) -> Option<&'a mut T>;
 }
 

trunk/src/libcore/ptr.rs

@@ -37,7 +37,7 @@ use util::nodemap::{FnvHashMap, NodeSet};
 use lint::{Context, LintPass, LintArray};
 
 use std::{cmp, slice};
-use std::collections::hash_map::{Occupied, Vacant};
+use std::collections::hash_map::Entry::{Occupied, Vacant};
 use std::num::SignedInt;
 use std::{i8, i16, i32, i64, u8, u16, u32, u64, f32, f64};
 use syntax::{abi, ast, ast_map};

trunk/src/librustc/lint/builtin.rs

@@ -23,7 +23,7 @@ use plugin::load::PluginMetadata;
 use util::nodemap::FnvHashMap;
 
 use std::rc::Rc;
-use std::collections::hash_map::{Occupied, Vacant};
+use std::collections::hash_map::Entry::{Occupied, Vacant};
 use syntax::ast;
 use syntax::abi;
 use syntax::attr;

trunk/src/librustc/metadata/creader.rs

@@ -228,7 +228,7 @@ use util::fs;
 
 use std::c_str::ToCStr;
 use std::cmp;
-use std::collections::hash_map::{Occupied, Vacant};
+use std::collections::hash_map::Entry::{Occupied, Vacant};
 use std::collections::{HashMap, HashSet};
 use std::io::fs::PathExtensions;
 use std::io;

trunk/src/librustc/metadata/loader.rs

@@ -28,7 +28,7 @@ use syntax::visit::{mod, Visitor};
 use syntax::{ast_map, ast_util, codemap};
 
 use std::rc::Rc;
-use std::collections::hash_map::Vacant;
+use std::collections::hash_map::Entry::Vacant;
 
 //
 // This pass classifies expressions by their constant-ness.

trunk/src/librustc/middle/const_eval.rs

@@ -34,7 +34,7 @@ use middle::ty::{mod, Ty};
 use middle::ty_fold;
 use middle::ty_fold::TypeFoldable;
 use middle::ty_fold::TypeFolder;
-use std::collections::hash_map;
+use std::collections::hash_map::{mod, Entry};
 
 use super::InferCtxt;
 use super::unify::InferCtxtMethodsForSimplyUnifiableTypes;
@@ -67,8 +67,8 @@ impl<'a, 'tcx> TypeFreshener<'a, 'tcx> {
         }
 
         match self.freshen_map.entry(key) {
-            hash_map::Occupied(entry) => *entry.get(),
-            hash_map::Vacant(entry) => {
+            Entry::Occupied(entry) => *entry.get(),
+            Entry::Vacant(entry) => {
                 let index = self.freshen_count;
                 self.freshen_count += 1;
                 let t = ty::mk_infer(self.infcx.tcx, freshener(index));

trunk/src/librustc/middle/infer/freshen.rs

@@ -26,7 +26,7 @@ use session::config;
 use util::nodemap::{FnvHashMap, FnvHashSet};
 use util::ppaux::Repr;
 
-use std::collections::hash_map::Vacant;
+use std::collections::hash_map::Entry::Vacant;
 use std::io::{mod, File};
 use std::os;
 use std::sync::atomic;