---

yaml
---
r: 42003
b: refs/heads/master
c: aff3db2
h: refs/heads/master
i:
  42001: 1ebe3ab
  41999: 86f379d
v: v3

Author: thestinger

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 19aa88cd64c81b77b874f9396a43fedfa28f14ee
+refs/heads/master: aff3db26aa6e427b68fea577548a270cacdd0153
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
 refs/heads/try: 3d5418789064fdb463e872a4e651af1c628a3650

trunk/AUTHORS.txt

@@ -7,13 +7,15 @@ Other authors:
 
 Adam Bozanich <[email protected]>
 Aleksander Balicki <[email protected]>
+Alex Crichton <[email protected]>
 Alex Rønne Petersen <[email protected]>
 Alexander Stavonin <[email protected]>
 Andreas Gal <[email protected]>
 Andrew Dunham <[email protected]>
 Andrew Paseltiner <[email protected]>
 Arkaitz Jimenez <[email protected]>
 Armin Ronacher <[email protected]>
+Ashok Gautham <[email protected]>
 Austin Seipp <[email protected]>
 auREAX <[email protected]>
 Ben Alpert <[email protected]>
@@ -24,6 +26,7 @@ Benjamin Jackman <[email protected]>
 Benjamin Kircher <[email protected]>
 Benjamin Peterson <[email protected]>
 Bilal Husain <[email protected]>
+Bill Fallon <[email protected]>
 Brendan Eich <[email protected]>
 Brian Anderson <[email protected]>
 Brian J. Burg <[email protected]>
@@ -88,6 +91,7 @@ Kelly Wilson <[email protected]>
 Kevin Atkinson <[email protected]>
 Kevin Cantu <[email protected]>
 Kyeongwoon Lee <[email protected]>
+Laurent Bonnans <[email protected]>
 Lennart Kudling <[email protected]>
 Lindsey Kuper <[email protected]>
 Luca Bruno <[email protected]>
@@ -127,6 +131,7 @@ Sean Stangl <[email protected]>
 Sebastian N. Fernandez <[email protected]>
 Seo Sanghyeon <[email protected]>
 Simon Barber-Dueck <[email protected]>
+Simon Sapin <[email protected]>
 startling <[email protected]>
 Stefan Plantikow <[email protected]>
 Steve Klabnik <[email protected]>
@@ -143,4 +148,5 @@ Vincent Belliard <[email protected]>
 Wade Mealing <[email protected]>
 William Ting <[email protected]>
 Yasuhiro Fujii <[email protected]>
+Youngsoo Son <[email protected]>
 Zack Corr <[email protected]>

trunk/doc/rust.md

@@ -222,7 +222,7 @@ let log loop
 match mod move mut
 priv pub pure
 ref return
-self static struct
+self static struct super
 true trait type
 unsafe use
 while
@@ -594,16 +594,16 @@ and may optionally begin with any number of `attributes` that apply to the conta
 Atributes on the anonymous crate module define important metadata that influences
 the behavior of the compiler.
 
-~~~~~~~~{.xfail-test}
+~~~~~~~~
 // Linkage attributes
-#[ link(name = "projx"
+#[ link(name = "projx",
         vers = "2.5",
         uuid = "9cccc5d5-aceb-4af5-8285-811211826b82") ];
 
 // Additional metadata attributes
-#[ desc = "Project X",
-   license = "BSD" ];
-   author = "Jane Doe" ];
+#[ desc = "Project X" ];
+#[ license = "BSD" ];
+#[ author = "Jane Doe" ];
 
 // Specify the output type
 #[ crate_type = "lib" ];
@@ -2472,7 +2472,7 @@ disabled dynamically at run-time on a per-task and per-item basis. See
 Each `log` expression must be provided with a *level* argument in
 addition to the value to log. The logging level is a `u32` value, where
 lower levels indicate more-urgent levels of logging. By default, the lowest
-four logging levels (`0_u32 ... 3_u32`) are predefined as the constants
+four logging levels (`1_u32 ... 4_u32`) are predefined as the constants
 `error`, `warn`, `info` and `debug` in the `core` library.
 
 Additionally, the macros `error!`, `warn!`, `info!` and `debug!` are defined
