---

yaml
---
r: 163391
b: refs/heads/snap-stage3
c: 38d2909
h: refs/heads/master
i:
  163389: 4a67fde
  163387: 331f4d9
  163383: 0adfd59
  163375: 797f6a3
  163359: b0e4721
  163327: ea191f7
v: v3

Author: steveklabnik

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 9146a919b616e39e528e4d7100d16eef52f1f852
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: cb2119823d097439db53933186632cf4ca96711d
+refs/heads/snap-stage3: 38d29092f95a2ff8794513b64c1069e1680adf9e
 refs/heads/try: 20cbbffeefc1f35e2ea63afce7b42fbd79611d42
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/mk/crates.mk

@@ -53,7 +53,7 @@ TARGET_CRATES := libc std flate arena term \
                  serialize getopts collections test time rand \
                  log regex graphviz core rbml alloc rustrt \
                  unicode
-RUSTC_CRATES := rustc rustc_typeck rustc_borrowck rustc_driver rustc_trans rustc_back rustc_llvm 
+RUSTC_CRATES := rustc rustc_typeck rustc_driver rustc_trans rustc_back rustc_llvm 
 HOST_CRATES := syntax $(RUSTC_CRATES) rustdoc regex_macros fmt_macros
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
@@ -67,12 +67,11 @@ DEPS_std := core libc rand alloc collections rustrt unicode \
 	native:rust_builtin native:backtrace
 DEPS_graphviz := std
 DEPS_syntax := std term serialize log fmt_macros arena libc
-DEPS_rustc_driver := arena flate getopts graphviz libc rustc rustc_back rustc_borrowck \
+DEPS_rustc_driver := arena flate getopts graphviz libc rustc rustc_back \
                      rustc_typeck log syntax serialize rustc_llvm rustc_trans
 DEPS_rustc_trans := arena flate getopts graphviz libc rustc rustc_back \
 	                log syntax serialize rustc_llvm
 DEPS_rustc_typeck := rustc syntax
-DEPS_rustc_borrowck := rustc log graphviz syntax
 DEPS_rustc := syntax flate arena serialize getopts rbml \
               time log graphviz rustc_llvm rustc_back
 DEPS_rustc_llvm := native:rustllvm libc std
@@ -118,10 +117,9 @@ ONLY_RLIB_unicode := 1
 DOC_CRATES := $(filter-out rustc, \
               $(filter-out rustc_trans, \
               $(filter-out rustc_typeck, \
-              $(filter-out rustc_borrowck, \
               $(filter-out rustc_driver, \
-              $(filter-out syntax, $(CRATES)))))))
-COMPILER_DOC_CRATES := rustc rustc_trans rustc_borrowck rustc_typeck rustc_driver syntax
+              $(filter-out syntax, $(CRATES))))))
+COMPILER_DOC_CRATES := rustc rustc_trans rustc_typeck rustc_driver syntax
 
 # This macro creates some simple definitions for each crate being built, just
 # some munging of all of the parameters above.

branches/snap-stage3/mk/rustllvm.mk

@@ -22,8 +22,7 @@ LLVM_EXTRA_INCDIRS_$(1)= -iquote $(S)src/llvm/include \
                          -iquote $$(CFG_LLVM_BUILD_DIR_$(1))/include
 endif
 
-RUSTLLVM_OBJS_CS_$(1) := $$(addprefix rustllvm/, \
-	ExecutionEngineWrapper.cpp RustWrapper.cpp PassWrapper.cpp)
+RUSTLLVM_OBJS_CS_$(1) := $$(addprefix rustllvm/, RustWrapper.cpp PassWrapper.cpp)
 
 RUSTLLVM_DEF_$(1) := $(1)/rustllvm/rustllvm$(CFG_DEF_SUFFIX_$(1))
 

branches/snap-stage3/mk/tests.mk

@@ -21,7 +21,7 @@ $(eval $(call RUST_CRATE,coretest))
 
 TEST_TARGET_CRATES = $(filter-out core unicode,$(TARGET_CRATES)) coretest
 TEST_DOC_CRATES = $(DOC_CRATES)
