---

yaml
---
r: 50111
b: refs/heads/auto
c: 557b8cc
h: refs/heads/master
i:
  50109: bf95ed8
  50107: 1c2c49b
  50103: 68f7cd3
  50095: b73c257
  50079: f532cfe
  50047: 2213e19
v: v3

Author: erickt

[refs]

@@ -14,5 +14,5 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: d52408d46a0d7f7ba0004a829207fef6870fa88c
+refs/heads/auto: 557b8cce8e5dc12b868ae32f8969464cd38105ae
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167

branches/auto/src/libcore/condition.rs

@@ -84,7 +84,6 @@ struct Guard<T, U> {
     cond: &'self Condition/&self<T, U>
 }
 
-#[unsafe_destructor]
 impl<T, U> Drop for Guard/&self<T, U> {
     fn finalize(&self) {
         unsafe {

branches/auto/src/libcore/io.rs

@@ -1230,17 +1230,15 @@ pub mod fsync {
         arg: Arg<t>,
     }
 
-    #[unsafe_destructor]
     impl<T:Copy> Drop for Res<T> {
         fn finalize(&self) {
-            match self.arg.opt_level {
-                None => (),
-                Some(level) => {
-                  // fail hard if not succesful
-                  fail_unless!(((self.arg.fsync_fn)(self.arg.val, level)
-                    != -1));
-                }
+          match self.arg.opt_level {
+            None => (),
+            Some(level) => {
+              // fail hard if not succesful
+              fail_unless!(((self.arg.fsync_fn)(self.arg.val, level) != -1));
             }
+          }
         }
     }
 

branches/auto/src/libcore/managed.rs

@@ -49,43 +49,23 @@ pub pure fn mut_ptr_eq<T>(a: @mut T, b: @mut T) -> bool {
 }
 
 #[cfg(notest)]
-impl<T:Eq> Eq for @T {
+impl<T:Eq> Eq for @const T {
     #[inline(always)]
-    pure fn eq(&self, other: &@T) -> bool { *(*self) == *(*other) }
+    pure fn eq(&self, other: &@const T) -> bool { *(*self) == *(*other) }
     #[inline(always)]
-    pure fn ne(&self, other: &@T) -> bool { *(*self) != *(*other) }
+    pure fn ne(&self, other: &@const T) -> bool { *(*self) != *(*other) }
 }
 
 #[cfg(notest)]
-impl<T:Eq> Eq for @mut T {
+impl<T:Ord> Ord for @const T {
     #[inline(always)]
-    pure fn eq(&self, other: &@mut T) -> bool { *(*self) == *(*other) }
+    pure fn lt(&self, other: &@const T) -> bool { *(*self) < *(*other) }
     #[inline(always)]
-    pure fn ne(&self, other: &@mut T) -> bool { *(*self) != *(*other) }
-}
-
-#[cfg(notest)]
-impl<T:Ord> Ord for @T {
-    #[inline(always)]
-    pure fn lt(&self, other: &@T) -> bool { *(*self) < *(*other) }
-    #[inline(always)]
-    pure fn le(&self, other: &@T) -> bool { *(*self) <= *(*other) }
-    #[inline(always)]
-    pure fn ge(&self, other: &@T) -> bool { *(*self) >= *(*other) }
-    #[inline(always)]
-    pure fn gt(&self, other: &@T) -> bool { *(*self) > *(*other) }
-}
-
-#[cfg(notest)]
-impl<T:Ord> Ord for @mut T {
-    #[inline(always)]
-    pure fn lt(&self, other: &@mut T) -> bool { *(*self) < *(*other) }
-    #[inline(always)]
-    pure fn le(&self, other: &@mut T) -> bool { *(*self) <= *(*other) }
+    pure fn le(&self, other: &@const T) -> bool { *(*self) <= *(*other) }
     #[inline(always)]
-    pure fn ge(&self, other: &@mut T) -> bool { *(*self) >= *(*other) }
+    pure fn ge(&self, other: &@const T) -> bool { *(*self) >= *(*other) }
     #[inline(always)]
-    pure fn gt(&self, other: &@mut T) -> bool { *(*self) > *(*other) }
+    pure fn gt(&self, other: &@const T) -> bool { *(*self) > *(*other) }
 }
 
 #[test]

branches/auto/src/libcore/option.rs

@@ -514,7 +514,6 @@ fn test_unwrap_resource() {
        i: @mut int,
     }
 
-    #[unsafe_destructor]
     impl ::ops::Drop for R {
        fn finalize(&self) { *(self.i) += 1; }
     }

branches/auto/src/libcore/pipes.rs

@@ -350,7 +350,6 @@ struct BufferResource<T> {
 
 }
 
-#[unsafe_destructor]
 impl<T> ::ops::Drop for BufferResource<T> {
     fn finalize(&self) {
         unsafe {
@@ -446,17 +445,16 @@ pub fn try_recv<T:Owned,Tbuffer:Owned>(p: RecvPacketBuffered<T, Tbuffer>)
     let p_ = p.unwrap();
     let p = unsafe { &*p_ };
 
-    #[unsafe_destructor]
     struct DropState {
         p: &'self PacketHeader,
 
         drop {
-            unsafe {
-                if task::failing() {
-                    self.p.state = Terminated;
-                    let old_task = swap_task(&mut self.p.blocked_task,
-                                             ptr::null());
-                    if !old_task.is_null() {
+            if task::failing() {
+                self.p.state = Terminated;
+                let old_task = swap_task(&mut self.p.blocked_task,
+                                         ptr::null());
+                if !old_task.is_null() {
+                    unsafe {
                         rustrt::rust_task_deref(old_task);
                     }
                 }
@@ -775,7 +773,6 @@ pub struct SendPacketBuffered<T, Tbuffer> {
     mut buffer: Option<BufferResource<Tbuffer>>,
 }
 
-#[unsafe_destructor]
 impl<T:Owned,Tbuffer:Owned> ::ops::Drop for SendPacketBuffered<T,Tbuffer> {
     fn finalize(&self) {
         //if self.p != none {
@@ -845,7 +842,6 @@ pub struct RecvPacketBuffered<T, Tbuffer> {
     mut buffer: Option<BufferResource<Tbuffer>>,
 }
 
-#[unsafe_destructor]
 impl<T:Owned,Tbuffer:Owned> ::ops::Drop for RecvPacketBuffered<T,Tbuffer> {
     fn finalize(&self) {
         //if self.p != none {

branches/auto/src/libcore/str.rs

@@ -599,7 +599,7 @@ pub pure fn split_str_nonempty(s: &'a str, sep: &'b str) -> ~[~str] {
 pub fn levdistance(s: &str, t: &str) -> uint {
 
     let slen = s.len();
-    let tlen = s.len();
+    let tlen = t.len();
 
     if slen == 0 { return tlen; }
     if tlen == 0 { return slen; }
@@ -611,7 +611,7 @@ pub fn levdistance(s: &str, t: &str) -> uint {
         let mut current = i;
         dcol[0] = current + 1;
 
-        for s.each_chari |j, tc| {
+        for t.each_chari |j, tc| {
 
             let mut next = dcol[j + 1];
 

branches/auto/src/libcore/unstable.rs

@@ -118,7 +118,6 @@ struct ArcDestruct<T> {
     mut data: *libc::c_void,
 }
 
-#[unsafe_destructor]
 impl<T> Drop for ArcDestruct<T>{
     fn finalize(&self) {
         unsafe {

branches/auto/src/libcore/unstable/finally.rs

@@ -45,7 +45,6 @@ struct Finallyalizer {
     dtor: &'self fn()
 }
 
-#[unsafe_destructor]
 impl Drop for Finallyalizer/&self {
     fn finalize(&self) {
         (self.dtor)();

branches/auto/src/librustc/middle/kind.rs

@@ -22,7 +22,6 @@ use core::str;
 use core::vec;
 use std::oldmap::HashMap;
 use syntax::ast::*;
-use syntax::attr::attrs_contains_name;
 use syntax::codemap::{span, spanned};
 use syntax::print::pprust::expr_to_str;
 use syntax::{visit, ast_util};
@@ -56,8 +55,6 @@ use syntax::{visit, ast_util};
 // primitives in the stdlib are explicitly annotated to only take sendable
 // types.
 
-use core::hashmap::linear::LinearSet;
-
 pub const try_adding: &'static str = "Try adding a move";
 
 pub type rval_map = HashMap<node_id, ()>;
@@ -66,7 +63,7 @@ pub struct Context {
     tcx: ty::ctxt,
     method_map: typeck::method_map,
     last_use_map: liveness::last_use_map,
-    current_item: node_id,
+    current_item: node_id
 }
 
 pub fn check_crate(tcx: ty::ctxt,
@@ -77,15 +74,16 @@ pub fn check_crate(tcx: ty::ctxt,
         tcx: tcx,
         method_map: method_map,
         last_use_map: last_use_map,
-        current_item: -1,
+        current_item: -1
     };
     let visit = visit::mk_vt(@visit::Visitor {
         visit_arm: check_arm,
         visit_expr: check_expr,
         visit_fn: check_fn,
         visit_ty: check_ty,
-        visit_item: check_item,
-        visit_block: check_block,
+        visit_item: |i, cx, v| {
+            visit::visit_item(i, Context { current_item: i.id,.. cx }, v);
+        },
         .. *visit::default_visitor()
     });
     visit::visit_crate(*crate, ctx, visit);
@@ -94,93 +92,6 @@ pub fn check_crate(tcx: ty::ctxt,
 
 type check_fn = @fn(Context, @freevar_entry);
 
-fn check_struct_safe_for_destructor(cx: Context,
-                                    span: span,
-                                    struct_did: def_id) {
-    let struct_tpt = ty::lookup_item_type(cx.tcx, struct_did);
-    if struct_tpt.bounds.len() == 0 {
-        let struct_ty = ty::mk_struct(cx.tcx, struct_did, ty::substs {
-            self_r: None,
-            self_ty: None,
-            tps: ~[]
-        });
-        if !ty::type_is_owned(cx.tcx, struct_ty) {
-            cx.tcx.sess.span_err(span,
-                                 ~"cannot implement a destructor on a struct \
-                                   that is not Owned");
-            cx.tcx.sess.span_note(span,
-                                  ~"use \"#[unsafe_destructor]\" on the \
-                                    implementation to force the compiler to \
-                                    allow this");
-        }
-    } else {
-        cx.tcx.sess.span_err(span,
-                             ~"cannot implement a destructor on a struct \
-                               with type parameters");
-        cx.tcx.sess.span_note(span,
-                              ~"use \"#[unsafe_destructor]\" on the \
-                                implementation to force the compiler to \
-                                allow this");
-    }
-}
-
-fn check_block(block: &blk, cx: Context, visitor: visit::vt<Context>) {
-    visit::visit_block(block, cx, visitor);
-}
-
-fn check_item(item: @item, cx: Context, visitor: visit::vt<Context>) {
-    // If this is a destructor, check kinds.
-    if !attrs_contains_name(item.attrs, "unsafe_destructor") {
-        match item.node {
-            item_impl(_, Some(trait_ref), self_type, _) => {
-                match cx.tcx.def_map.find(&trait_ref.ref_id) {
-                    None => cx.tcx.sess.bug(~"trait ref not in def map!"),
-                    Some(trait_def) => {
-                        let trait_def_id = ast_util::def_id_of_def(trait_def);
-                        if cx.tcx.lang_items.drop_trait() == trait_def_id {
-                            // Yes, it's a destructor.
-                            match self_type.node {
-                                ty_path(_, path_node_id) => {
-                                    let struct_def = cx.tcx.def_map.get(
-                                        &path_node_id);
-                                    let struct_did =
-                                        ast_util::def_id_of_def(struct_def);
-                                    check_struct_safe_for_destructor(
-                                        cx,
-                                        self_type.span,
-                                        struct_did);
-                                }
-                                _ => {
-                                    cx.tcx.sess.span_bug(self_type.span,
-                                                         ~"the self type for \
-                                                           the Drop trait \
-                                                           impl is not a \
-                                                           path");
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            item_struct(struct_def, _) => {
-                match struct_def.dtor {
-                    None => {}
-                    Some(ref dtor) => {
-                        let struct_did = def_id { crate: 0, node: item.id };
-                        check_struct_safe_for_destructor(cx,
-                                                         dtor.span,
-                                                         struct_did);
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
-
-    let cx = Context { current_item: item.id, ..cx };
-    visit::visit_item(item, cx, visitor);
-}
-
 // Yields the appropriate function to check the kind of closed over
 // variables. `id` is the node_id for some expression that creates the
 // closure.

branches/auto/src/librustc/middle/trans/base.rs

@@ -88,14 +88,11 @@ pub struct icx_popper {
     ccx: @CrateContext,
 }
 
-#[unsafe_destructor]
 impl Drop for icx_popper {
     fn finalize(&self) {
-        unsafe {
-            if self.ccx.sess.count_llvm_insns() {
-                self.ccx.stats.llvm_insn_ctxt.pop();
-            }
-        }
+      if self.ccx.sess.count_llvm_insns() {
+          self.ccx.stats.llvm_insn_ctxt.pop();
+      }
     }
 }
 

branches/auto/src/libstd/arena.rs

@@ -88,7 +88,6 @@ pub struct Arena {
     priv mut chunks: @List<Chunk>,
 }
 
-#[unsafe_destructor]
 impl Drop for Arena {
     fn finalize(&self) {
         unsafe {

branches/auto/src/libstd/c_vec.rs

@@ -54,14 +54,11 @@ struct DtorRes {
   dtor: Option<@fn()>,
 }
 
-#[unsafe_destructor]
 impl Drop for DtorRes {
     fn finalize(&self) {
-        unsafe {
-            match self.dtor {
-                option::None => (),
-                option::Some(f) => f()
-            }
+        match self.dtor {
+          option::None => (),
+          option::Some(f) => f()
         }
     }
 }

branches/auto/src/libstd/future.rs

@@ -35,7 +35,6 @@ pub struct Future<A> {
 
 // FIXME(#2829) -- futures should not be copyable, because they close
 // over ~fn's that have pipes and so forth within!
-#[unsafe_destructor]
 impl<A> Drop for Future<A> {
     fn finalize(&self) {}
 }

branches/auto/src/libstd/net_tcp.rs

@@ -55,7 +55,6 @@ pub struct TcpSocket {
   socket_data: @TcpSocketData,
 }
 
-#[unsafe_destructor]
 impl Drop for TcpSocket {
     fn finalize(&self) {
         unsafe {

branches/auto/src/libstd/sort.rs

@@ -1190,7 +1190,6 @@ mod big_tests {
         key: &'self fn(@uint),
     }
 
-    #[unsafe_destructor]
     impl Drop for LVal/&self {
         fn finalize(&self) {
             let x = unsafe { task::local_data::local_data_get(self.key) };