@@ -3018,6 +3018,11 @@ Local variables are immutable unless declared with `let mut`.  The
 declaration (so `let mut x, y` declares two mutable variables, `x` and
 `y`).
 
+Function parameters are immutable unless declared with `mut`. The
+`mut` keyword applies only to the following parameter (so `|mut x, y|`
+and `fn f(mut x: ~int, y: ~int)` declare one mutable variable `x` and
+one immutable variable `y`).
+
 Local variables are not initialized when allocated; the entire frame worth of
 local variables are allocated at once, on frame-entry, in an uninitialized
 state. Subsequent statements within a function may or may not initialize the
@@ -3242,10 +3247,10 @@ level will be output to the console.
 The path to a module consists of the crate name, any parent modules,
 then the module itself, all separated by double colons (`::`).  The
 optional log level can be appended to the module path with an equals
-sign (`=`) followed by the log level, from 0 to 3, inclusive. Level 0
-is the error level, 1 is warning, 2 info, and 3 debug. Any logs
+sign (`=`) followed by the log level, from 1 to 4, inclusive. Level 1
+is the error level, 2 is warning, 3 info, and 4 debug. Any logs
 less than or equal to the specified level will be output. If not
-specified then log level 3 is assumed.
+specified then log level 4 is assumed.
 
 As an example, to see all the logs generated by the compiler, you would set
 `RUST_LOG` to `rustc`, which is the crate name (as specified in its `link`

trunk/doc/tutorial-ffi.md

@@ -26,11 +26,14 @@ fn as_hex(data: ~[u8]) -> ~str {
     return acc;
 }
 
-fn sha1(data: ~str) -> ~str unsafe {
-    let bytes = str::to_bytes(data);
-    let hash = crypto::SHA1(vec::raw::to_ptr(bytes),
-                            vec::len(bytes) as c_uint, ptr::null());
-    return as_hex(vec::from_buf(hash, 20));
+fn sha1(data: ~str) -> ~str {
+    unsafe {
+        let bytes = str::to_bytes(data);
+        let hash = crypto::SHA1(vec::raw::to_ptr(bytes),
+                                vec::len(bytes) as c_uint,
+                                ptr::null());
+        return as_hex(vec::from_buf(hash, 20));
+    }
 }
 
 fn main() {
@@ -225,13 +228,15 @@ struct timeval {
 extern mod lib_c {
     fn gettimeofday(tv: *timeval, tz: *()) -> i32;
 }
-fn unix_time_in_microseconds() -> u64 unsafe {
-    let x = timeval {
-        mut tv_sec: 0 as c_ulonglong,
-        mut tv_usec: 0 as c_ulonglong
-    };
-    lib_c::gettimeofday(ptr::addr_of(&x), ptr::null());
-    return (x.tv_sec as u64) * 1000_000_u64 + (x.tv_usec as u64);
+fn unix_time_in_microseconds() -> u64 {
+    unsafe {
+        let x = timeval {
+            mut tv_sec: 0 as c_ulonglong,
+            mut tv_usec: 0 as c_ulonglong
+        };
+        lib_c::gettimeofday(ptr::addr_of(&x), ptr::null());
+        return (x.tv_sec as u64) * 1000_000_u64 + (x.tv_usec as u64);
+    }
 }
 
 # fn main() { assert fmt!("%?", unix_time_in_microseconds()) != ~""; }

trunk/doc/tutorial-tasks.md

@@ -220,7 +220,7 @@ let result = port.recv();
 The `Port` and `Chan` pair created by `stream` enables efficient communication
 between a single sender and a single receiver, but multiple senders cannot use
 a single `Chan`, and multiple receivers cannot use a single `Port`.  What if our
-example needed to computer multiple results across a number of tasks? The
+example needed to compute multiple results across a number of tasks? The
 following program is ill-typed:
 
 ~~~ {.xfail-test}

trunk/doc/tutorial.md

@@ -863,11 +863,34 @@ allocating memory and indirecting through a pointer. But for big structs, or
 those with mutable fields, it can be useful to have a single copy on
 the stack or on the heap, and refer to that through a pointer.
 
-Rust supports several types of pointers. The safe pointer types are
-`@T`, for managed boxes allocated on the local heap, `~T`, for
-uniquely-owned boxes allocated on the exchange heap, and `&T`, for
-borrowed pointers, which may point to any memory, and whose lifetimes
-are governed by the call stack.
+Whenever memory is allocated on the heap, the program needs a strategy to
+dispose of the memory when no longer needed. Most languages, such as Java or
+Python, use *garbage collection* for this, a strategy in which the program
+periodically searches for allocations that are no longer reachable in order
+to dispose of them. Other languages, such as C, use *manual memory
+management*, which relies on the programmer to specify when memory should be
+reclaimed.
+
+Rust is in a different position. It differs from the garbage-collected
+environments in that allows the programmer to choose the disposal
+strategy on an object-by-object basis. Not only does this have benefits for
+performance, but we will later see that this model has benefits for
+concurrency as well, by making it possible for the Rust compiler to detect
+data races at compile time. Rust also differs from the manually managed
+languages in that it is *safe*—it uses a [pointer lifetime
+analysis][borrow] to ensure that manual memory management cannot cause memory
+errors at runtime.
+
+[borrow]: tutorial-borrowed-ptr.html
+
+The cornerstone of Rust's memory management is the concept of a *smart
+pointer*—a pointer type that indicates the lifetime of the object it points
+to. This solution is familiar to C++ programmers; Rust differs from C++,
+however, in that a small set of smart pointers are built into the language.
+The safe pointer types are `@T`, for *managed* boxes allocated on the *local
+heap*, `~T`, for *uniquely-owned* boxes allocated on the *exchange
+heap*, and `&T`, for *borrowed* pointers, which may point to any memory, and
+whose lifetimes are governed by the call stack.
 
 All pointer types can be dereferenced with the `*` unary operator.
 
@@ -919,7 +942,17 @@ node2.next = SomeNode(node3);
 node3.prev = SomeNode(node2);
 ~~~
 
-Managed boxes never cross task boundaries.
+Managed boxes never cross task boundaries. This has several benefits for
+performance:
+
+* The Rust garbage collector does not need to stop multiple threads in order
+  to collect garbage.
+
+* You can separate your application into "real-time" tasks that do not use
+  the garbage collector and "non-real-time" tasks that do, and the real-time
+  tasks will not be interrupted by the non-real-time tasks.
+
+C++ programmers will recognize `@T` as similar to `std::shared_ptr<T>`.
 
 > ***Note:*** Currently, the Rust compiler generates code to reclaim
 > managed boxes through reference counting and a cycle collector, but
@@ -956,10 +989,19 @@ let z = *x + *y;
 assert z == 20;
 ~~~~
 
-Owned boxes, when they do not contain any managed boxes, can be sent
-to other tasks. The sending task will give up ownership of the box,
+When they do not contain any managed boxes, owned boxes can be sent
+to other tasks. The sending task will give up ownership of the box
 and won't be able to access it afterwards. The receiving task will
-become the sole owner of the box.
+become the sole owner of the box. This prevents *data races*—errors
+that could otherwise result from multiple tasks working on the same
+data without synchronization.
+
+When an owned pointer goes out of scope or is overwritten, the object
+it points to is immediately freed. Effective use of owned boxes can
+therefore be an efficient alternative to garbage collection.
+
+C++ programmers will recognize `~T` as similar to `std::unique_ptr<T>`
+(or `std::auto_ptr<T>` in C++03 and below).
 
 ## Borrowed pointers
 
@@ -1184,6 +1226,18 @@ match crayons[0] {
 }
 ~~~~
 
+A vector can be destructured using pattern matching:
+
+~~~~
+let numbers: [int * 3] = [1, 2, 3];
+let score = match numbers {
+    [] => 0,
+    [a] => a * 10,
+    [a, b] => a * 6 + b * 4,
+    [a, b, c, ..rest] => a * 5 + b * 3 + c * 2 + rest.len() as int
+};
+~~~~
+
 The elements of a vector _inherit the mutability of the vector_,
 and as such, individual elements may not be reassigned when the
 vector lives in an immutable slot.
@@ -2351,7 +2405,7 @@ override the name used to search for the crate.
 
 Our example crate declared this set of `link` attributes:
 
-~~~~ {.xfail-test}
+~~~~
 #[link(name = "farm", vers = "2.5", author = "mjh")];
 ~~~~
 

trunk/src/compiletest/compiletest.rc

@@ -158,17 +158,10 @@ fn run_tests(config: config) {
 }
 
 fn test_opts(config: config) -> test::TestOpts {
-    {filter:
-         match config.filter {
-           option::Some(s) => option::Some(s),
-           option::None => option::None
-         },
-     run_ignored: config.run_ignored,
-     logfile:
-         match config.logfile {
-           option::Some(s) => option::Some(s.to_str()),
-           option::None => option::None
-         }
+    test::TestOpts {
+        filter: config.filter,
+        run_ignored: config.run_ignored,
+        logfile: config.logfile.map(|s| s.to_str()),
     }
 }
 

trunk/src/compiletest/errors.rs

@@ -33,34 +33,36 @@ fn load_errors(testfile: &Path) -> ~[expected_error] {
     return error_patterns;
 }
 
-fn parse_expected(line_num: uint, line: ~str) -> ~[expected_error] unsafe {
-    let error_tag = ~"//~";
-    let mut idx;
-    match str::find_str(line, error_tag) {
-      None => return ~[],
-      Some(nn) => { idx = (nn as uint) + str::len(error_tag); }
-    }
+fn parse_expected(line_num: uint, line: ~str) -> ~[expected_error] {
+    unsafe {
+        let error_tag = ~"//~";
+        let mut idx;
+        match str::find_str(line, error_tag) {
+          None => return ~[],
+          Some(nn) => { idx = (nn as uint) + str::len(error_tag); }
+        }
 
-    // "//~^^^ kind msg" denotes a message expected
-    // three lines above current line:
-    let mut adjust_line = 0u;
-    let len = str::len(line);
-    while idx < len && line[idx] == ('^' as u8) {
-        adjust_line += 1u;
-        idx += 1u;
-    }
+        // "//~^^^ kind msg" denotes a message expected
+        // three lines above current line:
+        let mut adjust_line = 0u;
+        let len = str::len(line);
+        while idx < len && line[idx] == ('^' as u8) {
+            adjust_line += 1u;
+            idx += 1u;
+        }
 
-    // Extract kind:
-    while idx < len && line[idx] == (' ' as u8) { idx += 1u; }
-    let start_kind = idx;
-    while idx < len && line[idx] != (' ' as u8) { idx += 1u; }
-    let kind = str::to_lower(str::slice(line, start_kind, idx));
+        // Extract kind:
+        while idx < len && line[idx] == (' ' as u8) { idx += 1u; }
+        let start_kind = idx;
+        while idx < len && line[idx] != (' ' as u8) { idx += 1u; }
+        let kind = str::to_lower(str::slice(line, start_kind, idx));
 
-    // Extract msg:
-    while idx < len && line[idx] == (' ' as u8) { idx += 1u; }
-    let msg = str::slice(line, idx, len);
+        // Extract msg:
+        while idx < len && line[idx] == (' ' as u8) { idx += 1u; }
+        let msg = str::slice(line, idx, len);
 
-    debug!("line=%u kind=%s msg=%s", line_num - adjust_line, kind, msg);
+        debug!("line=%u kind=%s msg=%s", line_num - adjust_line, kind, msg);
 
-    return ~[{line: line_num - adjust_line, kind: kind, msg: msg}];
+        return ~[{line: line_num - adjust_line, kind: kind, msg: msg}];
+    }
 }

trunk/src/compiletest/header.rs

@@ -146,15 +146,17 @@ fn parse_name_directive(line: ~str, directive: ~str) -> bool {
 }
 
 fn parse_name_value_directive(line: ~str,
-                              directive: ~str) -> Option<~str> unsafe {
-    let keycolon = directive + ~":";
-    match str::find_str(line, keycolon) {
-        Some(colon) => {
-            let value = str::slice(line, colon + str::len(keycolon),
-                                   str::len(line));
-            debug!("%s: %s", directive,  value);
-            Some(value)
+                              directive: ~str) -> Option<~str> {
+    unsafe {
+        let keycolon = directive + ~":";
+        match str::find_str(line, keycolon) {
+            Some(colon) => {
+                let value = str::slice(line, colon + str::len(keycolon),
+                                       str::len(line));
+                debug!("%s: %s", directive,  value);
+                Some(value)
+            }
+            None => None
         }
-        None => None
     }
 }