---

yaml
---
r: 219134
b: refs/heads/snap-stage3
c: 1ece005
h: refs/heads/master
v: v3

Author: mcast

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: c044791d80ea0dc5c4b57b6030a67b69f8510239
-refs/heads/snap-stage3: bd7a6ec8ecdf0dadd88aae0040a5cf0d00e2f32f
+refs/heads/snap-stage3: 1ece0058382c234dc64ce596eb62b1f636632566
 refs/heads/try: b53c0f93eedcdedd4fd89bccc5a3a09d1c5cd23e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/snap-stage3/src/doc/trpl/enums.md

@@ -64,45 +64,3 @@ equality yet, but we’ll find out in the [`traits`][traits] section.
 [match]: match.html
 [if-let]: if-let.html
 [traits]: traits.html
-
-# Constructors as functions
-
-An enum’s constructors can also be used like functions. For example:
-
-```rust
-# enum Message {
-# Write(String),
-# }
-let m = Message::Write("Hello, world".to_string());
-```
-
-Is the same as
-
-```rust
-# enum Message {
-# Write(String),
-# }
-fn foo(x: String) -> Message {
-    Message::Write(x)
-}
-
-let x = foo("Hello, world".to_string());
-```
-
-This is not immediately useful to us, but when we get to
-[`closures`][closures], we’ll talk about passing functions as arguments to
-other functions. For example, with [`iterators`][iterators], we can do this
-to convert a vector of `String`s into a vector of `Message::Write`s:
-
-```rust
-# enum Message {
-# Write(String),
-# }
-
-let v = vec!["Hello".to_string(), "World".to_string()];
-
-let v1: Vec<Message> = v.into_iter().map(Message::Write).collect();
-```
-
-[closures]: closures.html
-[iterators]: iterators.html

branches/snap-stage3/src/doc/trpl/ffi.md

@@ -238,7 +238,7 @@ However it is often desired that the callback is targeted to a special
 Rust object. This could be the object that represents the wrapper for the
 respective C object.
 
-This can be achieved by passing an raw pointer to the object down to the
+This can be achieved by passing an unsafe pointer to the object down to the
 C library. The C library can then include the pointer to the Rust object in
 the notification. This will allow the callback to unsafely access the
 referenced Rust object.
@@ -370,7 +370,7 @@ On OSX, frameworks behave with the same semantics as a dynamic library.
 
 # Unsafe blocks
 
-Some operations, like dereferencing raw pointers or calling functions that have been marked
+Some operations, like dereferencing unsafe pointers or calling functions that have been marked
 unsafe are only allowed inside unsafe blocks. Unsafe blocks isolate unsafety and are a promise to
 the compiler that the unsafety does not leak out of the block.
 

branches/snap-stage3/src/doc/trpl/functions.md

@@ -144,7 +144,9 @@ an expression, and a `let` can only begin a statement, not an expression.
 Note that assigning to an already-bound variable (e.g. `y = 5`) is still an
 expression, although its value is not particularly useful. Unlike other
 languages where an assignment evaluates to the assigned value (e.g. `5` in the
-previous example), in Rust the value of an assignment is an empty tuple `()`:
+previous example), in Rust the value of an assignment is an empty tuple `()`
+because the assigned value can have (just one owner)[ownership.html], and any
+other returned value would be too surprising:
 
 ```rust
 let mut y = 5;

branches/snap-stage3/src/doc/trpl/raw-pointers.md

@@ -52,9 +52,9 @@ println!("raw points at {}", *raw);
 It gives this error:
 
 ```text
