---

yaml
---
r: 152307
b: refs/heads/try2
c: d123188
h: refs/heads/master
i:
  152305: 53b3a24
  152303: 2688048
v: v3

Author: Cameron Zwarich

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 3744940706f58eea8185cab2987738a79d11098a
+refs/heads/try2: d123188b20222c8fc5fbc386bd15100b6f3c80ed
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/crates.mk

@@ -84,7 +84,7 @@ DEPS_collections := core alloc
 DEPS_fourcc := syntax std
 DEPS_hexfloat := syntax std
 DEPS_num := std
-DEPS_test := std getopts serialize term time regex native:rust_test_helpers
+DEPS_test := std getopts serialize term time regex
 DEPS_time := std serialize sync
 DEPS_rand := core
 DEPS_url := std

branches/try2/mk/rt.mk

@@ -35,8 +35,7 @@
 # that's per-target so you're allowed to conditionally add files based on the
 # target.
 ################################################################################
-NATIVE_LIBS := rustrt hoedown uv_support morestack miniz context_switch \
-		rust_test_helpers
+NATIVE_LIBS := rustrt hoedown uv_support morestack miniz context_switch
 
 # $(1) is the target triple
 define NATIVE_LIBRARIES
@@ -54,9 +53,9 @@ NATIVE_DEPS_uv_support_$(1) := rust_uv.c
 NATIVE_DEPS_miniz_$(1) = miniz.c
 NATIVE_DEPS_rustrt_$(1) := rust_builtin.c \
 			rust_android_dummy.c \
+			rust_test_helpers.c \
 			rust_try.ll \
 			arch/$$(HOST_$(1))/record_sp.S
-NATIVE_DEPS_rust_test_helpers_$(1) := rust_test_helpers.c
 NATIVE_DEPS_morestack_$(1) := arch/$$(HOST_$(1))/morestack.S
 NATIVE_DEPS_context_switch_$(1) := \
 			arch/$$(HOST_$(1))/_context.S

branches/try2/src/librustc/middle/borrowck/check_loans.rs

@@ -385,37 +385,47 @@ impl<'a> CheckLoanCtxt<'a> {
         });
     }
 
