---

yaml
---
r: 138590
b: refs/heads/try2
c: 2f858de
h: refs/heads/master
v: v3

Author: brson

[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: c705440ee3f98a01c0e840202f320ed7998221d6
+refs/heads/try2: 2f858de1c39f3fd8bdc77a6517e12a6458c54f03
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/rust.md

@@ -297,7 +297,7 @@ the following forms:
 num_lit : nonzero_dec [ dec_digit | '_' ] * num_suffix ?
         | '0' [       [ dec_digit | '_' ] + num_suffix ?
               | 'b'   [ '1' | '0' | '_' ] + int_suffix ?
-              | 'x'   [ hex_digit | '_' ] + int_suffix ? ] ;
+              | 'x'   [ hex_digit | '-' ] + int_suffix ? ] ;
 
 num_suffix : int_suffix | float_suffix ;
 

branches/try2/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));
         }
     }
 

branches/try2/src/libcore/io.rs

@@ -474,10 +474,7 @@ impl<R:Reader,C> Reader for Wrapper<R, C> {
 
 pub struct FILERes {
     f: *libc::FILE,
-}
-
-impl Drop for FILERes {
-    fn finalize(&self) {
+    drop {
         unsafe {
             libc::fclose(self.f);
         }
@@ -686,10 +683,7 @@ impl Writer for fd_t {
 
 pub struct FdRes {
     fd: fd_t,
-}
-
-impl Drop for FdRes {
-    fn finalize(&self) {
+    drop {
         unsafe {
             libc::close(self.fd);
         }

branches/try2/src/libcore/option.rs

@@ -450,10 +450,7 @@ fn test_unwrap_str() {
 fn test_unwrap_resource() {
     struct R {
        i: @mut int,
-    }
-
-    impl ::ops::Drop for R {
-       fn finalize(&self) { *(self.i) += 1; }
+       drop { *(self.i) += 1; }
     }
 
     fn R(i: @mut int) -> R {

branches/try2/src/libcore/pipes.rs

@@ -346,10 +346,7 @@ pub unsafe fn get_buffer<T>(p: *PacketHeader) -> ~Buffer<T> {
 struct BufferResource<T> {
     buffer: ~Buffer<T>,
 
-}
-
-impl<T> ::ops::Drop for BufferResource<T> {
-    fn finalize(&self) {
+    drop {
         unsafe {
             let b = move_it!(self.buffer);
             //let p = ptr::addr_of(*b);

branches/try2/src/libcore/private.rs

@@ -126,10 +126,7 @@ struct ArcData<T> {
 
 struct ArcDestruct<T> {
     mut data: *libc::c_void,
-}
-
-impl<T> Drop for ArcDestruct<T>{
-    fn finalize(&self) {
+    drop {
         unsafe {
             if self.data.is_null() {
                 return; // Happens when destructing an unwrapper's handle.
@@ -181,10 +178,7 @@ pub unsafe fn unwrap_shared_mutable_state<T:Owned>(rc: SharedMutableState<T>)
     struct DeathThroes<T> {
         mut ptr:      Option<~ArcData<T>>,
         mut response: Option<comm::ChanOne<bool>>,
-    }
-
-    impl<T> Drop for DeathThroes<T>{
-        fn finalize(&self) {
+        drop {
             unsafe {
                 let response = option::swap_unwrap(&mut self.response);
                 // In case we get killed early, we need to tell the person who
@@ -317,10 +311,7 @@ type rust_little_lock = *libc::c_void;
 
 struct LittleLock {
     l: rust_little_lock,
-}
-
-impl Drop for LittleLock {
-    fn finalize(&self) {
+    drop {
         unsafe {
             rustrt::rust_destroy_little_lock(self.l);
         }

branches/try2/src/libcore/rand.rs

@@ -365,10 +365,7 @@ impl Rng {
 
 struct RandRes {
     rng: *rust_rng,
-}
-
-impl Drop for RandRes {
-    fn finalize(&self) {
+    drop {
         unsafe {
             rustrt::rand_free(self.rng);
         }

branches/try2/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();
     }
 }
 

branches/try2/src/libcore/run.rs

@@ -248,10 +248,7 @@ pub fn start_program(prog: &str, args: &[~str]) -> Program {
     }
     struct ProgRes {
         r: ProgRepr,
-    }
-
-    impl Drop for ProgRes {
-        fn finalize(&self) {
+        drop {
             unsafe {
                 // FIXME #4943: This is bad.
                 destroy_repr(cast::transmute(&self.r));

branches/try2/src/libcore/task/spawn.rs

@@ -308,11 +308,8 @@ struct TCB {
     mut ancestors: AncestorList,
     is_main:       bool,
     notifier:      Option<AutoNotify>,
-}
-
-impl Drop for TCB {
     // Runs on task exit.
-    fn finalize(&self) {
+    drop {
         unsafe {
             // If we are failing, the whole taskgroup needs to die.
             if rt::rust_task_is_unwinding(self.me) {
@@ -356,10 +353,7 @@ fn TCB(me: *rust_task, tasks: TaskGroupArc, ancestors: AncestorList,
 struct AutoNotify {
     notify_chan: Chan<TaskResult>,
     mut failed:  bool,
-}
-
-impl Drop for AutoNotify {
-    fn finalize(&self) {
+    drop {
         let result = if self.failed { Failure } else { Success };
         self.notify_chan.send(result);
     }

branches/try2/src/libcore/to_str.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -137,6 +137,15 @@ impl<A:ToStr> ToStr for @[A] {
     }
 }
 
+impl<A:ToStr> ToStr for @A {
+    #[inline(always)]
+    pure fn to_str(&self) -> ~str { ~"@" + (**self).to_str() }
+}
+impl<A:ToStr> ToStr for ~A {
+    #[inline(always)]
+    pure fn to_str(&self) -> ~str { ~"~" + (**self).to_str() }
+}
+
 #[cfg(test)]
 #[allow(non_implicitly_copyable_typarams)]
 mod tests {
@@ -161,12 +170,19 @@ mod tests {
     }
 
     #[test]
+    #[ignore]
     fn test_vectors() {
         let x: ~[int] = ~[];
-        assert x.to_str() == ~"[]";
-        assert (~[1]).to_str() == ~"[1]";
-        assert (~[1, 2, 3]).to_str() == ~"[1, 2, 3]";
+        assert x.to_str() == ~"~[]";
+        assert (~[1]).to_str() == ~"~[1]";
+        assert (~[1, 2, 3]).to_str() == ~"~[1, 2, 3]";
         assert (~[~[], ~[1], ~[1, 1]]).to_str() ==
-               ~"[[], [1], [1, 1]]";
+               ~"~[~[], ~[1], ~[1, 1]]";
+    }
+
+    #[test]
+    fn test_pointer_types() {
+        assert (@1).to_str() == ~"@1";
+        assert (~(true, false)).to_str() == ~"~(true, false)";
     }
 }

branches/try2/src/libcore/util.rs

@@ -66,10 +66,7 @@ pub fn replace<T>(dest: &mut T, src: T) -> T {
 /// A non-copyable dummy type.
 pub struct NonCopyable {
     i: (),
-}
-
-impl Drop for NonCopyable {
-    fn finalize(&self) { }
+    drop { }
 }
 
 pub fn NonCopyable() -> NonCopyable { NonCopyable { i: () } }

branches/try2/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

branches/try2/src/librustc/lib/llvm.rs

@@ -1458,10 +1458,7 @@ pub fn struct_tys(struct_ty: TypeRef) -> ~[TypeRef] {
 
 pub struct target_data_res {
     TD: TargetDataRef,
-}
-
-impl Drop for target_data_res {
-    fn finalize(&self) {
+    drop {
         unsafe {
             llvm::LLVMDisposeTargetData(self.TD);
         }
@@ -1495,10 +1492,7 @@ pub fn mk_target_data(string_rep: ~str) -> TargetData {
 
 pub struct pass_manager_res {
     PM: PassManagerRef,
-}
-
-impl Drop for pass_manager_res {
-    fn finalize(&self) {
+    drop {
         unsafe {
             llvm::LLVMDisposePassManager(self.PM);
         }
@@ -1531,10 +1525,7 @@ pub fn mk_pass_manager() -> PassManager {
 
 pub struct object_file_res {
     ObjectFile: ObjectFileRef,
-}
-
-impl Drop for object_file_res {
-    fn finalize(&self) {
+    drop {
         unsafe {
             llvm::LLVMDisposeObjectFile(self.ObjectFile);
         }
@@ -1568,10 +1559,7 @@ pub fn mk_object_file(llmb: MemoryBufferRef) -> Option<ObjectFile> {
 
 pub struct section_iter_res {
     SI: SectionIteratorRef,
-}
-
-impl Drop for section_iter_res {
-    fn finalize(&self) {
+    drop {
         unsafe {
             llvm::LLVMDisposeSectionIterator(self.SI);
         }