squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

rustc: remove the rest of drop

Browse source 
Removes:

ast::struct_def::dtor
syntax::ast::ii_dtor
syntax::visit::fk_dtor
syntax::ast_map::node_dtor
syntax:struct_dtor
This commit is contained in:
Erick Tryzelaar 2013-04-30 21:00:45 -07:00
parent 7d6d0029ba
commit c2e1f47955
30 changed files with 21 additions and 538 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/librustc/metadata/common.rs
View file

@ -100,7 +100,6 @@ pub static tag_mod_impl_trait: uint = 0x47u;
different tags.
*/
pub static tag_item_impl_method: uint = 0x48u;
pub static tag_item_dtor: uint = 0x49u;
pub static tag_item_trait_method_self_ty: uint = 0x4b;
pub static tag_item_trait_method_self_ty_region: uint = 0x4c;

7
src/librustc/metadata/csearch.rs
View file

@ -230,13 +230,6 @@ pub fn get_impl_method(cstore: @mut cstore::CStore,
decoder::get_impl_method(cstore.intr, cdata, def.node, mname)
}
/* If def names a class with a dtor, return it. Otherwise, return none. */
pub fn struct_dtor(cstore: @mut cstore::CStore, def: ast::def_id)
-> Option<ast::def_id> {
let cdata = cstore::get_crate_data(cstore, def.crate);
decoder::struct_dtor(cdata, def.node)
}
pub fn get_item_visibility(cstore: @mut cstore::CStore,
def_id: ast::def_id)
-> ast::visibility {

16
src/librustc/metadata/decoder.rs
View file

@ -445,22 +445,6 @@ pub fn get_impl_method(intr: @ident_interner, cdata: cmd, id: ast::node_id,
found.get()
}
pub fn struct_dtor(cdata: cmd, id: ast::node_id) -> Option<ast::def_id> {
let items = reader::get_doc(reader::Doc(cdata.data), tag_items);
let mut found = None;
let cls_items = match maybe_find_item(id, items) {
Some(it) => it,
None => fail!(fmt!("struct_dtor: class id not found \
when looking up dtor for %d", id))
};
for reader::tagged_docs(cls_items, tag_item_dtor) |doc| {
let doc1 = reader::get_doc(doc, tag_def_id);
let did = reader::with_doc_data(doc1, |d| parse_def_id(d));
found = Some(translate_def_id(cdata, did));
};
found
}
pub fn get_symbol(data: @~[u8], id: ast::node_id) -> ~str {
return item_symbol(lookup_item(id, data));
}

27
src/librustc/metadata/encoder.rs
View file

@ -765,26 +765,6 @@ fn encode_info_for_item(ecx: @EncodeContext, ebml_w: &writer::Encoder,
class itself */
let idx = encode_info_for_struct(ecx, ebml_w, path,
struct_def.fields, index);
/* Encode the dtor */
for struct_def.dtor.each |dtor| {
index.push(entry {val: dtor.node.id, pos: ebml_w.writer.tell()});
encode_info_for_ctor(ecx,
ebml_w,
dtor.node.id,
ecx.tcx.sess.ident_of(
*ecx.tcx.sess.str_of(item.ident) +
~"_dtor"),
path,
if generics.ty_params.len() > 0u {
Some(ii_dtor(copy *dtor,
item.ident,
copy *generics,
local_def(item.id))) }
else {
None
},
generics);
}
/* Index the class*/
add_to_index();
@ -816,13 +796,6 @@ fn encode_info_for_item(ecx: @EncodeContext, ebml_w: &writer::Encoder,
encode_name(ecx, ebml_w, item.ident);
encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
encode_region_param(ecx, ebml_w, item);
/* Encode the dtor */
/* Encode id for dtor */
for struct_def.dtor.each |dtor| {
do ebml_w.wr_tag(tag_item_dtor) {
encode_def_id(ebml_w, local_def(dtor.node.id));
}
};
/* Encode def_ids for each field and method
for methods, write all the stuff get_trait_method

26
src/librustc/middle/astencode.rs
View file

@ -327,15 +327,6 @@ fn simplify_ast(ii: &ast::inlined_item) -> ast::inlined_item {
ast::ii_foreign(i) => {
ast::ii_foreign(fld.fold_foreign_item(i))
}
ast::ii_dtor(ref dtor, nm, ref tps, parent_id) => {
let dtor_body = fld.fold_block(&dtor.node.body);
ast::ii_dtor(
codemap::spanned {
node: ast::struct_dtor_ { body: dtor_body,
.. /*bad*/copy (*dtor).node },
.. (/*bad*/copy *dtor) },
nm, /*bad*/copy *tps, parent_id)
}
}
}
@ -363,23 +354,6 @@ fn renumber_ast(xcx: @ExtendedDecodeContext, ii: ast::inlined_item)
ast::ii_foreign(i) => {
ast::ii_foreign(fld.fold_foreign_item(i))
}
ast::ii_dtor(ref dtor, nm, ref generics, parent_id) => {
let dtor_body = fld.fold_block(&dtor.node.body);
let dtor_attrs = fld.fold_attributes(/*bad*/copy (*dtor).node.attrs);
let new_generics = fold::fold_generics(generics, fld);
let dtor_id = fld.new_id((*dtor).node.id);
let new_parent = xcx.tr_def_id(parent_id);
let new_self = fld.new_id((*dtor).node.self_id);
ast::ii_dtor(
codemap::spanned {
node: ast::struct_dtor_ { id: dtor_id,
attrs: dtor_attrs,
self_id: new_self,
body: dtor_body },
.. (/*bad*/copy *dtor)
},
nm, new_generics, new_parent)
}
}
}