-error: dereference of raw pointer requires unsafe function or block [E0133]
-     println!("raw points at {}", *raw);
-                                  ^~~~
+error: dereference of unsafe pointer requires unsafe function or block [E0133]
+     println!("raw points at{}", *raw);
+                                 ^~~~
 ```
 
 When you dereference a raw pointer, you’re taking responsibility that it’s not

branches/snap-stage3/src/doc/trpl/strings.md

@@ -117,30 +117,6 @@ let dog = hachiko.chars().nth(1); // kinda like hachiko[1]
 
 This emphasizes that we have to go through the whole list of `chars`.
 
-## Slicing
-
-You can get a slice of a string with slicing syntax:
-
-```rust
-let dog = "hachiko";
-let hachi = &dog[0..5];
-```
-
-But note that these are _byte_ offsets, not _character_ offsets. So
-this will fail at runtime:
-
-```rust,should_panic
-let dog = "忠犬ハチ公";
-let hachi = &dog[0..2];
-```
-
-with this error:
-
-```text
-thread '<main>' panicked at 'index 0 and/or 2 in `忠犬ハチ公` do not lie on
-character boundary'
-```
-
 ## Concatenation
 
 If you have a `String`, you can concatenate a `&str` to the end of it:

branches/snap-stage3/src/liballoc/lib.rs

@@ -22,9 +22,9 @@
 //!
 //! ## Boxed values
 //!
-//! The [`Box`](boxed/index.html) type is a smart pointer type. There can
-//! only be one owner of a `Box`, and the owner can decide to mutate the
-//! contents, which live on the heap.
+//! The [`Box`](boxed/index.html) type is the core owned pointer type in Rust.
+//! There can only be one owner of a `Box`, and the owner can decide to mutate
+//! the contents, which live on the heap.
 //!
 //! This type can be sent among threads efficiently as the size of a `Box` value
 //! is the same as that of a pointer. Tree-like data structures are often built

branches/snap-stage3/src/libcollections/slice.rs

@@ -370,7 +370,7 @@ impl<T> [T] {
         core_slice::SliceExt::get_unchecked_mut(self, index)
     }
 
-    /// Returns an raw pointer to the slice's buffer
+    /// Returns an unsafe pointer to the slice's buffer
     ///
     /// The caller must ensure that the slice outlives the pointer this
     /// function returns, or else it will end up pointing to garbage.

branches/snap-stage3/src/libcollections/str.rs

@@ -525,7 +525,7 @@ impl str {
         core_str::StrExt::as_bytes(&self[..])
     }
 
-    /// Returns a raw pointer to the `&str`'s buffer.
+    /// Returns an unsafe pointer to the `&str`'s buffer.
     ///
     /// The caller must ensure that the string outlives this pointer, and
     /// that it is not

branches/snap-stage3/src/libcollections/vec.rs

@@ -1213,9 +1213,9 @@ impl<T: PartialEq> Vec<T> {
             // Duplicate, advance r. End of vec. Truncate to w.
 
             let ln = self.len();
-            if ln <= 1 { return; }
+            if ln < 1 { return; }
 
-            // Avoid bounds checks by using raw pointers.
+            // Avoid bounds checks by using unsafe pointers.
             let p = self.as_mut_ptr();
             let mut r: usize = 1;
             let mut w: usize = 1;

branches/snap-stage3/src/libcore/intrinsics.rs

@@ -46,7 +46,7 @@ use marker::Sized;
 
 extern "rust-intrinsic" {
 
-    // NB: These intrinsics take raw pointers because they mutate aliased
+    // NB: These intrinsics take unsafe pointers because they mutate aliased
     // memory, which is not valid for either `&` or `&mut`.
 
     pub fn atomic_cxchg<T>(dst: *mut T, old: T, src: T) -> T;

branches/snap-stage3/src/libcore/marker.rs

@@ -357,7 +357,7 @@ macro_rules! impls{
 /// struct is dropped, it may in turn drop one or more instances of
 /// the type `T`, though that may not be apparent from the other
 /// structure of the type itself. This is commonly necessary if the
-/// structure is using a raw pointer like `*mut T` whose referent
+/// structure is using an unsafe pointer like `*mut T` whose referent
 /// may be dropped when the type is dropped, as a `*mut T` is
 /// otherwise not treated as owned.
 ///

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

@@ -10,16 +10,16 @@
 
 // FIXME: talk about offset, copy_memory, copy_nonoverlapping_memory
 
-//! Operations on raw pointers, `*const T`, and `*mut T`.
+//! Operations on unsafe pointers, `*const T`, and `*mut T`.
 //!
-//! Working with raw pointers in Rust is uncommon,
+//! Working with unsafe pointers in Rust is uncommon,
 //! typically limited to a few patterns.
 //!
 //! Use the `null` function to create null pointers, and the `is_null` method
 //! of the `*const T` type  to check for null. The `*const T` type also defines
 //! the `offset` method, for pointer math.
 //!
-//! # Common ways to create raw pointers
+//! # Common ways to create unsafe pointers
 //!
 //! ## 1. Coerce a reference (`&T`) or mutable reference (`&mut T`).
 //!
@@ -86,7 +86,7 @@
 //!
 //! Usually you wouldn't literally use `malloc` and `free` from Rust,
 //! but C APIs hand out a lot of pointers generally, so are a common source
-//! of raw pointers in Rust.
+//! of unsafe pointers in Rust.
 
 #![stable(feature = "rust1", since = "1.0.0")]
 #![doc(primitive = "pointer")]

branches/snap-stage3/src/librustc/middle/check_const.rs

@@ -13,10 +13,10 @@
 //
 // - For each *mutable* static item, it checks that its **type**:
 //     - doesn't have a destructor
-//     - doesn't own a box
+//     - doesn't own an owned pointer
 //
 // - For each *immutable* static item, it checks that its **value**:
-//       - doesn't own a box
+//       - doesn't own owned, managed pointers
 //       - doesn't contain a struct literal or a call to an enum variant / struct constructor where
 //           - the type of the struct/enum has a dtor
 //

branches/snap-stage3/src/librustc/middle/effect.rs

@@ -162,7 +162,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EffectCheckVisitor<'a, 'tcx> {
                 debug!("effect: unary case, base type is {}",
                        ppaux::ty_to_string(self.tcx, base_type));
                 if let ty::ty_ptr(_) = base_type.sty {
-                    self.require_unsafe(expr.span, "dereference of raw pointer")
+                    self.require_unsafe(expr.span, "dereference of unsafe pointer")
                 }
             }
             ast::ExprAssign(ref base, _) | ast::ExprAssignOp(_, ref base, _) => {

branches/snap-stage3/src/librustc/middle/mem_categorization.rs

@@ -1410,7 +1410,7 @@ pub enum AliasableReason {
 
 impl<'tcx> cmt_<'tcx> {
     pub fn guarantor(&self) -> cmt<'tcx> {
-        //! Returns `self` after stripping away any derefs or
+        //! Returns `self` after stripping away any owned pointer derefs or
         //! interior content. The return value is basically the `cmt` which
         //! determines how long the value in `self` remains live.
 
@@ -1546,7 +1546,7 @@ impl<'tcx> cmt_<'tcx> {
                                 format!("`Box` content")
                             }
                             UnsafePtr(..) => {
-                                format!("dereference of raw pointer")
+                                format!("dereference of unsafe pointer")
                             }
                             BorrowedPtr(..) => {
                                 format!("borrowed content")

branches/snap-stage3/src/librustc/middle/ty.rs

@@ -3646,7 +3646,7 @@ impl TypeContents {
             *self & TC::ReachesAll)
     }
 
-    /// Includes only those bits that still apply when indirected through a raw pointer (`*`)
+    /// Includes only those bits that still apply when indirected through an unsafe pointer (`*`)
     pub fn unsafe_pointer(&self) -> TypeContents {
         *self & TC::ReachesAll
     }

branches/snap-stage3/src/librustc_borrowck/borrowck/README.md

@@ -170,7 +170,7 @@ overwrite (or freeze) `(*x).f`, and thus invalidate the reference
 that was created. In general it holds that when a path is
 lent, restrictions are issued for all the owning prefixes of that
 path. In this case, the path `*x` owns the path `(*x).f` and,
-because `x` has ownership, the path `x` owns the path `*x`.
+because `x` is an owned pointer, the path `x` owns the path `*x`.
 Therefore, borrowing `(*x).f` yields restrictions on both
 `*x` and `x`.
 
@@ -286,7 +286,7 @@ MUTABILITY(X, imm)                  // M-Var-Imm
 
 ### Checking mutability of owned content
 
-Fields and boxes inherit their mutability from
+Fields and owned pointers inherit their mutability from
 their base expressions, so both of their rules basically
 delegate the check to the base expression `LV`:
 
@@ -387,7 +387,7 @@ LIFETIME(X, LT, MQ)                 // L-Local
 
 ### Checking lifetime for owned content
 
-The lifetime of a field or box is the same as the lifetime
+The lifetime of a field or owned pointer is the same as the lifetime
 of its owner:
 
 ```text
