---

yaml
---
r: 46653
b: refs/heads/auto
c: aa3505d
h: refs/heads/master
i:
  46651: cb89862
v: v3

Author: erickt

[refs]

@@ -14,4 +14,4 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 95bc9ea26df56b29f74583317ab080fdc7b99757
+refs/heads/auto: aa3505d8ff043f0c1da62de4f517eed6defb6187

branches/auto/doc/rust.md

@@ -1285,22 +1285,19 @@ An _implementation_ is an item that implements a [trait](#traits) for a specific
 Implementations are defined with the keyword `impl`.
 
 ~~~~
-# struct Point {x: float, y: float};
+# type Point = {x: float, y: float};
 # type Surface = int;
-# struct BoundingBox {x: float, y: float, width: float, height: float};
+# type BoundingBox = {x: float, y: float, width: float, height: float};
 # trait Shape { fn draw(Surface); fn bounding_box() -> BoundingBox; }
 # fn do_draw_circle(s: Surface, c: Circle) { }
 
-struct Circle {
-    radius: float,
-    center: Point,
-}
+type Circle = {radius: float, center: Point};
 
 impl Shape for Circle {
     fn draw(s: Surface) { do_draw_circle(s, self); }
     fn bounding_box() -> BoundingBox {
         let r = self.radius;
-        BoundingBox{x: self.center.x - r, y: self.center.y - r,
+        {x: self.center.x - r, y: self.center.y - r,
          width: 2.0 * r, height: 2.0 * r}
     }
 }
@@ -1640,6 +1637,38 @@ rec_expr : '{' ident ':' expr
                [ ".." expr ] '}'
 ~~~~~~~~
 
+> **Note:** In future versions of Rust, record expressions and [record types](#record-types) will be removed.
+
+A [_record_](#record-types) _expression_ is one or more comma-separated
+name-value pairs enclosed by braces. A fieldname can be any identifier,
+and is separated from its value expression by a
+colon. To indicate that a field is mutable, the `mut` keyword is
+written before its name.
+
+~~~~
+{x: 10f, y: 20f};
+{name: "Joe", age: 35u, score: 100_000};
+{ident: "X", mut count: 0u};
+~~~~
+
+The order of the fields in a record expression is significant, and
+determines the type of the resulting value. `{a: u8, b: u8}` and `{b:
+u8, a: u8}` are two different fields.
+
+A record expression can terminate with the syntax `..` followed by an
+expression to denote a functional update. The expression following
+`..` (the base) must be of a record type that includes at least all the
+fields mentioned in the record expression. A new record will be
+created, of the same type as the base expression, with the given
+values for the fields that were explicitly specified, and the values
+in the base record for all other fields. The ordering of the fields in
+such a record expression is not significant.
+
+~~~~
+let base = {x: 1, y: 2, z: 3};
+{y: 0, z: 10, .. base};
+~~~~
+
 ### Method-call expressions
 
 ~~~~~~~~{.ebnf .gram}
@@ -1660,7 +1689,7 @@ field_expr : expr '.' ident
 
 A _field expression_ consists of an expression followed by a single dot and an identifier,
 when not immediately followed by a parenthesized expression-list (the latter is a [method call expression](#method-call-expressions)).
-A field expression denotes a field of a [structure](#structure-types).
+A field expression denotes a field of a [structure](#structure-types) or [record](#record-types).
 
 ~~~~~~~~ {.field}
 myrecord.myfield;
@@ -1876,10 +1905,8 @@ An example of three different swap expressions:
 # let mut x = &mut [0];
 # let mut a = &mut [0];
 # let i = 0;
-# struct S1 { z: int };
-# struct S2 { c: int };
-# let mut y = S1{z: 0};
-# let mut b = S2{c: 0};
+# let y = {mut z: 0};
+# let b = {mut c: 0};
 
 x <-> a;
 x[i] <-> a[i];
@@ -2301,6 +2328,42 @@ match x {
 }
 ~~~~
 
+Records and structures can also be pattern-matched and their fields bound to variables.
+When matching fields of a record,
+the fields being matched are specified first,
+then a placeholder (`_`) represents the remaining fields.
+
+~~~~
+# type options = {choose: bool, size: ~str};
+# type player = {player: ~str, stats: (), options: options};
+# fn load_stats() { }
+# fn choose_player(r: &player) { }
+# fn next_player() { }
+
+fn main() {
+    let r = {
+        player: ~"ralph",
+        stats: load_stats(),
+        options: {
+            choose: true,
+            size: ~"small"
+        }
+    };
+
+    match r {
+      {options: {choose: true, _}, _} => {
+        choose_player(&r)
+      }
+      {player: ref p, options: {size: ~"small", _}, _} => {
+        log(info, (copy *p) + ~" is small");
+      }
+      _ => {
+        next_player();
+      }
+    }
+}
+~~~~
+
 Patterns that bind variables default to binding to a copy of the matched value. This can be made
 explicit using the ```copy``` keyword, changed to bind to a borrowed pointer by using the ```ref```
 keyword, or to a mutable borrowed pointer using ```ref mut```, or the value can be moved into
@@ -2629,6 +2692,25 @@ let a: List<int> = Cons(7, @Cons(13, @Nil));
 ~~~~
 
 
+### Record types
+
+> **Note:** Records are not nominal types, thus do not directly support recursion, visibility control,
+> out-of-order field initialization, or coherent trait implementation.
+> Records are therefore deprecated and will be removed in future versions of Rust.
+> [Structure types](#structure-types) should be used instead.
+
+The record type-constructor forms a new heterogeneous product of values.
+Fields of a record type are accessed by name and are arranged in memory in the order specified by the record type.
+
+An example of a record type and its use:
+
+~~~~
+type Point = {x: int, y: int};
+let p: Point = {x: 10, y: 11};
+let px: int = p.x;
+~~~~
+
+
 ### Pointer types
 
 All pointers in Rust are explicit first-class values.
@@ -2958,8 +3040,7 @@ Some operations (such as field selection) implicitly dereference boxes. An
 example of an _implicit dereference_ operation performed on box values:
 
 ~~~~~~~~
-struct Foo { y: int }
-let x = @Foo{y: 10};
+let x = @{y: 10};
 assert x.y == 10;
 ~~~~~~~~
 

branches/auto/doc/tutorial-borrowed-ptr.md

@@ -166,9 +166,9 @@ operator. For example, I could write:
 # struct Point {x: float, y: float} // as before
 # struct Size {w: float, h: float} // as before
 # struct Rectangle {origin: Point, size: Size}
-# let rect_stack  = &Rectangle {origin: Point {x: 1f, y: 2f}, size: Size {w: 3f, h: 4f}};
-# let rect_managed = @Rectangle {origin: Point {x: 3f, y: 4f}, size: Size {w: 3f, h: 4f}};
-# let rect_unique = ~Rectangle {origin: Point {x: 5f, y: 6f}, size: Size {w: 3f, h: 4f}};
+# let rect_stack  = &{origin: Point {x: 1f, y: 2f}, size: Size {w: 3f, h: 4f}};
+# let rect_managed = @{origin: Point {x: 3f, y: 4f}, size: Size {w: 3f, h: 4f}};
+# let rect_unique = ~{origin: Point {x: 5f, y: 6f}, size: Size {w: 3f, h: 4f}};
 # fn compute_distance(p1: &Point, p2: &Point) -> float { 0f }
 compute_distance(&rect_stack.origin, &rect_managed.origin);
 ~~~
@@ -274,14 +274,13 @@ the following function is legal:
 
 ~~~
 # fn some_condition() -> bool { true }
-# struct Foo { f: int }
 fn example3() -> int {
-    let mut x = ~Foo {f: 3};
+    let mut x = ~{f: 3};
     if some_condition() {
         let y = &x.f;      // -+ L
         return *y;         //  |
     }                      // -+
-    x = ~Foo {f: 4};
+    x = ~{f: 4};
     ...
 # return 0;
 }

branches/auto/src/libcore/dvec.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -62,17 +62,17 @@ pub struct DVec<A> {
 
 /// Creates a new, empty dvec
 pub pure fn DVec<A>() -> DVec<A> {
-    DVec {data: ~[]}
+    DVec {mut data: ~[]}
 }
 
 /// Creates a new dvec with a single element
 pub pure fn from_elem<A>(e: A) -> DVec<A> {
-    DVec {data: ~[e]}
+    DVec {mut data: ~[e]}
 }
 
 /// Creates a new dvec with the contents of a vector
 pub pure fn from_vec<A>(v: ~[A]) -> DVec<A> {
-    DVec {data: v}
+    DVec {mut data: v}
 }
 
 /// Consumes the vector and returns its contents

branches/auto/src/libcore/os.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -322,8 +322,8 @@ pub struct Pipe { mut in: c_int, mut out: c_int }
 #[cfg(unix)]
 pub fn pipe() -> Pipe {
     unsafe {
-        let mut fds = Pipe {in: 0 as c_int,
-                        out: 0 as c_int };
+        let mut fds = Pipe {mut in: 0 as c_int,
+                        mut out: 0 as c_int };
         assert (libc::pipe(&mut fds.in) == (0 as c_int));
         return Pipe {in: fds.in, out: fds.out};
     }
@@ -339,8 +339,8 @@ pub fn pipe() -> Pipe {
         // fully understand. Here we explicitly make the pipe non-inheritable,
         // which means to pass it to a subprocess they need to be duplicated
         // first, as in rust_run_program.
-        let mut fds = Pipe {in: 0 as c_int,
-                    out: 0 as c_int };
+        let mut fds = Pipe { mut in: 0 as c_int,
+                    mut out: 0 as c_int };
         let res = libc::pipe(&mut fds.in, 1024 as c_uint,
                              (libc::O_BINARY | libc::O_NOINHERIT) as c_int);
         assert (res == 0 as c_int);
@@ -566,17 +566,13 @@ pub fn path_exists(p: &Path) -> bool {
  *
  * If the given path is relative, return it prepended with the current working
  * directory. If the given path is already an absolute path, return it
- * as is.
+ * as is.  This is a shortcut for calling os::getcwd().unsafe_join(p)
  */
 // NB: this is here rather than in path because it is a form of environment
 // querying; what it does depends on the process working directory, not just
 // the input paths.
 pub fn make_absolute(p: &Path) -> Path {
-    if p.is_absolute {
-        copy *p
-    } else {
-        getcwd().push_many(p.components)
-    }
+    getcwd().unsafe_join(p)
 }
 
 

branches/auto/src/libcore/ptr.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -300,15 +300,15 @@ impl<T:Ord> Ord for &const T {
 pub fn test() {
     unsafe {
         struct Pair {mut fst: int, mut snd: int};
-        let mut p = Pair {fst: 10, snd: 20};
+        let mut p = Pair {mut fst: 10, mut snd: 20};
         let pptr: *mut Pair = &mut p;
         let iptr: *mut int = cast::reinterpret_cast(&pptr);
         assert (*iptr == 10);;
         *iptr = 30;
         assert (*iptr == 30);
         assert (p.fst == 30);;
 
-        *pptr = Pair {fst: 50, snd: 60};
+        *pptr = Pair {mut fst: 50, mut snd: 60};
         assert (*iptr == 50);
         assert (p.fst == 50);
         assert (p.snd == 60);

branches/auto/src/libfuzzer/fuzzer.rc

@@ -134,7 +134,7 @@ pub pure fn safe_to_use_expr(e: ast::expr, tm: test_mode) -> bool {
 
 pub fn safe_to_steal_ty(t: @ast::Ty, tm: test_mode) -> bool {
     // Restrictions happen to be the same.
-    safe_to_replace_ty(t.node, tm)
+    safe_to_replace_ty(&t.node, tm)
 }
 
 // Not type-parameterized: https://github.com/mozilla/rust/issues/898 (FIXED)
@@ -175,8 +175,8 @@ pub fn steal(crate: ast::crate, tm: test_mode) -> StolenStuff {
 }
 
 
-pub fn safe_to_replace_expr(e: ast::expr_, _tm: test_mode) -> bool {
-    match e {
+pub fn safe_to_replace_expr(e: &ast::expr_, _tm: test_mode) -> bool {
+    match *e {
       // https://github.com/mozilla/rust/issues/652
       ast::expr_if(*) => { false }
       ast::expr_block(_) => { false }
@@ -188,8 +188,8 @@ pub fn safe_to_replace_expr(e: ast::expr_, _tm: test_mode) -> bool {
     }
 }
 
-pub fn safe_to_replace_ty(t: ast::ty_, _tm: test_mode) -> bool {
-    match t {
+pub fn safe_to_replace_ty(t: &ast::ty_, _tm: test_mode) -> bool {
+    match *t {
       ast::ty_infer => { false } // always implicit, always top level
       ast::ty_bot => { false }   // in source, can only appear
                               // as the out type of a function
@@ -204,7 +204,7 @@ pub fn replace_expr_in_crate(crate: ast::crate, i: uint,
    ast::crate {
     let j: @mut uint = @mut 0u;
     fn fold_expr_rep(j_: @mut uint, i_: uint, newexpr_: ast::expr_,
-                     original: ast::expr_, fld: fold::ast_fold,
+                     original: &ast::expr_, fld: fold::ast_fold,
                      tm_: test_mode) ->
        ast::expr_ {
         *j_ += 1u;
@@ -221,7 +221,7 @@ pub fn replace_expr_in_crate(crate: ast::crate, i: uint,
         .. *fold::default_ast_fold()
     };
     let af = fold::make_fold(afp);
-    let crate2: @ast::crate = @af.fold_crate(crate);
+    let crate2: @ast::crate = @af.fold_crate(&crate);
     *crate2
 }
 
@@ -231,7 +231,7 @@ pub fn replace_ty_in_crate(crate: ast::crate, i: uint, newty: ast::Ty,
                            tm: test_mode) -> ast::crate {
     let j: @mut uint = @mut 0u;
     fn fold_ty_rep(j_: @mut uint, i_: uint, newty_: ast::ty_,
-                   original: ast::ty_, fld: fold::ast_fold,
+                   original: &ast::ty_, fld: fold::ast_fold,
                    tm_: test_mode) ->
        ast::ty_ {
         *j_ += 1u;
@@ -244,7 +244,7 @@ pub fn replace_ty_in_crate(crate: ast::crate, i: uint, newty: ast::Ty,
         .. *fold::default_ast_fold()
     };
     let af = fold::make_fold(afp);
-    let crate2: @ast::crate = @af.fold_crate(crate);
+    let crate2: @ast::crate = @af.fold_crate(&crate);
     *crate2
 }
 

branches/auto/src/librustc/driver/driver.rs

@@ -396,7 +396,7 @@ pub fn pretty_print_input(sess: Session, +cfg: ast::crate_cfg, input: input,
           pprust::node_block(s, ref blk) => {
             pp::space(s.s);
             pprust::synth_comment(
-                s, ~"block " + int::to_str((*blk).node.id));
+                s, ~"block " + int::to_str(blk.node.id));
           }
           pprust::node_expr(s, expr) => {
             pp::space(s.s);

branches/auto/src/librustc/driver/session.rs

@@ -358,7 +358,7 @@ pub mod test {
     pub fn make_crate_type_attr(+t: ~str) -> ast::attribute {
         codemap::respan(codemap::dummy_sp(), ast::attribute_ {
             style: ast::attr_outer,
-            value: codemap::respan(codemap::dummy_sp(),
+            value: @codemap::respan(codemap::dummy_sp(),
                 ast::meta_name_value(
                     @~"crate_type",
                     codemap::respan(codemap::dummy_sp(),