---

yaml
---
r: 41942
b: refs/heads/master
c: 25184da
h: refs/heads/master
v: v3

Author: jbclements

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: bc0c5bb447ac8eba0a80599305c23db6c8a1ed6a
+refs/heads/master: 25184da1e722095902725ef520590fc464faf082
 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]>

trunk/doc/rust.md

@@ -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-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/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
     }
 }

trunk/src/compiletest/runtest.rs

@@ -273,7 +273,7 @@ fn check_expected_errors(expected_errors: ~[errors::expected_error],
                          procres: procres) {
 
     // true if we found the error in question
-    let found_flags = vec::to_mut(vec::from_elem(
+    let found_flags = vec::cast_to_mut(vec::from_elem(
         vec::len(expected_errors), false));
 
     if procres.status == 0 {

trunk/src/etc/check-summary.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python
+# xfail-license
 
 import sys
 

trunk/src/etc/combine-tests.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python
+# xfail-license
 
 # this combines all the working run-pass tests into a single large crate so we
 # can run it "fast": spawning zillions of windows processes is our major build

trunk/src/etc/extract-tests.py

@@ -1,10 +1,12 @@
+# xfail-license
+
 # Script for extracting compilable fragments from markdown
 # documentation. See prep.js for a description of the format
-# recognized by this tool. Expects a directory fragements/ to exist
+# recognized by this tool. Expects a directory fragments/ to exist
 # under the current directory, and writes the fragments in there as
 # individual .rs files.
 
-import sys, re;
+import sys, re
 
 if len(sys.argv) < 3:
     print("Please provide an input filename")
@@ -24,7 +26,7 @@
 while cur < len(lines):
     line = lines[cur]
     cur += 1
-    chap = re.match("# (.*)", line);
+    chap = re.match("# (.*)", line)
     if chap:
         chapter = re.sub(r"\W", "_", chap.group(1)).lower()
         chapter_n = 1
@@ -49,14 +51,30 @@
             else:
                 # Lines beginning with '# ' are turned into valid code
                 line = re.sub("^# ", "", line)
-                # Allow elipses in code snippets
+                # Allow ellipses in code snippets
                 line = re.sub("\.\.\.", "", line)
                 block += line
         if not ignore:
             if not re.search(r"\bfn main\b", block):
                 block = "fn main() {\n" + block + "\n}\n"
             if not re.search(r"\bextern mod std\b", block):
-                block = "extern mod std;\n" + block;
+                block = "extern mod std;\n" + block
+            block = """#[ forbid(ctypes) ];
+#[ forbid(deprecated_mode) ];
+#[ forbid(deprecated_pattern) ];
+#[ forbid(implicit_copies) ];
+#[ forbid(non_implicitly_copyable_typarams) ];
+#[ forbid(path_statement) ];
+#[ forbid(type_limits) ];
+#[ forbid(unrecognized_lint) ];
+#[ forbid(unused_imports) ];
+#[ forbid(vecs_implicitly_copyable) ];
+#[ forbid(while_true) ];
+
+#[ warn(deprecated_self) ];
+#[ warn(non_camel_case_types) ];
+#[ warn(structural_records) ];\n
+""" + block
             if xfail:
                 block = "// xfail-test\n" + block
             filename = (dest + "/" + str(chapter)

trunk/src/etc/extract_grammar.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python
+# xfail-license
 
 # This script is for extracting the grammar from the rust docs.