First cut at dtors for classes

Classes with dtors should compile now. Haven't yet tested
whether they actually run correctly.

Beginnings of support for #2295, though that won't be done until
there's more test cases and resources are removed.

Author: catamorphism

src/librustsyntax/ast.rs

@@ -669,8 +669,10 @@ enum item_ {
     item_class([ty_param], /* ty params for class */
                [@iface_ref],   /* ifaces this class implements */
                [@class_member], /* methods, etc. */
-                               /* (not including ctor) */
+                               /* (not including ctor or dtor) */
                class_ctor,
+               /* dtor is optional */
+               option<class_dtor>,
                region_param
                ),
     item_iface([ty_param], region_param, [ty_method]),
@@ -699,6 +701,14 @@ type class_ctor_ = {id: node_id,
                     dec: fn_decl,
                     body: blk};
 
+#[auto_serialize]
+type class_dtor = spanned<class_dtor_>;
+
+#[auto_serialize]
+type class_dtor_ = {id: node_id,
+                    self_id: node_id,
+                    body: blk};
+
 #[auto_serialize]
 type native_item =
     {ident: ident,

src/librustsyntax/ast_util.rs

@@ -361,6 +361,12 @@ fn operator_prec(op: ast::binop) -> uint {
       or                {  1u }
   }
 }
+
+fn dtor_dec() -> fn_decl {
+    {inputs: [], output: @{id: 0, node: ty_nil, span: dummy_sp()},
+     purity: impure_fn, cf: return_val, constraints: []}
+}
+
 // Local Variables:
 // mode: rust
 // fill-column: 78;

src/librustsyntax/fold.rs

@@ -274,19 +274,24 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
                       fold_ty_params(typms, fld),
                       r)
           }
-          item_class(typms, ifaces, items, ctor, rp) {
+          item_class(typms, ifaces, items, ctor, m_dtor, rp) {
               let ctor_body = fld.fold_block(ctor.node.body);
               let ctor_decl = fold_fn_decl(ctor.node.dec, fld);
               let ctor_id   = fld.new_id(ctor.node.id);
+              let dtor = option::map(m_dtor) {|dtor|
+                let dtor_body = fld.fold_block(dtor.node.body);
+                let dtor_id   = fld.new_id(dtor.node.id);
+                {node: {body: dtor_body,
+                        id: dtor_id with dtor.node}
+                    with dtor}};
               item_class(
                   typms,
                   vec::map(ifaces, {|p| fold_iface_ref(p, fld) }),
                   vec::map(items, fld.fold_class_item),
                   {node: {body: ctor_body,
                           dec: ctor_decl,
                           id: ctor_id with ctor.node}
-                   with ctor},
-                  rp)
+                      with ctor}, dtor, rp)
           }
           item_impl(tps, rp, ifce, ty, methods) {
               item_impl(fold_ty_params(tps, fld),

src/librustsyntax/parse/parser.rs

@@ -1940,14 +1940,24 @@ fn parse_item_class(p: parser) -> item_info {
     let mut ms: [@class_member] = [];
     let ctor_id = p.get_id();
     let mut the_ctor : option<(fn_decl, blk, codemap::span)> = none;
+    let mut the_dtor : option<(blk, codemap::span)> = none;
     while p.token != token::RBRACE {
         alt parse_class_item(p, class_path) {
-            ctor_decl(a_fn_decl, blk, s) {
-               the_ctor = some((a_fn_decl, blk, s));
-            }
-            members(mms) { ms += mms; }
+          ctor_decl(a_fn_decl, blk, s) {
+            the_ctor = some((a_fn_decl, blk, s));
+          }
+          dtor_decl(blk, s) {
+            the_dtor = some((blk, s));
+          }
+          members(mms) { ms += mms; }
        }
     }
+    let actual_dtor = option::map(the_dtor) {|dtor|
+       let (d_body, d_s) = dtor;
+       {node: {id: p.get_id(),
+               self_id: p.get_id(),
+               body: d_body},
+               span: d_s}};
     p.bump();
     alt the_ctor {
       some((ct_d, ct_b, ct_s)) {
@@ -1957,7 +1967,7 @@ fn parse_item_class(p: parser) -> item_info {
                     self_id: p.get_id(),
                     dec: ct_d,
                     body: ct_b},
-             span: ct_s}, rp),
+                     span: ct_s}, actual_dtor, rp),
         none)
       }
        /*
@@ -1982,24 +1992,41 @@ fn parse_single_class_item(p: parser, vis: visibility)
    }
 }
 
-// lets us identify the constructor declaration at
-// parse time
+/*
+  So that we can distinguish a class ctor or dtor
+  from other class members
+ */
 enum class_contents { ctor_decl(fn_decl, blk, codemap::span),
+                      dtor_decl(blk, codemap::span),
                       members([@class_member]) }
 
