From 487cbf8e906f73589df9501004abeb570b24f121 Mon Sep 17 00:00:00 2001 From: Tim Chevalier Date: Sun, 24 Jun 2012 15:09:57 -0700 Subject: [PATCH] Remove resources Also fixed shapes for classes with dtors, as well as handling offsets for classes with dtors correctly in take glue. Closes #2485 --- src/libsyntax/ast.rs | 3 - src/libsyntax/ast_map.rs | 21 +- src/libsyntax/ast_util.rs | 4 +- src/libsyntax/fold.rs | 8 - src/libsyntax/parse/parser.rs | 25 --- src/libsyntax/parse/token.rs | 3 +- src/libsyntax/print/pprust.rs | 49 ----- src/libsyntax/visit.rs | 11 +- src/rt/rust_box_annihilator.cpp | 7 +- src/rt/rust_cc.cpp | 6 +- src/rt/rust_shape.cpp | 8 +- src/rt/rust_shape.h | 5 +- src/rustc/metadata/encoder.rs | 39 ---- src/rustc/metadata/tydecode.rs | 8 - src/rustc/metadata/tyencode.rs | 8 - src/rustc/middle/borrowck.rs | 5 +- src/rustc/middle/borrowck/categorization.rs | 4 - src/rustc/middle/borrowck/check_loans.rs | 2 +- src/rustc/middle/borrowck/loan.rs | 3 +- src/rustc/middle/borrowck/preserve.rs | 3 +- src/rustc/middle/kind.rs | 6 +- src/rustc/middle/region.rs | 2 +- src/rustc/middle/resolve.rs | 20 +- src/rustc/middle/trans/base.rs | 202 +++--------------- src/rustc/middle/trans/debuginfo.rs | 15 +- src/rustc/middle/trans/reachable.rs | 12 +- src/rustc/middle/trans/reflect.rs | 1 - src/rustc/middle/trans/shape.rs | 32 +-- src/rustc/middle/trans/type_of.rs | 4 - src/rustc/middle/trans/type_use.rs | 4 +- .../middle/tstate/pre_post_conditions.rs | 8 - src/rustc/middle/ty.rs | 67 +----- src/rustc/middle/typeck/check.rs | 4 - src/rustc/middle/typeck/collect.rs | 65 ++---- src/rustc/middle/typeck/infer.rs | 10 - src/rustc/util/ppaux.rs | 4 +- src/rustdoc/demo.rs | 6 +- src/rustdoc/doc.rs | 22 -- src/rustdoc/extract.rs | 19 -- src/rustdoc/fold.rs | 21 -- src/rustdoc/markdown_pass.rs | 9 - src/rustdoc/prune_unexported_pass.rs | 13 -- src/rustdoc/reexport_pass.rs | 6 - src/rustdoc/sort_item_type_pass.rs | 3 - src/rustdoc/text_pass.rs | 12 -- src/rustdoc/tystr_pass.rs | 28 --- src/test/compile-fail/regions-in-rsrcs.rs | 8 +- src/test/run-pass/resource-cycle.rs | 40 +++- src/test/run-pass/resource-cycle2.rs | 8 +- 49 files changed, 145 insertions(+), 728 deletions(-) diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 9d3dcb0f23e3..fd7c3aa9e71d 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -670,9 +670,6 @@ enum item_ { item_native_mod(native_mod), item_ty(@ty, [ty_param], region_param), item_enum([variant], [ty_param], region_param), - item_res(fn_decl /* dtor */, [ty_param], blk /* dtor body */, - node_id /* dtor id */, node_id /* ctor id */, - region_param), item_class([ty_param], /* ty params for class */ [@iface_ref], /* ifaces this class implements */ [@class_member], /* methods, etc. */ diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs index 9355da5779e1..219769dd28cf 100644 --- a/src/libsyntax/ast_map.rs +++ b/src/libsyntax/ast_map.rs @@ -43,18 +43,14 @@ enum ast_node { // order they are introduced. node_arg(arg, uint), node_local(uint), - // Constructor for either a resource or a class - node_ctor(ident, [ty_param], a_ctor, @path), + // Constructor for a class + // def_id is parent id + node_ctor(ident, [ty_param], @class_ctor, def_id, @path), // Destructor for a class node_dtor([ty_param], @class_dtor, def_id, @path), node_block(blk), } -enum a_ctor { - res_ctor(fn_decl, node_id, codemap::span), - class_ctor(@class_ctor, def_id /* ID for parent class */), -} - type map = std::map::hashmap; type ctx = {map: map, mut path: path, mut local_id: uint, diag: span_handler}; @@ -138,7 +134,7 @@ fn map_fn(fk: visit::fn_kind, decl: fn_decl, body: blk, span: sp}; cx.map.insert(id, node_ctor(/* FIXME (#2543) */ copy nm, /* FIXME (#2543) */ copy tps, - class_ctor(ct, parent_id), + ct, parent_id, @/* FIXME (#2543) */ copy cx.path)); } visit::fk_dtor(tps, self_id, parent_id) { @@ -199,15 +195,6 @@ fn map_item(i: @item, cx: ctx, v: vt) { cx); } } - item_res(decl, tps, _, dtor_id, ctor_id, _) { - cx.map.insert(ctor_id, node_ctor(/* FIXME (#2543) */ copy i.ident, - /* FIXME (#2543) */ copy tps, - res_ctor(/* FIXME (#2543) */ - copy decl, - ctor_id, i.span), - item_path)); - cx.map.insert(dtor_id, node_item(i, item_path)); - } item_enum(vs, _, _) { for vs.each {|v| cx.map.insert(v.node.id, node_variant( diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index 8ce34a06329e..f402e1f6ab59 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -425,7 +425,6 @@ fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> { visit_item: fn@(i: @item) { vfn(i.id); alt i.node { - item_res(_, _, _, d_id, c_id, _) { vfn(d_id); vfn(c_id); } item_enum(vs, _, _) { for vs.each {|v| vfn(v.node.id); } } _ {} } @@ -497,8 +496,7 @@ fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> { vfn(self_id); vfn(parent_id.node); } - visit::fk_item_fn(_, tps) | - visit::fk_res(_, tps, _) { + visit::fk_item_fn(_, tps) { vec::iter(tps) {|tp| vfn(tp.id)} } visit::fk_method(_, tps, m) { diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index ff296eb5aad3..492210a55b84 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -281,14 +281,6 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ { rp, /* FIXME (#2543) */ copy methods) } - item_res(decl, typms, body, did, cid, rp) { - item_res(fold_fn_decl(decl, fld), - fold_ty_params(typms, fld), - fld.fold_block(body), - fld.new_id(did), - fld.new_id(cid), - rp) - } }; } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 46e838fd4bef..2196ae9d4be3 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -1917,29 +1917,6 @@ class parser { (ident, item_impl(tps, rp, ifce, ty, meths), none) } - fn parse_item_res() -> item_info { - let ident = self.parse_value_ident(); - let rp = self.parse_region_param(); - let ty_params = self.parse_ty_params(); - self.expect(token::LPAREN); - let arg_ident = self.parse_value_ident(); - self.expect(token::COLON); - let t = self.parse_ty(false); - self.expect(token::RPAREN); - let dtor = self.parse_block_no_value(); - let decl = { - inputs: [{mode: expl(by_ref), ty: t, - ident: arg_ident, id: self.get_id()}], - output: @{id: self.get_id(), node: ty_nil, - span: ast_util::dummy_sp()}, - purity: impure_fn, - cf: return_val, - constraints: [] - }; - (ident, item_res(decl, ty_params, dtor, - self.get_id(), self.get_id(), rp), none) - } - // Instantiates ident with references to as arguments. // Used to create a path that refers to a class which will be defined as // the return type of the ctor function. @@ -2341,8 +2318,6 @@ class parser { self.parse_item_iface() } else if self.eat_keyword("impl") { self.parse_item_impl() - } else if self.eat_keyword("resource") { - self.parse_item_res() } else if self.eat_keyword("class") { self.parse_item_class() } else { ret none; }; diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 39327f1efadb..478d7f536581 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -293,8 +293,7 @@ fn restricted_keyword_table() -> hashmap { "let", "log", "loop", "mod", "mut", "native", "new", - "pure", - "resource", "ret", + "pure", "ret", "true", "trait", "type", "unchecked", "unsafe", "while" diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 89f3b2d3aba9..54864c287ae8 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -130,38 +130,6 @@ fn test_fun_to_str() { assert fun_to_str(decl, "a", []) == "fn a()"; } -fn res_to_str(decl: ast::fn_decl, name: ast::ident, - params: [ast::ty_param], rp: ast::region_param) -> str { - let buffer = io::mem_buffer(); - let s = rust_printer(io::mem_buffer_writer(buffer)); - print_res(s, decl, name, params, rp); - end(s); // Close the head box - end(s); // Close the outer box - eof(s.s); - io::mem_buffer_str(buffer) -} - -#[test] -fn test_res_to_str() { - let decl: ast::fn_decl = { - inputs: [{ - mode: ast::expl(ast::by_val), - ty: @{id: 0, - node: ast::ty_nil, - span: ast_util::dummy_sp()}, - ident: "b", - id: 0 - }], - output: @{id: 0, - node: ast::ty_nil, - span: ast_util::dummy_sp()}, - purity: ast::impure_fn, - cf: ast::return_val, - constraints: [] - }; - assert res_to_str(decl, "a", []) == "resource a(b: ())"; -} - fn block_to_str(blk: ast::blk) -> str { let buffer = io::mem_buffer(); let s = rust_printer(io::mem_buffer_writer(buffer)); @@ -615,27 +583,10 @@ fn print_item(s: ps, &&item: @ast::item) { for methods.each {|meth| print_ty_method(s, meth); } bclose(s, item.span); } - ast::item_res(decl, tps, body, dt_id, ct_id, rp) { - print_res(s, decl, item.ident, tps, rp); - print_block(s, body); - } } s.ann.post(ann_node); } -fn print_res(s: ps, decl: ast::fn_decl, name: ast::ident, - typarams: [ast::ty_param], rp: ast::region_param) { - head(s, "resource"); - word(s.s, *name); - print_region_param(s, rp); - print_type_params(s, typarams); - popen(s); - word_space(s, *decl.inputs[0].ident + ":"); - print_type(s, decl.inputs[0].ty); - pclose(s); - space(s.s); -} - fn print_variant(s: ps, v: ast::variant) { word(s.s, *v.node.name); if vec::len(v.node.args) > 0u { diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index 5d27ee1452fe..714097d356da 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -15,7 +15,6 @@ enum vt { mk_vt(visitor), } enum fn_kind { fk_item_fn(ident, [ty_param]), //< an item declared with fn() fk_method(ident, [ty_param], @method), - fk_res(ident, [ty_param], region_param), 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 */, @@ -27,7 +26,7 @@ enum fn_kind { fn name_of_fn(fk: fn_kind) -> ident { alt fk { - fk_item_fn(name, _) | fk_method(name, _, _) | fk_res(name, _, _) + fk_item_fn(name, _) | fk_method(name, _, _) | fk_ctor(name, _, _, _) { /* FIXME (#2543) */ copy name } fk_anon(*) | fk_fn_block(*) { @"anon" } fk_dtor(*) { @"drop" } @@ -36,7 +35,7 @@ fn name_of_fn(fk: fn_kind) -> ident { fn tps_of_fn(fk: fn_kind) -> [ty_param] { alt fk { - fk_item_fn(_, tps) | fk_method(_, tps, _) | fk_res(_, tps, _) + fk_item_fn(_, tps) | fk_method(_, tps, _) | fk_ctor(_, tps, _, _) | fk_dtor(tps, _, _) { /* FIXME (#2543) */ copy tps } @@ -130,12 +129,6 @@ fn visit_item(i: @item, e: E, v: vt) { v.visit_ty(t, e, v); v.visit_ty_params(tps, e, v); } - item_res(decl, tps, body, dtor_id, _, rp) { - v.visit_fn(fk_res(/* FIXME (#2543) */ copy i.ident, - /* FIXME (#2543) */ copy tps, - rp), - decl, body, i.span, dtor_id, e, v); - } item_enum(variants, tps, _) { v.visit_ty_params(tps, e, v); for variants.each {|vr| diff --git a/src/rt/rust_box_annihilator.cpp b/src/rt/rust_box_annihilator.cpp index 20058a8a9db8..1ac0ac78ca7f 100644 --- a/src/rt/rust_box_annihilator.cpp +++ b/src/rt/rust_box_annihilator.cpp @@ -138,15 +138,14 @@ class annihilator : public shape::data { void *data; }; - typedef void (*dtor)(void **retptr, void *env, void *dptr); + typedef void (*dtor)(void **retptr, void *dptr); static void run_dtor(run_dtor_args *args) { dtor f = (dtor)args->dtor; - f(NULL, args->dtor->env, args->data); + f(NULL, args->data); } - void walk_res2(const shape::rust_fn *dtor, const uint8_t *end_sp, - bool live) { + void walk_res2(const shape::rust_fn *dtor, const uint8_t *end_sp) { void *data = (void*)(uintptr_t)dp; // Switch back to the Rust stack to run the destructor run_dtor_args args = {dtor, data}; diff --git a/src/rt/rust_cc.cpp b/src/rt/rust_cc.cpp index ed31ddd9dad7..1d3ae3ccccf2 100644 --- a/src/rt/rust_cc.cpp +++ b/src/rt/rust_cc.cpp @@ -147,8 +147,7 @@ class irc : public shape::data { void walk_tydesc2(char) { } - void walk_res2(const shape::rust_fn *dtor, const uint8_t *end_sp, - bool live) { + void walk_res2(const shape::rust_fn *dtor, const uint8_t *end_sp) { while (this->sp != end_sp) { this->walk(); align = true; @@ -394,8 +393,7 @@ class mark : public shape::data { } } - void walk_res2(const shape::rust_fn *dtor, const uint8_t *end_sp, - bool live) { + void walk_res2(const shape::rust_fn *dtor, const uint8_t *end_sp) { while (this->sp != end_sp) { this->walk(); align = true; diff --git a/src/rt/rust_shape.cpp b/src/rt/rust_shape.cpp index 444bcc9e0887..b0f6f1f77a48 100644 --- a/src/rt/rust_shape.cpp +++ b/src/rt/rust_shape.cpp @@ -304,8 +304,7 @@ public: void walk_tag2(tag_info &tinfo, const data_pair &tag_variants); void walk_struct2(const uint8_t *end_sp); - void walk_res2(const rust_fn *dtor, const uint8_t *end_sp, - const data_pair &live); + void walk_res2(const rust_fn *dtor, const uint8_t *end_sp); void walk_variant2(tag_info &tinfo, tag_variant_t variant_id, const std::pair @@ -356,8 +355,7 @@ cmp::walk_struct2(const uint8_t *end_sp) { } void -cmp::walk_res2(const rust_fn *dtor, const uint8_t *end_sp, - const data_pair &live) { +cmp::walk_res2(const rust_fn *dtor, const uint8_t *end_sp) { abort(); // TODO } @@ -463,7 +461,7 @@ log::walk_variant2(tag_info &tinfo, } void -log::walk_res2(const rust_fn *dtor, const uint8_t *end_sp, bool live) { +log::walk_res2(const rust_fn *dtor, const uint8_t *end_sp) { out << prefix << "res"; if (this->sp == end_sp) diff --git a/src/rt/rust_shape.h b/src/rt/rust_shape.h index cfac33008b94..26f775c9fac1 100644 --- a/src/rt/rust_shape.h +++ b/src/rt/rust_shape.h @@ -950,9 +950,8 @@ public: } void walk_res1(const rust_fn *dtor, const uint8_t *end_sp) { - typename U::template data::t live = bump_dp(dp); // Delegate to the implementation. - static_cast(this)->walk_res2(dtor, end_sp, live); + static_cast(this)->walk_res2(dtor, end_sp); } template @@ -1287,7 +1286,7 @@ private: const std::pair variant_ptr_and_end); void walk_string2(const std::pair &data); - void walk_res2(const rust_fn *dtor, const uint8_t *end_sp, bool live); + void walk_res2(const rust_fn *dtor, const uint8_t *end_sp); template inline void walk_number2() { diff --git a/src/rustc/metadata/encoder.rs b/src/rustc/metadata/encoder.rs index 62c4a0789528..7f2474e57ca9 100644 --- a/src/rustc/metadata/encoder.rs +++ b/src/rustc/metadata/encoder.rs @@ -186,17 +186,6 @@ fn encode_module_item_paths(ebml_w: ebml::writer, ecx: @encode_ctxt, encode_name_and_def_id(ebml_w, it.ident, it.id); } } - item_res(_, tps, _, _, ctor_id, _) { - ebml_w.wr_tag(tag_paths_data_item) {|| - encode_name_and_def_id(ebml_w, it.ident, ctor_id); - } - // The same ident has to be added twice (with different positions) - // because it's for both the ctor and the dtor. - add_to_index(ebml_w, path, index, it.ident); - ebml_w.wr_tag(tag_paths_data_item) {|| - encode_name_and_def_id(ebml_w, it.ident, it.id); - } - } item_class(_, _, items, ctor, m_dtor, _) { ebml_w.wr_tag(tag_paths_data_item) {|| encode_name_and_def_id(ebml_w, it.ident, it.id); @@ -698,34 +687,6 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item, encode_index(ebml_w, bkts, write_int); ebml_w.end_tag(); } - item_res(_, tps, _, _, ctor_id, rp) { - add_to_index(); - let fn_ty = node_id_to_type(tcx, ctor_id); - - ebml_w.start_tag(tag_items_data_item); - encode_def_id(ebml_w, local_def(ctor_id)); - encode_family(ebml_w, 'y'); - encode_type_param_bounds(ebml_w, ecx, tps); - encode_type(ecx, ebml_w, ty::ty_fn_ret(fn_ty)); - encode_name(ebml_w, item.ident); - ecx.encode_inlined_item(ecx, ebml_w, path, ii_item(item)); - if (tps.len() == 0u) { - encode_symbol(ecx, ebml_w, item.id); - } - encode_path(ebml_w, path, ast_map::path_name(item.ident)); - encode_region_param(ebml_w, rp); - ebml_w.end_tag(); - - *index += [{val: ctor_id, pos: ebml_w.writer.tell()}]; - ebml_w.start_tag(tag_items_data_item); - encode_def_id(ebml_w, local_def(ctor_id)); - encode_family(ebml_w, 'f'); - encode_type_param_bounds(ebml_w, ecx, tps); - encode_type(ecx, ebml_w, fn_ty); - encode_parent_item(ebml_w, local_def(item.id)); - encode_path(ebml_w, path, ast_map::path_name(item.ident)); - ebml_w.end_tag(); - } item_impl(tps, rp, ifce, _, methods) { add_to_index(); ebml_w.start_tag(tag_items_data_item); diff --git a/src/rustc/metadata/tydecode.rs b/src/rustc/metadata/tydecode.rs index f7c4628e51ca..794af5577e77 100644 --- a/src/rustc/metadata/tydecode.rs +++ b/src/rustc/metadata/tydecode.rs @@ -338,14 +338,6 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t { 'f' { parse_ty_rust_fn(st, conv) } - 'r' { - assert next(st) == '['; - let def = parse_def(st, conv); - let inner = parse_ty(st, conv); - let substs = parse_substs(st, conv); - assert next(st) == ']'; - ret ty::mk_res(st.tcx, def, inner, substs); - } 'X' { ret ty::mk_var(st.tcx, ty::tv_vid(parse_int(st) as uint)); } diff --git a/src/rustc/metadata/tyencode.rs b/src/rustc/metadata/tyencode.rs index f21b3850a984..dc1cbac434bf 100644 --- a/src/rustc/metadata/tyencode.rs +++ b/src/rustc/metadata/tyencode.rs @@ -265,14 +265,6 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) { ty::ty_fn(f) { enc_ty_fn(w, cx, f); } - ty::ty_res(def, ty, substs) { - w.write_str("r["/&); - w.write_str(cx.ds(def)); - w.write_char('|'); - enc_ty(w, cx, ty); - enc_substs(w, cx, substs); - w.write_char(']'); - } ty::ty_var(id) { w.write_char('X'); w.write_uint(id.to_uint()); diff --git a/src/rustc/middle/borrowck.rs b/src/rustc/middle/borrowck.rs index 9818c1c648b6..7ce20dbd82f3 100644 --- a/src/rustc/middle/borrowck.rs +++ b/src/rustc/middle/borrowck.rs @@ -249,7 +249,6 @@ enum ptr_kind {uniq_ptr, gc_ptr, region_ptr, unsafe_ptr} // structure accessible without a dereference": enum comp_kind { comp_tuple, // elt in a tuple - comp_res, // data for a resource comp_variant(ast::def_id), // internals to a variant of given enum comp_field(ast::ident, // name of field ast::mutability), // declared mutability of field @@ -423,7 +422,6 @@ impl to_str_methods for borrowck_ctxt { comp_field(fld, _) { *fld } comp_index(*) { "[]" } comp_tuple { "()" } - comp_res { "" } comp_variant(_) { "" } } } @@ -483,7 +481,6 @@ impl to_str_methods for borrowck_ctxt { } cat_comp(_, comp_field(*)) { mut_str + " field" } cat_comp(_, comp_tuple) { "tuple content" } - cat_comp(_, comp_res) { "resource content" } cat_comp(_, comp_variant(_)) { "enum content" } cat_comp(_, comp_index(t, _)) { alt ty::get(t).struct { @@ -530,7 +527,7 @@ impl to_str_methods for borrowck_ctxt { // mutable structure. fn inherent_mutability(ck: comp_kind) -> mutability { alt ck { - comp_tuple | comp_res | comp_variant(_) {m_imm} + comp_tuple | comp_variant(_) {m_imm} comp_field(_, m) | comp_index(_, m) {m} } } diff --git a/src/rustc/middle/borrowck/categorization.rs b/src/rustc/middle/borrowck/categorization.rs index b7143706fc3f..9e8ac411a1ff 100644 --- a/src/rustc/middle/borrowck/categorization.rs +++ b/src/rustc/middle/borrowck/categorization.rs @@ -71,10 +71,6 @@ fn opt_deref_kind(t: ty::t) -> option { some(deref_comp(comp_variant(did))) } - ty::ty_res(*) { - some(deref_comp(comp_res)) - } - ty::ty_evec(mt, ty::vstore_fixed(_)) { some(deref_comp(comp_index(t, mt.mutbl))) } diff --git a/src/rustc/middle/borrowck/check_loans.rs b/src/rustc/middle/borrowck/check_loans.rs index bae0f4648d2b..af5055368c83 100644 --- a/src/rustc/middle/borrowck/check_loans.rs +++ b/src/rustc/middle/borrowck/check_loans.rs @@ -532,7 +532,7 @@ fn check_loans_in_fn(fk: visit::fn_kind, decl: ast::fn_decl, body: ast::blk, } visit::fk_anon(*) | visit::fk_fn_block(*) | visit::fk_method(*) | visit::fk_item_fn(*) | - visit::fk_res(*) | visit::fk_dtor(*) { + visit::fk_dtor(*) { self.in_ctor = false; self.declared_purity = decl.purity; self.fn_args = @decl.inputs.map({|i| i.id}); diff --git a/src/rustc/middle/borrowck/loan.rs b/src/rustc/middle/borrowck/loan.rs index bbeca8517423..84f7f5a9d159 100644 --- a/src/rustc/middle/borrowck/loan.rs +++ b/src/rustc/middle/borrowck/loan.rs @@ -57,8 +57,7 @@ impl loan_methods for loan_ctxt { } cat_comp(cmt_base, comp_field(*)) | cat_comp(cmt_base, comp_index(*)) | - cat_comp(cmt_base, comp_tuple) | - cat_comp(cmt_base, comp_res) { + cat_comp(cmt_base, comp_tuple) { // For most components, the type of the embedded data is // stable. Therefore, the base structure need only be // const---unless the component must be immutable. In diff --git a/src/rustc/middle/borrowck/preserve.rs b/src/rustc/middle/borrowck/preserve.rs index cbe9c4e3a4ad..7ec2520cd59d 100644 --- a/src/rustc/middle/borrowck/preserve.rs +++ b/src/rustc/middle/borrowck/preserve.rs @@ -43,8 +43,7 @@ impl public_methods for borrowck_ctxt { } cat_comp(cmt_base, comp_field(*)) | cat_comp(cmt_base, comp_index(*)) | - cat_comp(cmt_base, comp_tuple) | - cat_comp(cmt_base, comp_res) { + cat_comp(cmt_base, comp_tuple) { // Most embedded components: if the base is stable, the // type never changes. self.preserve(cmt_base, opt_scope_id) diff --git a/src/rustc/middle/kind.rs b/src/rustc/middle/kind.rs index 2f9e8472022e..465799c850c6 100644 --- a/src/rustc/middle/kind.rs +++ b/src/rustc/middle/kind.rs @@ -22,8 +22,8 @@ import lint::{non_implicitly_copyable_typarams,implicit_copies}; // const: Things thare are deeply immutable. They are guaranteed never to // change, and can be safely shared without copying between tasks. // -// Send includes scalar types, resources and unique types containing only -// sendable types. +// Send includes scalar types as well as classes and unique types containing +// only sendable types. // // Copy includes boxes, closure and unique types containing copyable types. // @@ -160,7 +160,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_dtor(*) { @[] } + 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); diff --git a/src/rustc/middle/region.rs b/src/rustc/middle/region.rs index 50f38b16e096..e17343a0b9ed 100644 --- a/src/rustc/middle/region.rs +++ b/src/rustc/middle/region.rs @@ -359,7 +359,7 @@ fn resolve_fn(fk: visit::fn_kind, decl: ast::fn_decl, body: ast::blk, visitor: visit::vt) { let fn_cx = alt fk { - visit::fk_item_fn(*) | visit::fk_method(*) | visit::fk_res(*) | + visit::fk_item_fn(*) | visit::fk_method(*) | visit::fk_ctor(*) | visit::fk_dtor(*) { // Top-level functions are a root scope. {parent: some(id) with cx} diff --git a/src/rustc/middle/resolve.rs b/src/rustc/middle/resolve.rs index 0ae04c25ccd2..b693d83e1936 100644 --- a/src/rustc/middle/resolve.rs +++ b/src/rustc/middle/resolve.rs @@ -639,9 +639,8 @@ fn visit_fn_with_scope(e: @env, fk: visit::fn_kind, decl: ast::fn_decl, // for f's constrs in the table. for decl.constraints.each {|c| resolve_constr(e, c, sc, v); } let scope = alt fk { - visit::fk_item_fn(_, tps) | visit::fk_res(_, tps, _) | - visit::fk_method(_, tps, _) | visit::fk_ctor(_, tps, _, _) | - visit::fk_dtor(tps, _, _) { + visit::fk_item_fn(_, tps) | visit::fk_method(_, tps, _) + | visit::fk_ctor(_, tps, _, _) | visit::fk_dtor(tps, _, _) { scope_bare_fn(decl, id, tps) } visit::fk_anon(ast::proto_bare, _) { scope_bare_fn(decl, id, []) } @@ -1333,15 +1332,6 @@ fn found_def_item(i: @ast::item, ns: namespace) -> option { ast::item_ty(*) | item_iface(*) | item_enum(*) { if ns == ns_type { ret some(ast::def_ty(local_def(i.id))); } } - ast::item_res(_, _, _, _, ctor_id, _) { - alt ns { - ns_val { - ret some(ast::def_fn(local_def(ctor_id), ast::impure_fn)); - } - ns_type { ret some(ast::def_ty(local_def(i.id))); } - _ { } - } - } ast::item_class(_, _, _members, ct, _, _) { alt ns { ns_type { @@ -1644,7 +1634,7 @@ fn index_mod(md: ast::_mod) -> mod_index { alt it.node { ast::item_const(_, _) | ast::item_fn(_, _, _) | ast::item_mod(_) | ast::item_native_mod(_) | ast::item_ty(_, _, _) | - ast::item_res(*) | ast::item_impl(*) | ast::item_iface(*) { + ast::item_impl(*) | ast::item_iface(*) { add_to_index(index, it.ident, mie_item(it)); } ast::item_enum(variants, _, _) { @@ -1868,10 +1858,6 @@ fn check_block(e: @env, b: ast::blk, &&x: (), v: vt<()>) { ast::item_ty(*) | ast::item_iface(*) { add_name(types, it.span, it.ident); } - ast::item_res(*) { - add_name(types, it.span, it.ident); - add_name(values, it.span, it.ident); - } _ { } } } diff --git a/src/rustc/middle/trans/base.rs b/src/rustc/middle/trans/base.rs index dc4e681dc162..13201d4e6735 100644 --- a/src/rustc/middle/trans/base.rs +++ b/src/rustc/middle/trans/base.rs @@ -50,7 +50,7 @@ import type_of::type_of; // Issue #1873 import syntax::ast_map::{path, path_mod, path_name}; import std::smallintmap; -import option::is_none; +import option::{is_none, is_some}; // Destinations @@ -758,8 +758,7 @@ fn trans_class_drop(bcx: block, v0: ValueRef, dtor_did: ast::def_id, // We have to cast v0 let classptr = GEPi(bcx, v0, [0u, 1u]); // Find and call the actual destructor - let dtor_addr = get_res_dtor(bcx.ccx(), dtor_did, some(class_did), - substs.tps); + let dtor_addr = get_res_dtor(bcx.ccx(), dtor_did, class_did, substs.tps); // The second argument is the "self" argument for drop let params = lib::llvm::fn_ty_param_tys (llvm::LLVMGetElementType @@ -799,9 +798,6 @@ fn make_drop_glue(bcx: block, v0: ValueRef, t: ty::t) { ty::ty_unboxed_vec(_) { tvec::make_drop_glue_unboxed(bcx, v0, t) } - ty::ty_res(did, inner, substs) { - trans_res_drop(bcx, v0, did, inner, substs.tps) - } ty::ty_class(did, substs) { let tcx = bcx.tcx(); alt ty::ty_dtor(tcx, did) { @@ -835,10 +831,7 @@ fn make_drop_glue(bcx: block, v0: ValueRef, t: ty::t) { } fn get_res_dtor(ccx: @crate_ctxt, did: ast::def_id, - // Parent ID is an option because resources don't - // have one. We can make this a def_id when - // resources get removed. - opt_id: option, substs: [ty::t]) + parent_id: ast::def_id, substs: [ty::t]) -> ValueRef { let _icx = ccx.insn_ctxt("trans_res_dtor"); if (substs.len() > 0u) { @@ -850,54 +843,13 @@ fn get_res_dtor(ccx: @crate_ctxt, did: ast::def_id, } else if did.crate == ast::local_crate { get_item_val(ccx, did.node) } else { - alt opt_id { - some(parent_id) { - let tcx = ccx.tcx; - let name = csearch::get_symbol(ccx.sess.cstore, did); - let class_ty = ty::subst_tps(tcx, substs, - ty::lookup_item_type(tcx, parent_id).ty); - let llty = type_of_dtor(ccx, class_ty); - get_extern_fn(ccx.externs, ccx.llmod, name, lib::llvm::CCallConv, - llty) - } - none { - let fty = ty::mk_fn(ccx.tcx, {purity: ast::impure_fn, - proto: ast::proto_bare, - inputs: [{mode: ast::expl(ast::by_ref), - ty: ty::mk_nil_ptr(ccx.tcx)}], - output: ty::mk_nil(ccx.tcx), - ret_style: ast::return_val, - constraints: []}); - trans_external_path(ccx, did, fty) - } - } - } -} - -fn trans_res_drop(bcx: block, rs: ValueRef, did: ast::def_id, - inner_t: ty::t, tps: [ty::t]) -> block { - let _icx = bcx.insn_ctxt("trans_res_drop"); - let ccx = bcx.ccx(); - let inner_t_s = ty::subst_tps(ccx.tcx, tps, inner_t); - - let drop_flag = GEPi(bcx, rs, [0u, 0u]); - with_cond(bcx, IsNotNull(bcx, Load(bcx, drop_flag))) {|bcx| - let valptr = GEPi(bcx, rs, [0u, 1u]); - // Find and call the actual destructor. - let dtor_addr = get_res_dtor(ccx, did, none, tps); - let args = [bcx.fcx.llretptr, null_env_ptr(bcx)]; - // Kludge to work around the fact that we know the precise type of the - // value here, but the dtor expects a type that might have opaque - // boxes and such. - let val_llty = lib::llvm::fn_ty_param_tys - (llvm::LLVMGetElementType - (llvm::LLVMTypeOf(dtor_addr)))[args.len()]; - let val_cast = BitCast(bcx, valptr, val_llty); - Call(bcx, dtor_addr, args + [val_cast]); - - let bcx = drop_ty(bcx, valptr, inner_t_s); - Store(bcx, C_u8(0u), drop_flag); - bcx + let tcx = ccx.tcx; + let name = csearch::get_symbol(ccx.sess.cstore, did); + let class_ty = ty::subst_tps(tcx, substs, + ty::lookup_item_type(tcx, parent_id).ty); + let llty = type_of_dtor(ccx, class_ty); + get_extern_fn(ccx.externs, ccx.llmod, name, lib::llvm::CCallConv, + llty) } } @@ -1086,12 +1038,6 @@ fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t, cx = f(cx, llfld_a, arg); } } - ty::ty_res(_, inner, substs) { - let tcx = cx.tcx(); - let inner1 = ty::subst(tcx, substs, inner); - let llfld_a = GEPi(cx, av, [0u, 1u]); - ret f(cx, llfld_a, inner1); - } ty::ty_enum(tid, substs) { let variants = ty::enum_variants(cx.tcx(), tid); let n_variants = (*variants).len(); @@ -1130,10 +1076,15 @@ fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t, ret next_cx; } ty::ty_class(did, substs) { + // Take the drop bit into account + let classptr = if is_some(ty::ty_dtor(cx.tcx(), did)) { + GEPi(cx, av, [0u, 1u]) + } + else { av }; for vec::eachi(ty::class_items_as_mutable_fields(cx.tcx(), did, substs)) {|i, fld| - let llfld_a = GEPi(cx, av, [0u, i]); + let llfld_a = GEPi(cx, classptr, [0u, i]); cx = f(cx, llfld_a, fld.mt.ty); } } @@ -1895,10 +1846,6 @@ fn autoderef(cx: block, e_id: ast::node_id, t1 = mt.ty; v1 = v; } - ty::ty_res(did, inner, substs) { - t1 = ty::subst(ccx.tcx, substs, inner); - v1 = GEPi(cx, v1, [0u, 1u]); - } ty::ty_enum(did, substs) { let variants = ty::enum_variants(ccx.tcx, did); if (*variants).len() != 1u || variants[0].args.len() != 1u { @@ -2221,15 +2168,7 @@ fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id, real_substs: [ty::t], crate?)", fn_id)}); // Get the path so that we can create a symbol let (pt, name, span) = alt map_node { - ast_map::node_item(i, pt) { - alt i.node { - ast::item_res(_, _, _, dtor_id, _, _) { - item_ty = ty::node_id_to_type(ccx.tcx, dtor_id); - } - _ {} - } - (pt, i.ident, i.span) - } + ast_map::node_item(i, pt) { (pt, i.ident, i.span) } ast_map::node_variant(v, enm, pt) { (pt, v.node.name, enm.span) } ast_map::node_method(m, _, pt) { (pt, m.ident, m.span) } ast_map::node_native_item(i, ast::native_abi_rust_intrinsic, pt) @@ -2239,9 +2178,7 @@ fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id, real_substs: [ty::t], ret {val: get_item_val(ccx, fn_id.node), must_cast: true}; } - ast_map::node_ctor(nm, _, ct, pt) { (pt, nm, alt ct { - ast_map::res_ctor(_, _, sp) { sp } - ast_map::class_ctor(ct_, _) { ct_.span }}) } + ast_map::node_ctor(nm, _, ct, _, pt) { (pt, nm, ct.span) } ast_map::node_dtor(_, dtor, _, pt) {(pt, @"drop", dtor.span)} ast_map::node_expr(*) { ccx.tcx.sess.bug("Can't monomorphize an expr") } ast_map::node_export(*) { @@ -2285,12 +2222,6 @@ fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id, real_substs: [ty::t], trans_fn(ccx, pt, decl, body, d, no_self, psubsts, fn_id.node); d } - ast_map::node_item( - @{node: ast::item_res(dt, _, body, d_id, _, _), _}, _) { - let d = mk_lldecl(); - trans_fn(ccx, pt, dt, body, d, no_self, psubsts, d_id); - d - } ast_map::node_item(*) { ccx.tcx.sess.bug("Can't monomorphize this kind of item") } @@ -2319,24 +2250,15 @@ fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id, real_substs: [ty::t], impl_self(selfty), psubsts, fn_id.node); d } - ast_map::node_ctor(nm, tps, ct, _) { + ast_map::node_ctor(nm, tps, ctor, parent_id, _) { + // ctors don't have attrs, at least not right now let d = mk_lldecl(); - alt ct { - ast_map::res_ctor(decl,_, _) { - set_inline_hint(d); - trans_res_ctor(ccx, pt, decl, fn_id.node, psubsts, d); - d - } - ast_map::class_ctor(ctor, parent_id) { - // ctors don't have attrs, at least not right now - let tp_tys: [ty::t] = ty::ty_params_to_tys(ccx.tcx, tps); - trans_class_ctor(ccx, pt, ctor.node.dec, ctor.node.body, d, - option::get_default(psubsts, - {tys:tp_tys, vtables: none, bounds: @[]}), - fn_id.node, parent_id, ctor.span); - d - } - } + let tp_tys: [ty::t] = ty::ty_params_to_tys(ccx.tcx, tps); + trans_class_ctor(ccx, pt, ctor.node.dec, ctor.node.body, d, + option::get_default(psubsts, + {tys:tp_tys, vtables: none, bounds: @[]}), + fn_id.node, parent_id, ctor.span); + d } ast_map::node_dtor(_, dtor, _, pt) { let parent_id = alt ty::ty_to_def_id(ty::node_id_to_type(ccx.tcx, @@ -2412,9 +2334,6 @@ fn maybe_instantiate_inline(ccx: @crate_ctxt, fn_id: ast::def_id) ccx.external.insert(there.id, some(here.id.node)); } } - ast::item_res(_, _, _, _, ctor_id, _) { - my_id = ctor_id; - } } trans_item(ccx, *item); local_def(my_id) @@ -2639,8 +2558,13 @@ fn trans_rec_field_inner(bcx: block, val: ValueRef, ty: ty::t, _ { bcx.tcx().sess.span_bug(sp, "trans_rec_field:\ base expr has non-record type"); } }; + // seems wrong? Doesn't take into account the field + // sizes + let ix = field_idx_strict(bcx.tcx(), sp, field, fields); + #debug("val = %s ix = %u", bcx.val_str(val), ix); + /* self is a class with a dtor, which means we have to select out the object itself (If any other code does the same thing, that's @@ -2789,9 +2713,6 @@ fn trans_lval(cx: block, e: @ast::expr) -> lval_result { let non_gc_val = non_gc_box_cast(sub.bcx, sub.val); GEPi(sub.bcx, non_gc_val, [0u, abi::box_field_body]) } - ty::ty_res(_, _, _) { - GEPi(sub.bcx, sub.val, [0u, 1u]) - } ty::ty_enum(_, _) { let ety = expr_ty(cx, e); let ellty = T_ptr(type_of(ccx, ety)); @@ -4683,34 +4604,6 @@ fn trans_fn(ccx: @crate_ctxt, } } -fn trans_res_ctor(ccx: @crate_ctxt, path: path, dtor: ast::fn_decl, - ctor_id: ast::node_id, - param_substs: option, llfndecl: ValueRef) { - let _icx = ccx.insn_ctxt("trans_res_ctor"); - // Create a function for the constructor - let fcx = new_fn_ctxt_w_id(ccx, path, llfndecl, ctor_id, param_substs, - none); - create_llargs_for_fn_args(fcx, no_self, dtor.inputs); - let mut bcx = top_scope_block(fcx, none), lltop = bcx.llbb; - let fty = node_id_type(bcx, ctor_id); - let arg_t = ty::ty_fn_args(fty)[0].ty; - let arg = alt fcx.llargs.find(dtor.inputs[0].id) { - some(local_mem(x)) { x } - _ { ccx.sess.bug("Someone forgot to document an invariant \ - in trans_res_ctor"); } - }; - let llretptr = fcx.llretptr; - - let dst = GEPi(bcx, llretptr, [0u, 1u]); - memmove_ty(bcx, dst, arg, arg_t); - let flag = GEPi(bcx, llretptr, [0u, 0u]); - let one = C_u8(1u); - Store(bcx, one, flag); - build_return(bcx); - finish_fn(fcx, lltop); -} - - fn trans_enum_variant(ccx: @crate_ctxt, enum_id: ast::node_id, variant: ast::variant, disr: int, is_degen: bool, param_substs: option, @@ -5029,16 +4922,6 @@ fn trans_item(ccx: @crate_ctxt, item: ast::item) { ast::item_impl(tps, _rp, _, _, ms) { impl::trans_impl(ccx, *path, item.ident, ms, tps); } - ast::item_res(decl, tps, body, dtor_id, ctor_id, _) { - if tps.len() == 0u { - let llctor_decl = get_item_val(ccx, ctor_id); - trans_res_ctor(ccx, *path, decl, ctor_id, none, llctor_decl); - - let lldtor_decl = get_item_val(ccx, item.id); - trans_fn(ccx, *path + [path_name(item.ident)], decl, body, - lldtor_decl, no_self, none, dtor_id); - } - } ast::item_mod(m) { trans_mod(ccx, m); } @@ -5293,16 +5176,6 @@ fn get_item_val(ccx: @crate_ctxt, id: ast::node_id) -> ValueRef { set_inline_hint_if_appr(i.attrs, llfn); llfn } - ast::item_res(_, _, _, dtor_id, _, _) { - // Note that the destructor is associated with the item's id, - // not the dtor_id. This is a bit counter-intuitive, but - // simplifies ty_res, which would have to carry around two - // def_ids otherwise -- one to identify the type, and one to - // find the dtor symbol. - let t = ty::node_id_to_type(ccx.tcx, dtor_id); - register_fn_full(ccx, i.span, my_path + [path_name(@"dtor")], - i.id, t) - } } } ast_map::node_method(m, impl_id, pth) { @@ -5318,18 +5191,9 @@ fn get_item_val(ccx: @crate_ctxt, id: ast::node_id) -> ValueRef { exprt = true; register_fn(ccx, ni.span, *pth + [path_name(ni.ident)], ni.id) } - ast_map::node_ctor(nm, tps, ct, pt) { + ast_map::node_ctor(nm, tps, ctor, _, pt) { let my_path = *pt + [path_name(nm)]; - alt ct { - ast_map::res_ctor(_,_,sp) { - let llctor = register_fn(ccx, sp, my_path, id); - set_inline_hint(llctor); - llctor - } - ast_map::class_ctor(ctor, _) { - register_fn(ccx, ctor.span, my_path, ctor.node.id) - } - } + register_fn(ccx, ctor.span, my_path, ctor.node.id) } ast_map::node_dtor(tps, dt, parent_id, pt) { /* diff --git a/src/rustc/middle/trans/debuginfo.rs b/src/rustc/middle/trans/debuginfo.rs index e90590f0228e..48a087d0c279 100644 --- a/src/rustc/middle/trans/debuginfo.rs +++ b/src/rustc/middle/trans/debuginfo.rs @@ -743,7 +743,7 @@ fn create_function(fcx: fn_ctxt) -> @metadata { let (ident, ret_ty, id) = alt cx.tcx.items.get(fcx.id) { ast_map::node_item(item, _) { alt item.node { - ast::item_fn(decl, _, _) | ast::item_res(decl, _, _, _, _, _) { + ast::item_fn(decl, _, _) { (item.ident, decl.output, item.id) } _ { fcx.ccx.sess.span_bug(item.span, "create_function: item \ @@ -753,16 +753,9 @@ fn create_function(fcx: fn_ctxt) -> @metadata { ast_map::node_method(method, _, _) { (method.ident, method.decl.output, method.id) } - ast_map::node_ctor(nm, _, ct, _) { - alt ct { - ast_map::res_ctor(decl, ctor_id, _) { - (nm, decl.output, ctor_id) - } - ast_map::class_ctor(ctor,_) { - // FIXME: output type may be wrong (#2194) - (nm, ctor.node.dec.output, ctor.node.id) - } - } + ast_map::node_ctor(nm, _, ctor, _, _) { + // FIXME: output type may be wrong (#2194) + (nm, ctor.node.dec.output, ctor.node.id) } ast_map::node_expr(expr) { alt expr.node { diff --git a/src/rustc/middle/trans/reachable.rs b/src/rustc/middle/trans/reachable.rs index ed4f34eb75f0..86da0c72eccd 100644 --- a/src/rustc/middle/trans/reachable.rs +++ b/src/rustc/middle/trans/reachable.rs @@ -69,8 +69,8 @@ fn traverse_def_id(cx: ctx, did: def_id) { ast_map::node_method(_, impl_id, _) { traverse_def_id(cx, impl_id); } ast_map::node_native_item(item, _, _) { cx.rmap.insert(item.id, ()); } ast_map::node_variant(v, _, _) { cx.rmap.insert(v.node.id, ()); } - // If it's a class ctor, consider the parent reachable - ast_map::node_ctor(_, _, ast_map::class_ctor(_, parent_id), _) { + // If it's a ctor, consider the parent reachable + ast_map::node_ctor(_, _, _, parent_id, _) { traverse_def_id(cx, parent_id); } _ {} @@ -94,10 +94,6 @@ fn traverse_public_item(cx: ctx, item: @item) { for vec::each(nm.items) {|item| cx.rmap.insert(item.id, ()); } } } - item_res(_, tps, blk, _, _, _) { - // resources seem to be unconditionally inlined - traverse_inline_body(cx, blk); - } item_fn(_, tps, blk) { if tps.len() > 0u || attr::find_inline_attr(item.attrs) != attr::ia_none { @@ -209,10 +205,6 @@ fn traverse_all_resources(cx: ctx, crate_mod: _mod) { visit_item: {|i, cx, v| visit::visit_item(i, cx, v); alt i.node { - item_res(*) { - traverse_public_item(cx, i); - } - // Classes with dtors too! item_class(_, _, _, _, some(_), _) { traverse_public_item(cx, i); } diff --git a/src/rustc/middle/trans/reflect.rs b/src/rustc/middle/trans/reflect.rs index 740d53ed7731..0ca89ac6a94e 100644 --- a/src/rustc/middle/trans/reflect.rs +++ b/src/rustc/middle/trans/reflect.rs @@ -255,7 +255,6 @@ impl methods for reflector { // Miscallaneous extra types ty::ty_iface(_, _) { self.leaf("iface") } - ty::ty_res(_, t, _) { self.bracketed_t("res", t, []) } ty::ty_var(_) { self.leaf("var") } ty::ty_var_integral(_) { self.leaf("var_integral") } ty::ty_param(n, _) { self.visit("param", [self.c_uint(n)]) } diff --git a/src/rustc/middle/trans/shape.rs b/src/rustc/middle/trans/shape.rs index f28d0b53e538..d7e7020f20d5 100644 --- a/src/rustc/middle/trans/shape.rs +++ b/src/rustc/middle/trans/shape.rs @@ -335,7 +335,6 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t) -> [u8] { [shape_res] } else { [shape_struct] }; - let mut sub = []; option::iter(m_dtor_did) {|dtor_did| let ri = @{did: dtor_did, parent_id: some(did), tps: tps}; let id = interner::intern(ccx.shape_cx.resources, ri); @@ -346,9 +345,8 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t) -> [u8] { add_u16(s, 0_u16); }; for ty::class_items_as_mutable_fields(ccx.tcx, did, substs).each {|f| - sub += shape_of(ccx, f.mt.ty); + add_substr(s, shape_of(ccx, f.mt.ty)); } - add_substr(s, sub); s } ty::ty_rptr(_, mt) { @@ -356,25 +354,6 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t) -> [u8] { add_substr(s, shape_of(ccx, mt.ty)); s } - ty::ty_res(did, raw_subt, substs) { - #debug["ty_res(%?, %?, %?)", - did, - ty_to_str(ccx.tcx, raw_subt), - substs.tps.map({|t| ty_to_str(ccx.tcx, t) })]; - for substs.tps.each() {|t| assert !ty::type_has_params(t); } - let subt = ty::subst(ccx.tcx, substs, raw_subt); - let tps = substs.tps; - let ri = @{did: did, parent_id: none, tps: tps}; - let id = interner::intern(ccx.shape_cx.resources, ri); - - let mut s = [shape_res]; - add_u16(s, id as u16); - // Hack: always encode 0 tps, since the shape glue format - // hasn't changed since we started monomorphizing. - add_u16(s, 0_u16); - add_substr(s, shape_of(ccx, subt)); - s - } ty::ty_param(*) { ccx.tcx.sess.bug("non-monomorphized type parameter"); } @@ -599,8 +578,9 @@ fn gen_resource_shapes(ccx: @crate_ctxt) -> ValueRef { for uint::range(0u, len) {|i| let ri = interner::get(ccx.shape_cx.resources, i); for ri.tps.each() {|s| assert !ty::type_has_params(s); } - dtors += [trans::base::get_res_dtor(ccx, ri.did, ri.parent_id, - ri.tps)]; + option::iter(ri.parent_id) {|id| + dtors += [trans::base::get_res_dtor(ccx, ri.did, id, ri.tps)]; + } } ret mk_global(ccx, "resource_shapes", C_struct(dtors), true); } @@ -744,10 +724,6 @@ fn simplify_type(tcx: ty::ctxt, typ: ty::t) -> ty::t { ty::ty_estr(ty::vstore_uniq) | ty::ty_estr(ty::vstore_box) | ty::ty_ptr(_) | ty::ty_rptr(_,_) { nilptr(tcx) } ty::ty_fn(_) { ty::mk_tup(tcx, [nilptr(tcx), nilptr(tcx)]) } - ty::ty_res(_, sub, substs) { - let sub1 = ty::subst(tcx, substs, sub); - ty::mk_tup(tcx, [ty::mk_int(tcx), simplify_type(tcx, sub1)]) - } ty::ty_evec(_, ty::vstore_slice(_)) | ty::ty_estr(ty::vstore_slice(_)) { ty::mk_tup(tcx, [nilptr(tcx), ty::mk_int(tcx)]) diff --git a/src/rustc/middle/trans/type_of.rs b/src/rustc/middle/trans/type_of.rs index dc8dc1b92cf3..2b610a996621 100644 --- a/src/rustc/middle/trans/type_of.rs +++ b/src/rustc/middle/trans/type_of.rs @@ -141,10 +141,6 @@ fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef { } ty::ty_fn(_) { T_fn_pair(cx, type_of_fn_from_ty(cx, t)) } ty::ty_iface(_, _) { T_opaque_iface(cx) } - ty::ty_res(_, sub, substs) { - let sub1 = ty::subst(cx.tcx, substs, sub); - ret T_struct([T_i8(), type_of(cx, sub1)]); - } ty::ty_type { T_ptr(cx.tydesc_type) } ty::ty_tup(elts) { let mut tys = []; diff --git a/src/rustc/middle/trans/type_use.rs b/src/rustc/middle/trans/type_use.rs index 628d407feadc..fb0b983ae65c 100644 --- a/src/rustc/middle/trans/type_use.rs +++ b/src/rustc/middle/trans/type_use.rs @@ -66,11 +66,9 @@ fn type_uses_for(ccx: @crate_ctxt, fn_id: def_id, n_tps: uint) }; alt check map_node { ast_map::node_item(@{node: item_fn(_, _, body), _}, _) | - ast_map::node_item(@{node: item_res(_, _, body, _, _, _), _}, _) | ast_map::node_method(@{body, _}, _, _) { handle_body(cx, body); } - ast_map::node_ctor(_, _, ast_map::res_ctor(_, _, _), _) | ast_map::node_variant(_, _, _) { for uint::range(0u, n_tps) {|n| cx.uses[n] |= use_repr;} } @@ -88,7 +86,7 @@ fn type_uses_for(ccx: @crate_ctxt, fn_id: def_id, n_tps: uint) for uint::range(0u, n_tps) {|n| cx.uses[n] |= flags;} } } - ast_map::node_ctor(_, _, ast_map::class_ctor(ctor, _), _){ + ast_map::node_ctor(_, _, ctor, _, _){ handle_body(cx, ctor.node.body); } ast_map::node_dtor(_, dtor, _, _){ diff --git a/src/rustc/middle/tstate/pre_post_conditions.rs b/src/rustc/middle/tstate/pre_post_conditions.rs index e1d0bf332c0d..aa7a3d6e3444 100644 --- a/src/rustc/middle/tstate/pre_post_conditions.rs +++ b/src/rustc/middle/tstate/pre_post_conditions.rs @@ -49,14 +49,6 @@ fn find_pre_post_item(ccx: crate_ctxt, i: item) { item_mod(m) { find_pre_post_mod(m); } item_native_mod(nm) { find_pre_post_native_mod(nm); } item_ty(*) | item_enum(*) | item_iface(*) { ret; } - item_res(_, _, body, dtor_id, _, _) { - let fcx = - {enclosing: ccx.fm.get(dtor_id), - id: dtor_id, - name: i.ident, - ccx: ccx}; - find_pre_post_fn(fcx, body); - } item_class(*) { fail "find_pre_post_item: shouldn't be called on item_class"; } diff --git a/src/rustc/middle/ty.rs b/src/rustc/middle/ty.rs index 3083563d220e..1c0f5ed053c5 100644 --- a/src/rustc/middle/ty.rs +++ b/src/rustc/middle/ty.rs @@ -93,7 +93,6 @@ export ty_unboxed_vec, mk_unboxed_vec, mk_mut_unboxed_vec; export vstore, vstore_fixed, vstore_uniq, vstore_box, vstore_slice; export ty_nil, mk_nil, type_is_nil; export ty_iface, mk_iface; -export ty_res, mk_res; export ty_param, mk_param, ty_params_to_tys; export ty_ptr, mk_ptr, mk_mut_ptr, mk_imm_ptr, mk_nil_ptr, type_is_unsafe_ptr; export ty_rptr, mk_rptr; @@ -366,7 +365,6 @@ enum sty { ty_fn(fn_ty), ty_iface(def_id, substs), ty_class(def_id, substs), - ty_res(def_id, t, substs), ty_tup([t]), ty_var(tv_vid), // type variable during typechecking @@ -598,11 +596,6 @@ fn mk_t_with_id(cx: ctxt, st: sty, o_def_id: option) -> t { for f.inputs.each {|a| flags |= get(a.ty).flags; } flags |= get(f.output).flags; } - ty_res(_, tt, substs) { - flags |= (has_resources as uint); - flags |= get(tt).flags; - flags |= sflags(substs); - } ty_constr(tt, _) { flags |= get(tt).flags; } @@ -716,11 +709,6 @@ fn mk_class(cx: ctxt, class_id: ast::def_id, substs: substs) -> t { mk_t(cx, ty_class(class_id, substs)) } -fn mk_res(cx: ctxt, did: ast::def_id, - inner: t, substs: substs) -> t { - mk_t(cx, ty_res(did, inner, substs)) -} - fn mk_var(cx: ctxt, v: tv_vid) -> t { mk_t(cx, ty_var(v)) } fn mk_var_integral(cx: ctxt, v: tvi_vid) -> t { @@ -795,10 +783,6 @@ fn maybe_walk_ty(ty: t, f: fn(t) -> bool) { for ft.inputs.each {|a| maybe_walk_ty(a.ty, f); } maybe_walk_ty(ft.output, f); } - ty_res(_, sub, substs) { - maybe_walk_ty(sub, f); - for substs.tps.each {|tp| maybe_walk_ty(tp, f); } - } ty_constr(sub, _) { maybe_walk_ty(sub, f); } ty_uniq(tm) { maybe_walk_ty(tm.ty, f); } } @@ -860,10 +844,6 @@ fn fold_sty(sty: sty, fldop: fn(t) -> t) -> sty { let new_output = fldop(f.output); ty_fn({inputs: new_args, output: new_output with f}) } - ty_res(did, subty, substs) { - ty_res(did, fldop(subty), - fold_substs(substs, fldop)) - } ty_rptr(r, tm) { ty_rptr(r, {ty: fldop(tm.ty), mutbl: tm.mutbl}) } @@ -944,10 +924,6 @@ fn fold_regions_and_ty( ty_iface(def_id, substs) { ty::mk_iface(cx, def_id, fold_substs(substs, fldr, fldt)) } - ty_res(def_id, t, substs) { - ty::mk_res(cx, def_id, fldt(t), - fold_substs(substs, fldr, fldt)) - } sty @ ty_fn(_) { fold_sty_to_ty(cx, sty) {|t| fldfnt(t) @@ -1100,8 +1076,8 @@ fn type_is_bool(ty: t) -> bool { get(ty).struct == ty_bool } fn type_is_structural(ty: t) -> bool { alt get(ty).struct { - ty_rec(_) | ty_class(_, _) | ty_tup(_) | ty_enum(_, _) | ty_fn(_) | - ty_iface(_, _) | ty_res(_, _, _) | ty_evec(_, vstore_fixed(_)) + ty_rec(_) | ty_class(*) | ty_tup(_) | ty_enum(*) | ty_fn(_) | + ty_iface(*) | ty_evec(_, vstore_fixed(_)) | ty_estr(vstore_fixed(_)) { true } _ { false } } @@ -1318,7 +1294,7 @@ fn type_needs_unwind_cleanup_(cx: ctxt, ty: t, } !needs_unwind_cleanup } - ty_uniq(_) | ty_str | ty_vec(_) | ty_res(_, _, _) | + ty_uniq(_) | ty_str | ty_vec(_) | ty_estr(vstore_uniq) | ty_estr(vstore_box) | ty_evec(_, vstore_uniq) | @@ -1605,10 +1581,6 @@ fn type_kind(cx: ctxt, ty: t) -> kind { } lowest } - ty_res(did, inner, tps) { - let inner = subst(cx, tps, inner); - (kind_const() | kind_send_only()) & type_kind(cx, inner) - } ty_param(_, did) { param_bounds_to_kind(cx.ty_param_bounds.get(did.node)) } @@ -1713,18 +1685,6 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool { r } - ty_res(did, _, _) if vec::contains(*seen, did) { - false - } - - ty_res(did, sub, substs) { - vec::push(*seen, did); - let sty = subst(cx, substs, sub); - let r = type_requires(cx, seen, r_ty, sty); - vec::pop(*seen); - r - } - ty_tup(ts) { vec::any(ts) {|t| type_requires(cx, seen, r_ty, t) @@ -1787,10 +1747,6 @@ fn type_structurally_contains(cx: ctxt, ty: t, test: fn(sty) -> bool) -> } ret false; } - ty_res(_, sub, substs) { - let sty = subst(cx, substs, sub); - ret type_structurally_contains(cx, sty, test); - } ty_evec(mt, vstore_fixed(_)) { ret type_structurally_contains(cx, mt.ty, test); } @@ -1895,9 +1851,6 @@ fn type_is_pod(cx: ctxt, ty: t) -> bool { ty_evec(mt, vstore_fixed(_)) | ty_unboxed_vec(mt) { result = type_is_pod(cx, mt.ty); } - ty_res(_, inner, substs) { - result = type_is_pod(cx, subst(cx, substs, inner)); - } ty_constr(subt, _) { result = type_is_pod(cx, subt); } ty_param(_, _) { result = false; } ty_opaque_closure_ptr(_) { result = true; } @@ -1966,11 +1919,6 @@ fn deref_sty(cx: ctxt, sty: sty, expl: bool) -> option { some(mt) } - ty_res(_, inner, substs) { - let inner = subst(cx, substs, inner); - some({ty: inner, mutbl: ast::m_imm}) - } - ty_enum(did, substs) { let variants = enum_variants(cx, did); if vec::len(*variants) == 1u && vec::len(variants[0].args) == 1u { @@ -2111,10 +2059,6 @@ fn hash_type_structure(st: sty) -> uint { h } ty_uniq(mt) { hash_subty(37u, mt.ty) } - ty_res(did, sub, substs) { - let mut h = hash_subty(hash_def(38u, did), sub); - hash_substs(h, substs) - } ty_iface(did, substs) { let mut h = hash_def(40u, did); hash_substs(h, substs) @@ -2452,7 +2396,6 @@ fn ty_sort_str(cx: ctxt, t: t) -> str { ty_fn(_) { "fn" } ty_iface(id, _) { #fmt["iface %s", item_path_str(cx, id)] } ty_class(id, _) { #fmt["class %s", item_path_str(cx, id)] } - ty_res(id, _, _) { #fmt["resource %s", item_path_str(cx, id)] } ty_tup(_) { "tuple" } ty_var(_) { "variable" } ty_var_integral(_) { "integral variable" } @@ -2606,7 +2549,7 @@ fn impl_iface(cx: ctxt, id: ast::def_id) -> option { fn ty_to_def_id(ty: t) -> option { alt get(ty).struct { - ty_iface(id, _) | ty_class(id, _) | ty_res(id, _, _) | ty_enum(id, _) { + ty_iface(id, _) | ty_class(id, _) | ty_enum(id, _) { some(id) } _ { none } @@ -2685,7 +2628,7 @@ fn item_path(cx: ctxt, id: ast::def_id) -> ast_map::path { vec::init(*path) + [ast_map::path_name(variant.node.name)] } - ast_map::node_ctor(nm, _, _, path) { + ast_map::node_ctor(nm, _, _, _, path) { *path + [ast_map::path_name(nm)] } ast_map::node_dtor(_, _, _, path) { diff --git a/src/rustc/middle/typeck/check.rs b/src/rustc/middle/typeck/check.rs index e3f6ba40aefd..86d105adb990 100644 --- a/src/rustc/middle/typeck/check.rs +++ b/src/rustc/middle/typeck/check.rs @@ -354,10 +354,6 @@ fn check_item(ccx: @crate_ctxt, it: @ast::item) { ast::item_fn(decl, tps, body) { check_bare_fn(ccx, decl, body, it.id, none); } - ast::item_res(decl, tps, body, dtor_id, _, rp) { - check_instantiable(ccx.tcx, it.span, it.id); - check_bare_fn(ccx, decl, body, dtor_id, none); - } ast::item_impl(tps, rp, _, ty, ms) { let self_ty = ccx.to_ty(rscope::type_rscope(rp), ty); for ms.each {|m| check_method(ccx, m, self_ty);} diff --git a/src/rustc/middle/typeck/collect.rs b/src/rustc/middle/typeck/collect.rs index b693ddb8492e..ea04fd96b276 100644 --- a/src/rustc/middle/typeck/collect.rs +++ b/src/rustc/middle/typeck/collect.rs @@ -261,11 +261,6 @@ fn convert_class_item(ccx: @crate_ctxt, rp: ast::region_param, bounds: @[ty::param_bounds], v: ast_util::ivar) { - /* we want to do something here, b/c within the - scope of the class, it's ok to refer to fields & - methods unqualified */ - /* they have these types *within the scope* of the - class. outside the class, it's done with expr_field */ let tt = ccx.to_ty(type_rscope(rp), v.ty); write_ty_to_tcx(ccx.tcx, v.id, tt); /* add the field to the tcache */ @@ -322,37 +317,6 @@ fn convert(ccx: @crate_ctxt, it: @ast::item) { check_methods_against_iface(ccx, tps, rp, selfty, t, cms); } } - ast::item_res(decl, tps, _, dtor_id, ctor_id, rp) { - let {bounds, substs} = mk_substs(ccx, tps, rp); - let def_id = local_def(it.id); - let t_arg = ty_of_arg(ccx, type_rscope(rp), - decl.inputs[0], none); - let t_res = ty::mk_res(tcx, def_id, t_arg.ty, substs); - - let t_ctor = ty::mk_fn(tcx, { - purity: ast::pure_fn, - proto: ast::proto_box, - inputs: [{mode: ast::expl(ast::by_copy), ty: t_arg.ty}], - output: t_res, - ret_style: ast::return_val, constraints: [] - }); - let t_dtor = ty::mk_fn(tcx, { - purity: ast::impure_fn, - proto: ast::proto_box, - inputs: [t_arg], output: ty::mk_nil(tcx), - ret_style: ast::return_val, constraints: [] - }); - write_ty_to_tcx(tcx, it.id, t_res); - write_ty_to_tcx(tcx, ctor_id, t_ctor); - tcx.tcache.insert(local_def(ctor_id), - {bounds: bounds, - rp: rp, - ty: t_ctor}); - tcx.tcache.insert(def_id, {bounds: bounds, - rp: rp, - ty: t_res}); - write_ty_to_tcx(tcx, dtor_id, t_dtor); - } ast::item_iface(*) { let tpt = ty_of_item(ccx, it); #debug["item_iface(it.id=%d, tpt.ty=%s)", @@ -366,11 +330,21 @@ fn convert(ccx: @crate_ctxt, it: @ast::item) { write_ty_to_tcx(tcx, it.id, tpt.ty); tcx.tcache.insert(local_def(it.id), tpt); // Write the ctor type - let t_ctor = - ty::mk_fn( - tcx, - ty_of_fn_decl(ccx, type_rscope(rp), ast::proto_any, - ctor.node.dec, none)); + let t_args = ctor.node.dec.inputs.map {|a| + ty_of_arg(ccx, type_rscope(rp), a, none)}; + let t_res = ty::mk_class(tcx, local_def(it.id), + {self_r: alt rp { + ast::rp_none { none } + ast::rp_self { some(ty::re_bound(ty::br_self)) } + }, + self_ty: none, + tps: ty::ty_params_to_tys(tcx, tps)}); + let t_ctor = ty::mk_fn(tcx, {purity: ast::impure_fn, + proto: ast::proto_any, + inputs: t_args, + output: t_res, + ret_style: ast::return_val, + constraints: []}); // tjc TODO write_ty_to_tcx(tcx, ctor.node.id, t_ctor); tcx.tcache.insert(local_def(ctor.node.id), {bounds: tpt.bounds, @@ -538,15 +512,6 @@ fn ty_of_item(ccx: @crate_ctxt, it: @ast::item) tcx.tcache.insert(local_def(it.id), tpt); ret tpt; } - ast::item_res(decl, tps, _, _, _, rp) { - let {bounds, substs} = mk_substs(ccx, tps, rp); - let t_arg = ty_of_arg(ccx, type_rscope(rp), - decl.inputs[0], none); - let t = ty::mk_res(tcx, local_def(it.id), t_arg.ty, substs); - let t_res = {bounds: bounds, rp: rp, ty: t}; - tcx.tcache.insert(local_def(it.id), t_res); - ret t_res; - } ast::item_enum(_, tps, rp) { // Create a new generic polytype. let {bounds, substs} = mk_substs(ccx, tps, rp); diff --git a/src/rustc/middle/typeck/infer.rs b/src/rustc/middle/typeck/infer.rs index e948e999e5c8..1225908abb84 100644 --- a/src/rustc/middle/typeck/infer.rs +++ b/src/rustc/middle/typeck/infer.rs @@ -1851,16 +1851,6 @@ fn super_tys( } } - (ty::ty_res(a_id, a_t, a_substs), - ty::ty_res(b_id, b_t, b_substs)) - if a_id == b_id { - self.tys(a_t, b_t).chain {|t| - self.substs(a_substs, b_substs).chain {|substs| - ok(ty::mk_res(tcx, a_id, t, substs)) - } - } - } - (ty::ty_rec(as), ty::ty_rec(bs)) { if check vec::same_length(as, bs) { map_vec2(as, bs) {|a,b| diff --git a/src/rustc/util/ppaux.rs b/src/rustc/util/ppaux.rs index 83167597bb87..f44d43d35ede 100644 --- a/src/rustc/util/ppaux.rs +++ b/src/rustc/util/ppaux.rs @@ -6,7 +6,7 @@ import middle::ty::{mt, re_bound, re_free, re_scope, re_var, region, t}; import middle::ty::{ty_bool, ty_bot, ty_box, ty_class, ty_constr, ty_enum}; import middle::ty::{ty_estr, ty_evec, ty_float, ty_fn, ty_iface, ty_int}; import middle::ty::{ty_nil, ty_opaque_box, ty_opaque_closure_ptr, ty_param}; -import middle::ty::{ty_ptr, ty_rec, ty_res, ty_rptr, ty_self, ty_str, ty_tup}; +import middle::ty::{ty_ptr, ty_rec, ty_rptr, ty_self, ty_str, ty_tup}; import middle::ty::{ty_type, ty_uniq, ty_uint, ty_var, ty_var_integral}; import middle::ty::{ty_vec, ty_unboxed_vec, vid}; import metadata::encoder; @@ -208,7 +208,7 @@ fn ty_to_str(cx: ctxt, typ: t) -> str { "'" + str::from_bytes([('a' as u8) + (id as u8)]) } ty_self { "self" } - ty_enum(did, substs) | ty_res(did, _, substs) | ty_class(did, substs) { + ty_enum(did, substs) | ty_class(did, substs) { let path = ty::item_path(cx, did); let base = ast_map::path_to_str(path); parameterized(cx, base, substs.self_r, substs.tps) diff --git a/src/rustdoc/demo.rs b/src/rustdoc/demo.rs index f39fe1f8120d..9c700a237200 100644 --- a/src/rustdoc/demo.rs +++ b/src/rustdoc/demo.rs @@ -115,8 +115,10 @@ eget ante feugiat tortor congue auctor ac quis ante. Proin condimentum lacinia tincidunt. "] -resource bored(bored: bool) { - log(error, bored); +class bored { + let bored: bool; + new(bored: bool) { self.bored = bored; } + drop { log(error, self.bored); } } #[doc = " diff --git a/src/rustdoc/doc.rs b/src/rustdoc/doc.rs index 84d7c8c31fd3..12ee7e6ca709 100644 --- a/src/rustdoc/doc.rs +++ b/src/rustdoc/doc.rs @@ -33,7 +33,6 @@ enum itemtag { consttag(constdoc), fntag(fndoc), enumtag(enumdoc), - restag(resdoc), ifacetag(ifacedoc), impltag(impldoc), tytag(tydoc) @@ -82,8 +81,6 @@ type variantdoc = { sig: option }; -type resdoc = simpleitemdoc; - type ifacedoc = { item: itemdoc, methods: [methoddoc] @@ -192,15 +189,6 @@ impl util for moddoc { } } - fn resources() -> [resdoc] { - vec::filter_map(self.items) {|itemtag| - alt itemtag { - restag(resdoc) { some(resdoc) } - _ { none } - } - } - } - fn ifaces() -> [ifacedoc] { vec::filter_map(self.items) {|itemtag| alt itemtag { @@ -276,15 +264,6 @@ impl util for [page] { } } - fn resources() -> [resdoc] { - vec::filter_map(self) {|page| - alt page { - itempage(restag(resdoc)) { some(resdoc) } - _ { none } - } - } - } - fn ifaces() -> [ifacedoc] { vec::filter_map(self) {|page| alt page { @@ -325,7 +304,6 @@ impl of item for itemtag { doc::fntag(doc) { doc.item } doc::consttag(doc) { doc.item } doc::enumtag(doc) { doc.item } - doc::restag(doc) { doc.item } doc::ifacetag(doc) { doc.item } doc::impltag(doc) { doc.item } doc::tytag(doc) { doc.item } diff --git a/src/rustdoc/extract.rs b/src/rustdoc/extract.rs index 35e9fd5ea31b..99663adf32ff 100644 --- a/src/rustdoc/extract.rs +++ b/src/rustdoc/extract.rs @@ -83,11 +83,6 @@ fn moddoc_from_mod( enumdoc_from_enum(itemdoc, variants) )) } - ast::item_res(_, _, _, _, _, _) { - some(doc::restag( - resdoc_from_resource(itemdoc) - )) - } ast::item_iface(_, _, methods) { some(doc::ifacetag( ifacedoc_from_iface(itemdoc, methods) @@ -188,20 +183,6 @@ fn should_extract_enum_variants() { assert doc.cratemod().enums()[0].variants[0].name == "v"; } -fn resdoc_from_resource(itemdoc: doc::itemdoc) -> doc::resdoc { - { - item: itemdoc, - sig: none - } -} - -#[test] -fn should_extract_resources() { - let doc = test::mk_doc("resource r(b: bool) { }"); - assert doc.cratemod().resources()[0].id() != 0; - assert doc.cratemod().resources()[0].name() == "r"; -} - fn ifacedoc_from_iface( itemdoc: doc::itemdoc, methods: [ast::ty_method] diff --git a/src/rustdoc/fold.rs b/src/rustdoc/fold.rs index 02d98164d10f..e502bb7ce417 100644 --- a/src/rustdoc/fold.rs +++ b/src/rustdoc/fold.rs @@ -8,7 +8,6 @@ export default_seq_fold_nmod; export default_seq_fold_fn; export default_seq_fold_const; export default_seq_fold_enum; -export default_seq_fold_res; export default_seq_fold_iface; export default_seq_fold_impl; export default_seq_fold_type; @@ -29,7 +28,6 @@ type fold_nmod = fn~(fold: fold, doc: doc::nmoddoc) -> doc::nmoddoc; type fold_fn = fn~(fold: fold, doc: doc::fndoc) -> doc::fndoc; type fold_const = fn~(fold: fold, doc: doc::constdoc) -> doc::constdoc; type fold_enum = fn~(fold: fold, doc: doc::enumdoc) -> doc::enumdoc; -type fold_res = fn~(fold: fold, doc: doc::resdoc) -> doc::resdoc; type fold_iface = fn~(fold: fold, doc: doc::ifacedoc) -> doc::ifacedoc; type fold_impl = fn~(fold: fold, doc: doc::impldoc) -> doc::impldoc; type fold_type = fn~(fold: fold, doc: doc::tydoc) -> doc::tydoc; @@ -44,7 +42,6 @@ type t = { fold_fn: fold_fn, fold_const: fold_const, fold_enum: fold_enum, - fold_res: fold_res, fold_iface: fold_iface, fold_impl: fold_impl, fold_type: fold_type @@ -63,7 +60,6 @@ fn mk_fold( +fold_fn: fold_fn, +fold_const: fold_const, +fold_enum: fold_enum, - +fold_res: fold_res, +fold_iface: fold_iface, +fold_impl: fold_impl, +fold_type: fold_type @@ -78,7 +74,6 @@ fn mk_fold( fold_fn: fold_fn, fold_const: fold_const, fold_enum: fold_enum, - fold_res: fold_res, fold_iface: fold_iface, fold_impl: fold_impl, fold_type: fold_type @@ -96,7 +91,6 @@ fn default_any_fold(ctxt: T) -> fold { {|f, d| default_seq_fold_fn(f, d)}, {|f, d| default_seq_fold_const(f, d)}, {|f, d| default_seq_fold_enum(f, d)}, - {|f, d| default_seq_fold_res(f, d)}, {|f, d| default_seq_fold_iface(f, d)}, {|f, d| default_seq_fold_impl(f, d)}, {|f, d| default_seq_fold_type(f, d)} @@ -114,7 +108,6 @@ fn default_seq_fold(ctxt: T) -> fold { {|f, d| default_seq_fold_fn(f, d)}, {|f, d| default_seq_fold_const(f, d)}, {|f, d| default_seq_fold_enum(f, d)}, - {|f, d| default_seq_fold_res(f, d)}, {|f, d| default_seq_fold_iface(f, d)}, {|f, d| default_seq_fold_impl(f, d)}, {|f, d| default_seq_fold_type(f, d)} @@ -132,7 +125,6 @@ fn default_par_fold(ctxt: T) -> fold { {|f, d| default_seq_fold_fn(f, d)}, {|f, d| default_seq_fold_const(f, d)}, {|f, d| default_seq_fold_enum(f, d)}, - {|f, d| default_seq_fold_res(f, d)}, {|f, d| default_seq_fold_iface(f, d)}, {|f, d| default_seq_fold_impl(f, d)}, {|f, d| default_seq_fold_type(f, d)} @@ -266,9 +258,6 @@ fn fold_itemtag(fold: fold, doc: doc::itemtag) -> doc::itemtag { doc::enumtag(enumdoc) { doc::enumtag(fold.fold_enum(fold, enumdoc)) } - doc::restag(resdoc) { - doc::restag(fold.fold_res(fold, resdoc)) - } doc::ifacetag(ifacedoc) { doc::ifacetag(fold.fold_iface(fold, ifacedoc)) } @@ -311,16 +300,6 @@ fn default_seq_fold_enum( } } -fn default_seq_fold_res( - fold: fold, - doc: doc::resdoc -) -> doc::resdoc { - { - item: fold.fold_item(fold, doc.item) - with doc - } -} - fn default_seq_fold_iface( fold: fold, doc: doc::ifacedoc diff --git a/src/rustdoc/markdown_pass.rs b/src/rustdoc/markdown_pass.rs index b98690f4fd9f..ec700b755e79 100644 --- a/src/rustdoc/markdown_pass.rs +++ b/src/rustdoc/markdown_pass.rs @@ -198,9 +198,6 @@ fn header_kind(doc: doc::itemtag) -> str { doc::enumtag(_) { "Enum" } - doc::restag(_) { - "Resource" - } doc::ifacetag(_) { "Interface" } @@ -352,7 +349,6 @@ fn write_item_(ctxt: ctxt, doc: doc::itemtag, write_header: bool) { doc::fntag(fndoc) { write_fn(ctxt, fndoc) } doc::consttag(constdoc) { write_const(ctxt, constdoc) } doc::enumtag(enumdoc) { write_enum(ctxt, enumdoc) } - doc::restag(resdoc) { write_res(ctxt, resdoc) } doc::ifacetag(ifacedoc) { write_iface(ctxt, ifacedoc) } doc::impltag(impldoc) { write_impl(ctxt, impldoc) } doc::tytag(tydoc) { write_type(ctxt, tydoc) } @@ -643,11 +639,6 @@ fn should_write_variant_list_with_signatures() { \n* `c(int)` - a\n\n"); } -fn write_res(ctxt: ctxt, doc: doc::resdoc) { - write_sig(ctxt, doc.sig); - write_common(ctxt, doc.desc(), doc.sections()); -} - #[test] fn should_write_resource_header() { let markdown = test::render("resource r(a: bool) { }"); diff --git a/src/rustdoc/prune_unexported_pass.rs b/src/rustdoc/prune_unexported_pass.rs index d581ead494a9..f0eac40a297f 100644 --- a/src/rustdoc/prune_unexported_pass.rs +++ b/src/rustdoc/prune_unexported_pass.rs @@ -201,19 +201,6 @@ fn should_prune_unexported_variants() { assert vec::len(doc.cratemod().mods()[0].enums()[0].variants) == 0u; } -#[test] -fn should_prune_unexported_resources_from_top_mod() { - let doc = test::mk_doc("export a; mod a { } resource r(a: bool) { }"); - assert vec::is_empty(doc.cratemod().resources()); -} - -#[test] -fn should_prune_unexported_resources() { - let doc = test::mk_doc( - "mod a { export a; mod a { } resource r(a: bool) { } }"); - assert vec::is_empty(doc.cratemod().mods()[0].resources()); -} - #[test] fn should_prune_unexported_ifaces_from_top_mod() { let doc = test::mk_doc("export a; mod a { } iface b { fn c(); }"); diff --git a/src/rustdoc/reexport_pass.rs b/src/rustdoc/reexport_pass.rs index b79d8e88f504..54beb0139607 100644 --- a/src/rustdoc/reexport_pass.rs +++ b/src/rustdoc/reexport_pass.rs @@ -374,12 +374,6 @@ fn merge_reexports( with doc }) } - doc::restag(doc @ {item, _}) { - doc::restag({ - item: reexport(item, name) - with doc - }) - } doc::ifacetag(doc @ {item, _}) { doc::ifacetag({ item: reexport(item, name) diff --git a/src/rustdoc/sort_item_type_pass.rs b/src/rustdoc/sort_item_type_pass.rs index a01c914b8a4d..96c438a0678a 100644 --- a/src/rustdoc/sort_item_type_pass.rs +++ b/src/rustdoc/sort_item_type_pass.rs @@ -9,7 +9,6 @@ fn mk_pass() -> pass { doc::consttag(_) { 0 } doc::tytag(_) { 1 } doc::enumtag(_) { 2 } - doc::restag(_) { 3 } doc::ifacetag(_) { 4 } doc::impltag(_) { 5 } doc::fntag(_) { 6 } @@ -30,7 +29,6 @@ fn test() { const iconst: int = 0; \ fn ifn() { } \ enum ienum { ivar } \ - resource ires(a: bool) { } \ iface iiface { fn a(); } \ impl iimpl for int { fn a() { } } \ type itype = int;"; @@ -40,7 +38,6 @@ fn test() { assert doc.cratemod().items[0].name() == "iconst"; assert doc.cratemod().items[1].name() == "itype"; assert doc.cratemod().items[2].name() == "ienum"; - assert doc.cratemod().items[3].name() == "ires"; assert doc.cratemod().items[4].name() == "iiface"; assert doc.cratemod().items[5].name() == "iimpl"; assert doc.cratemod().items[6].name() == "ifn"; diff --git a/src/rustdoc/text_pass.rs b/src/rustdoc/text_pass.rs index fa14367a3160..bbeaf4b9d2fa 100644 --- a/src/rustdoc/text_pass.rs +++ b/src/rustdoc/text_pass.rs @@ -114,18 +114,6 @@ fn should_execute_op_on_variant_desc() { assert doc.cratemod().enums()[0].variants[0].desc == some("a"); } -#[test] -fn should_execute_op_on_resource_brief() { - let doc = test::mk_doc("#[doc = \" a \"] resource r(a: bool) { }"); - assert doc.cratemod().resources()[0].brief() == some("a"); -} - -#[test] -fn should_execute_op_on_resource_desc() { - let doc = test::mk_doc("#[doc = \" a \"] resource r(a: bool) { }"); - assert doc.cratemod().resources()[0].desc() == some("a"); -} - #[test] fn should_execute_op_on_iface_brief() { let doc = test::mk_doc( diff --git a/src/rustdoc/tystr_pass.rs b/src/rustdoc/tystr_pass.rs index 85740205ffa5..e18be9b43012 100644 --- a/src/rustdoc/tystr_pass.rs +++ b/src/rustdoc/tystr_pass.rs @@ -23,7 +23,6 @@ fn run( fold_fn: fold_fn, fold_const: fold_const, fold_enum: fold_enum, - fold_res: fold_res, fold_iface: fold_iface, fold_impl: fold_impl, fold_type: fold_type @@ -139,33 +138,6 @@ fn should_add_variant_sigs() { assert doc.cratemod().enums()[0].variants[0].sig == some("b(int)"); } -fn fold_res( - fold: fold::fold, - doc: doc::resdoc -) -> doc::resdoc { - let srv = fold.ctxt; - - { - sig: some(astsrv::exec(srv) {|ctxt| - alt check ctxt.ast_map.get(doc.id()) { - ast_map::node_item(@{ - node: ast::item_res(decl, tys, _, _, _, rp), _ - }, _) { - pprust::res_to_str(decl, @doc.name(), tys, rp) - } - } - }) - with doc - } -} - -#[test] -fn should_add_resource_sigs() { - let doc = test::mk_doc("resource r(b: bool) { }"); - assert doc.cratemod().resources()[0].sig - == some("resource r(b: bool)"); -} - fn fold_iface( fold: fold::fold, doc: doc::ifacedoc diff --git a/src/test/compile-fail/regions-in-rsrcs.rs b/src/test/compile-fail/regions-in-rsrcs.rs index b190491e6d6b..fe1482f92e81 100644 --- a/src/test/compile-fail/regions-in-rsrcs.rs +++ b/src/test/compile-fail/regions-in-rsrcs.rs @@ -1,17 +1,17 @@ class no0 { - let x: &uint; + let x: &uint; //! ERROR to use region types here, the containing type must be declared with a region bound new(x: &uint) { self.x = x; } //! ERROR to use region types here, the containing type must be declared with a region bound drop {} } class no1 { - let x: &self.uint; + let x: &self.uint; //! ERROR to use region types here, the containing type must be declared with a region bound new(x: &self.uint) { self.x = x; } //! ERROR to use region types here, the containing type must be declared with a region bound drop {} } class no2 { - let x: &foo.uint; + let x: &foo.uint; //! ERROR named regions other than `self` are not allowed as part of a type declaration new(x: &foo.uint) { self.x = x; } //! ERROR named regions other than `self` are not allowed as part of a type declaration drop {} } @@ -29,7 +29,7 @@ class yes1/& { } class yes2/& { - let x: &foo.uint; + let x: &foo.uint; //! ERROR named regions other than `self` are not allowed as part of a type declaration new(x: &foo.uint) { self.x = x; } //! ERROR named regions other than `self` are not allowed as part of a type declaration drop {} } diff --git a/src/test/run-pass/resource-cycle.rs b/src/test/run-pass/resource-cycle.rs index d991fc2dffa3..a20d18ea61ed 100644 --- a/src/test/run-pass/resource-cycle.rs +++ b/src/test/run-pass/resource-cycle.rs @@ -1,7 +1,20 @@ // Don't leak the unique pointers -resource r(v: *int) unsafe { - let v2: ~int = unsafe::reinterpret_cast(v); +class r { + let v: *int; + new(v: *int) unsafe { + self.v = v; + #debug("r's ctor: v = %x, self = %x, self.v = %x", + unsafe::reinterpret_cast::<*int, uint>(v), + unsafe::reinterpret_cast::<*r, uint>(ptr::addr_of(self)), + unsafe::reinterpret_cast::<**int, uint>(ptr::addr_of(self.v))); + } + drop unsafe { + #debug("r's dtor: self = %x, self.v = %x, self.v's value = %x", + unsafe::reinterpret_cast::<*r, uint>(ptr::addr_of(self)), + unsafe::reinterpret_cast::<**int, uint>(ptr::addr_of(self.v)), + unsafe::reinterpret_cast::<*int, uint>(self.v)); + let v2: ~int = unsafe::reinterpret_cast(self.v); } } enum t = { @@ -19,12 +32,31 @@ fn main() unsafe { let x1 = @t({ mut next: none, - r: r(i1p) + r: { + let rs = r(i1p); + #debug("r = %x", + unsafe::reinterpret_cast::<*r, uint>(ptr::addr_of(rs))); + rs } }); + + #debug("x1 = %x, x1.r = %x", + unsafe::reinterpret_cast::<@t, uint>(x1), + unsafe::reinterpret_cast::<*r, uint>(ptr::addr_of(x1.r))); + let x2 = @t({ mut next: none, - r: r(i2p) + r: { + let rs = r(i2p); + #debug("r2 = %x", + unsafe::reinterpret_cast::<*r, uint>(ptr::addr_of(rs))); + rs + } }); + + #debug("x2 = %x, x2.r = %x", + unsafe::reinterpret_cast::<@t, uint>(x2), + unsafe::reinterpret_cast::<*r, uint>(ptr::addr_of(x2.r))); + x1.next = some(x2); x2.next = some(x1); } diff --git a/src/test/run-pass/resource-cycle2.rs b/src/test/run-pass/resource-cycle2.rs index 85bfc195bd4a..4f0f87908cff 100644 --- a/src/test/run-pass/resource-cycle2.rs +++ b/src/test/run-pass/resource-cycle2.rs @@ -6,8 +6,12 @@ type u = { c: *int }; -resource r(v: u) unsafe { - let v2: ~int = unsafe::reinterpret_cast(v.c); +class r { + let v: u; + new(v: u) { self.v = v; } + drop unsafe { + let v2: ~int = unsafe::reinterpret_cast(self.v.c); + } } enum t = {