-    pub fn check_assignment(&self, expr: &ast::Expr) {
+    pub fn check_assignment_expr(&self, expr: &ast::Expr) {
+        let assignment_id = expr.id;
+        let assignment_span = expr.span;
+
         // We don't use cat_expr() here because we don't want to treat
         // auto-ref'd parameters in overloaded operators as rvalues.
-        let cmt = match self.bccx.tcx.adjustments.borrow().find(&expr.id) {
+        let assignee_cmt = match self.bccx.tcx.adjustments.borrow().find(&assignment_id) {
             None => self.bccx.cat_expr_unadjusted(expr),
             Some(adj) => self.bccx.cat_expr_autoderefd(expr, adj)
         };
 
-        debug!("check_assignment(cmt={})", cmt.repr(self.tcx()));
+        self.check_assignment(assignment_id, assignment_span, assignee_cmt);
+    }
+
+    fn check_assignment(&self,
+                        assignment_id: ast::NodeId,
+                        assignment_span: Span,
+                        assignee_cmt: mc::cmt) {
+        debug!("check_assignment(assignee_cmt={})", assignee_cmt.repr(self.tcx()));
 
         // Mutable values can be assigned, as long as they obey loans
         // and aliasing restrictions:
-        if cmt.mutbl.is_mutable() {
-            if check_for_aliasable_mutable_writes(self, expr, cmt.clone()) {
+        if assignee_cmt.mutbl.is_mutable() {
+            if check_for_aliasable_mutable_writes(self, assignment_span, assignee_cmt.clone()) {
                 if check_for_assignment_to_restricted_or_frozen_location(
-                    self, expr, cmt.clone()) {
+                    self, assignment_id, assignment_span, assignee_cmt.clone()) {
                     // Safe, but record for lint pass later:
-                    mark_variable_as_used_mut(self, cmt);
+                    mark_variable_as_used_mut(self, assignee_cmt);
                 }
             }
             return;
         }
 
         // For immutable local variables, assignments are legal
         // if they cannot already have been assigned
-        if self.is_local_variable(cmt.clone()) {
-            assert!(cmt.mutbl.is_immutable()); // no "const" locals
-            let lp = opt_loan_path(&cmt).unwrap();
-            self.move_data.each_assignment_of(expr.id, &lp, |assign| {
+        if self.is_local_variable(assignee_cmt.clone()) {
+            assert!(assignee_cmt.mutbl.is_immutable()); // no "const" locals
+            let lp = opt_loan_path(&assignee_cmt).unwrap();
+            self.move_data.each_assignment_of(assignment_id, &lp, |assign| {
                 self.bccx.report_reassigned_immutable_variable(
-                    expr.span,
+                    assignment_span,
                     &*lp,
                     assign);
                 false
@@ -424,21 +434,21 @@ impl<'a> CheckLoanCtxt<'a> {
         }
 
         // Otherwise, just a plain error.
-        match opt_loan_path(&cmt) {
+        match opt_loan_path(&assignee_cmt) {
             Some(lp) => {
                 self.bccx.span_err(
-                    expr.span,
+                    assignment_span,
                     format!("cannot assign to {} {} `{}`",
-                            cmt.mutbl.to_user_str(),
-                            self.bccx.cmt_to_str(&*cmt),
+                            assignee_cmt.mutbl.to_user_str(),
+                            self.bccx.cmt_to_str(&*assignee_cmt),
                             self.bccx.loan_path_to_str(&*lp)).as_slice());
             }
             None => {
                 self.bccx.span_err(
-                    expr.span,
+                    assignment_span,
                     format!("cannot assign to {} {}",
-                            cmt.mutbl.to_user_str(),
-                            self.bccx.cmt_to_str(&*cmt)).as_slice());
+                            assignee_cmt.mutbl.to_user_str(),
+                            self.bccx.cmt_to_str(&*assignee_cmt)).as_slice());
             }
         }
         return;
@@ -495,7 +505,7 @@ impl<'a> CheckLoanCtxt<'a> {
         }
 
         fn check_for_aliasable_mutable_writes(this: &CheckLoanCtxt,
-                                              expr: &ast::Expr,
+                                              span: Span,
                                               cmt: mc::cmt) -> bool {
             //! Safety checks related to writes to aliasable, mutable locations
 
@@ -506,7 +516,7 @@ impl<'a> CheckLoanCtxt<'a> {
                 mc::cat_deref(ref b, _, mc::BorrowedPtr(ty::MutBorrow, _)) => {
                     // Statically prohibit writes to `&mut` when aliasable
 
-                    check_for_aliasability_violation(this, expr, b.clone());
+                    check_for_aliasability_violation(this, span, b.clone());
                 }
 
                 _ => {}
@@ -516,7 +526,7 @@ impl<'a> CheckLoanCtxt<'a> {
         }
 
         fn check_for_aliasability_violation(this: &CheckLoanCtxt,
-                                            expr: &ast::Expr,
+                                            span: Span,
                                             cmt: mc::cmt)
                                             -> bool {
             match cmt.freely_aliasable(this.tcx()) {
@@ -528,7 +538,7 @@ impl<'a> CheckLoanCtxt<'a> {
                 }
                 Some(cause) => {
                     this.bccx.report_aliasability_violation(
-                        expr.span,
+                        span,
                         MutabilityViolation,
                         cause);
                     return false;
@@ -538,13 +548,14 @@ impl<'a> CheckLoanCtxt<'a> {
 
         fn check_for_assignment_to_restricted_or_frozen_location(
             this: &CheckLoanCtxt,
-            expr: &ast::Expr,
-            cmt: mc::cmt) -> bool
+            assignment_id: ast::NodeId,
+            assignment_span: Span,
+            assignee_cmt: mc::cmt) -> bool
         {
             //! Check for assignments that violate the terms of an
             //! outstanding loan.
 
-            let loan_path = match opt_loan_path(&cmt) {
+            let loan_path = match opt_loan_path(&assignee_cmt) {
                 Some(lp) => lp,
                 None => { return true; /* no loan path, can't be any loans */ }
             };
@@ -579,11 +590,11 @@ impl<'a> CheckLoanCtxt<'a> {
             // `RESTR_MUTATE` restriction whenever the contents of an
             // owned pointer are borrowed, and hence while `v[*]` is not
             // restricted from being written, `v` is.
-            let cont = this.each_in_scope_restriction(expr.id,
+            let cont = this.each_in_scope_restriction(assignment_id,
                                                       &*loan_path,
                                                       |loan, restr| {
                 if restr.set.intersects(RESTR_MUTATE) {
-                    this.report_illegal_mutation(expr, &*loan_path, loan);
+                    this.report_illegal_mutation(assignment_span, &*loan_path, loan);
                     false
                 } else {
                     true
@@ -656,9 +667,9 @@ impl<'a> CheckLoanCtxt<'a> {
                 };
 
                 // Check for a non-const loan of `loan_path`
-                let cont = this.each_in_scope_loan(expr.id, |loan| {
+                let cont = this.each_in_scope_loan(assignment_id, |loan| {
                     if loan.loan_path == loan_path {
-                        this.report_illegal_mutation(expr, &*full_loan_path, loan);
+                        this.report_illegal_mutation(assignment_span, &*full_loan_path, loan);
                         false
                     } else {
                         true
@@ -671,11 +682,11 @@ impl<'a> CheckLoanCtxt<'a> {
     }
 
     pub fn report_illegal_mutation(&self,
-                                   expr: &ast::Expr,
+                                   span: Span,
                                    loan_path: &LoanPath,
                                    loan: &Loan) {
         self.bccx.span_err(
-            expr.span,
+            span,
             format!("cannot assign to `{}` because it is borrowed",
                     self.bccx.loan_path_to_str(loan_path)).as_slice());
         self.bccx.span_note(
@@ -733,7 +744,7 @@ impl<'a> CheckLoanCtxt<'a> {
                 match freevar_mode {
                     freevars::CaptureByRef => { }
                     freevars::CaptureByValue => {
-                        check_by_move_capture(self, closure_id, freevar, &*var_path);
+                        check_by_move_capture(self, closure_id, freevar.span, &*var_path);
                     }
                 }
             }
@@ -742,14 +753,14 @@ impl<'a> CheckLoanCtxt<'a> {
 
         fn check_by_move_capture(this: &CheckLoanCtxt,
                                  closure_id: ast::NodeId,
-                                 freevar: &freevars::freevar_entry,
+                                 freevar_span: Span,
                                  move_path: &LoanPath) {
             let move_err = this.analyze_move_out_from(closure_id, move_path);
             match move_err {
                 MoveOk => {}
                 MoveWhileBorrowed(loan_path, loan_span) => {
                     this.bccx.span_err(
-                        freevar.span,
+                        freevar_span,
                         format!("cannot move `{}` into closure \
                                 because it is borrowed",
                                 this.bccx.loan_path_to_str(
@@ -841,7 +852,7 @@ fn check_loans_in_expr<'a>(this: &mut CheckLoanCtxt<'a>,
       }
       ast::ExprAssign(dest, _) |
       ast::ExprAssignOp(_, dest, _) => {
-        this.check_assignment(dest);
+        this.check_assignment_expr(dest);
       }
       ast::ExprCall(f, ref args) => {
         this.check_call(expr, Some(f), f.span, args.as_slice());
@@ -859,7 +870,7 @@ fn check_loans_in_expr<'a>(this: &mut CheckLoanCtxt<'a>,
       }
       ast::ExprInlineAsm(ref ia) => {
           for &(_, out) in ia.outputs.iter() {
-              this.check_assignment(out);
+              this.check_assignment_expr(out);
           }
       }
       _ => {}

branches/try2/src/libstd/rt/unwind.rs

@@ -387,7 +387,9 @@ fn begin_unwind_inner(msg: Box<Any:Send>,
             // just abort. In the future we may consider resuming
             // unwinding or otherwise exiting the task cleanly.
             if task.unwinder.unwinding {
-                rterrln!("task failed during unwinding. aborting.");
+                rterrln!("task failed during unwinding (double-failure - \
+                          total drag!)")
+                rterrln!("rust must abort now. so sorry.");
 
                 // Don't print the backtrace twice (it would have already been
                 // printed if logging was enabled).

branches/try2/src/test/auxiliary/anon-extern-mod-cross-crate-1.rs

@@ -12,7 +12,7 @@
 
 extern crate libc;
 
-#[link(name="rust_test_helpers")]
+#[link(name="rustrt")]
 extern {
     pub fn rust_get_test_int() -> libc::intptr_t;
 }

branches/try2/src/test/auxiliary/extern-crosscrate-source.rs

@@ -16,7 +16,7 @@ extern crate libc;
 pub mod rustrt {
     extern crate libc;
 
-    #[link(name = "rust_test_helpers")]
+    #[link(name = "rustrt")]
     extern {
         pub fn rust_dbg_call(cb: extern "C" fn(libc::uintptr_t) -> libc::uintptr_t,
                              data: libc::uintptr_t)

branches/try2/src/test/auxiliary/foreign_lib.rs

@@ -13,7 +13,7 @@
 pub mod rustrt {
     extern crate libc;
 
-    #[link(name = "rust_test_helpers")]
+    #[link(name = "rustrt")]
     extern {
         fn rust_get_test_int() -> libc::intptr_t;
     }

branches/try2/src/test/run-pass/anon-extern-mod.rs

@@ -10,7 +10,7 @@
 
 extern crate libc;
 
-#[link(name = "rust_test_helpers")]
+#[link(name = "rustrt")]
 extern {
     fn rust_get_test_int() -> libc::intptr_t;
 }

branches/try2/src/test/run-pass/c-stack-as-value.rs

@@ -11,7 +11,7 @@
 mod rustrt {
     extern crate libc;
 
-    #[link(name = "rust_test_helpers")]
+    #[link(name = "rustrt")]
     extern {
         pub fn rust_get_test_int() -> libc::intptr_t;
     }

branches/try2/src/test/run-pass/extern-call-deep.rs

@@ -13,7 +13,7 @@ extern crate libc;
 mod rustrt {
     extern crate libc;
 
-    #[link(name = "rust_test_helpers")]
+    #[link(name = "rustrt")]
     extern {
         pub fn rust_dbg_call(cb: extern "C" fn(libc::uintptr_t) -> libc::uintptr_t,
                              data: libc::uintptr_t)

branches/try2/src/test/run-pass/extern-call-deep2.rs

@@ -14,7 +14,7 @@ use std::task;
 mod rustrt {
     extern crate libc;
 
-    #[link(name = "rust_test_helpers")]
+    #[link(name = "rustrt")]
     extern {
         pub fn rust_dbg_call(cb: extern "C" fn(libc::uintptr_t) -> libc::uintptr_t,
                              data: libc::uintptr_t)

branches/try2/src/test/run-pass/extern-call-indirect.rs

@@ -13,7 +13,7 @@ extern crate libc;
 mod rustrt {
     extern crate libc;
 
-    #[link(name = "rust_test_helpers")]
+    #[link(name = "rustrt")]
     extern {
         pub fn rust_dbg_call(cb: extern "C" fn(libc::uintptr_t) -> libc::uintptr_t,
                              data: libc::uintptr_t)

branches/try2/src/test/run-pass/extern-call-scrub.rs

@@ -18,7 +18,7 @@ use std::task;
 mod rustrt {
     extern crate libc;
 
-    #[link(name = "rust_test_helpers")]
+    #[link(name = "rustrt")]
     extern {
         pub fn rust_dbg_call(cb: extern "C" fn(libc::uintptr_t) -> libc::uintptr_t,
                              data: libc::uintptr_t)

branches/try2/src/test/run-pass/extern-pass-TwoU16s.rs

@@ -16,7 +16,7 @@ struct TwoU16s {
     one: u16, two: u16
 }
 
-#[link(name = "rust_test_helpers")]
+#[link(name = "rustrt")]
 extern {
     pub fn rust_dbg_extern_identity_TwoU16s(v: TwoU16s) -> TwoU16s;
 }

branches/try2/src/test/run-pass/extern-pass-TwoU32s.rs

@@ -16,7 +16,7 @@ struct TwoU32s {
     one: u32, two: u32
 }
 
-#[link(name = "rust_test_helpers")]
+#[link(name = "rustrt")]
 extern {
     pub fn rust_dbg_extern_identity_TwoU32s(v: TwoU32s) -> TwoU32s;
 }

branches/try2/src/test/run-pass/extern-pass-TwoU64s.rs

@@ -16,7 +16,7 @@ struct TwoU64s {
     one: u64, two: u64
 }
 
-#[link(name = "rust_test_helpers")]
+#[link(name = "rustrt")]
 extern {
     pub fn rust_dbg_extern_identity_TwoU64s(v: TwoU64s) -> TwoU64s;
 }

branches/try2/src/test/run-pass/extern-pass-TwoU8s.rs

@@ -16,7 +16,7 @@ struct TwoU8s {
     one: u8, two: u8
 }
 
-#[link(name = "rust_test_helpers")]
+#[link(name = "rustrt")]
 extern {
     pub fn rust_dbg_extern_identity_TwoU8s(v: TwoU8s) -> TwoU8s;
 }