6
src/librustc/middle/borrowck/check_loans.rs
View file

@ -629,8 +629,7 @@ fn check_loans_in_fn(fk: &visit::fn_kind,
let declared_purity, src;
match *fk {
visit::fk_item_fn(*) | visit::fk_method(*) |
visit::fk_dtor(*) => {
visit::fk_item_fn(*) | visit::fk_method(*) => {
declared_purity = ty::ty_fn_purity(fty);
src = id;
}
@ -658,8 +657,7 @@ fn check_loans_in_fn(fk: &visit::fn_kind,
// inherits the fn_args from enclosing ctxt
}
visit::fk_anon(*) | visit::fk_fn_block(*) |
visit::fk_method(*) | visit::fk_item_fn(*) |
visit::fk_dtor(*) => {
visit::fk_method(*) | visit::fk_item_fn(*) => {
let mut fn_args = ~[];
for decl.inputs.each |input| {
// For the purposes of purity, only consider function-

3
src/librustc/middle/borrowck/gather_loans.rs
View file

@ -104,8 +104,7 @@ fn req_loans_in_fn(fk: &visit::fn_kind,
match *fk {
visit::fk_anon(*) | visit::fk_fn_block(*) => {}
visit::fk_item_fn(*) | visit::fk_method(*) |
visit::fk_dtor(*) => {
visit::fk_item_fn(*) | visit::fk_method(*) => {
self.item_ub = body.node.id;
}
}

11
src/librustc/middle/kind.rs
View file

@ -153,17 +153,6 @@ fn check_item(item: @item, cx: Context, visitor: visit::vt<Context>) {
}
}
}
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);
}
}
}
_ => {}
}
}

29
src/librustc/middle/lint.rs
View file

