---

yaml
---
r: 130133
b: refs/heads/master
c: 7241267
h: refs/heads/master
i:
  130131: 1b6bcb8
v: v3

Author: jbcrail

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: e59a4584c98e0eb21be5ba0a972a647025f14df5
+refs/heads/master: 7241267b93ea02cc25edda531fdc5b6261a96d01
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 67b97ab6d2b7de9b69fd97dc171fcf8feec932ff
 refs/heads/try: 28d5878c1f0465c11c8e7a3085008b0c592d48d0

trunk/src/doc/complement-lang-faq.md

@@ -83,7 +83,7 @@ We want to maintain the option to parametrize at runtime. We may eventually chan
 
 ## Why aren't values type-parametric? Why only items?
 
-Doing so would make type inference much more complex, and require the implementation strategy of runtime parametrization.
+Doing so would make type inference much more complex, and require the implementation strategy of runtime parameterization.
 
 ## Why are enumerations nominal and closed?
 

trunk/src/doc/guide.md

@@ -1808,7 +1808,7 @@ our code in this file. We'll talk about multiple-file projects later on in the
 guide.
 
 Before we move on, let me show you one more Cargo command: `run`. `cargo run`
-is kind of like `cargo build`, but it also then runs the produced exectuable.
+is kind of like `cargo build`, but it also then runs the produced executable.
 Try it out:
 
 ```{notrust,ignore}

trunk/src/doc/rust.md

@@ -1954,7 +1954,7 @@ On `struct`s:
 
 - `repr` - specifies the representation to use for this struct. Takes a list
   of options. The currently accepted ones are `C` and `packed`, which may be
-  combined. `C` will use a C ABI comptible struct layout, and `packed` will
+  combined. `C` will use a C ABI compatible struct layout, and `packed` will
   remove any padding between fields (note that this is very fragile and may
   break platforms which require aligned access).
 
@@ -2367,7 +2367,7 @@ One can indicate the stability of an API using the following attributes:
 These levels are directly inspired by
 [Node.js' "stability index"](http://nodejs.org/api/documentation.html).
 
-Stability levels are inherited, so an items's stability attribute is the
+Stability levels are inherited, so an item's stability attribute is the
 default stability for everything nested underneath it.
 
 There are lints for disallowing items marked with certain levels: `deprecated`,
@@ -2444,7 +2444,7 @@ The currently implemented features of the reference compiler are:
 
 * `concat_idents` - Allows use of the `concat_idents` macro, which is in many
                     ways insufficient for concatenating identifiers, and may
-                    be removed entirely for something more wholsome.
+                    be removed entirely for something more wholesome.
 
 * `default_type_params` - Allows use of default type parameters. The future of
                           this feature is uncertain.
@@ -3604,7 +3604,7 @@ of the type.[^structtype]
 
 New instances of a `struct` can be constructed with a [struct expression](#structure-expressions).
 
-The memory layout of a `struct` is undefined by default to allow for compiler optimziations like
+The memory layout of a `struct` is undefined by default to allow for compiler optimizations like
 field reordering, but it can be fixed with the `#[repr(...)]` attribute.
 In either case, fields may be given in any order in a corresponding struct *expression*;
 the resulting `struct` value will always have the same memory layout.
@@ -3668,17 +3668,32 @@ let a: List<int> = Cons(7, box Cons(13, box Nil));
 
 All pointers in Rust are explicit first-class values.
 They can be copied, stored into data structures, and returned from functions.
-There are two varieties of pointer in Rust:
+There are four varieties of pointer in Rust:
+
+* Owning pointers (`Box`)
+  : These point to owned heap allocations (or "boxes") in the shared, inter-task heap.
+    Each owned box has a single owning pointer; pointer and pointee retain a 1:1 relationship at all times.
+    Owning pointers are written `Box<content>`,
+    for example `Box<int>` means an owning pointer to an owned box containing an integer.
+    Copying an owned box is a "deep" operation:
+    it involves allocating a new owned box and copying the contents of the old box into the new box.
+    Releasing an owning pointer immediately releases its corresponding owned box.
 
 * References (`&`)
   : These point to memory _owned by some other value_.
