---

yaml
---
r: 62968
b: refs/heads/snap-stage3
c: fe70361
h: refs/heads/master
v: v3

Author: steveklabnik

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 5ddbc881c52a111da2e61772ec5f7b2826f3d9cb
+refs/heads/snap-stage3: fe70361bb6d89a6226d558c64c03d05bba46412b
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/librustc/middle/trans/base.rs

@@ -1730,15 +1730,8 @@ pub fn copy_args_to_allocas(fcx: fn_ctxt,
         // We really should do this regardless of whether self is owned, but
         // it doesn't work right with default method impls yet. (FIXME: #2794)
         if slf.is_owned {
-            let self_val = if datum::appropriate_mode(slf.t).is_by_value() {
-                let tmp = BitCast(bcx, slf.v, type_of(bcx.ccx(), slf.t));
-                let alloc = alloc_ty(bcx, slf.t);
-                Store(bcx, tmp, alloc);
-                alloc
-            } else {
-                PointerCast(bcx, slf.v, T_ptr(type_of(bcx.ccx(), slf.t)))
-            };
-
+            let self_val = PointerCast(bcx, slf.v,
+                                       T_ptr(type_of(bcx.ccx(), slf.t)));
             fcx.llself = Some(ValSelfData {v: self_val, ..slf});
             add_clean(bcx, self_val, slf.t);
         }

branches/snap-stage3/src/libstd/pipes.rs

@@ -94,7 +94,7 @@ use option::{None, Option, Some};
 use unstable::finally::Finally;
 use unstable::intrinsics;
 use ptr;
-use ptr::RawPtr;
+use ptr::Ptr;
 use task;
 use vec;
 use vec::OwnedVector;

branches/snap-stage3/src/libstd/prelude.rs

@@ -8,7 +8,24 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! The Rust prelude. Imported into every module by default.
+/*!
+
+Many programming languages have a 'prelude': a particular subset of the
+libraries that come with the language. Every program imports the prelude by
+default.
+
+For example, it would be annoying to add `use io::println;` to every single
+program, and the vast majority of Rust programs will wish to print to standard
+output. Therefore, it makes sense to import it into every program.
+
+Rust's prelude has three main parts:
+
+1. io::print and io::println.
+2. Core operators, such as `Add`, `Mul`, and `Not`.
+3. Various types and traits, such as `Clone`, `Eq`, and `comm::Chan`.
+
+*/
+
 
 // Reexported core operators
 pub use either::{Either, Left, Right};
@@ -43,9 +60,9 @@ pub use path::GenericPath;
 pub use path::Path;
 pub use path::PosixPath;
 pub use path::WindowsPath;
-pub use ptr::RawPtr;
+pub use ptr::Ptr;
 pub use ascii::{Ascii, AsciiCast, OwnedAsciiCast, AsciiStr};
-pub use str::{StrVector, StrSlice, OwnedStr, StrUtil};
+pub use str::{StrSlice, OwnedStr, StrUtil};
 pub use from_str::{FromStr};
 pub use to_bytes::IterBytes;
 pub use to_str::{ToStr, ToStrConsume};
@@ -56,7 +73,7 @@ pub use tuple::{CloneableTuple10, CloneableTuple11, CloneableTuple12};
 pub use tuple::{ImmutableTuple2, ImmutableTuple3, ImmutableTuple4, ImmutableTuple5};
 pub use tuple::{ImmutableTuple6, ImmutableTuple7, ImmutableTuple8, ImmutableTuple9};
 pub use tuple::{ImmutableTuple10, ImmutableTuple11, ImmutableTuple12};
-pub use vec::{VectorVector, CopyableVector, ImmutableVector};
+pub use vec::{CopyableVector, ImmutableVector};
 pub use vec::{ImmutableEqVector, ImmutableCopyableVector};
 pub use vec::{OwnedVector, OwnedCopyableVector, MutableVector};
 pub use io::{Reader, ReaderUtil, Writer, WriterUtil};

branches/snap-stage3/src/libstd/ptr.rs

@@ -296,15 +296,15 @@ pub unsafe fn array_each<T>(arr: **T, cb: &fn(*T)) {
 }
 
 #[allow(missing_doc)]
-pub trait RawPtr<T> {
+pub trait Ptr<T> {
     fn is_null(&const self) -> bool;
     fn is_not_null(&const self) -> bool;
     unsafe fn to_option(&const self) -> Option<&T>;
     fn offset(&self, count: uint) -> Self;
 }
 
 /// Extension methods for immutable pointers
-impl<T> RawPtr<T> for *T {
+impl<T> Ptr<T> for *T {
     /// Returns true if the pointer is equal to the null pointer.
     #[inline(always)]
     fn is_null(&const self) -> bool { is_null(*self) }
@@ -336,7 +336,7 @@ impl<T> RawPtr<T> for *T {
 }
 
 /// Extension methods for mutable pointers
-impl<T> RawPtr<T> for *mut T {
+impl<T> Ptr<T> for *mut T {
     /// Returns true if the pointer is equal to the null pointer.
     #[inline(always)]
     fn is_null(&const self) -> bool { is_null(*self) }

branches/snap-stage3/src/libstd/rt/mod.rs

@@ -56,7 +56,7 @@ Several modules in `core` are clients of `rt`:
 
 #[doc(hidden)];
 
-use ptr::RawPtr;
+use ptr::Ptr;
 
 /// The global (exchange) heap.
 pub mod global_heap;

branches/snap-stage3/src/libstd/rt/stack.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use container::Container;
-use ptr::RawPtr;
+use ptr::Ptr;
 use vec;
 use ops::Drop;
 use libc::{c_uint, uintptr_t};

branches/snap-stage3/src/libstd/rt/uv/mod.rs

@@ -38,7 +38,7 @@ use container::Container;
 use option::*;
 use str::raw::from_c_str;
 use to_str::ToStr;
-use ptr::RawPtr;
+use ptr::Ptr;
 use libc;
 use vec;
 use ptr;