@ -57,7 +57,6 @@ pub enum lint {
type_limits,
default_methods,
deprecated_mutable_fields,
deprecated_drop,
unused_unsafe,
managed_heap_memory,
@ -210,13 +209,6 @@ pub fn get_lint_dict() -> LintDict {
default: deny
}),
(~"deprecated_drop",
LintSpec {
lint: deprecated_drop,
desc: "deprecated \"drop\" notation for the destructor",
default: deny
}),
(~"unused_unsafe",
LintSpec {
lint: unused_unsafe,
@ -463,7 +455,6 @@ fn check_item(i: @ast::item, cx: ty::ctxt) {
check_item_type_limits(cx, i);
check_item_default_methods(cx, i);
check_item_deprecated_mutable_fields(cx, i);
check_item_deprecated_drop(cx, i);
check_item_unused_unsafe(cx, i);
check_item_unused_mut(cx, i);
}
@ -668,26 +659,6 @@ fn check_item_deprecated_mutable_fields(cx: ty::ctxt, item: @ast::item) {
}
}
fn check_item_deprecated_drop(cx: ty::ctxt, item: @ast::item) {
match item.node {
ast::item_struct(struct_def, _) => {
match struct_def.dtor {
None => {}
Some(ref dtor) => {
cx.sess.span_lint(deprecated_drop,
item.id,
item.id,
dtor.span,
~"`drop` notation for destructors is \
deprecated; implement the `Drop` \
trait instead");
}
}
}
_ => {}
}
}
fn check_item_ctypes(cx: ty::ctxt, it: @ast::item) {
fn check_foreign_fn(cx: ty::ctxt, fn_id: ast::node_id,

5
src/librustc/middle/liveness.rs
View file

@ -117,7 +117,7 @@ use syntax::ast::*;
use syntax::codemap::span;
use syntax::parse::token::special_idents;
use syntax::print::pprust::{expr_to_str, block_to_str};
use syntax::visit::{fk_anon, fk_dtor, fk_fn_block, fk_item_fn, fk_method};
use syntax::visit::{fk_anon, fk_fn_block, fk_item_fn, fk_method};
use syntax::visit::{vt};
use syntax::{visit, ast_util};
@ -440,9 +440,6 @@ fn visit_fn(fk: &visit::fn_kind,
sty_static => {}
}
}
fk_dtor(_, _, self_id, _) => {
fn_maps.add_variable(Arg(self_id, special_idents::self_));
}
fk_item_fn(*) | fk_anon(*) | fk_fn_block(*) => {}
}

3
src/librustc/middle/region.rs
View file

@ -438,8 +438,7 @@ pub fn resolve_fn(fk: &visit::fn_kind,
cx: ctxt,
visitor: visit::vt<ctxt>) {
let fn_cx = match *fk {
visit::fk_item_fn(*) | visit::fk_method(*) |
visit::fk_dtor(*) => {
visit::fk_item_fn(*) | visit::fk_method(*) => {
// Top-level functions are a root scope.
ctxt {parent: Some(id),.. cx}
}

21
src/librustc/middle/resolve.rs
View file

@ -47,7 +47,7 @@ use syntax::ast::{named_field, ne, neg, node_id, pat, pat_enum, pat_ident};
use syntax::ast::{Path, pat_lit, pat_range, pat_struct};
use syntax::ast::{prim_ty, private, provided};
use syntax::ast::{public, required, rem, self_ty_, shl, shr, stmt_decl};
use syntax::ast::{struct_dtor, struct_field, struct_variant_kind};
use syntax::ast::{struct_field, struct_variant_kind};
use syntax::ast::{sty_static, subtract, trait_ref, tuple_variant_kind, Ty};
use syntax::ast::{ty_bool, ty_char, ty_f, ty_f32, ty_f64, ty_float, ty_i};
use syntax::ast::{ty_i16, ty_i32, ty_i64, ty_i8, ty_int, TyParam, ty_path};
@ -3512,7 +3512,6 @@ pub impl Resolver {
self.resolve_struct(item.id,
generics,
struct_def.fields,
&struct_def.dtor,
visitor);
}
@ -3770,7 +3769,6 @@ pub impl Resolver {
id: node_id,
generics: &Generics,
fields: &[@struct_field],
optional_destructor: &Option<struct_dtor>,
visitor: ResolveVisitor) {
// If applicable, create a rib for the type parameters.
do self.with_type_parameter_rib(HasTypeParameters
@ -3784,23 +3782,6 @@ pub impl Resolver {
for fields.each |field| {
self.resolve_type(field.node.ty, visitor);
}
// Resolve the destructor, if applicable.
match *optional_destructor {
None => {
// Nothing to do.
}
Some(ref destructor) => {
self.resolve_function(NormalRibKind,
None,
NoTypeParameters,
&destructor.node.body,
HasSelfBinding
((*destructor).node.self_id,
true),
visitor);
}
}
}
}

124
src/librustc/middle/trans/base.rs
View file

@ -2093,53 +2093,6 @@ pub fn trans_tuple_struct(ccx: @CrateContext,
finish_fn(fcx, lltop);
}
pub fn trans_struct_dtor(ccx: @CrateContext,
path: path,
body: &ast::blk,
dtor_id: ast::node_id,
psubsts: Option<@param_substs>,
hash_id: Option<mono_id>,
parent_id: ast::def_id)
-> ValueRef {
let tcx = ccx.tcx;
/* Look up the parent class's def_id */
let mut class_ty = ty::lookup_item_type(tcx, parent_id).ty;
/* Substitute in the class type if necessary */
for psubsts.each |ss| {
class_ty = ty::subst_tps(tcx, ss.tys, ss.self_ty, class_ty);
}
/* The dtor takes a (null) output pointer, and a self argument,
and returns () */
let lldty = type_of_dtor(ccx, class_ty);
// XXX: Bad copies.
let s = get_dtor_symbol(ccx, copy path, dtor_id, psubsts);
/* Register the dtor as a function. It has external linkage */
let lldecl = decl_internal_cdecl_fn(ccx.llmod, s, lldty);
lib::llvm::SetLinkage(lldecl, lib::llvm::ExternalLinkage);
/* If we're monomorphizing, register the monomorphized decl
for the dtor */
for hash_id.each |h_id| {
ccx.monomorphized.insert(*h_id, lldecl);
}
/* Translate the dtor body */
let decl = ast_util::dtor_dec();
trans_fn(ccx,
path,
&decl,
body,
lldecl,
impl_self(class_ty),
psubsts,
dtor_id,
None,
[]);
lldecl
}
pub fn trans_enum_def(ccx: @CrateContext, enum_definition: &ast::enum_def,
id: ast::node_id,
path: @ast_map::path, vi: @~[ty::VariantInfo],
@ -2158,8 +2111,7 @@ pub fn trans_enum_def(ccx: @CrateContext, enum_definition: &ast::enum_def,
// Nothing to do.
}
ast::struct_variant_kind(struct_def) => {
trans_struct_def(ccx, struct_def, path,
variant.node.id);
trans_struct_def(ccx, struct_def);
}
}
}
@ -2228,22 +2180,14 @@ pub fn trans_item(ccx: @CrateContext, item: &ast::item) {
}
ast::item_struct(struct_def, ref generics) => {
if !generics.is_type_parameterized() {
trans_struct_def(ccx, struct_def, path, item.id);
trans_struct_def(ccx, struct_def);
}
}
_ => {/* fall through */ }
}
}
pub fn trans_struct_def(ccx: @CrateContext, struct_def: @ast::struct_def,
path: @ast_map::path,
id: ast::node_id) {
// Translate the destructor.
for struct_def.dtor.each |dtor| {
trans_struct_dtor(ccx, /*bad*/copy *path, &dtor.node.body,
dtor.node.id, None, None, local_def(id));
};
pub fn trans_struct_def(ccx: @CrateContext, struct_def: @ast::struct_def) {
// If this is a tuple-like struct, translate the constructor.
match struct_def.ctor_id {
// We only need to translate a constructor if there are fields;
@ -2477,46 +2421,6 @@ pub fn item_path(ccx: @CrateContext, i: @ast::item) -> path {
vec::append(/*bad*/copy *base, ~[path_name(i.ident)])
}
/* If there's already a symbol for the dtor with <id> and substs <substs>,
return it; otherwise, create one and register it, returning it as well */
pub fn get_dtor_symbol(ccx: @CrateContext,
path: path,
id: ast::node_id,
substs: Option<@param_substs>)
-> ~str {
let t = ty::node_id_to_type(ccx.tcx, id);
match ccx.item_symbols.find(&id) {
Some(s) => (/*bad*/copy *s),
None if substs.is_none() => {
let s = mangle_exported_name(
ccx,
vec::append(path, ~[path_name((ccx.names)(~"dtor"))]),
t);
// XXX: Bad copy, use `@str`?
ccx.item_symbols.insert(id, copy s);
s
}
None => {
// Monomorphizing, so just make a symbol, don't add
// this to item_symbols
match substs {
Some(ss) => {
let mono_ty = ty::subst_tps(ccx.tcx, ss.tys, ss.self_ty, t);
mangle_exported_name(
ccx,
vec::append(path,
~[path_name((ccx.names)(~"dtor"))]),
mono_ty)
}
None => {
ccx.sess.bug(fmt!("get_dtor_symbol: not monomorphizing and \
couldn't find a symbol for dtor %?", path));
}
}
}
}
}
pub fn get_item_val(ccx: @CrateContext, id: ast::node_id) -> ValueRef {
debug!("get_item_val(id=`%?`)", id);
let tcx = ccx.tcx;
@ -2602,28 +2506,6 @@ pub fn get_item_val(ccx: @CrateContext, id: ast::node_id) -> ValueRef {
}
}
}
ast_map::node_dtor(_, dt, parent_id, pt) => {
/*
Don't just call register_fn, since we don't want to add
the implicit self argument automatically (we want to make sure
it has the right type)
*/
// Want parent_id and not id, because id is the dtor's type
let class_ty = ty::lookup_item_type(tcx, parent_id).ty;
// This code shouldn't be reached if the class is generic
assert!(!ty::type_has_params(class_ty));
let lldty = T_fn(~[
T_ptr(T_i8()),
T_ptr(type_of(ccx, class_ty))
],
T_nil());
let s = get_dtor_symbol(ccx, /*bad*/copy *pt, dt.node.id, None);
/* Make the declaration for the dtor */
let llfn = decl_internal_cdecl_fn(ccx.llmod, s, lldty);
lib::llvm::SetLinkage(llfn, lib::llvm::ExternalLinkage);
llfn
}
ast_map::node_variant(ref v, enm, pth) => {
let llfn;

3
src/librustc/middle/trans/debuginfo.rs
View file

@ -983,9 +983,6 @@ pub fn create_function(fcx: fn_ctxt) -> @Metadata<SubProgramMetadata> {
expected an expr_fn_block here")
}
}
ast_map::node_dtor(_, _, did, _) => {
((dbg_cx.names)(~"dtor"), ast_util::dtor_ty(), did.node)
}
_ => fcx.ccx.sess.bug(~"create_function: unexpected \
sort of node")
};

4
src/librustc/middle/trans/inline.rs
View file

@ -118,10 +118,6 @@ pub fn maybe_instantiate_inline(ccx: @CrateContext, fn_id: ast::def_id,
}
local_def(mth.id)
}
csearch::found(ast::ii_dtor(ref dtor, _, _, _)) => {
ccx.external.insert(fn_id, Some((*dtor).node.id));
local_def((*dtor).node.id)
}
}
}
}

