---

yaml
---
r: 42668
b: refs/heads/try
c: 19aa88c
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 19dfec2aaf746535de1521f68421f9980dbf25de
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
-refs/heads/try: e447521c1ca2dbead5b485ddc43060b282840817
+refs/heads/try: 19aa88cd64c81b77b874f9396a43fedfa28f14ee
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278

branches/try/AUTHORS.txt

@@ -7,15 +7,13 @@ 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]>
@@ -26,7 +24,6 @@ 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]>
@@ -91,7 +88,6 @@ 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]>
@@ -131,7 +127,6 @@ 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]>
@@ -148,5 +143,4 @@ Vincent Belliard <[email protected]>
 Wade Mealing <[email protected]>
 William Ting <[email protected]>
 Yasuhiro Fujii <[email protected]>
-Youngsoo Son <[email protected]>
 Zack Corr <[email protected]>

branches/try/doc/rust.md

@@ -222,7 +222,7 @@ let log loop
 match mod move mut
 priv pub pure
 ref return
-self static struct super
+self static struct
 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 (`1_u32 ... 4_u32`) are predefined as the constants
+four logging levels (`0_u32 ... 3_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,11 +3018,6 @@ 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
@@ -3247,10 +3242,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 1 to 4, inclusive. Level 1
-is the error level, 2 is warning, 3 info, and 4 debug. Any logs
+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
 less than or equal to the specified level will be output. If not
-specified then log level 4 is assumed.
+specified then log level 3 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`

branches/try/doc/tutorial-ffi.md

@@ -26,14 +26,11 @@ 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() {
@@ -228,15 +225,13 @@ 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()) != ~""; }

branches/try/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 compute multiple results across a number of tasks? The
+example needed to computer multiple results across a number of tasks? The
 following program is ill-typed:
 
 ~~~ {.xfail-test}

branches/try/doc/tutorial.md

@@ -863,34 +863,11 @@ 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.
 
-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.
+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.
 
 All pointer types can be dereferenced with the `*` unary operator.
 
@@ -942,17 +919,7 @@ node2.next = SomeNode(node3);
 node3.prev = SomeNode(node2);
 ~~~
 
-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>`.
+Managed boxes never cross task boundaries.
 
 > ***Note:*** Currently, the Rust compiler generates code to reclaim
 > managed boxes through reference counting and a cycle collector, but
@@ -989,19 +956,10 @@ let z = *x + *y;
 assert z == 20;
 ~~~~
 
-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
+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,
 and won't be able to access it afterwards. The receiving task will
-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).
+become the sole owner of the box.
 
 ## Borrowed pointers
 
@@ -1226,18 +1184,6 @@ 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.
@@ -2405,7 +2351,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")];
 ~~~~
 

branches/try/src/compiletest/compiletest.rc

@@ -158,10 +158,17 @@ fn run_tests(config: config) {
 }
 
 fn test_opts(config: config) -> test::TestOpts {
-    test::TestOpts {
-        filter: config.filter,
-        run_ignored: config.run_ignored,
-        logfile: config.logfile.map(|s| s.to_str()),
+    {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
+         }
     }
 }
 

branches/try/src/compiletest/errors.rs

@@ -33,36 +33,34 @@ 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}];
 }

branches/try/src/compiletest/header.rs

@@ -146,17 +146,15 @@ 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)
-            }
-            None => None
+                              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
     }
 }