-    A reference type is written `&type` for some lifetime-variable `f`,
-    or just `&'a type` when you need an explicit lifetime.
+    References arise by (automatic) conversion from owning pointers, managed pointers,
+    or by applying the borrowing operator `&` to some other value,
+    including [lvalues, rvalues or temporaries](#lvalues,-rvalues-and-temporaries).
+    A borrow expression is written `&content`.
+
+    A reference type is written `&'f type` for some lifetime-variable `f`,
+    or just `&type` when the lifetime can be elided;
+    for example `&int` means a reference to an integer.
     Copying a reference is a "shallow" operation:
     it involves only copying the pointer itself.
     Releasing a reference typically has no effect on the value it points to,
-    with the exception of temporary values, which are released when the last
-    reference to them is released.
+    with the exception of temporary values,
+    which are released when the last reference to them is released.
 
 * Raw pointers (`*`)
   : Raw pointers are pointers without safety or liveness guarantees.
@@ -3691,9 +3706,6 @@ There are two varieties of pointer in Rust:
     they exist to support interoperability with foreign code,
     and writing performance-critical or low-level functions.
 
-The standard library contains addtional 'smart pointer' types beyond references
-and raw pointers.
-
 ### Function types
 
 The function type constructor `fn` forms new function types.
@@ -4202,7 +4214,7 @@ be ignored in favor of only building the artifacts specified by command line.
   purpose of this output type is to create a static library containing all of
   the local crate's code along with all upstream dependencies. The static
   library is actually a `*.a` archive on linux and osx and a `*.lib` file on
-  windows. This format is recommended for use in situtations such as linking
+  windows. This format is recommended for use in situations such as linking
   Rust code into an existing non-Rust application because it will not have
   dynamic dependencies on other Rust code.
 

trunk/src/libcore/slice.rs

@@ -996,15 +996,6 @@ impl<'a, T> Collection for &'a [T] {
     }
 }
 
-#[experimental = "trait is experimental"]
-impl<'a, T> Collection for &'a mut [T] {
-    /// Returns the length of a vector
-    #[inline]
-    fn len(&self) -> uint {
-        self.repr().len
-    }
-}
-
 #[unstable = "waiting for DST"]
 impl<'a, T> Default for &'a [T] {
     fn default() -> &'a [T] { &[] }

trunk/src/librustc/diagnostics.rs

@@ -169,7 +169,5 @@ register_diagnostics!(
     E0155,
     E0156,
     E0157,
-    E0158,
-    E0159,
-    E0160
+    E0158
 )

trunk/src/librustc/middle/astencode.rs

@@ -1073,18 +1073,9 @@ impl<'a> rbml_writer_helpers for Encoder<'a> {
                         this.emit_enum_variant_arg(0, |this| Ok(this.emit_unsize_kind(ecx, uk)))
                     })
                 }