15
src/librustc/middle/trans/monomorphize.rs
View file

@ -13,7 +13,7 @@ use driver::session;
use lib::llvm::ValueRef;
use middle::trans::base::{get_insn_ctxt};
use middle::trans::base::{set_inline_hint_if_appr, set_inline_hint};
use middle::trans::base::{trans_enum_variant, trans_struct_dtor};
use middle::trans::base::{trans_enum_variant};
use middle::trans::base::{trans_fn, decl_internal_cdecl_fn};
use middle::trans::base::{get_item_val, no_self};
use middle::trans::base;
@ -35,7 +35,6 @@ use syntax::ast_map;
use syntax::ast_map::path_name;
use syntax::ast_util::local_def;
use syntax::opt_vec;
use syntax::parse::token::special_idents;
use syntax::abi::AbiSet;
pub fn monomorphic_fn(ccx: @CrateContext,
@ -116,8 +115,6 @@ pub fn monomorphic_fn(ccx: @CrateContext,
// Foreign externs don't have to be monomorphized.
return (get_item_val(ccx, fn_id.node), true);
}
ast_map::node_dtor(_, dtor, _, pt) =>
(pt, special_idents::dtor, dtor.span),
ast_map::node_trait_method(@ast::provided(m), _, pt) => {
(pt, m.ident, m.span)
}
@ -243,16 +240,6 @@ pub fn monomorphic_fn(ccx: @CrateContext,
meth::trans_method(ccx, pt, mth, psubsts, None, d, impl_did);
d
}
ast_map::node_dtor(_, dtor, _, pt) => {
let parent_id = match ty::ty_to_def_id(ty::node_id_to_type(ccx.tcx,
dtor.node.self_id)) {
Some(did) => did,
None => ccx.sess.span_bug(dtor.span, ~"Bad self ty in \
dtor")
};
trans_struct_dtor(ccx, /*bad*/copy *pt, &dtor.node.body,
dtor.node.id, psubsts, Some(hash_id), parent_id)
}
ast_map::node_trait_method(@ast::provided(mth), _, pt) => {
let d = mk_lldecl();
set_inline_hint_if_appr(/*bad*/copy mth.attrs, d);

13
src/librustc/middle/trans/reachable.rs
View file

@ -124,18 +124,10 @@ fn traverse_public_item(cx: &ctx, item: @item) {
}
}
}
item_struct(ref struct_def, ref generics) => {
item_struct(ref struct_def, _) => {
for struct_def.ctor_id.each |&ctor_id| {
cx.rmap.insert(ctor_id);
}
for struct_def.dtor.each |dtor| {
cx.rmap.insert(dtor.node.id);
if generics.ty_params.len() > 0u ||
attr::find_inline_attr(dtor.node.attrs) != attr::ia_none
{
traverse_inline_body(cx, &dtor.node.body);
}
}
}
item_ty(t, _) => {
traverse_ty(t, cx,
@ -239,9 +231,6 @@ fn traverse_all_resources_and_impls(cx: &ctx, crate_mod: &_mod) {
visit_item: |i, cx, v| {
visit::visit_item(i, cx, v);
match i.node {
item_struct(sdef, _) if sdef.dtor.is_some() => {
traverse_public_item(cx, i);
}
item_impl(*) => {
traverse_public_item(cx, i);
}

3
src/librustc/middle/trans/type_use.rs
View file

@ -157,9 +157,6 @@ pub fn type_uses_for(ccx: @CrateContext, fn_id: def_id, n_tps: uint)
for uint::range(0u, n_tps) |n| { cx.uses[n] |= flags;}
}
}
ast_map::node_dtor(_, ref dtor, _, _) => {
handle_body(cx, &dtor.node.body);
}
ast_map::node_struct_ctor(*) => {
// Similarly to node_variant, this monomorphized function just uses
// the representations of all of its type parameters.

27
src/librustc/middle/ty.rs
View file

@ -3748,28 +3748,8 @@ pub impl DtorKind {
Otherwise return none. */
pub fn ty_dtor(cx: ctxt, struct_id: def_id) -> DtorKind {
match cx.destructor_for_type.find(&struct_id) {
Some(&method_def_id) => return TraitDtor(method_def_id),
None => {} // Continue.
}
if is_local(struct_id) {
match cx.items.find(&struct_id.node) {
Some(&ast_map::node_item(@ast::item {
node: ast::item_struct(@ast::struct_def { dtor: Some(ref dtor),
_ },
_),
_
}, _)) =>
LegacyDtor(local_def((*dtor).node.id)),
_ =>
NoDtor
}
}
else {
match csearch::struct_dtor(cx.sess.cstore, struct_id) {
Some(&method_def_id) => TraitDtor(method_def_id),
None => NoDtor,
Some(did) => LegacyDtor(did),
}
}
}
@ -3819,11 +3799,6 @@ pub fn item_path(cx: ctxt, id: ast::def_id) -> ast_map::path {
ast_map::path_name((*variant).node.name))
}
ast_map::node_dtor(_, _, _, path) => {
vec::append_one(/*bad*/copy *path, ast_map::path_name(
syntax::parse::token::special_idents::literally_dtor))
}
ast_map::node_struct_ctor(_, item, path) => {
vec::append_one(/*bad*/copy *path, ast_map::path_name(item.ident))
}

29
src/librustc/middle/typeck/check/mod.rs
View file

@ -557,30 +557,7 @@ pub fn check_no_duplicate_fields(tcx: ty::ctxt,
}
}
pub fn check_struct(ccx: @mut CrateCtxt,
struct_def: @ast::struct_def,
id: ast::node_id,
span: span) {
let tcx = ccx.tcx;
let self_ty = ty::node_id_to_type(tcx, id);
for struct_def.dtor.each |dtor| {
let class_t = SelfInfo {
self_ty: self_ty,
self_id: dtor.node.self_id,
span: dtor.span,
};
// typecheck the dtor
let dtor_dec = ast_util::dtor_dec();
check_bare_fn(
ccx,
&dtor_dec,
&dtor.node.body,
dtor.node.id,
Some(class_t)
);
};
pub fn check_struct(ccx: @mut CrateCtxt, id: ast::node_id, span: span) {
// Check that the class is instantiable
check_instantiable(ccx.tcx, span, id);
}
@ -623,8 +600,8 @@ pub fn check_item(ccx: @mut CrateCtxt, it: @ast::item) {
}
}
}
ast::item_struct(struct_def, _) => {
check_struct(ccx, struct_def, it.id, it.span);
ast::item_struct(*) => {
check_struct(ccx, it.id, it.span);
}
ast::item_ty(t, ref generics) => {
let tpt_ty = ty::node_id_to_type(ccx.tcx, it.id);

25
src/librustc/middle/typeck/collect.rs
View file

@ -49,7 +49,6 @@ use syntax::ast::{RegionTyParamBound, TraitTyParamBound};
use syntax::ast;
use syntax::ast_map;
use syntax::ast_util::{local_def, split_trait_methods};
use syntax::ast_util;
use syntax::codemap::span;
use syntax::codemap;
use syntax::print::pprust::{path_to_str, self_ty_to_str};
@ -897,30 +896,6 @@ pub fn convert_struct(ccx: &CrateCtxt,
id: ast::node_id) {
let tcx = ccx.tcx;
for struct_def.dtor.each |dtor| {
let region_parameterization =
RegionParameterization::from_variance_and_generics(rp, generics);
// Write the dtor type
let t_dtor = ty::mk_bare_fn(
tcx,
astconv::ty_of_bare_fn(
ccx,
&type_rscope(region_parameterization),
ast::impure_fn,
AbiSet::Rust(),
&opt_vec::Empty,
&ast_util::dtor_dec()));
write_ty_to_tcx(tcx, dtor.node.id, t_dtor);
tcx.tcache.insert(local_def(dtor.node.id),
ty_param_bounds_and_ty {
generics: ty::Generics {
type_param_defs: tpt.generics.type_param_defs,
region_param: rp
},
ty: t_dtor});
};
// Write the type of each of the members
for struct_def.fields.each |f| {
convert_field(ccx, rp, tpt.generics.type_param_defs, *f, generics);

8
src/librustdoc/tystr_pass.rs
View file

@ -332,13 +332,7 @@ fn fold_struct(
/// what I actually want
fn strip_struct_extra_stuff(item: @ast::item) -> @ast::item {
let node = match copy item.node {
ast::item_struct(def, tys) => {
let def = @ast::struct_def {
dtor: None, // Remove the drop { } block
.. copy *def
};
ast::item_struct(def, tys)
}
ast::item_struct(def, tys) => ast::item_struct(def, tys),
_ => fail!(~"not a struct")
};

18
src/libsyntax/ast.rs
View file

@ -1174,10 +1174,7 @@ pub enum struct_field_kind {
#[auto_decode]
#[deriving(Eq)]
pub struct struct_def {
fields: ~[@struct_field], /* fields */
/* (not including ctor or dtor) */
/* dtor is optional */
dtor: Option<struct_dtor>,
fields: ~[@struct_field], /* fields, not including ctor */
/* ID of the constructor. This is only used for tuple- or enum-like
* structs. */
ctor_id: Option<node_id>
@ -1230,18 +1227,6 @@ impl to_bytes::IterBytes for struct_mutability {
}
}
pub type struct_dtor = spanned<struct_dtor_>;
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct struct_dtor_ {
id: node_id,
attrs: ~[attribute],
self_id: node_id,
body: blk,
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
@ -1272,7 +1257,6 @@ pub enum inlined_item {
ii_item(@item),
ii_method(def_id /* impl id */, @method),
ii_foreign(@foreign_item),
ii_dtor(struct_dtor, ident, Generics, def_id /* parent id */)
}
/* hold off on tests ... they appear in a later merge.

29
src/libsyntax/ast_map.rs
View file

@ -14,7 +14,6 @@ use ast;
use ast_util::{inlined_item_utils, stmt_id};
use ast_util;
use codemap;
use codemap::spanned;
use diagnostic::span_handler;
use parse::token::ident_interner;
use print::pprust;
@ -93,8 +92,6 @@ pub enum ast_node {
// order they are introduced.
node_arg(arg, uint),
node_local(uint),
// Destructor for a struct
node_dtor(Generics, @struct_dtor, def_id, @path),
node_block(blk),
node_struct_ctor(@struct_def, @item, @path),
}
@ -163,7 +160,7 @@ pub fn map_decoded_item(diag: @span_handler,
// don't decode and instantiate the impl, but just the method, we have to
// add it to the table now:
match *ii {
ii_item(*) | ii_dtor(*) => { /* fallthrough */ }
ii_item(*) => { /* fallthrough */ }
ii_foreign(i) => {
cx.map.insert(i.id, node_foreign_item(i,
AbiSet::Intrinsic(),
@ -193,27 +190,6 @@ pub fn map_fn(
node_arg(/* FIXME (#2543) */ copy *a, cx.local_id));
cx.local_id += 1u;
}
match *fk {
visit::fk_dtor(generics, ref attrs, self_id, parent_id) => {
let dt = @spanned {
node: ast::struct_dtor_ {
id: id,
attrs: /* FIXME (#2543) */ vec::from_slice(*attrs),
self_id: self_id,
body: /* FIXME (#2543) */ copy *body,
},
span: sp,
};
cx.map.insert(
id,
node_dtor(
/* FIXME (#2543) */ copy *generics,
dt,
parent_id,
@/* FIXME (#2543) */ copy cx.path));
}
_ => ()
}
visit::visit_fn(fk, decl, body, sp, id, cx, v);
}
@ -411,9 +387,6 @@ pub fn node_id_to_str(map: map, id: node_id, itr: @ident_interner) -> ~str {
Some(&node_local(_)) => { // add more info here
fmt!("local (id=%?)", id)
}
Some(&node_dtor(*)) => { // add more info here
fmt!("node_dtor (id=%?)", id)
}
Some(&node_block(_)) => {
fmt!("block")
}

26
src/libsyntax/ast_util.rs
View file

@ -302,7 +302,6 @@ impl inlined_item_utils for inlined_item {
ii_item(i) => /* FIXME (#2543) */ copy i.ident,
ii_foreign(i) => /* FIXME (#2543) */ copy i.ident,
ii_method(_, m) => /* FIXME (#2543) */ copy m.ident,
ii_dtor(_, nm, _, _) => /* FIXME (#2543) */ copy nm
}
}
@ -311,7 +310,6 @@ impl inlined_item_utils for inlined_item {
ii_item(i) => i.id,
ii_foreign(i) => i.id,
ii_method(_, m) => m.id,
ii_dtor(ref dtor, _, _, _) => (*dtor).node.id
}
}
@ -320,10 +318,6 @@ impl inlined_item_utils for inlined_item {
ii_item(i) => (v.visit_item)(i, e, v),
ii_foreign(i) => (v.visit_foreign_item)(i, e, v),
ii_method(_, m) => visit::visit_method_helper(m, e, v),
ii_dtor(/*bad*/ copy dtor, _, ref generics, parent_id) => {
visit::visit_struct_dtor_helper(dtor, generics,
parent_id, e, v);
}
}
}
}
@ -359,20 +353,6 @@ pub fn operator_prec(op: ast::binop) -> uint {
/// not appearing in the prior table.
pub static as_prec: uint = 11u;
pub fn dtor_ty() -> @ast::Ty {
@ast::Ty {id: 0, node: ty_nil, span: dummy_sp()}
}
pub fn dtor_dec() -> fn_decl {
let nil_t = dtor_ty();
// dtor has no args
ast::fn_decl {
inputs: ~[],
output: nil_t,
cf: return_val,
}
}
pub fn empty_generics() -> Generics {
Generics {lifetimes: opt_vec::Empty,
ty_params: opt_vec::Empty}
@ -457,12 +437,6 @@ pub fn id_visitor(vfn: @fn(node_id)) -> visit::vt<()> {
vfn(id);
match *fk {
visit::fk_dtor(generics, _, self_id, parent_id) => {
visit_generics(generics);
vfn(id);
vfn(self_id);
vfn(parent_id.node);
}
visit::fk_item_fn(_, generics, _, _) => {
visit_generics(generics);
}

1
src/libsyntax/ext/pipes/pipec.rs
View file

@ -431,7 +431,6 @@ impl gen_init for protocol {
dummy_sp(),
ast::struct_def {
fields: fields,
dtor: None,
ctor_id: None
},
cx.strip_bounds(&generics))

26
src/libsyntax/fold.rs
View file

@ -290,21 +290,8 @@ pub fn noop_fold_item_underscore(i: &item_, fld: @ast_fold) -> item_ {
fn fold_struct_def(struct_def: @ast::struct_def, fld: @ast_fold)
-> @ast::struct_def {
let dtor = do struct_def.dtor.map |dtor| {
let dtor_body = fld.fold_block(&dtor.node.body);
let dtor_id = fld.new_id(dtor.node.id);
spanned {
node: ast::struct_dtor_ {
body: dtor_body,
id: dtor_id,
.. copy dtor.node
},
span: copy dtor.span
}
};
@ast::struct_def {
fields: struct_def.fields.map(|f| fold_struct_field(*f, fld)),
dtor: dtor,
ctor_id: struct_def.ctor_id.map(|cid| fld.new_id(*cid)),
}
}
@ -655,22 +642,9 @@ fn noop_fold_variant(v: &variant_, fld: @ast_fold) -> variant_ {
})
}
struct_variant_kind(struct_def) => {
let dtor = do struct_def.dtor.map |dtor| {
let dtor_body = fld.fold_block(&dtor.node.body);
let dtor_id = fld.new_id(dtor.node.id);
spanned {
node: ast::struct_dtor_ {
body: dtor_body,
id: dtor_id,
.. copy dtor.node
},
.. copy *dtor
}
};
kind = struct_variant_kind(@ast::struct_def {
fields: vec::map(struct_def.fields,
|f| fld.fold_struct_field(*f)),
dtor: dtor,
ctor_id: struct_def.ctor_id.map(|c| fld.new_id(*c))
})
}

2
src/libsyntax/parse/parser.rs
View file

@ -3346,7 +3346,6 @@ pub impl Parser {
(class_name,
item_struct(@ast::struct_def {
fields: fields,
dtor: None,
ctor_id: if is_tuple_like { Some(new_id) } else { None }
}, generics),
None)
@ -3803,7 +3802,6 @@ pub impl Parser {
return @ast::struct_def {
fields: fields,
dtor: None,
ctor_id: None
};
}

7
src/libsyntax/print/pprust.rs
View file

@ -693,13 +693,6 @@ pub fn print_struct(s: @ps,
nbsp(s);
bopen(s);
hardbreak_if_not_bol(s);
for struct_def.dtor.each |dtor| {
hardbreak_if_not_bol(s);
maybe_print_comment(s, dtor.span.lo);
print_outer_attributes(s, dtor.node.attrs);
head(s, ~"drop");
print_block(s, &dtor.node.body);
}
for struct_def.fields.each |field| {
match field.node.kind {

44
src/libsyntax/visit.rs
View file

@ -11,7 +11,6 @@
use abi::AbiSet;
use ast::*;
use ast;
use ast_util;
use codemap::span;
use parse;
use opt_vec;
@ -39,13 +38,6 @@ pub enum fn_kind<'self> {
// |x, y| ...
fk_fn_block,
fk_dtor( // class destructor
&'self Generics,
&'self [attribute],
node_id /* self id */,
def_id /* parent class id */
)
}
pub fn name_of_fn(fk: &fn_kind) -> ident {
@ -54,15 +46,13 @@ pub fn name_of_fn(fk: &fn_kind) -> ident {
name
}
fk_anon(*) | fk_fn_block(*) => parse::token::special_idents::anon,
fk_dtor(*) => parse::token::special_idents::dtor
}
}
pub fn generics_of_fn(fk: &fn_kind) -> Generics {
match *fk {
fk_item_fn(_, generics, _, _) |
fk_method(_, generics, _) |
fk_dtor(generics, _, _, _) => {
fk_method(_, generics, _) => {
copy *generics
}
fk_anon(*) | fk_fn_block(*) => {
@ -369,25 +359,6 @@ pub fn visit_method_helper<E: Copy>(m: &method, e: E, v: vt<E>) {
);
}
pub fn visit_struct_dtor_helper<E>(dtor: struct_dtor, generics: &Generics,
parent_id: def_id, e: E, v: vt<E>) {
(v.visit_fn)(
&fk_dtor(
generics,
dtor.node.attrs,
dtor.node.self_id,
parent_id
),
&ast_util::dtor_dec(),
&dtor.node.body,
dtor.span,
dtor.node.id,
e,
v
)
}
pub fn visit_fn<E: Copy>(fk: &fn_kind, decl: &fn_decl, body: &blk, _sp: span,
_id: node_id, e: E, v: vt<E>) {
visit_fn_decl(decl, e, v);
@ -412,23 +383,14 @@ pub fn visit_trait_method<E: Copy>(m: &trait_method, e: E, v: vt<E>) {
pub fn visit_struct_def<E: Copy>(
sd: @struct_def,
_nm: ast::ident,
generics: &Generics,
id: node_id,
_generics: &Generics,
_id: node_id,
e: E,
v: vt<E>
) {
for sd.fields.each |f| {
(v.visit_struct_field)(*f, e, v);
}
for sd.dtor.each |dtor| {
visit_struct_dtor_helper(
*dtor,
generics,
ast_util::local_def(id),
e,
v
)
}
}
pub fn visit_struct_field<E: Copy>(sf: @struct_field, e: E, v: vt<E>) {