@@ -466,10 +466,10 @@ origin of inherited mutability.
 
 Because the mutability of owned referents is inherited, restricting an
 owned referent is similar to restricting a field, in that it implies
-restrictions on the pointer. However, boxes have an important
+restrictions on the pointer. However, owned pointers have an important
 twist: if the owner `LV` is mutated, that causes the owned referent
 `*LV` to be freed! So whenever an owned referent `*LV` is borrowed, we
-must prevent the box `LV` from being mutated, which means
+must prevent the owned pointer `LV` from being mutated, which means
 that we always add `MUTATE` and `CLAIM` to the restriction set imposed
 on `LV`:
 
@@ -648,7 +648,7 @@ fn main() {
 ```
 
 Clause (2) propagates the restrictions on the referent to the pointer
-itself. This is the same as with an box, though the
+itself. This is the same as with an owned pointer, though the
 reasoning is mildly different. The basic goal in all cases is to
 prevent the user from establishing another route to the same data. To
 see what I mean, let's examine various cases of what can go wrong and

branches/snap-stage3/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs

@@ -137,7 +137,7 @@ fn gather_move<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>,
                                move_info.id, move_info.kind);
         }
         None => {
-            // move from rvalue or raw pointer, hence ok
+            // move from rvalue or unsafe pointer, hence ok
         }
     }
 }

branches/snap-stage3/src/librustc_borrowck/borrowck/gather_loans/restrictions.rs

@@ -110,7 +110,7 @@ impl<'a, 'tcx> RestrictionsContext<'a, 'tcx> {
                     mc::Unique => {
                         // R-Deref-Send-Pointer
                         //
-                        // When we borrow the interior of a box, we
+                        // When we borrow the interior of an owned pointer, we
                         // cannot permit the base to be mutated, because that
                         // would cause the unique pointer to be freed.
                         //
@@ -145,7 +145,7 @@ impl<'a, 'tcx> RestrictionsContext<'a, 'tcx> {
                             }
                         }
                     }
-                    // Borrowck is not relevant for raw pointers
+                    // Borrowck is not relevant for unsafe pointers
                     mc::UnsafePtr(..) => Safe
                 }
             }

branches/snap-stage3/src/librustc_trans/trans/base.rs

@@ -1676,7 +1676,7 @@ pub fn trans_named_tuple_constructor<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
             if !type_is_zero_size(ccx, result_ty) {
                 alloc_ty(bcx, result_ty, "constructor_result")
             } else {
-                C_undef(type_of::type_of(ccx, result_ty).ptr_to())
+                C_undef(type_of::type_of(ccx, result_ty))
             }
         }
     };

branches/snap-stage3/src/librustc_typeck/check/cast.rs

@@ -341,8 +341,8 @@ impl<'tcx> CastCheck<'tcx> {
                 // Due to the limitations of LLVM global constants,
                 // region pointers end up pointing at copies of
                 // vector elements instead of the original values.
-                // To allow raw pointers to work correctly, we
-                // need to special-case obtaining a raw pointer
+                // To allow unsafe pointers to work correctly, we
+                // need to special-case obtaining an unsafe pointer
                 // from a region pointer to a vector.
 
                 // this will report a type mismatch if needed

branches/snap-stage3/src/librustc_typeck/check/regionck.rs

@@ -76,7 +76,7 @@
 //! the borrow itself (L2).  What do I mean by "guaranteed" by a
 //! borrowed pointer? I mean any data that is reached by first
 //! dereferencing a borrowed pointer and then either traversing
-//! interior offsets or boxes.  We say that the guarantor
+//! interior offsets or owned pointers.  We say that the guarantor
 //! of such data it the region of the borrowed pointer that was
 //! traversed.  This is essentially the same as the ownership
 //! relation, except that a borrowed pointer never owns its

branches/snap-stage3/src/libstd/sys/common/thread_local.rs

@@ -102,7 +102,7 @@ pub struct StaticKey {
 /// type is entirely safe to use.
 ///
 /// Implementations will likely, however, contain unsafe code as this type only
-/// operates on `*mut u8`, a raw pointer.
+/// operates on `*mut u8`, an unsafe pointer.
 ///
 /// # Examples
 ///

branches/snap-stage3/src/libsyntax/parse/parser.rs

@@ -4215,7 +4215,7 @@ impl<'a> Parser<'a> {
                 };
                 if self.is_self_ident() {
                     let span = self.span;
-                    self.span_err(span, "cannot pass self by raw pointer");
+                    self.span_err(span, "cannot pass self by unsafe pointer");
                     try!(self.bump());
                 }
                 // error case, making bogus self ident:

branches/snap-stage3/src/test/compile-fail/borrowck-move-from-unsafe-ptr.rs

@@ -10,7 +10,7 @@
 
 
 fn foo(x: *const Box<isize>) -> Box<isize> {
-    let y = *x; //~ ERROR dereference of raw pointer requires unsafe function or block
+    let y = *x; //~ ERROR dereference of unsafe pointer requires unsafe function or block
     return y;
 }