-                &ty::AutoUnsafe(m, None) => {
-                    this.emit_enum_variant("AutoUnsafe", 3, 2, |this| {
-                        this.emit_enum_variant_arg(0, |this| m.encode(this));
-                        this.emit_enum_variant_arg(1,
-                            |this| this.emit_option(|this| this.emit_option_none()))
-                    })
-                }
-                &ty::AutoUnsafe(m, Some(box ref a)) => {
-                    this.emit_enum_variant("AutoUnsafe", 3, 2, |this| {
-                        this.emit_enum_variant_arg(0, |this| m.encode(this));
-                        this.emit_enum_variant_arg(1, |this| this.emit_option(
-                            |this| this.emit_option_some(|this| Ok(this.emit_autoref(ecx, a)))))
+                &ty::AutoUnsafe(m) => {
+                    this.emit_enum_variant("AutoUnsafe", 3, 1, |this| {
+                        this.emit_enum_variant_arg(0, |this| m.encode(this))
                     })
                 }
             }
@@ -1644,16 +1635,8 @@ impl<'a> rbml_decoder_decoder_helpers for reader::Decoder<'a> {
                     3 => {
                         let m: ast::Mutability =
                             this.read_enum_variant_arg(0, |this| Decodable::decode(this)).unwrap();
-                        let a: Option<Box<ty::AutoRef>> =
-                            this.read_enum_variant_arg(1, |this| this.read_option(|this, b| {
-                                if b {
-                                    Ok(Some(box this.read_autoref(xcx)))
-                                } else {
-                                    Ok(None)
-                                }
-                            })).unwrap();
 
-                        ty::AutoUnsafe(m, a)
+                        ty::AutoUnsafe(m)
                     }
                     _ => fail!("bad enum variant for ty::AutoRef")
                 })

trunk/src/librustc/middle/expr_use_visitor.rs

@@ -762,7 +762,7 @@ impl<'d,'t,TYPER:mc::Typer> ExprUseVisitor<'d,'t,TYPER> {
                                      ty::BorrowKind::from_mutbl(m),
                                      AutoRef);
             }
-            ty::AutoUnsizeUniq(_) | ty::AutoUnsize(_) | ty::AutoUnsafe(..) => {}
+            ty::AutoUnsizeUniq(_) | ty::AutoUnsize(_) | ty::AutoUnsafe(_) => {}
         }
     }
 

trunk/src/librustc/middle/trans/adt.rs

