---

yaml
---
r: 45046
b: refs/heads/master
c: 81e3702
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 14e5a6e5f74b174399a561c68e5214d572f7a667
+refs/heads/master: 81e370285f9709d133d114f405bd4f797f7dc3e9
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
 refs/heads/try: ef355f6332f83371e4acf04fc4eb940ab41d78d3

trunk/AUTHORS.txt

@@ -93,6 +93,7 @@ Josh Matthews <[email protected]>
 Joshua Clark <[email protected]>
 Joshua Wise <[email protected]>
 Jyun-Yan You <[email protected]>
+Kang Seonghoon <[email protected]>
 Kelly Wilson <[email protected]>
 Kevin Atkinson <[email protected]>
 Kevin Cantu <[email protected]>

trunk/CONTRIBUTING.md

@@ -11,7 +11,7 @@ You're not off the hook even if you just stick to documentation; code examples i
 Pull requests will be treated as "review requests",
 and we will give feedback we expect to see corrected on [style](https://github.com/mozilla/rust/wiki/Note-style-guide) and substance before pulling.
 Changes contributed via pull request should focus on a single issue at a time, like any other.
-We will not look accept pull-requests that try to "sneak" unrelated changes in.
+We will not accept pull-requests that try to "sneak" unrelated changes in.
 
 Normally, all pull requests must include regression tests (see [Note-testsuite](https://github.com/mozilla/rust/wiki/Note-testsuite)) that test your change.
 Occasionally, a change will be very difficult to test for.

trunk/Makefile.in

@@ -267,7 +267,7 @@ DRIVER_CRATE := $(S)src/driver/driver.rs
 ######################################################################
 
 # FIXME: x86-ism
-LLVM_COMPONENTS=x86 arm ipo bitreader bitwriter linker asmparser jit mcjit \
+LLVM_COMPONENTS=x86 arm mips ipo bitreader bitwriter linker asmparser jit mcjit \
                 interpreter
 
 define DEF_LLVM_VARS

trunk/configure

@@ -611,7 +611,8 @@ for t in $CFG_TARGET_TRIPLES
 do
   make_dir rt/$t
   for i in                                          \
-    isaac linenoise sync test arch/i386 arch/x86_64 arch/arm   \
+    isaac linenoise sync test \
+    arch/i386 arch/x86_64 arch/arm arch/mips  \
     libuv libuv/src/ares libuv/src/eio libuv/src/ev
   do
     make_dir rt/$t/$i
@@ -712,7 +713,7 @@ do
         LLVM_BUILD_DIR=${CFG_BUILD_DIR}llvm/$t
         if [ ! -z "$CFG_DISABLE_OPTIMIZE_LLVM" ]
         then
-            LLVM_DBG_OPTS=""
+            LLVM_DBG_OPTS="--enable-debug-symbols --disable-optimized"
             # Just use LLVM straight from its build directory to
             # avoid 'make install' time
             LLVM_INST_DIR=$LLVM_BUILD_DIR/Debug+Asserts
@@ -752,7 +753,7 @@ do
     then
         msg "configuring LLVM for $t"
 
-        LLVM_TARGETS="--enable-targets=x86,x86_64,arm"
+        LLVM_TARGETS="--enable-targets=x86,x86_64,arm,mips"
         LLVM_BUILD="--build=$t"
         LLVM_HOST="--host=$t"
         LLVM_TARGET="--target=$t"

trunk/doc/rust.md

@@ -297,7 +297,7 @@ the following forms:
 num_lit : nonzero_dec [ dec_digit | '_' ] * num_suffix ?
         | '0' [       [ dec_digit | '_' ] + num_suffix ?
               | 'b'   [ '1' | '0' | '_' ] + int_suffix ?
-              | 'x'   [ hex_digit | '-' ] + int_suffix ? ] ;
+              | 'x'   [ hex_digit | '_' ] + int_suffix ? ] ;
 
 num_suffix : int_suffix | float_suffix ;
 
@@ -908,6 +908,11 @@ function defined above on `[1, 2]` will instantiate type parameter `T`
 with `int`, and require the closure parameter to have type
 `fn(int)`.
 
+The type parameters can also be explicitly supplied in a trailing
+[path](#paths) component after the function name. This might be necessary
+if there is not sufficient context to determine the type parameters. For
+example, `sys::size_of::<u32>() == 4`.
+
 Since a parameter type is opaque to the generic function, the set of
 operations that can be performed on it is limited. Values of parameter
 type can always be moved, but they can only be copied when the
@@ -1085,6 +1090,15 @@ let p = Point(10, 11);
 let px: int = match p { Point(x, _) => x };
 ~~~~
 
+A _unit-like struct_ is a structure without any fields, defined by leaving off the fields list entirely.
+Such types will have a single value, just like the [unit value `()`](#unit-and-boolean-literals) of the unit type.
+For example:
+
+~~~~
+struct Cookie;
+let c = [Cookie, Cookie, Cookie, Cookie];
+~~~~
+
 ### Enumerations
 
 An _enumeration_ is a simultaneous definition of a nominal [enumerated type](#enumerated-types) as well as a set of *constructors*,
@@ -1130,22 +1144,23 @@ Constants are declared with the `const` keyword.
 A constant item must have an expression giving its definition.
 The definition expression of a constant is limited to expression forms that can be evaluated at compile time.
 
-Constants must be explicitly typed. The type may be ```bool```, ```char```, a number, or a type derived from
-those primitive types. The derived types are borrowed pointers, static arrays, tuples, and structs.
+Constants must be explicitly typed. The type may be ```bool```, ```char```, a number, or a type derived from those primitive types.
+The derived types are borrowed pointers, static arrays, tuples, and structs.
+Borrowed pointers must be have the `'static` lifetime.
 
 ~~~~
 const bit1: uint = 1 << 0;
 const bit2: uint = 1 << 1;
 
 const bits: [uint * 2] = [bit1, bit2];
-const string: &str = "bitstring";
+const string: &'static str = "bitstring";
 
 struct BitsNStrings {
     mybits: [uint *2],
-    mystring: &str
+    mystring: &'self str
 }
 
-const bits_n_strings: BitsNStrings = BitsNStrings {
+const bits_n_strings: BitsNStrings<'static> = BitsNStrings {
     mybits: bits,
     mystring: string
 };
@@ -1285,19 +1300,22 @@ An _implementation_ is an item that implements a [trait](#traits) for a specific
 Implementations are defined with the keyword `impl`.
 
 ~~~~
-# type Point = {x: float, y: float};
+# struct Point {x: float, y: float};
 # type Surface = int;
-# type BoundingBox = {x: float, y: float, width: float, height: float};
+# struct 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) { }
 
-type Circle = {radius: float, center: Point};
+struct 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;
-        {x: self.center.x - r, y: self.center.y - r,
+        BoundingBox{x: self.center.x - r, y: self.center.y - r,
          width: 2.0 * r, height: 2.0 * r}
     }
 }
@@ -1343,7 +1361,7 @@ Functions within foreign modules are declared in the same way as other Rust func
 with the exception that they may not have a body and are instead terminated by a semicolon.
 
 ~~~
-# use libc::{c_char, FILE};
+# use core::libc::{c_char, FILE};
 # #[nolink]
 
 extern mod c {
@@ -1590,7 +1608,8 @@ struct_expr : expr_path '{' ident ':' expr
                       [ ',' ident ':' expr ] *
                       [ ".." expr ] '}' |
               expr_path '(' expr
-                      [ ',' expr ] * ')'
+                      [ ',' expr ] * ')' |
+              expr_path
 ~~~~~~~~
 
 There are several forms of structure expressions.
@@ -1600,24 +1619,28 @@ providing the field values of a new instance of the structure.
 A field name 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.
 
-A _tuple structure expression_ constists of the [path](#paths) of a [structure item](#structures),
+A _tuple structure expression_ consists of the [path](#paths) of a [structure item](#structures),
 followed by a parenthesized list of one or more comma-separated expressions
 (in other words, the path of a structured item followed by a tuple expression).
 The structure item must be a tuple structure item.
 
+A _unit-like structure expression_ consists only of the [path](#paths) of a [structure item](#structures).
+
 The following are examples of structure expressions:
 
 ~~~~
 # struct Point { x: float, y: float }
 # struct TuplePoint(float, float);
-# mod game { pub struct User { name: &str, age: uint, mut score: uint } }
-# use game;
+# mod game { pub struct User<'self> { name: &'self str, age: uint, score: uint } }
+# struct Cookie; fn some_fn<T>(t: T) {}
 Point {x: 10f, y: 20f};
 TuplePoint(10f, 20f);
-let u = game::User {name: "Joe", age: 35u, mut score: 100_000};
+let u = game::User {name: "Joe", age: 35u, score: 100_000};
+some_fn::<Cookie>(Cookie);
 ~~~~
 
 A structure expression forms a new value of the named structure type.
+Note that for a given *unit-like* structure type, this will always be the same value.
 
 A structure expression can terminate with the syntax `..` followed by an expression to denote a functional update.
 The expression following `..` (the base) must be of the same structure type as the new structure type being formed.
@@ -1638,38 +1661,6 @@ 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}
@@ -1690,7 +1681,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) or [record](#record-types).
+A field expression denotes a field of a [structure](#structure-types).
 
 ~~~~~~~~ {.field}
 myrecord.myfield;
@@ -1906,8 +1897,10 @@ An example of three different swap expressions:
 # let mut x = &mut [0];
 # let mut a = &mut [0];
 # let i = 0;
-# let y = {mut z: 0};
-# let b = {mut c: 0};
+# struct S1 { z: int };
+# struct S2 { c: int };
+# let mut y = S1{z: 0};
+# let mut b = S2{c: 0};
 
 x <-> a;
 x[i] <-> a[i];
@@ -2041,12 +2034,14 @@ an optional reference slot to serve as the function's output, bound to the
 `lval` on the right hand side of the call. If the function eventually returns,
 then the expression completes.
 
-An example of a call expression:
+Some examples of call expressions:
 
 ~~~~
 # fn add(x: int, y: int) -> int { 0 }
+# use core::from_str::FromStr::from_str;
 
 let x: int = add(1, 2);
+let pi = from_str::<f32>("3.14");
 ~~~~
 
 ### Lambda expressions
@@ -2329,42 +2324,6 @@ 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
@@ -2598,8 +2557,8 @@ order specified by the tuple type.
 An example of a tuple type and its use:
 
 ~~~~
-type Pair = (int,&str);
-let p: Pair = (10,"hello");
+type Pair<'self> = (int,&'self str);
+let p: Pair<'static> = (10,"hello");
 let (a, b) = p;
 assert b != "world";
 ~~~~
@@ -2644,7 +2603,10 @@ the resulting `struct` value will always be laid out in memory in the order spec
 The fields of a `struct` may be qualified by [visibility modifiers](#visibility-modifiers),
 to restrict access to implementation-private data in a structure.
 
-A `tuple struct` type is just like a structure type, except that the fields are anonymous.
+A _tuple struct_ type is just like a structure type, except that the fields are anonymous.
+
+A _unit-like struct_ type is like a structure type, except that it has no fields.
+The one value constructed by the associated [structure expression](#structure-expression) is the only value that inhabits such a type.
 
 ### Enumerated types
 
@@ -2693,25 +2655,6 @@ 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.
@@ -2776,7 +2719,7 @@ fn add(x: int, y: int) -> int {
 
 let mut x = add(5,7);
 
-type Binop = fn(int,int) -> int;
+type Binop<'self> = &'self fn(int,int) -> int;
 let bo: Binop = add;
 x = bo(5,7);
 ~~~~~~~~
@@ -3041,7 +2984,8 @@ Some operations (such as field selection) implicitly dereference boxes. An
 example of an _implicit dereference_ operation performed on box values:
 
 ~~~~~~~~
-let x = @{y: 10};
+struct Foo { y: int }
+let x = @Foo{y: 10};
 assert x.y == 10;
 ~~~~~~~~