---

yaml
---
r: 30359
b: refs/heads/incoming
c: 5e36a99
h: refs/heads/master
i:
  30357: 5f18a55
  30355: 60509b6
  30351: 0e8f2f1
v: v3

Author: nikomatsakis

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
-refs/heads/incoming: adc1427282b4da8f963550e87cdbe512157958b4
+refs/heads/incoming: 5e36a997945ddc3964a1fe937bc5390cc5b526c8
 refs/heads/dist-snap: 2f32a1581f522e524009138b33b1c7049ced668d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/Makefile.in

@@ -100,6 +100,9 @@ endif
 ifdef TIME_LLVM_PASSES
   CFG_RUSTC_FLAGS += -Z time-llvm-passes
 endif
+ifdef TRACE
+  CFG_RUSTC_FLAGS += -Z trace
+endif
 
 # platform-specific auto-configuration
 include $(CFG_SRC_DIR)mk/platform.mk

branches/incoming/src/libcore/util.rs

@@ -65,7 +65,9 @@ mod tests {
     fn identity_crisis() {
         // Writing a test for the identity function. How did it come to this?
         let x = ~[(5, false)];
-        assert x.eq(id(copy x));
+        //FIXME #3387 assert x.eq(id(copy x));
+        let y = copy x;
+        assert x.eq(id(y));
     }
     #[test]
     fn test_swap() {

branches/incoming/src/libstd/getopts.rs

@@ -800,10 +800,11 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(m) => {
-            assert (opt_present(m, ~"test"));
-            assert (opt_str(m, ~"test") == ~"20");
-            assert (opt_strs(m, ~"test")[0] == ~"20");
-            assert (opt_strs(m, ~"test")[1] == ~"30");
+              assert (opt_present(m, ~"test"));
+              assert (opt_str(m, ~"test") == ~"20");
+              let pair = opt_strs(m, ~"test");
+              assert (pair[0] == ~"20");
+              assert (pair[1] == ~"30");
           }
           _ => fail
         }
@@ -854,8 +855,9 @@ mod tests {
           Ok(m) => {
             assert (opt_present(m, ~"t"));
             assert (opt_str(m, ~"t") == ~"20");
-            assert (opt_strs(m, ~"t")[0] == ~"20");
-            assert (opt_strs(m, ~"t")[1] == ~"30");
+            let pair = opt_strs(m, ~"t");
+            assert (pair[0] == ~"20");
+            assert (pair[1] == ~"30");
           }
           _ => fail
         }
@@ -903,10 +905,12 @@ mod tests {
             assert (opt_present(m, ~"flag"));
             assert (opt_str(m, ~"long") == ~"30");
             assert (opt_present(m, ~"f"));
-            assert (opt_strs(m, ~"m")[0] == ~"40");
-            assert (opt_strs(m, ~"m")[1] == ~"50");
-            assert (opt_strs(m, ~"n")[0] == ~"-A B");
-            assert (opt_strs(m, ~"n")[1] == ~"-60 70");
+            let pair = opt_strs(m, ~"m");
+            assert (pair[0] == ~"40");
+            assert (pair[1] == ~"50");
+            let pair = opt_strs(m, ~"n");
+            assert (pair[0] == ~"-A B");
+            assert (pair[1] == ~"-60 70");
             assert (!opt_present(m, ~"notpresent"));
           }
           _ => fail

branches/incoming/src/libstd/par.rs

@@ -19,7 +19,7 @@ const min_granularity : uint = 1024u;
  * like map or alli.
  */
 fn map_slices<A: copy send, B: copy send>(
-    xs: ~[A],
+    xs: &[A],
     f: fn() -> fn~(uint, v: &[A]) -> B)
     -> ~[B] {
 
@@ -104,7 +104,7 @@ fn mapi<A: copy send, B: copy send>(xs: ~[A],
  * inner elements. This is to skirt the need for copy constructors.
  */
 fn mapi_factory<A: copy send, B: copy send>(
-    xs: ~[A], f: fn() -> fn~(uint, A) -> B) -> ~[B] {
+    xs: &[A], f: fn() -> fn~(uint, A) -> B) -> ~[B] {
     let slices = map_slices(xs, || {
         let f = f();
         fn~(base: uint, slice : &[A], move f) -> ~[B] {

branches/incoming/src/libsyntax/print/pprust.rs

@@ -1169,29 +1169,38 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
               None => ()
             }
             word_space(s, ~"=>");
+
             // Extract the expression from the extra block the parser adds
-            assert arm.body.node.view_items.is_empty();
-            assert arm.body.node.stmts.is_empty();
-            assert arm.body.node.rules == ast::default_blk;
-            match arm.body.node.expr {
-              Some(expr) => {
-                match expr.node {
-                  ast::expr_block(blk) => {
-                    // the block will close the pattern's ibox
-                    print_block_unclosed_indent(s, blk, alt_indent_unit);
-                  }
-                  _ => {
-                    end(s); // close the ibox for the pattern
-                    print_expr(s, expr);
-                  }
-                }
-                if !expr_is_simple_block(expr)
-                    && i < len - 1 {
-                    word(s.s, ~",");
+            // in the case of foo => expr
+            if arm.body.node.view_items.is_empty() &&
+                arm.body.node.stmts.is_empty() &&
+                arm.body.node.rules == ast::default_blk &&
+                arm.body.node.expr.is_some()
+            {
+                match arm.body.node.expr {
+                    Some(expr) => {
+                        match expr.node {
+                            ast::expr_block(blk) => {
+                                // the block will close the pattern's ibox
+                                print_block_unclosed_indent(
+                                    s, blk, alt_indent_unit);
+                            }
+                            _ => {
+                                end(s); // close the ibox for the pattern
+                                print_expr(s, expr);
+                            }
+                        }
+                        if !expr_is_simple_block(expr)
+                            && i < len - 1 {
+                            word(s.s, ~",");
+                        }
+                        end(s); // close enclosing cbox
+                    }
+                    None => fail
                 }
-                end(s); // close enclosing cbox
-              }
-              None => fail
+            } else {
+                // the block will close the pattern's ibox
+                print_block_unclosed_indent(s, arm.body, alt_indent_unit);
             }
         }
         bclose_(s, expr.span, alt_indent_unit);

branches/incoming/src/rt/rust_upcall.cpp

@@ -147,7 +147,6 @@ extern "C" CDECL void
 upcall_s_exchange_malloc(s_exchange_malloc_args *args) {
     rust_task *task = args->task;
     LOG_UPCALL_ENTRY(task);
-    LOG(task, mem, "upcall exchange malloc(0x%" PRIxPTR ")", args->td);
 
     size_t total_size = get_box_size(args->size, args->td->align);
     // FIXME--does this have to be calloc? (Issue #2682)
@@ -159,6 +158,9 @@ upcall_s_exchange_malloc(s_exchange_malloc_args *args) {
     header->prev = 0;
     header->next = 0;
 
+    LOG(task, mem, "exchange malloced %p of size %" PRIuPTR,
+        header, args->size);
+
     args->retval = (uintptr_t)header;
 }
 
@@ -187,6 +189,7 @@ extern "C" CDECL void
 upcall_s_exchange_free(s_exchange_free_args *args) {
     rust_task *task = args->task;
     LOG_UPCALL_ENTRY(task);
+    LOG(task, mem, "exchange freed %p", args->ptr);
     task->kernel->free(args->ptr);
 }
 

branches/incoming/src/rustc/lib/llvm.rs

@@ -456,9 +456,11 @@ extern mod llvm {
        ValueRef;
     fn LLVMConstAShr(LHSConstant: ValueRef, RHSConstant: ValueRef) ->
        ValueRef;
-    fn LLVMConstGEP(ConstantVal: ValueRef, ConstantIndices: *uint,
+    fn LLVMConstGEP(ConstantVal: ValueRef,
+                    ConstantIndices: *ValueRef,
                     NumIndices: c_uint) -> ValueRef;
-    fn LLVMConstInBoundsGEP(ConstantVal: ValueRef, ConstantIndices: *uint,
+    fn LLVMConstInBoundsGEP(ConstantVal: ValueRef,
+                            ConstantIndices: *ValueRef,
                             NumIndices: c_uint) -> ValueRef;
     fn LLVMConstTrunc(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef;
     fn LLVMConstSExt(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef;
@@ -493,10 +495,10 @@ extern mod llvm {
     fn LLVMConstShuffleVector(VectorAConstant: ValueRef,
                               VectorBConstant: ValueRef,
                               MaskConstant: ValueRef) -> ValueRef;
-    fn LLVMConstExtractValue(AggConstant: ValueRef, IdxList: *uint,
+    fn LLVMConstExtractValue(AggConstant: ValueRef, IdxList: *c_uint,
                              NumIdx: c_uint) -> ValueRef;
     fn LLVMConstInsertValue(AggConstant: ValueRef,
-                            ElementValueConstant: ValueRef, IdxList: *uint,
+                            ElementValueConstant: ValueRef, IdxList: *c_uint,
                             NumIdx: c_uint) -> ValueRef;
     fn LLVMConstInlineAsm(Ty: TypeRef, AsmString: *c_char,
                           Constraints: *c_char, HasSideEffects: Bool,

branches/incoming/src/rustc/middle/borrowck.rs

@@ -220,7 +220,8 @@ use syntax::visit;
 use syntax::ast_util;
 use syntax::ast_map;
 use syntax::codemap::span;
-use util::ppaux::{ty_to_str, region_to_str, explain_region};
+use util::ppaux::{ty_to_str, region_to_str, explain_region,
+                  note_and_explain_region};
 use std::map::{int_hash, hashmap, set};
 use std::list;
 use std::list::{List, Cons, Nil};
@@ -464,6 +465,7 @@ impl borrowck_ctxt {
             err.cmt.span,
             fmt!("illegal borrow: %s",
                  self.bckerr_code_to_str(err.code)));
+        self.note_and_explain_bckerr(err.code);
     }
 
     fn span_err(s: span, m: ~str) {
@@ -488,37 +490,65 @@ impl borrowck_ctxt {
 
     fn bckerr_code_to_str(code: bckerr_code) -> ~str {
         match code {
-          err_mutbl(req, act) => {
-            fmt!("creating %s alias to aliasable, %s memory",
-                 self.mut_to_str(req), self.mut_to_str(act))
-          }
-          err_mut_uniq => {
-            ~"unique value in aliasable, mutable location"
-          }
-          err_mut_variant => {
-            ~"enum variant in aliasable, mutable location"
-          }
-          err_root_not_permitted => {
-            // note: I don't expect users to ever see this error
-            // message, reasons are discussed in attempt_root() in
-            // preserve.rs.
-            ~"rooting is not permitted"
-          }
-          err_out_of_root_scope(super_scope, sub_scope) => {
-            fmt!("managed value would have to be rooted for %s, \
-                  but can only be rooted for %s",
-                  explain_region(self.tcx, sub_scope),
-                  explain_region(self.tcx, super_scope))
-          }
-          err_out_of_scope(super_scope, sub_scope) => {
-            fmt!("borrowed pointer must be valid for %s, \
-                  but the borrowed value is only valid for %s",
-                  explain_region(self.tcx, sub_scope),
-                  explain_region(self.tcx, super_scope))
+            err_mutbl(req, act) => {
+                fmt!("creating %s alias to aliasable, %s memory",
+                     self.mut_to_str(req), self.mut_to_str(act))
+            }
+            err_mut_uniq => {
+                ~"unique value in aliasable, mutable location"
+            }
+            err_mut_variant => {
+                ~"enum variant in aliasable, mutable location"
+            }
+            err_root_not_permitted => {
+                // note: I don't expect users to ever see this error
+                // message, reasons are discussed in attempt_root() in
+                // preserve.rs.
+                ~"rooting is not permitted"
+            }
+            err_out_of_root_scope(*) => {
+                ~"cannot root managed value long enough"
+            }
+            err_out_of_scope(*) => {
+                ~"borrowed value does not live long enough"
+            }
+        }
+    }
+
+    fn note_and_explain_bckerr(code: bckerr_code) {
+        match code {
+            err_mutbl(*) | err_mut_uniq | err_mut_variant |
+            err_root_not_permitted => {}
+
+            err_out_of_root_scope(super_scope, sub_scope) => {
+                note_and_explain_region(
+                    self.tcx,
+                    ~"managed value would have to be rooted for ",
+                    sub_scope,
+                    ~"...");
+                note_and_explain_region(
+                    self.tcx,
+                    ~"...but can only be rooted for ",
+                    super_scope,
+                    ~"");
+            }
+
+            err_out_of_scope(super_scope, sub_scope) => {
+                note_and_explain_region(
+                    self.tcx,
+                    ~"borrowed pointer must be valid for ",
+                    sub_scope,
+                    ~"...");
+                note_and_explain_region(
+                    self.tcx,
+                    ~"...but borrowed value is only valid for ",
+                    super_scope,
+                    ~"");
           }
         }
     }
 
+
     fn cmt_to_str(cmt: cmt) -> ~str {
         let mc = &mem_categorization_ctxt {tcx: self.tcx,
                                            method_map: self.method_map};

branches/incoming/src/rustc/middle/borrowck/check_loans.rs

@@ -423,6 +423,7 @@ impl check_loan_ctxt {
                     e.cmt.span,
                     fmt!("illegal borrow unless pure: %s",
                          self.bccx.bckerr_code_to_str(e.code)));
+                self.bccx.note_and_explain_bckerr(e.code);
                 self.tcx().sess.span_note(
                     sp,
                     fmt!("impure due to %s", msg));
@@ -484,10 +485,14 @@ impl check_loan_ctxt {
     // when there is an outstanding loan.  In that case, it is not
     // safe to consider the use a last_use.
     fn check_last_use(expr: @ast::expr) {
+        debug!("Checking last use of expr %?", expr.id);
         let cmt = self.bccx.cat_expr(expr);
         let lp = match cmt.lp {
-          None => return,
-          Some(lp) => lp
+            None => {
+                debug!("Not a loanable expression");
+                return;
+            }
+            Some(lp) => lp
         };
         for self.walk_loans_of(cmt.id, lp) |_loan| {
             debug!("Removing last use entry %? due to outstanding loan",
@@ -592,6 +597,9 @@ fn check_loans_in_local(local: @ast::local,
 fn check_loans_in_expr(expr: @ast::expr,
                        &&self: check_loan_ctxt,
                        vt: visit::vt<check_loan_ctxt>) {
+    debug!("check_loans_in_expr(expr=%?/%s)",
+           expr.id, pprust::expr_to_str(expr, self.tcx().sess.intr()));
+
     self.check_for_conflicting_loans(expr.id);
 
     match expr.node {