+fn parse_ctor(p: parser, result_ty: ast::ty_) -> class_contents {
+  // Can ctors/dtors have attrs? FIXME
+  let lo = p.last_span.lo;
+  let (decl_, _) = parse_fn_decl(p, impure_fn, parse_arg);
+  let decl = {output: @{id: p.get_id(),
+                        node: result_ty, span: decl_.output.span}
+              with decl_};
+  let body = parse_block(p);
+  ctor_decl(decl, body, mk_sp(lo, p.last_span.hi))
+}
+
+fn parse_dtor(p: parser) -> class_contents {
+  // Can ctors/dtors have attrs? FIXME
+  let lo = p.last_span.lo;
+  let body = parse_block(p);
+  dtor_decl(body, mk_sp(lo, p.last_span.hi))
+}
+
 fn parse_class_item(p:parser, class_name_with_tps: @path)
     -> class_contents {
     if eat_keyword(p, "new") {
-        let lo = p.last_span.lo;
-        // Can ctors have attrs?
-            // result type is always the type of the class
-        let (decl_, _) = parse_fn_decl(p, impure_fn, parse_arg);
-        let decl = {output: @{id: p.get_id(),
-                      node: ty_path(class_name_with_tps, p.get_id()),
-                      span: decl_.output.span}
-                    with decl_};
-        let body = parse_block(p);
-        ret ctor_decl(decl, body, mk_sp(lo, p.last_span.hi));
+       // result type is always the type of the class
+       ret parse_ctor(p, ty_path(class_name_with_tps,
+                              p.get_id()));
+    }
+    else if eat_keyword(p, "drop") {
+      ret parse_dtor(p);
     }
     else if eat_keyword(p, "priv") {
             expect(p, token::LBRACE);

src/librustsyntax/parse/token.rs

@@ -261,7 +261,7 @@ fn restricted_keyword_table() -> hashmap<str, ()> {
         "assert",
         "be", "break",
         "check", "claim", "class", "const", "cont", "copy", "crust",
-        "do",
+        "do", "drop",
         "else", "enum", "export",
         "fail", "false", "fn", "for",
         "if", "iface", "impl", "import",

src/librustsyntax/print/pprust.rs

@@ -507,7 +507,7 @@ fn print_item(s: ps, &&item: @ast::item) {
             bclose(s, item.span);
         }
       }
-      ast::item_class(tps,ifaces,items,ctor, rp) {
+      ast::item_class(tps, ifaces, items, ctor, m_dtor, rp) {
           head(s, "class");
           word_nbsp(s, item.ident);
           print_region_param(s, rp);
@@ -522,6 +522,11 @@ fn print_item(s: ps, &&item: @ast::item) {
           print_fn_args_and_ret(s, ctor.node.dec, []);
           space(s.s);
           print_block(s, ctor.node.body);
+          option::iter(m_dtor) {|dtor|
+            hardbreak_if_not_bol(s);
+            head(s, "drop");
+            print_block(s, dtor.node.body);
+          }
           for items.each {|ci|
                   /*
                      FIXME: collect all private items and print them

src/librustsyntax/visit.rs

@@ -19,21 +19,25 @@ enum fn_kind {
     fk_anon(proto, capture_clause),  //< an anonymous function like fn@(...)
     fk_fn_block(capture_clause),     //< a block {||...}
     fk_ctor(ident, [ty_param], node_id /* self id */,
-            def_id /* parent class id */) // class constructor
+            def_id /* parent class id */), // class constructor
+    fk_dtor([ty_param], node_id /* self id */,
+            def_id /* parent class id */) // class destructor
+
 }
 
 fn name_of_fn(fk: fn_kind) -> ident {
     alt fk {
       fk_item_fn(name, _) | fk_method(name, _, _) | fk_res(name, _, _)
           | fk_ctor(name, _, _, _) { name }
       fk_anon(*) | fk_fn_block(*) { "anon" }
+      fk_dtor(*)                  { "drop" }
     }
 }
 
 fn tps_of_fn(fk: fn_kind) -> [ty_param] {
     alt fk {
       fk_item_fn(_, tps) | fk_method(_, tps, _) | fk_res(_, tps, _)
-          | fk_ctor(_, tps, _, _) { tps }
+          | fk_ctor(_, tps, _, _) | fk_dtor(tps, _, _) { tps }
       fk_anon(*) | fk_fn_block(*) { [] }
     }
 }
@@ -140,14 +144,17 @@ fn visit_item<E>(i: @item, e: E, v: vt<E>) {
             visit_method_helper(m, e, v)
         }
       }
-      item_class(tps, ifaces, members, ctor, _) {
+      item_class(tps, ifaces, members, ctor, m_dtor, _) {
           v.visit_ty_params(tps, e, v);
           for members.each {|m|
              v.visit_class_item(m, e, v);
           }
           for ifaces.each {|p| visit_path(p.path, e, v); }
           visit_class_ctor_helper(ctor, i.ident, tps,
                                   ast_util::local_def(i.id), e, v);
+          option::iter(m_dtor) {|dtor|
+                  visit_class_dtor_helper(dtor, tps,
+                     ast_util::local_def(i.id), e, v)};
       }
       item_iface(tps, _rp, methods) {
         v.visit_ty_params(tps, e, v);
@@ -280,12 +287,20 @@ fn visit_method_helper<E>(m: @method, e: E, v: vt<E>) {
 // Similar logic to the comment on visit_method_helper - Tim
 fn visit_class_ctor_helper<E>(ctor: class_ctor, nm: ident, tps: [ty_param],
                               parent_id: def_id, e: E, v: vt<E>) {
-    v.visit_fn(visit::fk_ctor(nm, tps, ctor.node.self_id,
+    v.visit_fn(fk_ctor(nm, tps, ctor.node.self_id,
                               parent_id), ctor.node.dec,
                ctor.node.body, ctor.span, ctor.node.id, e, v)
 
 }
 
+fn visit_class_dtor_helper<E>(dtor: class_dtor, tps: [ty_param],
+                              parent_id: def_id, e: E, v: vt<E>) {
+    v.visit_fn(fk_dtor(tps, dtor.node.self_id,
+                       parent_id), ast_util::dtor_dec(),
+               dtor.node.body, dtor.span, dtor.node.id, e, v)
+
+}
+
 fn visit_fn<E>(fk: fn_kind, decl: fn_decl, body: blk, _sp: span,
                _id: node_id, e: E, v: vt<E>) {
     visit_fn_decl(decl, e, v);

src/rustc/metadata/astencode.rs

@@ -214,6 +214,13 @@ fn visit_ids(item: ast::inlined_item, vfn: fn@(ast::node_id)) {
                 vfn(self_id);
                 vfn(parent_id.node);
               }
+              // not sure if this should be here? FIXME
+              visit::fk_dtor(tps, self_id, parent_id) {
+                vec::iter(tps) {|tp| vfn(tp.id)}
+                vfn(id);
+                vfn(self_id);
+                vfn(parent_id.node);
+              }
               visit::fk_item_fn(_, tps) |
               visit::fk_res(_, tps, _) {
                 vec::iter(tps) {|tp| vfn(tp.id)}

src/rustc/metadata/encoder.rs

@@ -187,7 +187,8 @@ fn encode_module_item_paths(ebml_w: ebml::writer, ecx: @encode_ctxt,
             encode_def_id(ebml_w, local_def(it.id));
             ebml_w.end_tag();
           }
-          item_class(_, _, items, ctor, _) {
+          // FIXME: I don't *think* dtor needs to be serialized?
+          item_class(_, _, items, ctor, _dtor, _) {
             add_to_index(ebml_w, path, index, it.ident);
             ebml_w.start_tag(tag_paths_data_item);
             encode_name(ebml_w, it.ident);
@@ -621,7 +622,8 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         encode_enum_variant_info(ecx, ebml_w, item.id, variants,
                                  path, index, tps);
       }
-      item_class(tps, ifaces, items, ctor, rp) {
+      // FIXME: not sure if the dtor should be serialized
+      item_class(tps, ifaces, items, ctor, _dtor, rp) {
         /* First, encode the fields and methods
            These come first because we need to write them to make
            the index, and the index needs to be in the item for the
@@ -801,7 +803,8 @@ fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::writer,
                 encode_info_for_item(ecx, ebml_w, i, index, *pt);
                 /* encode ctor, then encode items */
                 alt i.node {
-                  item_class(tps, _, _, ctor, _) {
+                   // FIXME: not doing anything with dtor
+                   item_class(tps, _, _, ctor, _, _) {
                    /* this is assuming that ctors aren't inlined...
                       probably shouldn't assume that */
                    #debug("encoding info for ctor %s %d", i.ident,

src/rustc/middle/ast_map.rs

@@ -47,6 +47,8 @@ enum ast_node {
     node_local(uint),
     // Constructor for either a resource or a class
     node_ctor(ident, [ty_param], a_ctor, @path),
+    // Destructor for a class
+    node_dtor([ty_param], @class_dtor, def_id, @path),
     node_block(blk),
 }
 
@@ -134,6 +136,12 @@ fn map_fn(fk: visit::fn_kind, decl: fn_decl, body: blk,
           cx.map.insert(id, node_ctor(nm, tps, class_ctor(ct, parent_id),
                                       @cx.path));
        }
+      visit::fk_dtor(tps, self_id, parent_id) {
+          let dt = @{node: {id: id, self_id: self_id, body: body},
+                    span: sp};
+          cx.map.insert(id, node_dtor(tps, dt, parent_id, @cx.path));
+       }
+
        _ {}
     }
     visit::visit_fn(fk, decl, body, sp, id, cx, v);
@@ -204,7 +212,7 @@ fn map_item(i: @item, cx: ctx, v: vt) {
             cx.map.insert(nitem.id, node_native_item(nitem, abi, @cx.path));
         }
       }
-      item_class(tps, ifces, items, ctor, _) {
+      item_class(tps, ifces, items, ctor, dtor, _) {
           let (_, ms) = ast_util::split_class_items(items);
           // Map iface refs to their parent classes. This is
           // so we can find the self_ty
@@ -283,9 +291,12 @@ fn node_id_to_str(map: map, id: node_id) -> str {
       some(node_local(_)) { // FIXME: add more info here
         #fmt["local (id=%?)", id]
       }
-      some(node_ctor(_, _, _, _)) { // FIXME: add more info here
+      some(node_ctor(*)) { // FIXME: add more info here
         #fmt["node_ctor (id=%?)", id]
       }
+      some(node_dtor(*)) { // FIXME: add more info here
+        #fmt["node_dtor (id=%?)", id]
+      }
       some(node_block(_)) {
         #fmt["block"]
       }

src/rustc/middle/kind.rs

@@ -133,7 +133,7 @@ fn check_fn(fk: visit::fn_kind, decl: fn_decl, body: blk, sp: span,
         let cap_clause = alt fk {
           visit::fk_anon(_, cc) | visit::fk_fn_block(cc) { cc }
           visit::fk_item_fn(*) | visit::fk_method(*) |
-          visit::fk_res(*) | visit::fk_ctor(*) { @[] }
+          visit::fk_res(*) | visit::fk_ctor(*) | visit::fk_dtor(*) { @[] }
         };
         let captured_vars = (*cap_clause).map { |cap_item|
             let cap_def = cx.tcx.def_map.get(cap_item.id);

src/rustc/middle/region.rs

@@ -375,7 +375,7 @@ fn resolve_fn(fk: visit::fn_kind, decl: ast::fn_decl, body: ast::blk,
 
     let fn_cx = alt fk {
       visit::fk_item_fn(*) | visit::fk_method(*) | visit::fk_res(*) |
-      visit::fk_ctor(*) {
+      visit::fk_ctor(*) | visit::fk_dtor(*) {
         // Top-level functions are a root scope.
         {parent: some(id), closure_parent: some(id) with cx}
       }