@@ -296,9 +296,8 @@ impl Case {
 
         for (i, &ty) in self.tys.iter().enumerate() {
             match ty::get(ty).sty {
-                // &T/&mut T/*T could either be a thin or fat pointer depending on T
-                ty::ty_rptr(_, ty::mt { ty, .. })
-                | ty::ty_ptr(ty::mt { ty, .. }) => match ty::get(ty).sty {
+                // &T/&mut T could either be a thin or fat pointer depending on T
+                ty::ty_rptr(_, ty::mt { ty, .. }) => match ty::get(ty).sty {
                     // &[T] and &str are a pointer and length pair
                     ty::ty_vec(_, None) | ty::ty_str => return Some(FatPointer(i, slice_elt_base)),
 

trunk/src/librustc/middle/trans/base.rs

@@ -566,8 +566,8 @@ pub fn compare_scalar_types<'a>(
 
     match ty::get(t).sty {
         ty::ty_nil => f(nil_type),
-        ty::ty_bool | ty::ty_uint(_) | ty::ty_char => f(unsigned_int),
-        ty::ty_ptr(mt) if ty::type_is_sized(cx.tcx(), mt.ty) => f(unsigned_int),
+        ty::ty_bool | ty::ty_ptr(_) |
+        ty::ty_uint(_) | ty::ty_char => f(unsigned_int),
         ty::ty_int(_) => f(signed_int),
         ty::ty_float(_) => f(floating_point),
             // Should never get here, because t is scalar.

trunk/src/librustc/middle/trans/consts.rs

@@ -243,7 +243,7 @@ pub fn const_expr(cx: &CrateContext, e: &ast::Expr, is_local: bool) -> (ValueRef
                         }
                         Some(ref autoref) => {
                             match *autoref {
-                                ty::AutoUnsafe(_, None) |
+                                ty::AutoUnsafe(_) |
                                 ty::AutoPtr(ty::ReStatic, _, None) => {
                                     // Don't copy data to do a deref+ref
                                     // (i.e., skip the last auto-deref).

trunk/src/librustc/middle/trans/expr.rs

@@ -254,7 +254,11 @@ fn apply_adjustments<'a>(bcx: &'a Block<'a>,
         let mut datum = datum;
 
         let datum = match autoref {
-            &AutoPtr(_, _, ref a) | &AutoUnsafe(_, ref a) => {
+            &AutoUnsafe(..) => {
+                debug!("  AutoUnsafe");
+                unpack_datum!(bcx, ref_ptr(bcx, expr, datum))
+            }
+            &AutoPtr(_, _, ref a) => {
                 debug!("  AutoPtr");
                 match a {
                     &Some(box ref a) => datum = unpack_datum!(bcx,
@@ -1843,7 +1847,8 @@ pub fn cast_type_kind(tcx: &ty::ctxt, t: ty::t) -> cast_kind {
     match ty::get(t).sty {
         ty::ty_char        => cast_integral,
         ty::ty_float(..)   => cast_float,
-        ty::ty_rptr(_, mt) | ty::ty_ptr(mt) => {
+        ty::ty_ptr(..)     => cast_pointer,
+        ty::ty_rptr(_, mt) => {
             if ty::type_is_sized(tcx, mt.ty) {
                 cast_pointer
             } else {

trunk/src/librustc/middle/trans/reflect.rs

@@ -154,7 +154,7 @@ impl<'a, 'b> Reflector<'a, 'b> {
               // Unfortunately we can't do anything here because at runtime we
               // pass around the value by pointer (*u8). But unsized pointers are
               // fat and so we can't just cast them to *u8 and back. So we have
-              // to work with the pointer directly (see ty_ptr/ty_rptr/ty_uniq).
+              // to work with the pointer directly (see ty_rptr/ty_uniq).
               fail!("Can't reflect unsized type")
           }
           // FIXME(15049) Reflection for unsized structs.
@@ -177,24 +177,8 @@ impl<'a, 'b> Reflector<'a, 'b> {
               self.visit("box", extra.as_slice())
           }
           ty::ty_ptr(ref mt) => {
-              match ty::get(mt.ty).sty {
-                  ty::ty_vec(ty, None) => {
-                      let extra = self.c_mt(&ty::mt{ty: ty, mutbl: mt.mutbl});
-                      self.visit("evec_slice", extra.as_slice())
-                  }
-                  ty::ty_str => self.visit("estr_slice", &[]),
-                  ty::ty_trait(..) => {
-                      let extra = [
-                          self.c_slice(token::intern_and_get_ident(
-                                  ty_to_string(tcx, t).as_slice()))
-                      ];
-                      self.visit("trait", extra);
-                  }
-                  _ => {
-                      let extra = self.c_mt(mt);
-                      self.visit("ptr", extra.as_slice())
-                  }
-              }
+              let extra = self.c_mt(mt);
+              self.visit("ptr", extra.as_slice())
           }
           ty::ty_uniq(typ) => {
               match ty::get(typ).sty {

trunk/src/librustc/middle/trans/type_of.rs

@@ -174,8 +174,9 @@ pub fn sizing_type_of(cx: &CrateContext, t: ty::t) -> Type {
         ty::ty_uint(t) => Type::uint_from_ty(cx, t),
         ty::ty_float(t) => Type::float_from_ty(cx, t),
 
-        ty::ty_box(..) => Type::i8p(cx),
-        ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) | ty::ty_ptr(ty::mt{ty, ..}) => {
+        ty::ty_box(..) |
+        ty::ty_ptr(..) => Type::i8p(cx),
+        ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) => {
             if ty::type_is_sized(cx.tcx(), ty) {
                 Type::i8p(cx)
             } else {
@@ -302,8 +303,9 @@ pub fn type_of(cx: &CrateContext, t: ty::t) -> Type {
       ty::ty_box(typ) => {
           Type::at_box(cx, type_of(cx, typ)).ptr_to()
       }
+      ty::ty_ptr(ref mt) => type_of(cx, mt.ty).ptr_to(),
 
-      ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) | ty::ty_ptr(ty::mt{ty, ..}) => {
+      ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) => {
           match ty::get(ty).sty {
               ty::ty_str => {
                   // This means we get a nicer name in the output (str is always

trunk/src/librustc/middle/ty.rs

@@ -298,8 +298,7 @@ pub enum AutoRef {
 
     /// Convert from T to *T
     /// Value to thin pointer
-    /// The second field allows us to wrap other AutoRef adjustments.
-    AutoUnsafe(ast::Mutability, Option<Box<AutoRef>>),
+    AutoUnsafe(ast::Mutability),
 }
 
 // Ugly little helper function. The first bool in the returned tuple is true if
@@ -327,7 +326,6 @@ fn autoref_object_region(autoref: &AutoRef) -> (bool, bool, Option<Region>) {
                 (b, u, Some(adj_r))
             }
         }
-        &AutoUnsafe(_, Some(box ref autoref)) => autoref_object_region(autoref),
         _ => (false, false, None)
     }
 }
@@ -382,12 +380,6 @@ pub fn type_of_adjust(cx: &ctxt, adj: &AutoAdjustment) -> Option<t> {
                     None => None
                 }
             }
-            &AutoUnsafe(m, Some(box ref autoref)) => {
-                match type_of_autoref(cx, autoref) {
-                    Some(t) => Some(mk_ptr(cx, mt {mutbl: m, ty: t})),
-                    None => None
-                }
-            }
             _ => None
         }
     }
@@ -1906,7 +1898,7 @@ pub fn type_is_self(ty: t) -> bool {
 
 fn type_is_slice(ty: t) -> bool {
     match get(ty).sty {
-        ty_ptr(mt) | ty_rptr(_, mt) => match get(mt.ty).sty {
+        ty_rptr(_, mt) => match get(mt.ty).sty {
             ty_vec(_, None) | ty_str => true,
             _ => false,
         },
@@ -2004,8 +1996,7 @@ pub fn type_is_unique(ty: t) -> bool {
 
 pub fn type_is_fat_ptr(cx: &ctxt, ty: t) -> bool {
     match get(ty).sty {
-        ty_ptr(mt{ty, ..}) | ty_rptr(_, mt{ty, ..})
-        | ty_uniq(ty) if !type_is_sized(cx, ty) => true,
+        ty_rptr(_, mt{ty, ..}) | ty_uniq(ty) if !type_is_sized(cx, ty) => true,
         _ => false,
     }
 }
@@ -2905,7 +2896,7 @@ pub fn is_type_representable(cx: &ctxt, sp: Span, ty: t) -> Representability {
 
 pub fn type_is_trait(ty: t) -> bool {
     match get(ty).sty {
-        ty_uniq(ty) | ty_rptr(_, mt { ty, ..}) | ty_ptr(mt { ty, ..}) => match get(ty).sty {
+        ty_uniq(ty) | ty_rptr(_, mt { ty, ..}) => match get(ty).sty {
             ty_trait(..) => true,
             _ => false
         },
@@ -3401,12 +3392,8 @@ pub fn adjust_ty(cx: &ctxt,
                 })
             }
 
-            AutoUnsafe(m, ref a) => {
-                let adjusted_ty = match a {
-                    &Some(box ref a) => adjust_for_autoref(cx, span, ty, a),
-                    &None => ty
-                };
-                mk_ptr(cx, mt {ty: adjusted_ty, mutbl: m})
+            AutoUnsafe(m) => {
+                mk_ptr(cx, mt {ty: ty, mutbl: m})
             }
 
             AutoUnsize(ref k) => unsize_ty(cx, ty, k, span),
@@ -3457,8 +3444,7 @@ impl AutoRef {
             ty::AutoPtr(r, m, Some(ref a)) => ty::AutoPtr(f(r), m, Some(box a.map_region(f))),
             ty::AutoUnsize(ref k) => ty::AutoUnsize(k.clone()),
             ty::AutoUnsizeUniq(ref k) => ty::AutoUnsizeUniq(k.clone()),
-            ty::AutoUnsafe(m, None) => ty::AutoUnsafe(m, None),
-            ty::AutoUnsafe(m, Some(ref a)) => ty::AutoUnsafe(m, Some(box a.map_region(f))),
+            ty::AutoUnsafe(m) => ty::AutoUnsafe(m),
         }
     }
 }