---

yaml
---
r: 44815
b: refs/heads/master
c: 2f858de
h: refs/heads/master
i:
  44813: cb52c7f
  44811: 1c14ef8
  44807: df0646b
  44799: f781b7c
v: v3

Author: brson

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: d0a12347dec3045eaf8dcded7add914d4491276f
+refs/heads/master: 2f858de1c39f3fd8bdc77a6517e12a6458c54f03
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
 refs/heads/try: ef355f6332f83371e4acf04fc4eb940ab41d78d3

trunk/src/libcore/cleanup.rs

@@ -154,7 +154,7 @@ fn debug_mem() -> bool {
 #[cfg(notest)]
 #[lang="annihilate"]
 pub unsafe fn annihilate() {
-    use rt::rt_free;
+    use rt::local_free;
     use io::WriterUtil;
     use io;
     use libc;
@@ -192,7 +192,7 @@ pub unsafe fn annihilate() {
             stats.n_bytes_freed +=
                 (*((*box).header.type_desc)).size
                 + sys::size_of::<BoxRepr>();
-            rt_free(transmute(box));
+            local_free(transmute(box));
         }
     }
 

trunk/src/libcore/rt.rs

@@ -36,60 +36,54 @@ pub extern mod rustrt {
     unsafe fn rust_upcall_free(ptr: *c_char);
 }
 
-#[rt(fail_)]
 #[lang="fail_"]
-pub fn rt_fail_(expr: *c_char, file: *c_char, line: size_t) -> ! {
+pub fn fail_(expr: *c_char, file: *c_char, line: size_t) -> ! {
     sys::begin_unwind_(expr, file, line);
 }
 
-#[rt(fail_bounds_check)]
 #[lang="fail_bounds_check"]
-pub unsafe fn rt_fail_bounds_check(file: *c_char, line: size_t,
-                                   index: size_t, len: size_t) {
+pub unsafe fn fail_bounds_check(file: *c_char, line: size_t,
+                                index: size_t, len: size_t) {
     let msg = fmt!("index out of bounds: the len is %d but the index is %d",
                     len as int, index as int);
     do str::as_buf(msg) |p, _len| {
-        rt_fail_(p as *c_char, file, line);
+        fail_(p as *c_char, file, line);
     }
 }
 
-pub unsafe fn rt_fail_borrowed() {
+pub unsafe fn fail_borrowed() {
     let msg = "borrowed";
     do str::as_buf(msg) |msg_p, _| {
         do str::as_buf("???") |file_p, _| {
-            rt_fail_(msg_p as *c_char, file_p as *c_char, 0);
+            fail_(msg_p as *c_char, file_p as *c_char, 0);
         }
     }
 }
 
 // FIXME #4942: Make these signatures agree with exchange_alloc's signatures
-#[rt(exchange_malloc)]
 #[lang="exchange_malloc"]
-pub unsafe fn rt_exchange_malloc(td: *c_char, size: uintptr_t) -> *c_char {
+pub unsafe fn exchange_malloc(td: *c_char, size: uintptr_t) -> *c_char {
     transmute(exchange_alloc::malloc(transmute(td), transmute(size)))
 }
 
 // NB: Calls to free CANNOT be allowed to fail, as throwing an exception from
 // inside a landing pad may corrupt the state of the exception handler. If a
 // problem occurs, call exit instead.
-#[rt(exchange_free)]
 #[lang="exchange_free"]
-pub unsafe fn rt_exchange_free(ptr: *c_char) {
+pub unsafe fn exchange_free(ptr: *c_char) {
     exchange_alloc::free(transmute(ptr))
 }
 
-#[rt(malloc)]
 #[lang="malloc"]
-pub unsafe fn rt_malloc(td: *c_char, size: uintptr_t) -> *c_char {
+pub unsafe fn local_malloc(td: *c_char, size: uintptr_t) -> *c_char {
     return rustrt::rust_upcall_malloc(td, size);
 }
 
 // NB: Calls to free CANNOT be allowed to fail, as throwing an exception from
 // inside a landing pad may corrupt the state of the exception handler. If a
 // problem occurs, call exit instead.
-#[rt(free)]
 #[lang="free"]
-pub unsafe fn rt_free(ptr: *c_char) {
+pub unsafe fn local_free(ptr: *c_char) {
     rustrt::rust_upcall_free(ptr);
 }
 
@@ -112,7 +106,7 @@ pub unsafe fn return_to_mut(a: *u8) {
 pub unsafe fn check_not_borrowed(a: *u8) {
     let a: *mut BoxRepr = transmute(a);
     if ((*a).header.ref_count & FROZEN_BIT) != 0 {
-        rt_fail_borrowed();
+        fail_borrowed();
     }
 }
 

trunk/src/librustc/front/test.rs

@@ -200,14 +200,14 @@ fn is_bench_fn(i: @ast::item) -> bool {
         vec::len(attr::find_attrs_by_name(i.attrs, ~"bench")) > 0u;
 
     fn has_test_signature(i: @ast::item) -> bool {
-        match i.node {
-            ast::item_fn(ref decl, _, ref generics, _) => {
+        match /*bad*/copy i.node {
+            ast::item_fn(decl, _, tps, _) => {
                 let input_cnt = vec::len(decl.inputs);
                 let no_output = match decl.output.node {
                     ast::ty_nil => true,
                     _ => false
                 };
-                let tparm_cnt = generics.ty_params.len();
+                let tparm_cnt = vec::len(tps);
                 // NB: inadequate check, but we're running
                 // well before resolve, can't get too deep.
                 input_cnt == 1u