-TEST_HOST_CRATES = $(filter-out rustc_typeck rustc_borrowck rustc_trans,$(HOST_CRATES))
+TEST_HOST_CRATES = $(filter-out rustc_typeck rustc_trans,$(HOST_CRATES))
 TEST_CRATES = $(TEST_TARGET_CRATES) $(TEST_HOST_CRATES)
 
 ######################################################################

branches/snap-stage3/src/compiletest/compiletest.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 #![crate_type = "bin"]
-#![feature(phase, slicing_syntax, globs, unboxed_closures)]
+#![feature(phase, slicing_syntax, globs)]
 
 #![deny(warnings)]
 
@@ -23,7 +23,6 @@ use std::os;
 use std::io;
 use std::io::fs;
 use std::str::FromStr;
-use std::thunk::{Thunk};
 use getopts::{optopt, optflag, reqopt};
 use common::Config;
 use common::{Pretty, DebugInfoGdb, DebugInfoLldb, Codegen};
@@ -370,16 +369,16 @@ pub fn make_test_closure(config: &Config, testfile: &Path) -> test::TestFn {
     let config = (*config).clone();
     // FIXME (#9639): This needs to handle non-utf8 paths
     let testfile = testfile.as_str().unwrap().to_string();
-    test::DynTestFn(Thunk::new(move || {
+    test::DynTestFn(proc() {
         runtest::run(config, testfile)
-    }))
+    })
 }
 
 pub fn make_metrics_test_closure(config: &Config, testfile: &Path) -> test::TestFn {
     let config = (*config).clone();
     // FIXME (#9639): This needs to handle non-utf8 paths
     let testfile = testfile.as_str().unwrap().to_string();
-    test::DynMetricFn(box move |: mm: &mut test::MetricMap| {
+    test::DynMetricFn(proc(mm) {
         runtest::run_metrics(config, testfile, mm)
     })
 }

branches/snap-stage3/src/compiletest/runtest.rs

@@ -445,7 +445,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
             loop {
                 //waiting 1 second for gdbserver start
                 timer::sleep(Duration::milliseconds(1000));
-                let result = task::try(move || {
+                let result = task::try(proc() {
                     tcp::TcpStream::connect("127.0.0.1:5039").unwrap();
                 });
                 if result.is_err() {

branches/snap-stage3/src/doc/complement-bugreport.md

@@ -37,7 +37,7 @@ It's also helpful to provide the exact version and host by copying the output of
 re-running the erroneous rustc command with the `--version=verbose` flag, which will
 produce something like this:
 
-```text
+```{ignore}
 rustc 0.12.0 (ba4081a5a 2014-10-07 13:44:41 -0700)
 binary: rustc
 commit-hash: ba4081a5a8573875fed17545846f6f6902c8ba8d
@@ -46,13 +46,8 @@ host: i686-apple-darwin
 release: 0.12.0
 ```
 
-Finally, if you can also provide a backtrace, that'd be great. You can get a
-backtrace by setting the `RUST_BACKTRACE` environment variable to `1`, like
-this: 
-
-```bash
-$ RUST_BACKTRACE=1 rustc ...
-```
+Finally, if you can run the offending command under gdb, pasting a stack trace can be
+useful; to do so, you will need to set a breakpoint on `rust_panic`.
 
 # I submitted a bug, but nobody has commented on it!
 

branches/snap-stage3/src/doc/guide-crates.md

@@ -452,7 +452,7 @@ fn main() {
 
 Rust will give us a compile-time error:
 
-```text
+```{notrust}
    Compiling phrases v0.0.1 (file:///home/you/projects/phrases)
 /home/you/projects/phrases/src/main.rs:4:5: 4:40 error: a value named `hello` has already been imported in this module
 /home/you/projects/phrases/src/main.rs:4 use phrases::japanese::greetings::hello;

branches/snap-stage3/src/doc/guide-error-handling.md

@@ -76,7 +76,7 @@ fn main() {
 
 This will give us an error:
 
-```text
+```{notrust}
 error: non-exhaustive patterns: `_` not covered [E0004]
 ```
 
@@ -189,7 +189,7 @@ panic!("boom");
 
 gives
 
-```text
+```{notrust}
 task '<main>' panicked at 'boom', hello.rs:2
 ```
 

branches/snap-stage3/src/doc/guide-ownership.md

@@ -130,7 +130,7 @@ fn add_one(mut num: Box<int>) {
 
 This does not compile, and gives us an error:
 
-```text
+```{notrust}
 error: use of moved value: `x`
    println!("{}", x);
                   ^
@@ -406,7 +406,7 @@ fn main() {
 We try to make four `Wheel`s, each with a `Car` that it's attached to. But the
 compiler knows that on the second iteration of the loop, there's a problem:
 
-```text
+```{notrust}
 error: use of moved value: `car`
     Wheel { size: 360, owner: car };
                               ^~~

branches/snap-stage3/src/doc/guide-pointers.md

@@ -84,7 +84,7 @@ println!("{}", x + z);
 
 This gives us an error:
 
-```text
+```{notrust}
 hello.rs:6:24: 6:25 error: mismatched types: expected `int` but found `&int` (expected int but found &-ptr)
 hello.rs:6     println!("{}", x + z);
                                   ^
@@ -132,7 +132,7 @@ Pointers are useful in languages that are pass-by-value, rather than
 pass-by-reference. Basically, languages can make two choices (this is made
 up syntax, it's not Rust):
 
-```text
+```{ignore}
 func foo(x) {
     x = 5
 }
@@ -152,7 +152,7 @@ and therefore, can change its value. At the comment, `i` will be `5`.
 So what do pointers have to do with this? Well, since pointers point to a
 location in memory...
 
-```text
+```{ignore}
 func foo(&int x) {
     *x = 5
 }
@@ -191,7 +191,7 @@ knows. This might be harmless, and it might be catastrophic.
 When you combine pointers and functions, it's easy to accidentally invalidate
 the memory the pointer is pointing to. For example:
 
-```text
+```{ignore}
 func make_pointer(): &int {
     x = 5;
 
@@ -213,7 +213,7 @@ As one last example of a big problem with pointers, **aliasing** can be an
 issue. Two pointers are said to alias when they point at the same location
 in memory. Like this:
 
-```text
+```{ignore}
 func mutate(&int i, int j) {
     *i = j;
 }
@@ -398,7 +398,7 @@ fn main() {
 
 It gives this error:
 
-```text
+```{notrust}
 test.rs:5:8: 5:10 error: cannot assign to `*x` because it is borrowed
 test.rs:5         *x -= 1;
                   ^~
@@ -522,7 +522,7 @@ boxes, though. As a rough approximation, you can treat this Rust code:
 
 As being similar to this C code:
 
-```c
+```{ignore}
 {
     int *x;
     x = (int *)malloc(sizeof(int));
@@ -626,7 +626,7 @@ fn main() {
 
 This prints:
 
-```text
+```{ignore}
 Cons(1, box Cons(2, box Cons(3, box Nil)))
 ```
 

branches/snap-stage3/src/doc/guide-tasks.md

@@ -29,37 +29,31 @@ with a closure argument. `spawn` executes the closure in the new task.
 fn print_message() { println!("I am running in a different task!"); }
 spawn(print_message);
 
-// Alternatively, use a `move ||` expression instead of a named function.
-// `||` expressions evaluate to an unnamed closure. The `move` keyword
-// indicates that the closure should take ownership of any variables it
-// touches.
-spawn(move || println!("I am also running in a different task!"));
+// Alternatively, use a `proc` expression instead of a named function.
+// The `proc` expression evaluates to an (unnamed) proc.
+// That proc will call `println!(...)` when the spawned task runs.
+spawn(proc() println!("I am also running in a different task!") );
 ```
 
 In Rust, a task is not a concept that appears in the language semantics.
 Instead, Rust's type system provides all the tools necessary to implement safe
 concurrency: particularly, ownership. The language leaves the implementation
 details to the standard library.
 
-The `spawn` function has the type signature: `fn
-spawn<F:FnOnce()+Send>(f: F)`.  This indicates that it takes as
-argument a closure (of type `F`) that it will run exactly once. This
-closure is limited to capturing `Send`-able data from its environment
-(that is, data which is deeply owned). Limiting the closure to `Send`
-ensures that `spawn` can safely move the entire closure and all its
-associated state into an entirely different task for execution.
+The `spawn` function has a very simple type signature: `fn spawn(f: proc():
+Send)`. Because it accepts only procs, and procs contain only owned data,
+`spawn` can safely move the entire proc and all its associated state into an
+entirely different task for execution. Like any closure, the function passed to
+`spawn` may capture an environment that it carries across tasks.
 
 ```{rust}
 # use std::task::spawn;
 # fn generate_task_number() -> int { 0 }
 // Generate some state locally
 let child_task_number = generate_task_number();
 
-spawn(move || {
-    // Capture it in the remote task. The `move` keyword indicates
-    // that this closure should move `child_task_number` into its
-    // environment, rather than capturing a reference into the
-    // enclosing stack frame.
+spawn(proc() {
+    // Capture it in the remote task
     println!("I am child number {}", child_task_number);
 });
 ```
@@ -80,7 +74,7 @@ example of calculating two results concurrently:
 
 let (tx, rx): (Sender<int>, Receiver<int>) = channel();
 
-spawn(move || {
+spawn(proc() {
     let result = some_expensive_computation();
     tx.send(result);
 });
@@ -108,7 +102,7 @@ task.
 # use std::task::spawn;
 # fn some_expensive_computation() -> int { 42 }
 # let (tx, rx) = channel();
-spawn(move || {
+spawn(proc() {
     let result = some_expensive_computation();
     tx.send(result);
 });
@@ -141,13 +135,13 @@ results across a number of tasks? The following program is ill-typed:
 # fn some_expensive_computation() -> int { 42 }
 let (tx, rx) = channel();
 
-spawn(move || {
+spawn(proc() {
     tx.send(some_expensive_computation());
 });
 
 // ERROR! The previous spawn statement already owns the sender,
 // so the compiler will not allow it to be captured again
-spawn(move || {
+spawn(proc() {
     tx.send(some_expensive_computation());
 });
 ```
@@ -160,7 +154,7 @@ let (tx, rx) = channel();
 for init_val in range(0u, 3) {
     // Create a new channel handle to distribute to the child task
     let child_tx = tx.clone();
-    spawn(move || {
+    spawn(proc() {
         child_tx.send(some_expensive_computation(init_val));
     });
 }
@@ -185,7 +179,7 @@ reference, written with multiple streams, it might look like the example below.
 // Create a vector of ports, one for each child task
 let rxs = Vec::from_fn(3, |init_val| {
     let (tx, rx) = channel();
-    spawn(move || {
+    spawn(proc() {
         tx.send(some_expensive_computation(init_val));
     });
     rx
@@ -213,7 +207,7 @@ fn fib(n: u64) -> u64 {
     12586269025
 }
 
-let mut delayed_fib = Future::spawn(move || fib(50));
+let mut delayed_fib = Future::spawn(proc() fib(50));
 make_a_sandwich();
 println!("fib(50) = {}", delayed_fib.get())
 # }
@@ -242,7 +236,7 @@ fn partial_sum(start: uint) -> f64 {
 }
 
 fn main() {
-    let mut futures = Vec::from_fn(200, |ind| Future::spawn(move || partial_sum(ind)));
+    let mut futures = Vec::from_fn(200, |ind| Future::spawn( proc() { partial_sum(ind) }));
 
     let mut final_res = 0f64;
     for ft in futures.iter_mut()  {
@@ -284,7 +278,7 @@ fn main() {
     for num in range(1u, 10) {
         let task_numbers = numbers_arc.clone();
 
-        spawn(move || {
+        spawn(proc() {
             println!("{}-norm = {}", num, pnorm(task_numbers.as_slice(), num));
         });
     }
@@ -318,7 +312,7 @@ if it were local.
 # let numbers_arc = Arc::new(numbers);
 # let num = 4;
 let task_numbers = numbers_arc.clone();
-spawn(move || {
+spawn(proc() {
     // Capture task_numbers and use it as if it was the underlying vector
     println!("{}-norm = {}", num, pnorm(task_numbers.as_slice(), num));
 });
@@ -350,7 +344,7 @@ result with an `int` field (representing a successful result) or an `Err` result
 # use std::task;
 # fn some_condition() -> bool { false }
 # fn calculate_result() -> int { 0 }
-let result: Result<int, Box<std::any::Any + Send>> = task::try(move || {
+let result: Result<int, Box<std::any::Any + Send>> = task::try(proc() {
     if some_condition() {
         calculate_result()
     } else {