OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

rustc: Remove uses of DVec

Browse Source
This commit is contained in:
Alex Crichton 2013-03-07 18:37:14 -05:00
parent 87f864292d
commit 2a72099063
16 changed files with 191 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/librustc/metadata/csearch.rs
View File

@ -19,7 +19,6 @@ use metadata::decoder;
use metadata; use metadata;
use middle::{ty, resolve}; use middle::{ty, resolve};
use core::dvec::DVec;
use core::vec; use core::vec;
use reader = std::ebml::reader; use reader = std::ebml::reader;
use syntax::ast; use syntax::ast;
@ -136,7 +135,7 @@ pub fn get_supertraits(tcx: ty::ctxt, def: ast::def_id) -> ~[ty::t] {
pub fn get_method_names_if_trait(cstore: @mut cstore::CStore, pub fn get_method_names_if_trait(cstore: @mut cstore::CStore,
def: ast::def_id) def: ast::def_id)
-> Option<@DVec<(ast::ident, ast::self_ty_)>> { -> Option<~[(ast::ident, ast::self_ty_)]> {
let cdata = cstore::get_crate_data(cstore, def.crate); let cdata = cstore::get_crate_data(cstore, def.crate);
return decoder::get_method_names_if_trait(cstore.intr, cdata, def.node); return decoder::get_method_names_if_trait(cstore.intr, cdata, def.node);
} }

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

@ -22,8 +22,6 @@ use metadata::decoder;
use metadata::tydecode::{parse_ty_data, parse_def_id, parse_bounds_data}; use metadata::tydecode::{parse_ty_data, parse_def_id, parse_bounds_data};
use middle::{ty, resolve}; use middle::{ty, resolve};
use core::dvec;
use core::dvec::DVec;
use core::hash::{Hash, HashUtil}; use core::hash::{Hash, HashUtil};
use core::int; use core::int;
use core::io::WriterUtil; use core::io::WriterUtil;
@ -766,12 +764,12 @@ pub fn get_provided_trait_methods(intr: @ident_interner, cdata: cmd,
/// Returns the supertraits of the given trait. /// Returns the supertraits of the given trait.
pub fn get_supertraits(cdata: cmd, id: ast::node_id, tcx: ty::ctxt) pub fn get_supertraits(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
-> ~[ty::t] { -> ~[ty::t] {
let results = dvec::DVec(); let mut results = ~[];
let item_doc = lookup_item(id, cdata.data); let item_doc = lookup_item(id, cdata.data);
for reader::tagged_docs(item_doc, tag_impl_trait) |trait_doc| { for reader::tagged_docs(item_doc, tag_impl_trait) |trait_doc| {
results.push(doc_type(trait_doc, tcx, cdata)); results.push(doc_type(trait_doc, tcx, cdata));
} }
return dvec::unwrap(results); return results;
} }
// If the item in question is a trait, returns its set of methods and // If the item in question is a trait, returns its set of methods and
@ -779,14 +777,14 @@ pub fn get_supertraits(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
// annoying way with get_trait_methods. // annoying way with get_trait_methods.
pub fn get_method_names_if_trait(intr: @ident_interner, cdata: cmd, pub fn get_method_names_if_trait(intr: @ident_interner, cdata: cmd,
node_id: ast::node_id) node_id: ast::node_id)
-> Option<@DVec<(ast::ident, ast::self_ty_)>> { -> Option<~[(ast::ident, ast::self_ty_)]> {
let item = lookup_item(node_id, cdata.data); let item = lookup_item(node_id, cdata.data);
if item_family(item) != Trait { if item_family(item) != Trait {
return None; return None;
} }
let resulting_methods = @DVec(); let mut resulting_methods = ~[];
for reader::tagged_docs(item, tag_item_trait_method) |method| { for reader::tagged_docs(item, tag_item_trait_method) |method| {
resulting_methods.push( resulting_methods.push(
(item_name(intr, method), get_self_ty(method))); (item_name(intr, method), get_self_ty(method)));
@ -823,12 +821,12 @@ pub fn get_static_methods_if_impl(intr: @ident_interner,
return None; return None;
} }
let impl_method_ids = DVec(); let mut impl_method_ids = ~[];
for reader::tagged_docs(item, tag_item_impl_method) |impl_method_doc| { for reader::tagged_docs(item, tag_item_impl_method) |impl_method_doc| {
impl_method_ids.push(parse_def_id(reader::doc_data(impl_method_doc))); impl_method_ids.push(parse_def_id(reader::doc_data(impl_method_doc)));
} }
let static_impl_methods = DVec(); let mut static_impl_methods = ~[];
for impl_method_ids.each |impl_method_id| { for impl_method_ids.each |impl_method_id| {
let impl_method_doc = lookup_item(impl_method_id.node, cdata.data); let impl_method_doc = lookup_item(impl_method_id.node, cdata.data);
let family = item_family(impl_method_doc); let family = item_family(impl_method_doc);
@ -852,7 +850,7 @@ pub fn get_static_methods_if_impl(intr: @ident_interner,
} }
} }
return Some(dvec::unwrap(static_impl_methods)); return Some(static_impl_methods);
} }
pub fn get_item_attrs(cdata: cmd, pub fn get_item_attrs(cdata: cmd,

15
src/librustc/metadata/encoder.rs
View File

@ -22,7 +22,6 @@ use middle::ty;
use middle; use middle;
use util::ppaux::ty_to_str; use util::ppaux::ty_to_str;
use core::dvec;
use core::flate; use core::flate;
use core::hash::{Hash, HashUtil}; use core::hash::{Hash, HashUtil};
use core::int; use core::int;
@ -857,7 +856,7 @@ fn encode_info_for_item(ecx: @EncodeContext, ebml_w: writer::Encoder,
} }
} }
item_trait(ref generics, ref traits, ref ms) => { item_trait(ref generics, ref traits, ref ms) => {
let provided_methods = dvec::DVec(); let mut provided_methods = ~[];
add_to_index(); add_to_index();
ebml_w.start_tag(tag_items_data_item); ebml_w.start_tag(tag_items_data_item);
@ -1366,13 +1365,11 @@ pub fn encode_metadata(parms: EncodeParams, crate: &crate) -> ~[u8] {
if (parms.tcx.sess.meta_stats()) { if (parms.tcx.sess.meta_stats()) {
do wr.bytes.borrow |v| { do wr.bytes.each |e| {
do v.each |e| { if *e == 0 {
if *e == 0 { ecx.stats.zero_bytes += 1;
ecx.stats.zero_bytes += 1;
}
true
} }
true
} }
io::println("metadata stats:"); io::println("metadata stats:");
@ -1401,7 +1398,7 @@ pub fn encode_metadata(parms: EncodeParams, crate: &crate) -> ~[u8] {
(do str::as_bytes(&~"rust\x00\x00\x00\x01") |bytes| { (do str::as_bytes(&~"rust\x00\x00\x00\x01") |bytes| {
vec::slice(*bytes, 0, 8).to_vec() vec::slice(*bytes, 0, 8).to_vec()
}) + flate::deflate_bytes(wr.bytes.check_out(|buf| buf)) }) + flate::deflate_bytes(wr.bytes)
} }
// Get the encoded string for a type // Get the encoded string for a type

9
src/librustc/middle/astencode.rs
View File

@ -25,7 +25,7 @@ use middle::{ty, typeck, moves};
use middle; use middle;
use util::ppaux::ty_to_str; use util::ppaux::ty_to_str;
use core::{dvec, io, option, vec}; use core::{io, option, vec};
use std::ebml::reader; use std::ebml::reader;
use std::ebml; use std::ebml;
use std::serialize; use std::serialize;
@ -912,11 +912,11 @@ fn encode_side_tables_for_id(ecx: @e::EncodeContext,
} }
} }
for maps.last_use_map.find(&id).each |m| { for maps.last_use_map.find(&id).each |&m| {
do ebml_w.tag(c::tag_table_last_use) { do ebml_w.tag(c::tag_table_last_use) {
ebml_w.id(id); ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) { do ebml_w.tag(c::tag_table_val) {
do ebml_w.emit_from_vec((*m).get()) |id| { do ebml_w.emit_from_vec(/*bad*/ copy *m) |id| {
id.encode(&ebml_w); id.encode(&ebml_w);
} }
} }
@ -1131,8 +1131,7 @@ fn decode_side_tables(xcx: @ExtendedDecodeContext,
let ids = val_dsr.read_to_vec(|| { let ids = val_dsr.read_to_vec(|| {
xcx.tr_id(val_dsr.read_int()) xcx.tr_id(val_dsr.read_int())
}); });
let dvec = @dvec::from_vec(ids); dcx.maps.last_use_map.insert(id, @mut ids);
dcx.maps.last_use_map.insert(id, dvec);
} else if tag == (c::tag_table_method_map as uint) { } else if tag == (c::tag_table_method_map as uint) {
dcx.maps.method_map.insert( dcx.maps.method_map.insert(
id, id,

4
src/librustc/middle/borrowck/gather_loans.rs
View File

@ -32,7 +32,6 @@ use middle::ty;
use util::common::indenter; use util::common::indenter;
use util::ppaux::{expr_repr, region_to_str}; use util::ppaux::{expr_repr, region_to_str};
use core::dvec;
use core::hashmap::linear::LinearSet; use core::hashmap::linear::LinearSet;
use core::vec; use core::vec;
use std::oldmap::HashMap; use std::oldmap::HashMap;
@ -575,9 +574,8 @@ pub impl GatherLoanCtxt {
req_loans.push_all(loans); req_loans.push_all(loans);
} }
None => { None => {
let dvec = @dvec::from_vec(loans);
let req_loan_map = self.req_maps.req_loan_map; let req_loan_map = self.req_maps.req_loan_map;
req_loan_map.insert(scope_id, dvec); req_loan_map.insert(scope_id, @mut loans);
} }
} }
} }

3
src/librustc/middle/borrowck/mod.rs
View File

@ -234,7 +234,6 @@ use middle::moves;
use util::common::{indenter, stmt_set}; use util::common::{indenter, stmt_set};
use util::ppaux::note_and_explain_region; use util::ppaux::note_and_explain_region;
use core::dvec::DVec;
use core::io; use core::io;
use core::result::{Result, Ok, Err}; use core::result::{Result, Ok, Err};
use core::to_bytes; use core::to_bytes;
@ -406,7 +405,7 @@ pub struct Loan {
/// - `pure_map`: map from block/expr that must be pure to the error message /// - `pure_map`: map from block/expr that must be pure to the error message
/// that should be reported if they are not pure /// that should be reported if they are not pure
pub struct ReqMaps { pub struct ReqMaps {
req_loan_map: HashMap<ast::node_id, @DVec<Loan>>, req_loan_map: HashMap<ast::node_id, @mut ~[Loan]>,
pure_map: HashMap<ast::node_id, bckerr> pure_map: HashMap<ast::node_id, bckerr>
} }

18
src/librustc/middle/liveness.rs
View File

@ -112,7 +112,6 @@ use middle::moves;
use util::ppaux::ty_to_str; use util::ppaux::ty_to_str;
use core::cmp; use core::cmp;
use core::dvec::DVec;
use core::io::WriterUtil; use core::io::WriterUtil;
use core::io; use core::io;
use core::ptr; use core::ptr;
@ -136,7 +135,7 @@ use syntax::{visit, ast_util};
// //
// Very subtle (#2633): borrowck will remove entries from this table // Very subtle (#2633): borrowck will remove entries from this table
// if it detects an outstanding loan (that is, the addr is taken). // if it detects an outstanding loan (that is, the addr is taken).
pub type last_use_map = HashMap<node_id, @DVec<node_id>>; pub type last_use_map = HashMap<node_id, @mut ~[node_id]>;
enum Variable = uint; enum Variable = uint;
enum LiveNode = uint; enum LiveNode = uint;
@ -419,13 +418,13 @@ pub impl IrMaps {
let v = match self.last_use_map.find(&expr_id) { let v = match self.last_use_map.find(&expr_id) {
Some(v) => v, Some(v) => v,
None => { None => {
let v = @DVec(); let v = @mut ~[];
self.last_use_map.insert(expr_id, v); self.last_use_map.insert(expr_id, v);
v v
} }
}; };
(*v).push(id); v.push(id);
} }
Arg(_, _, by_ref) | Arg(_, _, by_ref) |
Arg(_, _, by_val) | ImplicitRet => { Arg(_, _, by_val) | ImplicitRet => {
@ -667,7 +666,7 @@ struct Liveness {
users: @mut ~[Users], users: @mut ~[Users],
// The list of node IDs for the nested loop scopes // The list of node IDs for the nested loop scopes
// we're in. // we're in.
loop_scope: DVec<node_id>, loop_scope: @mut ~[node_id],
// mappings from loop node ID to LiveNode // mappings from loop node ID to LiveNode
// ("break" label should map to loop node ID, // ("break" label should map to loop node ID,
// it probably doesn't now) // it probably doesn't now)
@ -683,7 +682,7 @@ fn Liveness(ir: @mut IrMaps, specials: Specials) -> Liveness {
successors: @mut vec::from_elem(ir.num_live_nodes, invalid_node()), successors: @mut vec::from_elem(ir.num_live_nodes, invalid_node()),
users: @mut vec::from_elem(ir.num_live_nodes * ir.num_vars, users: @mut vec::from_elem(ir.num_live_nodes * ir.num_vars,
invalid_users()), invalid_users()),
loop_scope: DVec(), loop_scope: @mut ~[],
break_ln: HashMap(), break_ln: HashMap(),
cont_ln: HashMap() cont_ln: HashMap()
} }
@ -856,11 +855,16 @@ pub impl Liveness {
self.tcx.sess.span_bug(sp, ~"break outside loop"); self.tcx.sess.span_bug(sp, ~"break outside loop");
} }
else { else {
self.loop_scope.last() // FIXME(#5275): this shouldn't have to be a method...
self.last_loop_scope()
} }
} }
} }
fn last_loop_scope(&self) -> node_id {
*self.loop_scope.last()
}
fn ln_str(&self, ln: LiveNode) -> ~str { fn ln_str(&self, ln: LiveNode) -> ~str {
do io::with_str_writer |wr| { do io::with_str_writer |wr| {
wr.write_str(~"[ln("); wr.write_str(~"[ln(");

3
src/librustc/middle/privacy.rs
View File

@ -21,7 +21,6 @@ use middle::typeck::{method_map, method_origin, method_param, method_self};
use middle::typeck::{method_super}; use middle::typeck::{method_super};
use middle::typeck::{method_static, method_trait}; use middle::typeck::{method_static, method_trait};
use core::dvec::DVec;
use core::util::ignore; use core::util::ignore;
use syntax::ast::{def_variant, expr_field, expr_method_call, expr_struct}; use syntax::ast::{def_variant, expr_field, expr_method_call, expr_struct};
use syntax::ast::{expr_unary, ident, item_struct, item_enum, item_impl}; use syntax::ast::{expr_unary, ident, item_struct, item_enum, item_impl};
@ -38,7 +37,7 @@ use syntax::visit;
pub fn check_crate(tcx: ty::ctxt, pub fn check_crate(tcx: ty::ctxt,
method_map: &method_map, method_map: &method_map,
crate: @ast::crate) { crate: @ast::crate) {
let privileged_items = @DVec(); let privileged_items = @mut ~[];
// Adds structs that are privileged to this scope. // Adds structs that are privileged to this scope.
let add_privileged_items: @fn(&[@ast::item]) -> uint = |items| { let add_privileged_items: @fn(&[@ast::item]) -> uint = |items| {

5
src/librustc/middle/region.rs
View File

@ -26,7 +26,6 @@ use middle::ty::{region_variance, rv_covariant, rv_invariant};
use middle::ty::{rv_contravariant}; use middle::ty::{rv_contravariant};
use middle::ty; use middle::ty;
use core::dvec::DVec;
use core::vec; use core::vec;
use std::oldmap::HashMap; use std::oldmap::HashMap;
use syntax::ast_map; use syntax::ast_map;
@ -395,7 +394,7 @@ pub struct region_dep {
id: ast::node_id id: ast::node_id
} }
pub type dep_map = HashMap<ast::node_id, @DVec<region_dep>>; pub type dep_map = HashMap<ast::node_id, @mut ~[region_dep]>;
pub struct DetermineRpCtxt { pub struct DetermineRpCtxt {
sess: Session, sess: Session,
@ -498,7 +497,7 @@ pub impl DetermineRpCtxt {
let vec = match self.dep_map.find(&from) { let vec = match self.dep_map.find(&from) {
Some(vec) => vec, Some(vec) => vec,
None => { None => {
let vec = @DVec(); let vec = @mut ~[];
let dep_map = self.dep_map; let dep_map = self.dep_map;
dep_map.insert(from, vec); dep_map.insert(from, vec);
vec vec

201
src/librustc/middle/resolve.rs
View File

@ -75,7 +75,6 @@ use syntax::visit::{visit_foreign_item, visit_item, visit_method_helper};
use syntax::visit::{visit_mod, visit_ty, vt}; use syntax::visit::{visit_mod, visit_ty, vt};
use syntax::opt_vec::OptVec; use syntax::opt_vec::OptVec;
use core::dvec::DVec;
use core::option::{Some, get, is_some, is_none}; use core::option::{Some, get, is_some, is_none};
use core::str::{connect, split_str}; use core::str::{connect, split_str};
use std::oldmap::HashMap; use std::oldmap::HashMap;
@ -110,7 +109,7 @@ pub struct Impl {
} }
// Trait method resolution // Trait method resolution
pub type TraitMap = @HashMap<node_id,@DVec<def_id>>; pub type TraitMap = @HashMap<node_id,@mut ~[def_id]>;
// This is the replacement export map. It maps a module to all of the exports // This is the replacement export map. It maps a module to all of the exports
// within. // within.
@ -350,13 +349,13 @@ pub fn Rib(kind: RibKind) -> Rib {
/// One import directive. /// One import directive.
pub struct ImportDirective { pub struct ImportDirective {
privacy: Privacy, privacy: Privacy,
module_path: @DVec<ident>, module_path: ~[ident],
subclass: @ImportDirectiveSubclass, subclass: @ImportDirectiveSubclass,
span: span, span: span,
} }
pub fn ImportDirective(privacy: Privacy, pub fn ImportDirective(privacy: Privacy,
module_path: @DVec<ident>, +module_path: ~[ident],
subclass: @ImportDirectiveSubclass, subclass: @ImportDirectiveSubclass,
span: span) span: span)
-> ImportDirective { -> ImportDirective {
@ -458,7 +457,7 @@ pub struct Module {
kind: ModuleKind, kind: ModuleKind,
children: @HashMap<ident,@mut NameBindings>, children: @HashMap<ident,@mut NameBindings>,
imports: @DVec<@ImportDirective>, imports: ~[@ImportDirective],
// The anonymous children of this node. Anonymous children are pseudo- // The anonymous children of this node. Anonymous children are pseudo-
// modules that are implicitly created around items contained within // modules that are implicitly created around items contained within
@ -496,7 +495,7 @@ pub fn Module(parent_link: ParentLink,
def_id: def_id, def_id: def_id,
kind: kind, kind: kind,
children: @HashMap(), children: @HashMap(),
imports: @DVec(), imports: ~[],
anonymous_children: @HashMap(), anonymous_children: @HashMap(),
import_resolutions: @HashMap(), import_resolutions: @HashMap(),
glob_count: 0, glob_count: 0,
@ -781,9 +780,9 @@ pub fn Resolver(session: Session,
unresolved_imports: 0, unresolved_imports: 0,
current_module: current_module, current_module: current_module,
value_ribs: @DVec(), value_ribs: ~[],
type_ribs: @DVec(), type_ribs: ~[],
label_ribs: @DVec(), label_ribs: ~[],
xray_context: NoXray, xray_context: NoXray,
current_trait_refs: None, current_trait_refs: None,
@ -830,20 +829,20 @@ pub struct Resolver {
// The current set of local scopes, for values. // The current set of local scopes, for values.
// FIXME #4948: Reuse ribs to avoid allocation. // FIXME #4948: Reuse ribs to avoid allocation.
value_ribs: @DVec<@Rib>, value_ribs: ~[@Rib],
// The current set of local scopes, for types. // The current set of local scopes, for types.
type_ribs: @DVec<@Rib>, type_ribs: ~[@Rib],
// The current set of local scopes, for labels. // The current set of local scopes, for labels.
label_ribs: @DVec<@Rib>, label_ribs: ~[@Rib],
// Whether the current context is an X-ray context. An X-ray context is // Whether the current context is an X-ray context. An X-ray context is
// allowed to access private names of any module. // allowed to access private names of any module.
xray_context: XrayFlag, xray_context: XrayFlag,
// The trait that the current context can refer to. // The trait that the current context can refer to.
current_trait_refs: Option<@DVec<def_id>>, current_trait_refs: Option<~[def_id]>,
// The ident for the keyword "self". // The ident for the keyword "self".
self_ident: ident, self_ident: ident,
@ -1407,7 +1406,7 @@ pub impl Resolver {
// globs and lists, the path is found directly in the AST; // globs and lists, the path is found directly in the AST;
// for simple paths we have to munge the path a little. // for simple paths we have to munge the path a little.
let module_path = @DVec(); let mut module_path = ~[];
match view_path.node { match view_path.node {
view_path_simple(_, full_path, _, _) => { view_path_simple(_, full_path, _, _) => {
let path_len = full_path.idents.len(); let path_len = full_path.idents.len();
@ -1415,7 +1414,7 @@ pub impl Resolver {
for full_path.idents.eachi |i, ident| { for full_path.idents.eachi |i, ident| {
if i != path_len - 1 { if i != path_len - 1 {
(*module_path).push(*ident); module_path.push(*ident);
} }
} }
} }
@ -1423,7 +1422,7 @@ pub impl Resolver {
view_path_glob(module_ident_path, _) | view_path_glob(module_ident_path, _) |
view_path_list(module_ident_path, _, _) => { view_path_list(module_ident_path, _, _) => {
for module_ident_path.idents.each |ident| { for module_ident_path.idents.each |ident| {
(*module_path).push(*ident); module_path.push(*ident);
} }
} }
} }
@ -1457,7 +1456,7 @@ pub impl Resolver {
AnyNS); AnyNS);
self.build_import_directive(privacy, self.build_import_directive(privacy,
module_, module_,
module_path, copy module_path,
subclass, subclass,
view_path.span, view_path.span,
state); state);
@ -1857,7 +1856,7 @@ pub impl Resolver {
fn build_import_directive(@mut self, fn build_import_directive(@mut self,
privacy: Privacy, privacy: Privacy,
module_: @mut Module, module_: @mut Module,
module_path: @DVec<ident>, +module_path: ~[ident],
subclass: @ImportDirectiveSubclass, subclass: @ImportDirectiveSubclass,
span: span, span: span,
state: @mut ImportState) { state: @mut ImportState) {
@ -1873,7 +1872,7 @@ pub impl Resolver {
debug!("(building import directive) building import \ debug!("(building import directive) building import \
directive: privacy %? %s::%s", directive: privacy %? %s::%s",
privacy, privacy,
self.idents_to_str(module_path.get()), self.idents_to_str(directive.module_path),
*self.session.str_of(target)); *self.session.str_of(target));
match module_.import_resolutions.find(&target) { match module_.import_resolutions.find(&target) {
@ -1887,7 +1886,7 @@ pub impl Resolver {
let resolution = @mut ImportResolution(privacy, let resolution = @mut ImportResolution(privacy,
span, span,
state); state);
let name = self.idents_to_str(module_path.get()); let name = self.idents_to_str(directive.module_path);
// Don't warn about unused intrinsics because they're // Don't warn about unused intrinsics because they're
// automatically appended to all files // automatically appended to all files
if name == ~"intrinsic::rusti" { if name == ~"intrinsic::rusti" {
@ -1982,13 +1981,13 @@ pub impl Resolver {
let import_count = module.imports.len(); let import_count = module.imports.len();
while module.resolved_import_count < import_count { while module.resolved_import_count < import_count {
let import_index = module.resolved_import_count; let import_index = module.resolved_import_count;
let import_directive = module.imports.get_elt(import_index); let import_directive = module.imports[import_index];
match self.resolve_import_for_module(module, import_directive) { match self.resolve_import_for_module(module, import_directive) {
Failed => { Failed => {
// We presumably emitted an error. Continue. // We presumably emitted an error. Continue.
let idents = import_directive.module_path.get();
let msg = fmt!("failed to resolve import: %s", let msg = fmt!("failed to resolve import: %s",
*self.import_path_to_str(idents, *self.import_path_to_str(
import_directive.module_path,
*import_directive.subclass)); *import_directive.subclass));
self.session.span_err(import_directive.span, msg); self.session.span_err(import_directive.span, msg);
} }
@ -2005,7 +2004,7 @@ pub impl Resolver {
} }
} }
fn idents_to_str(@mut self, idents: ~[ident]) -> ~str { fn idents_to_str(@mut self, idents: &[ident]) -> ~str {
let ident_strs = do idents.map |ident| { let ident_strs = do idents.map |ident| {
/*bad*/ copy *self.session.str_of(*ident) /*bad*/ copy *self.session.str_of(*ident)
}; };
@ -2043,11 +2042,11 @@ pub impl Resolver {
import_directive: @ImportDirective) import_directive: @ImportDirective)
-> ResolveResult<()> { -> ResolveResult<()> {
let mut resolution_result = Failed; let mut resolution_result = Failed;
let module_path = import_directive.module_path; let module_path = &import_directive.module_path;
debug!("(resolving import for module) resolving import `%s::...` in \ debug!("(resolving import for module) resolving import `%s::...` in \
`%s`", `%s`",
self.idents_to_str(module_path.get()), self.idents_to_str(*module_path),
self.module_to_str(module_)); self.module_to_str(module_));
// First, resolve the module path for the directive, if necessary. // First, resolve the module path for the directive, if necessary.
@ -2056,7 +2055,7 @@ pub impl Resolver {
Some(self.graph_root.get_module()) Some(self.graph_root.get_module())
} else { } else {
match self.resolve_module_path_for_import(module_, match self.resolve_module_path_for_import(module_,
module_path, *module_path,
DontUseLexicalScope, DontUseLexicalScope,
import_directive.span) { import_directive.span) {
@ -2574,21 +2573,21 @@ pub impl Resolver {
/// Resolves the given module path from the given root `module_`. /// Resolves the given module path from the given root `module_`.
fn resolve_module_path_from_root(@mut self, fn resolve_module_path_from_root(@mut self,
module_: @mut Module, module_: @mut Module,
module_path: @DVec<ident>, module_path: ~[ident],
index: uint, index: uint,
span: span, span: span,
mut name_search_type: NameSearchType) mut name_search_type: NameSearchType)
-> ResolveResult<@mut Module> { -> ResolveResult<@mut Module> {
let mut search_module = module_; let mut search_module = module_;
let mut index = index; let mut index = index;
let module_path_len = (*module_path).len(); let module_path_len = module_path.len();
// Resolve the module part of the path. This does not involve looking // Resolve the module part of the path. This does not involve looking
// upward though scope chains; we simply resolve names directly in // upward though scope chains; we simply resolve names directly in
// modules as we go. // modules as we go.
while index < module_path_len { while index < module_path_len {
let name = (*module_path).get_elt(index); let name = module_path[index];
match self.resolve_name_in_module(search_module, match self.resolve_name_in_module(search_module,
name, name,
TypeNS, TypeNS,
@ -2659,7 +2658,7 @@ pub impl Resolver {
/// rooted at the given module. /// rooted at the given module.
fn resolve_module_path_for_import(@mut self, fn resolve_module_path_for_import(@mut self,
module_: @mut Module, module_: @mut Module,
module_path: @DVec<ident>, module_path: ~[ident],
use_lexical_scope: UseLexicalScopeFlag, use_lexical_scope: UseLexicalScopeFlag,
span: span) span: span)
-> ResolveResult<@mut Module> { -> ResolveResult<@mut Module> {
@ -2668,7 +2667,7 @@ pub impl Resolver {
debug!("(resolving module path for import) processing `%s` rooted at \ debug!("(resolving module path for import) processing `%s` rooted at \
`%s`", `%s`",
self.idents_to_str((*module_path).get()), self.idents_to_str(module_path),
self.module_to_str(module_)); self.module_to_str(module_));
// Resolve the module prefix, if any. // Resolve the module prefix, if any.
@ -2704,7 +2703,7 @@ pub impl Resolver {
// scope and then proceed to resolve below that. // scope and then proceed to resolve below that.
let result = self.resolve_module_in_lexical_scope( let result = self.resolve_module_in_lexical_scope(
module_, module_,
module_path.get_elt(0)); module_path[0]);
match result { match result {
Failed => { Failed => {
self.session.span_err(span, self.session.span_err(span,
@ -2945,7 +2944,7 @@ pub impl Resolver {
*/ */
fn resolve_module_prefix(@mut self, fn resolve_module_prefix(@mut self,
module_: @mut Module, module_: @mut Module,
module_path: @DVec<ident>) module_path: ~[ident])
-> ResolveResult<ModulePrefixResult> { -> ResolveResult<ModulePrefixResult> {
let interner = self.session.parse_sess.interner; let interner = self.session.parse_sess.interner;
@ -2953,11 +2952,11 @@ pub impl Resolver {
// top of the crate otherwise. // top of the crate otherwise.
let mut containing_module; let mut containing_module;
let mut i; let mut i;
if *interner.get(module_path.get_elt(0)) == ~"self" { if *interner.get(module_path[0]) == ~"self" {
containing_module = containing_module =
self.get_nearest_normal_module_parent_or_self(module_); self.get_nearest_normal_module_parent_or_self(module_);
i = 1; i = 1;
} else if *interner.get(module_path.get_elt(0)) == ~"super" { } else if *interner.get(module_path[0]) == ~"super" {
containing_module = containing_module =
self.get_nearest_normal_module_parent_or_self(module_); self.get_nearest_normal_module_parent_or_self(module_);
i = 0; // We'll handle `super` below. i = 0; // We'll handle `super` below.
@ -2967,7 +2966,7 @@ pub impl Resolver {
// Now loop through all the `super`s we find. // Now loop through all the `super`s we find.
while i < module_path.len() && while i < module_path.len() &&
*interner.get(module_path.get_elt(i)) == ~"super" { *interner.get(module_path[i]) == ~"super" {
debug!("(resolving module prefix) resolving `super` at %s", debug!("(resolving module prefix) resolving `super` at %s",
self.module_to_str(containing_module)); self.module_to_str(containing_module));
match self.get_nearest_normal_module_parent(containing_module) { match self.get_nearest_normal_module_parent(containing_module) {
@ -3064,7 +3063,7 @@ pub impl Resolver {
let index = module_.resolved_import_count; let index = module_.resolved_import_count;
let import_count = module_.imports.len(); let import_count = module_.imports.len();
if index != import_count { if index != import_count {
self.session.span_err(module_.imports.get_elt(index).span, self.session.span_err(module_.imports[index].span,
~"unresolved import"); ~"unresolved import");
} }
@ -3283,7 +3282,7 @@ pub impl Resolver {
// wrappers. // wrappers.
fn upvarify(@mut self, fn upvarify(@mut self,
ribs: @DVec<@Rib>, ribs: &mut ~[@Rib],
rib_index: uint, rib_index: uint,
def_like: def_like, def_like: def_like,
span: span, span: span,
@ -3313,9 +3312,8 @@ pub impl Resolver {
} }
let mut rib_index = rib_index + 1; let mut rib_index = rib_index + 1;
while rib_index < (*ribs).len() { while rib_index < ribs.len() {
let rib = (*ribs).get_elt(rib_index); match ribs[rib_index].kind {
match rib.kind {
NormalRibKind => { NormalRibKind => {
// Nothing to do. Continue. // Nothing to do. Continue.
} }
@ -3393,7 +3391,7 @@ pub impl Resolver {
} }
fn search_ribs(@mut self, fn search_ribs(@mut self,
ribs: @DVec<@Rib>, ribs: &mut ~[@Rib],
name: ident, name: ident,
span: span, span: span,
allow_capturing_self: AllowCapturingSelfFlag) allow_capturing_self: AllowCapturingSelfFlag)
@ -3401,14 +3399,13 @@ pub impl Resolver {
// FIXME #4950: This should not use a while loop. // FIXME #4950: This should not use a while loop.
// FIXME #4950: Try caching? // FIXME #4950: Try caching?
let mut i = (*ribs).len(); let mut i = ribs.len();
while i != 0 { while i != 0 {
i -= 1; i -= 1;
let rib = (*ribs).get_elt(i); match ribs[i].bindings.find(&name) {
match rib.bindings.find(&name) {
Some(def_like) => { Some(def_like) => {
return self.upvarify(ribs, i, def_like, span, return self.upvarify(ribs, i, def_like, span,
allow_capturing_self); allow_capturing_self);
} }
None => { None => {
// Continue. // Continue.
@ -3502,7 +3499,7 @@ pub impl Resolver {
item_trait(ref generics, ref traits, ref methods) => { item_trait(ref generics, ref traits, ref methods) => {
// Create a new rib for the self type. // Create a new rib for the self type.
let self_type_rib = @Rib(NormalRibKind); let self_type_rib = @Rib(NormalRibKind);
(*self.type_ribs).push(self_type_rib); self.type_ribs.push(self_type_rib);
self_type_rib.bindings.insert(self.type_self_ident, self_type_rib.bindings.insert(self.type_self_ident,
dl_def(def_self_ty(item.id))); dl_def(def_self_ty(item.id)));
@ -3573,7 +3570,7 @@ pub impl Resolver {
} }
} }
(*self.type_ribs).pop(); self.type_ribs.pop();
} }
item_struct(struct_def, ref generics) => { item_struct(struct_def, ref generics) => {
@ -3706,15 +3703,15 @@ pub impl Resolver {
} }
fn with_label_rib(@mut self, f: fn()) { fn with_label_rib(@mut self, f: fn()) {
(*self.label_ribs).push(@Rib(NormalRibKind)); self.label_ribs.push(@Rib(NormalRibKind));
f(); f();
(*self.label_ribs).pop(); self.label_ribs.pop();
} }
fn with_constant_rib(@mut self, f: fn()) { fn with_constant_rib(@mut self, f: fn()) {
(*self.value_ribs).push(@Rib(ConstantItemRibKind)); self.value_ribs.push(@Rib(ConstantItemRibKind));
f(); f();
(*self.value_ribs).pop(); self.value_ribs.pop();
} }
fn resolve_function(@mut self, fn resolve_function(@mut self,
@ -3726,11 +3723,11 @@ pub impl Resolver {
visitor: ResolveVisitor) { visitor: ResolveVisitor) {
// Create a value rib for the function. // Create a value rib for the function.
let function_value_rib = @Rib(rib_kind); let function_value_rib = @Rib(rib_kind);
(*self.value_ribs).push(function_value_rib); self.value_ribs.push(function_value_rib);
// Create a label rib for the function. // Create a label rib for the function.
let function_label_rib = @Rib(rib_kind); let function_label_rib = @Rib(rib_kind);
(*self.label_ribs).push(function_label_rib); self.label_ribs.push(function_label_rib);
// If this function has type parameters, add them now. // If this function has type parameters, add them now.
do self.with_type_parameter_rib(type_parameters) { do self.with_type_parameter_rib(type_parameters) {
@ -3790,8 +3787,8 @@ pub impl Resolver {
debug!("(resolving function) leaving function"); debug!("(resolving function) leaving function");
} }
(*self.label_ribs).pop(); self.label_ribs.pop();
(*self.value_ribs).pop(); self.value_ribs.pop();
} }
fn resolve_type_parameters(@mut self, fn resolve_type_parameters(@mut self,
@ -3891,10 +3888,10 @@ pub impl Resolver {
visitor); visitor);
// Resolve the trait reference, if necessary. // Resolve the trait reference, if necessary.
let original_trait_refs = self.current_trait_refs; let original_trait_refs;
match opt_trait_reference { match opt_trait_reference {
Some(trait_reference) => { Some(trait_reference) => {
let new_trait_refs = @DVec(); let mut new_trait_refs = ~[];
match self.resolve_path( match self.resolve_path(
trait_reference.path, TypeNS, true, visitor) { trait_reference.path, TypeNS, true, visitor) {
None => { None => {
@ -3906,13 +3903,17 @@ pub impl Resolver {
self.record_def(trait_reference.ref_id, def); self.record_def(trait_reference.ref_id, def);
// Record the current trait reference. // Record the current trait reference.
(*new_trait_refs).push(def_id_of_def(def)); new_trait_refs.push(def_id_of_def(def));
} }
} }
// Record the current set of trait references. // Record the current set of trait references.
self.current_trait_refs = Some(new_trait_refs); let mut old = Some(new_trait_refs);
self.current_trait_refs <-> old;
original_trait_refs = Some(old);
}
None => {
original_trait_refs = None;
} }
None => ()
} }
// Resolve the self type. // Resolve the self type.
@ -3945,7 +3946,10 @@ pub impl Resolver {
} }
// Restore the original trait references. // Restore the original trait references.
self.current_trait_refs = original_trait_refs; match original_trait_refs {
Some(r) => { self.current_trait_refs = r; }
None => ()
}
} }
} }
@ -4032,7 +4036,7 @@ pub impl Resolver {
} }
fn resolve_arm(@mut self, arm: &arm, visitor: ResolveVisitor) { fn resolve_arm(@mut self, arm: &arm, visitor: ResolveVisitor) {
(*self.value_ribs).push(@Rib(NormalRibKind)); self.value_ribs.push(@Rib(NormalRibKind));
let bindings_list = HashMap(); let bindings_list = HashMap();
for arm.pats.each |pattern| { for arm.pats.each |pattern| {
@ -4047,12 +4051,12 @@ pub impl Resolver {
visit_expr_opt(arm.guard, (), visitor); visit_expr_opt(arm.guard, (), visitor);
self.resolve_block(&arm.body, visitor); self.resolve_block(&arm.body, visitor);
(*self.value_ribs).pop(); self.value_ribs.pop();
} }
fn resolve_block(@mut self, block: &blk, visitor: ResolveVisitor) { fn resolve_block(@mut self, block: &blk, visitor: ResolveVisitor) {
debug!("(resolving block) entering block"); debug!("(resolving block) entering block");
(*self.value_ribs).push(@Rib(NormalRibKind)); self.value_ribs.push(@Rib(NormalRibKind));
// Move down in the graph, if there's an anonymous module rooted here. // Move down in the graph, if there's an anonymous module rooted here.
let orig_module = self.current_module; let orig_module = self.current_module;
@ -4071,7 +4075,7 @@ pub impl Resolver {
// Move back up. // Move back up.
self.current_module = orig_module; self.current_module = orig_module;
(*self.value_ribs).pop(); self.value_ribs.pop();
debug!("(resolving block) leaving block"); debug!("(resolving block) leaving block");
} }
@ -4251,7 +4255,8 @@ pub impl Resolver {
Some(bindings_list) Some(bindings_list)
if !bindings_list.contains_key(&ident) if !bindings_list.contains_key(&ident)
=> { => {
let last_rib = (*self.value_ribs).last(); let last_rib = self.value_ribs[
self.value_ribs.len() - 1];
last_rib.bindings.insert(ident, last_rib.bindings.insert(ident,
dl_def(def)); dl_def(def));
bindings_list.insert(ident, pat_id); bindings_list.insert(ident, pat_id);
@ -4270,7 +4275,8 @@ pub impl Resolver {
// Not bound in the same pattern: do nothing // Not bound in the same pattern: do nothing
} }
None => { None => {
let last_rib = (*self.value_ribs).last(); let last_rib = self.value_ribs[
self.value_ribs.len() - 1];
last_rib.bindings.insert(ident, last_rib.bindings.insert(ident,
dl_def(def)); dl_def(def));
} }
@ -4510,14 +4516,14 @@ pub impl Resolver {
} }
} }
fn intern_module_part_of_path(@mut self, path: @path) -> @DVec<ident> { fn intern_module_part_of_path(@mut self, path: @path) -> ~[ident] {
let module_path_idents = @DVec(); let mut module_path_idents = ~[];
for path.idents.eachi |index, ident| { for path.idents.eachi |index, ident| {
if index == path.idents.len() - 1 { if index == path.idents.len() - 1 {
break; break;
} }
(*module_path_idents).push(*ident); module_path_idents.push(*ident);
} }
return module_path_idents; return module_path_idents;
@ -4539,7 +4545,7 @@ pub impl Resolver {
self.session.span_err(path.span, self.session.span_err(path.span,
fmt!("use of undeclared module `%s`", fmt!("use of undeclared module `%s`",
self.idents_to_str( self.idents_to_str(
(*module_path_idents).get()))); module_path_idents)));
return None; return None;
} }
@ -4587,8 +4593,8 @@ pub impl Resolver {
Failed => { Failed => {
self.session.span_err(path.span, self.session.span_err(path.span,
fmt!("use of undeclared module `::%s`", fmt!("use of undeclared module `::%s`",
self.idents_to_str self.idents_to_str(
((*module_path_idents).get()))); module_path_idents)));
return None; return None;
} }
@ -4625,12 +4631,13 @@ pub impl Resolver {
let mut search_result; let mut search_result;
match namespace { match namespace {
ValueNS => { ValueNS => {
search_result = self.search_ribs(self.value_ribs, ident, span, search_result = self.search_ribs(&mut self.value_ribs, ident,
span,
DontAllowCapturingSelf); DontAllowCapturingSelf);
} }
TypeNS => { TypeNS => {
search_result = self.search_ribs(self.type_ribs, ident, span, search_result = self.search_ribs(&mut self.type_ribs, ident,
AllowCapturingSelf); span, AllowCapturingSelf);
} }
} }
@ -4688,8 +4695,7 @@ pub impl Resolver {
let mut j = self.value_ribs.len(); let mut j = self.value_ribs.len();
while j != 0 { while j != 0 {
j -= 1; j -= 1;
let rib = self.value_ribs.get_elt(j); for self.value_ribs[j].bindings.each_entry |e| {
for rib.bindings.each_entry |e| {
vec::push(&mut maybes, copy *self.session.str_of(e.key)); vec::push(&mut maybes, copy *self.session.str_of(e.key));
vec::push(&mut values, uint::max_value); vec::push(&mut values, uint::max_value);
} }
@ -4721,8 +4727,7 @@ pub impl Resolver {
let mut i = self.type_ribs.len(); let mut i = self.type_ribs.len();
while i != 0 { while i != 0 {
i -= 1; i -= 1;
let rib = self.type_ribs.get_elt(i); match self.type_ribs[i].kind {
match rib.kind {
MethodRibKind(node_id, _) => MethodRibKind(node_id, _) =>
for self.crate.node.module.items.each |item| { for self.crate.node.module.items.each |item| {
if item.id == node_id { if item.id == node_id {
@ -4839,14 +4844,15 @@ pub impl Resolver {
expr_loop(_, Some(label)) => { expr_loop(_, Some(label)) => {
do self.with_label_rib { do self.with_label_rib {
let def_like = dl_def(def_label(expr.id)); let def_like = dl_def(def_label(expr.id));
self.label_ribs.last().bindings.insert(label, def_like); let rib = self.label_ribs[self.label_ribs.len() - 1];
rib.bindings.insert(label, def_like);
visit_expr(expr, (), visitor); visit_expr(expr, (), visitor);
} }
} }
expr_break(Some(label)) | expr_again(Some(label)) => { expr_break(Some(label)) | expr_again(Some(label)) => {
match self.search_ribs(self.label_ribs, label, expr.span, match self.search_ribs(&mut self.label_ribs, label, expr.span,
DontAllowCapturingSelf) { DontAllowCapturingSelf) {
None => None =>
self.session.span_err(expr.span, self.session.span_err(expr.span,
@ -4873,11 +4879,11 @@ pub impl Resolver {
match expr.node { match expr.node {
expr_field(_, ident, _) => { expr_field(_, ident, _) => {
let traits = self.search_for_traits_containing_method(ident); let traits = self.search_for_traits_containing_method(ident);
self.trait_map.insert(expr.id, traits); self.trait_map.insert(expr.id, @mut traits);
} }
expr_method_call(_, ident, _, _, _) => { expr_method_call(_, ident, _, _, _) => {
let traits = self.search_for_traits_containing_method(ident); let traits = self.search_for_traits_containing_method(ident);
self.trait_map.insert(expr.id, traits); self.trait_map.insert(expr.id, @mut traits);
} }
expr_binary(add, _, _) | expr_assign_op(add, _, _) => { expr_binary(add, _, _) | expr_assign_op(add, _, _) => {
self.add_fixed_trait_for_expr(expr.id, self.add_fixed_trait_for_expr(expr.id,
@ -4948,11 +4954,11 @@ pub impl Resolver {
fn search_for_traits_containing_method(@mut self, fn search_for_traits_containing_method(@mut self,
name: ident) name: ident)
-> @DVec<def_id> { -> ~[def_id] {
debug!("(searching for traits containing method) looking for '%s'", debug!("(searching for traits containing method) looking for '%s'",
*self.session.str_of(name)); *self.session.str_of(name));
let found_traits = @DVec(); let mut found_traits = ~[];
let mut search_module = self.current_module; let mut search_module = self.current_module;
loop { loop {
// Look for the current trait. // Look for the current trait.
@ -4960,7 +4966,7 @@ pub impl Resolver {
Some(trait_def_ids) => { Some(trait_def_ids) => {
for trait_def_ids.each |trait_def_id| { for trait_def_ids.each |trait_def_id| {
self.add_trait_info_if_containing_method( self.add_trait_info_if_containing_method(
found_traits, *trait_def_id, name); &mut found_traits, *trait_def_id, name);
} }
} }
None => { None => {
@ -4975,7 +4981,7 @@ pub impl Resolver {
match def { match def {
def_ty(trait_def_id) => { def_ty(trait_def_id) => {
self.add_trait_info_if_containing_method( self.add_trait_info_if_containing_method(
found_traits, trait_def_id, name); &mut found_traits, trait_def_id, name);
} }
_ => { _ => {
// Continue. // Continue.
@ -5003,7 +5009,8 @@ pub impl Resolver {
def_ty(trait_def_id) => { def_ty(trait_def_id) => {
let added = self. let added = self.
add_trait_info_if_containing_method( add_trait_info_if_containing_method(
found_traits, trait_def_id, name); &mut found_traits,
trait_def_id, name);
if added { if added {
import_resolution.state.used = import_resolution.state.used =
true; true;
@ -5039,7 +5046,7 @@ pub impl Resolver {
} }
fn add_trait_info_if_containing_method(@mut self, fn add_trait_info_if_containing_method(@mut self,
found_traits: @DVec<def_id>, found_traits: &mut ~[def_id],
trait_def_id: def_id, trait_def_id: def_id,
name: ident) name: ident)
-> bool { -> bool {
@ -5056,7 +5063,7 @@ pub impl Resolver {
trait_def_id.crate, trait_def_id.crate,
trait_def_id.node, trait_def_id.node,
*self.session.str_of(name)); *self.session.str_of(name));
(*found_traits).push(trait_def_id); found_traits.push(trait_def_id);
true true
} }
Some(_) | None => { Some(_) | None => {
@ -5068,9 +5075,7 @@ pub impl Resolver {
fn add_fixed_trait_for_expr(@mut self, fn add_fixed_trait_for_expr(@mut self,
expr_id: node_id, expr_id: node_id,
+trait_id: def_id) { +trait_id: def_id) {
let traits = @DVec(); self.trait_map.insert(expr_id, @mut ~[trait_id]);
traits.push(trait_id);
self.trait_map.insert(expr_id, traits);
} }
fn record_def(@mut self, node_id: node_id, def: def) { fn record_def(@mut self, node_id: node_id, def: def) {
@ -5225,7 +5230,7 @@ pub impl Resolver {
/// A somewhat inefficient routine to obtain the name of a module. /// A somewhat inefficient routine to obtain the name of a module.
fn module_to_str(@mut self, module_: @mut Module) -> ~str { fn module_to_str(@mut self, module_: @mut Module) -> ~str {
let idents = DVec(); let mut idents = ~[];
let mut current_module = module_; let mut current_module = module_;
loop { loop {
match current_module.parent_link { match current_module.parent_link {
@ -5246,7 +5251,7 @@ pub impl Resolver {
if idents.len() == 0 { if idents.len() == 0 {
return ~"???"; return ~"???";
} }
return self.idents_to_str(vec::reversed(idents.get())); return self.idents_to_str(vec::reversed(idents));
} }
fn dump_module(@mut self, module_: @mut Module) { fn dump_module(@mut self, module_: @mut Module) {

38
src/librustc/middle/trans/_match.rs
View File

@ -167,8 +167,6 @@ use middle::trans::type_of;
use middle::ty; use middle::ty;
use util::common::indenter; use util::common::indenter;
use core::dvec::DVec;
use core::dvec;
use std::oldmap::HashMap; use std::oldmap::HashMap;
use syntax::ast; use syntax::ast;
use syntax::ast::ident; use syntax::ast::ident;
@ -553,7 +551,7 @@ pub fn enter_opt(bcx: block, m: &[@Match/&r], opt: &Opt, col: uint,
// Reorder the patterns into the same order they were // Reorder the patterns into the same order they were
// specified in the struct definition. Also fill in // specified in the struct definition. Also fill in
// unspecified fields with dummy. // unspecified fields with dummy.
let reordered_patterns = dvec::DVec(); let mut reordered_patterns = ~[];
for ty::lookup_struct_fields(tcx, struct_id).each for ty::lookup_struct_fields(tcx, struct_id).each
|field| { |field| {
match field_pats.find(|p| match field_pats.find(|p|
@ -562,7 +560,7 @@ pub fn enter_opt(bcx: block, m: &[@Match/&r], opt: &Opt, col: uint,
Some(fp) => reordered_patterns.push(fp.pat) Some(fp) => reordered_patterns.push(fp.pat)
} }
} }
Some(dvec::unwrap(reordered_patterns)) Some(reordered_patterns)
} else { } else {
None None
} }
@ -764,32 +762,32 @@ pub fn enter_region(bcx: block,
// on a set of enum variants or a literal. // on a set of enum variants or a literal.
pub fn get_options(bcx: block, m: &[@Match], col: uint) -> ~[Opt] { pub fn get_options(bcx: block, m: &[@Match], col: uint) -> ~[Opt] {
let ccx = bcx.ccx(); let ccx = bcx.ccx();
fn add_to_set(tcx: ty::ctxt, set: &DVec<Opt>, +val: Opt) { fn add_to_set(tcx: ty::ctxt, set: &mut ~[Opt], +val: Opt) {
if set.any(|l| opt_eq(tcx, l, &val)) {return;} if set.any(|l| opt_eq(tcx, l, &val)) {return;}
set.push(val); set.push(val);
} }
let found = DVec(); let mut found = ~[];
for vec::each(m) |br| { for m.each |br| {
let cur = br.pats[col]; let cur = br.pats[col];
match /*bad*/copy cur.node { match /*bad*/copy cur.node {
ast::pat_lit(l) => { ast::pat_lit(l) => {
add_to_set(ccx.tcx, &found, lit(ExprLit(l))); add_to_set(ccx.tcx, &mut found, lit(ExprLit(l)));
} }
ast::pat_ident(*) => { ast::pat_ident(*) => {
// This is one of: an enum variant, a unit-like struct, or a // This is one of: an enum variant, a unit-like struct, or a
// variable binding. // variable binding.
match ccx.tcx.def_map.find(&cur.id) { match ccx.tcx.def_map.find(&cur.id) {
Some(ast::def_variant(*)) => { Some(ast::def_variant(*)) => {
add_to_set(ccx.tcx, &found, add_to_set(ccx.tcx, &mut found,
variant_opt(bcx, cur.id)); variant_opt(bcx, cur.id));
} }
Some(ast::def_struct(*)) => { Some(ast::def_struct(*)) => {
add_to_set(ccx.tcx, &found, add_to_set(ccx.tcx, &mut found,
lit(UnitLikeStructLit(cur.id))); lit(UnitLikeStructLit(cur.id)));
} }
Some(ast::def_const(const_did)) => { Some(ast::def_const(const_did)) => {
add_to_set(ccx.tcx, &found, add_to_set(ccx.tcx, &mut found,
lit(ConstLit(const_did))); lit(ConstLit(const_did)));
} }
_ => {} _ => {}
@ -800,26 +798,26 @@ pub fn get_options(bcx: block, m: &[@Match], col: uint) -> ~[Opt] {
// struct-like enum variant, or a struct. // struct-like enum variant, or a struct.
match ccx.tcx.def_map.find(&cur.id) { match ccx.tcx.def_map.find(&cur.id) {
Some(ast::def_variant(*)) => { Some(ast::def_variant(*)) => {
add_to_set(ccx.tcx, &found, add_to_set(ccx.tcx, &mut found,
variant_opt(bcx, cur.id)); variant_opt(bcx, cur.id));
} }
_ => {} _ => {}
} }
} }
ast::pat_range(l1, l2) => { ast::pat_range(l1, l2) => {
add_to_set(ccx.tcx, &found, range(l1, l2)); add_to_set(ccx.tcx, &mut found, range(l1, l2));
} }
ast::pat_vec(elems, tail) => { ast::pat_vec(elems, tail) => {
let opt = match tail { let opt = match tail {
None => vec_len_eq(elems.len()), None => vec_len_eq(elems.len()),
Some(_) => vec_len_ge(elems.len()) Some(_) => vec_len_ge(elems.len())
}; };
add_to_set(ccx.tcx, &found, opt); add_to_set(ccx.tcx, &mut found, opt);
} }
_ => {} _ => {}
} }
} }
return dvec::unwrap(found); return found;
} }
pub struct ExtractedBlock { pub struct ExtractedBlock {
@ -1074,7 +1072,7 @@ pub fn compare_values(cx: block,
pub fn store_non_ref_bindings(bcx: block, pub fn store_non_ref_bindings(bcx: block,
data: &ArmData, data: &ArmData,
opt_temp_cleanups: Option<&DVec<ValueRef>>) opt_temp_cleanups: Option<&mut ~[ValueRef]>)
-> block { -> block {
/*! /*!
* *
@ -1166,8 +1164,8 @@ pub fn compile_guard(bcx: block,
let _indenter = indenter(); let _indenter = indenter();
let mut bcx = bcx; let mut bcx = bcx;
let temp_cleanups = DVec(); let mut temp_cleanups = ~[];
bcx = store_non_ref_bindings(bcx, data, Some(&temp_cleanups)); bcx = store_non_ref_bindings(bcx, data, Some(&mut temp_cleanups));
bcx = insert_lllocals(bcx, data, false); bcx = insert_lllocals(bcx, data, false);
let val = unpack_result!(bcx, { let val = unpack_result!(bcx, {
@ -1627,7 +1625,7 @@ pub fn trans_match_inner(scope_cx: block,
let lldiscr = discr_datum.to_ref_llval(bcx); let lldiscr = discr_datum.to_ref_llval(bcx);
compile_submatch(bcx, matches, ~[lldiscr], chk); compile_submatch(bcx, matches, ~[lldiscr], chk);
let arm_cxs = DVec(); let mut arm_cxs = ~[];
for arm_datas.each |arm_data| { for arm_datas.each |arm_data| {
let mut bcx = arm_data.bodycx; let mut bcx = arm_data.bodycx;
@ -1647,7 +1645,7 @@ pub fn trans_match_inner(scope_cx: block,
arm_cxs.push(bcx); arm_cxs.push(bcx);
} }
bcx = controlflow::join_blocks(scope_cx, dvec::unwrap(arm_cxs)); bcx = controlflow::join_blocks(scope_cx, arm_cxs);
return bcx; return bcx;
fn mk_fail(bcx: block, sp: span, msg: @~str, fn mk_fail(bcx: block, sp: span, msg: @~str,

8
src/librustc/middle/ty.rs
View File

@ -29,8 +29,6 @@ use util::common::{indenter};
use core::cast; use core::cast;
use core::cmp; use core::cmp;
use core::dvec::DVec;
use core::dvec;
use core::ops; use core::ops;
use core::option; use core::option;
use core::ptr::to_unsafe_ptr; use core::ptr::to_unsafe_ptr;
@ -213,7 +211,7 @@ pub enum AutoRefKind {
// This is a map from ID of each implementation to the method info and trait // This is a map from ID of each implementation to the method info and trait
// method ID of each of the default methods belonging to the trait that that // method ID of each of the default methods belonging to the trait that that
// implementation implements. // implementation implements.
pub type ProvidedMethodsMap = HashMap<def_id,@DVec<@ProvidedMethodInfo>>; pub type ProvidedMethodsMap = HashMap<def_id,@mut ~[@ProvidedMethodInfo]>;
// Stores the method info and definition ID of the associated trait method for // Stores the method info and definition ID of the associated trait method for
// each instantiation of each provided method. // each instantiation of each provided method.
@ -3522,7 +3520,7 @@ pub fn trait_supertraits(cx: ctxt,
// Get the supertraits out of the metadata and create the // Get the supertraits out of the metadata and create the
// InstantiatedTraitRef for each. // InstantiatedTraitRef for each.
let result = dvec::DVec(); let mut result = ~[];
for csearch::get_supertraits(cx, id).each |trait_type| { for csearch::get_supertraits(cx, id).each |trait_type| {
match get(*trait_type).sty { match get(*trait_type).sty {
ty_trait(def_id, ref substs, _) => { ty_trait(def_id, ref substs, _) => {
@ -3539,7 +3537,7 @@ pub fn trait_supertraits(cx: ctxt,
} }
// Unwrap and return the result. // Unwrap and return the result.
return @dvec::unwrap(result); return @result;
} }
pub fn trait_methods(cx: ctxt, id: ast::def_id) -> @~[method] { pub fn trait_methods(cx: ctxt, id: ast::def_id) -> @~[method] {

37
src/librustc/middle/typeck/check/method.rs
View File

@ -95,7 +95,6 @@ use middle::typeck::{method_self, method_static, method_trait, method_super};
use util::common::indenter; use util::common::indenter;
use util::ppaux::expr_repr; use util::ppaux::expr_repr;
use core::dvec::DVec;
use core::result; use core::result;
use core::uint; use core::uint;
use core::vec; use core::vec;
@ -127,8 +126,8 @@ pub fn lookup(
m_name: m_name, m_name: m_name,
supplied_tps: supplied_tps, supplied_tps: supplied_tps,
impl_dups: HashMap(), impl_dups: HashMap(),
inherent_candidates: DVec(), inherent_candidates: @mut ~[],
extension_candidates: DVec(), extension_candidates: @mut ~[],
deref_args: deref_args, deref_args: deref_args,
}; };
let mme = lcx.do_lookup(self_ty); let mme = lcx.do_lookup(self_ty);
@ -145,8 +144,8 @@ pub struct LookupContext {
m_name: ast::ident, m_name: ast::ident,
supplied_tps: &self/[ty::t], supplied_tps: &self/[ty::t],
impl_dups: HashMap<def_id, ()>, impl_dups: HashMap<def_id, ()>,
inherent_candidates: DVec<Candidate>, inherent_candidates: @mut ~[Candidate],
extension_candidates: DVec<Candidate>, extension_candidates: @mut ~[Candidate],
deref_args: check::DerefArgs, deref_args: check::DerefArgs,
} }
@ -188,7 +187,7 @@ pub impl LookupContext/&self {
self.push_inherent_candidates(self_ty); self.push_inherent_candidates(self_ty);
self.push_extension_candidates(self_ty); self.push_extension_candidates(self_ty);
let enum_dids = DVec(); let mut enum_dids = ~[];
let mut self_ty = self_ty; let mut self_ty = self_ty;
let mut autoderefs = 0; let mut autoderefs = 0;
loop { loop {
@ -224,7 +223,7 @@ pub impl LookupContext/&self {
} }
} }
match self.deref(self_ty, &enum_dids) { match self.deref(self_ty, &mut enum_dids) {
None => { break; } None => { break; }
Some(ty) => { Some(ty) => {
self_ty = ty; self_ty = ty;
@ -236,7 +235,7 @@ pub impl LookupContext/&self {
self.search_for_autosliced_method(self_ty, autoderefs) self.search_for_autosliced_method(self_ty, autoderefs)
} }
fn deref(ty: ty::t, enum_dids: &DVec<ast::def_id>) -> Option<ty::t> { fn deref(ty: ty::t, enum_dids: &mut ~[ast::def_id]) -> Option<ty::t> {
match ty::get(ty).sty { match ty::get(ty).sty {
ty_enum(did, _) => { ty_enum(did, _) => {
// Watch out for newtype'd enums like "enum t = @T". // Watch out for newtype'd enums like "enum t = @T".
@ -272,7 +271,7 @@ pub impl LookupContext/&self {
* example, if the receiver is @@C where `C` is a struct type, * example, if the receiver is @@C where `C` is a struct type,
* we'll want to find the inherent impls for `C`. */ * we'll want to find the inherent impls for `C`. */
let enum_dids = DVec(); let mut enum_dids = ~[];
let mut self_ty = self_ty; let mut self_ty = self_ty;
loop { loop {
match get(self_ty).sty { match get(self_ty).sty {
@ -307,7 +306,7 @@ pub impl LookupContext/&self {
// n.b.: Generally speaking, we only loop if we hit the // n.b.: Generally speaking, we only loop if we hit the
// fallthrough case in the match above. The exception // fallthrough case in the match above. The exception
// would be newtype enums. // would be newtype enums.
self_ty = match self.deref(self_ty, &enum_dids) { self_ty = match self.deref(self_ty, &mut enum_dids) {
None => { return; } None => { return; }
Some(ty) => { ty } Some(ty) => { ty }
} }
@ -330,7 +329,7 @@ pub impl LookupContext/&self {
for opt_impl_infos.each |impl_infos| { for opt_impl_infos.each |impl_infos| {
for impl_infos.each |impl_info| { for impl_infos.each |impl_info| {
self.push_candidates_from_impl( self.push_candidates_from_impl(
&self.extension_candidates, *impl_info); self.extension_candidates, *impl_info);
} }
} }
@ -338,7 +337,7 @@ pub impl LookupContext/&self {
match self.tcx().provided_methods.find(trait_did) { match self.tcx().provided_methods.find(trait_did) {
Some(methods) => { Some(methods) => {
self.push_candidates_from_provided_methods( self.push_candidates_from_provided_methods(
&self.extension_candidates, self_ty, *trait_did, self.extension_candidates, self_ty, *trait_did,
methods); methods);
} }
None => {} None => {}
@ -606,12 +605,12 @@ pub impl LookupContext/&self {
for opt_impl_infos.each |impl_infos| { for opt_impl_infos.each |impl_infos| {
for impl_infos.each |impl_info| { for impl_infos.each |impl_info| {
self.push_candidates_from_impl( self.push_candidates_from_impl(
&self.inherent_candidates, *impl_info); self.inherent_candidates, *impl_info);
} }
} }
} }
fn push_candidates_from_impl(&self, candidates: &DVec<Candidate>, fn push_candidates_from_impl(&self, candidates: &mut ~[Candidate],
impl_info: &resolve::Impl) { impl_info: &resolve::Impl) {
if !self.impl_dups.insert(impl_info.did, ()) { if !self.impl_dups.insert(impl_info.did, ()) {
return; // already visited return; // already visited
@ -657,10 +656,10 @@ pub impl LookupContext/&self {
fn push_candidates_from_provided_methods( fn push_candidates_from_provided_methods(
&self, &self,
candidates: &DVec<Candidate>, candidates: &mut ~[Candidate],
self_ty: ty::t, self_ty: ty::t,
trait_def_id: def_id, trait_def_id: def_id,
methods: @DVec<@ProvidedMethodInfo>) { methods: &mut ~[@ProvidedMethodInfo]) {
debug!("(pushing candidates from provided methods) considering trait \ debug!("(pushing candidates from provided methods) considering trait \
id %d:%d", id %d:%d",
trait_def_id.crate, trait_def_id.crate,
@ -970,7 +969,7 @@ pub impl LookupContext/&self {
// existing code. // existing code.
debug!("searching inherent candidates"); debug!("searching inherent candidates");
match self.consider_candidates(self_ty, &self.inherent_candidates) { match self.consider_candidates(self_ty, self.inherent_candidates) {
None => {} None => {}
Some(mme) => { Some(mme) => {
return Some(mme); return Some(mme);
@ -978,7 +977,7 @@ pub impl LookupContext/&self {
} }
debug!("searching extension candidates"); debug!("searching extension candidates");
match self.consider_candidates(self_ty, &self.extension_candidates) { match self.consider_candidates(self_ty, self.extension_candidates) {
None => { None => {
return None; return None;
} }
@ -990,7 +989,7 @@ pub impl LookupContext/&self {
fn consider_candidates(&self, fn consider_candidates(&self,
self_ty: ty::t, self_ty: ty::t,
candidates: &DVec<Candidate>) candidates: &mut ~[Candidate])
-> Option<method_map_entry> -> Option<method_map_entry>
{ {
let relevant_candidates = let relevant_candidates =

26
src/librustc/middle/typeck/coherence.rs
View File

@ -55,7 +55,6 @@ use syntax::visit::{Visitor, SimpleVisitor};
use syntax::visit::{visit_mod}; use syntax::visit::{visit_mod};
use util::ppaux::ty_to_str; use util::ppaux::ty_to_str;
use core::dvec::DVec;
use core::result::Ok; use core::result::Ok;
use core::hashmap::linear::LinearSet; use core::hashmap::linear::LinearSet;
use core::uint; use core::uint;
@ -151,11 +150,11 @@ pub fn method_to_MethodInfo(ast_method: @method) -> @MethodInfo {
pub struct CoherenceInfo { pub struct CoherenceInfo {
// Contains implementations of methods that are inherent to a type. // Contains implementations of methods that are inherent to a type.
// Methods in these implementations don't need to be exported. // Methods in these implementations don't need to be exported.
inherent_methods: HashMap<def_id,@DVec<@Impl>>, inherent_methods: HashMap<def_id,@mut ~[@Impl]>,
// Contains implementations of methods associated with a trait. For these, // Contains implementations of methods associated with a trait. For these,
// the associated trait must be imported at the call site. // the associated trait must be imported at the call site.
extension_methods: HashMap<def_id,@DVec<@Impl>>, extension_methods: HashMap<def_id,@mut ~[@Impl]>,
} }
@ -372,9 +371,8 @@ pub impl CoherenceChecker {
for method `%s`", for method `%s`",
*self.crate_context.tcx.sess.str_of( *self.crate_context.tcx.sess.str_of(
provided_method_info.method_info.ident)); provided_method_info.method_info.ident));
let method_infos = @DVec(); pmm.insert(local_def(impl_id),
method_infos.push(provided_method_info); @mut ~[provided_method_info]);
pmm.insert(local_def(impl_id), method_infos);
} }
} }
} }
@ -386,7 +384,7 @@ pub impl CoherenceChecker {
match self.crate_context.coherence_info.inherent_methods match self.crate_context.coherence_info.inherent_methods
.find(&base_def_id) { .find(&base_def_id) {
None => { None => {
implementation_list = @DVec(); implementation_list = @mut ~[];
self.crate_context.coherence_info.inherent_methods self.crate_context.coherence_info.inherent_methods
.insert(base_def_id, implementation_list); .insert(base_def_id, implementation_list);
} }
@ -403,7 +401,7 @@ pub impl CoherenceChecker {
match self.crate_context.coherence_info.extension_methods match self.crate_context.coherence_info.extension_methods
.find(&trait_id) { .find(&trait_id) {
None => { None => {
implementation_list = @DVec(); implementation_list = @mut ~[];
self.crate_context.coherence_info.extension_methods self.crate_context.coherence_info.extension_methods
.insert(trait_id, implementation_list); .insert(trait_id, implementation_list);
} }
@ -741,13 +739,13 @@ pub impl CoherenceChecker {
// Converts an implementation in the AST to an Impl structure. // Converts an implementation in the AST to an Impl structure.
fn create_impl_from_item(&self, item: @item) -> @Impl { fn create_impl_from_item(&self, item: @item) -> @Impl {
fn add_provided_methods(all_methods: &mut ~[@MethodInfo], fn add_provided_methods(all_methods: &mut ~[@MethodInfo],
all_provided_methods: ~[@ProvidedMethodInfo], all_provided_methods: &mut ~[@ProvidedMethodInfo],
sess: driver::session::Session) { sess: driver::session::Session) {
for all_provided_methods.each |provided_method| { for all_provided_methods.each |provided_method| {
debug!( debug!(
"(creating impl) adding provided method `%s` to impl", "(creating impl) adding provided method `%s` to impl",
*sess.str_of(provided_method.method_info.ident)); *sess.str_of(provided_method.method_info.ident));
vec::push(&mut *all_methods, provided_method.method_info); vec::push(all_methods, provided_method.method_info);
} }
} }
@ -790,7 +788,7 @@ pub impl CoherenceChecker {
// Add all provided methods. // Add all provided methods.
add_provided_methods( add_provided_methods(
&mut methods, &mut methods,
all_provided.get(), all_provided,
self.crate_context.tcx.sess); self.crate_context.tcx.sess);
} }
} }
@ -943,9 +941,7 @@ pub impl CoherenceChecker {
trait_method_def_id: trait_method_info.def_id trait_method_def_id: trait_method_info.def_id
}; };
let method_infos = @DVec(); pmm.insert(trait_def_id, @mut ~[provided_method_info]);
method_infos.push(provided_method_info);
pmm.insert(trait_def_id, method_infos);
} }
} }

6
src/librustc/middle/typeck/collect.rs
View File

@ -46,7 +46,6 @@ use middle::typeck::{CrateCtxt, lookup_def_tcx, no_params, write_ty_to_tcx};
use util::common::{indenter, pluralize}; use util::common::{indenter, pluralize};
use util::ppaux; use util::ppaux;
use core::dvec;
use core::vec; use core::vec;
use syntax::ast::{RegionTyParamBound, TraitTyParamBound}; use syntax::ast::{RegionTyParamBound, TraitTyParamBound};
use syntax::ast; use syntax::ast;
@ -321,7 +320,7 @@ pub fn ensure_supertraits(ccx: &CrateCtxt,
let tcx = ccx.tcx; let tcx = ccx.tcx;
if tcx.supertraits.contains_key(&local_def(id)) { return; } if tcx.supertraits.contains_key(&local_def(id)) { return; }
let instantiated = dvec::DVec(); let mut instantiated = ~[];
for trait_refs.each |trait_ref| { for trait_refs.each |trait_ref| {
let (did, tpt) = instantiate_trait_ref(ccx, *trait_ref, rp); let (did, tpt) = instantiate_trait_ref(ccx, *trait_ref, rp);
if instantiated.any(|other_trait: &InstantiatedTraitRef| if instantiated.any(|other_trait: &InstantiatedTraitRef|
@ -334,8 +333,7 @@ pub fn ensure_supertraits(ccx: &CrateCtxt,
} }
instantiated.push(InstantiatedTraitRef { def_id: did, tpt: tpt }); instantiated.push(InstantiatedTraitRef { def_id: did, tpt: tpt });
} }
tcx.supertraits.insert(local_def(id), tcx.supertraits.insert(local_def(id), @instantiated);
@dvec::unwrap(instantiated));
} }
/** /**

5
src/librustc/middle/typeck/infer/region_inference.rs
View File

@ -549,7 +549,6 @@ use util::ppaux::note_and_explain_region;
use core::cell::{Cell, empty_cell}; use core::cell::{Cell, empty_cell};
use core::cmp; use core::cmp;
use core::dvec::DVec;
use core::result::{Err, Ok, Result}; use core::result::{Err, Ok, Result};
use core::to_bytes; use core::to_bytes;
use core::uint; use core::uint;
@ -627,7 +626,7 @@ type CombineMap = HashMap<TwoRegions, RegionVid>;
pub struct RegionVarBindings { pub struct RegionVarBindings {
tcx: ty::ctxt, tcx: ty::ctxt,
var_spans: DVec<span>, var_spans: ~[span],
constraints: HashMap<Constraint, span>, constraints: HashMap<Constraint, span>,
lubs: CombineMap, lubs: CombineMap,
glbs: CombineMap, glbs: CombineMap,
@ -653,7 +652,7 @@ pub struct RegionVarBindings {
pub fn RegionVarBindings(tcx: ty::ctxt) -> RegionVarBindings { pub fn RegionVarBindings(tcx: ty::ctxt) -> RegionVarBindings {
RegionVarBindings { RegionVarBindings {
tcx: tcx, tcx: tcx,
var_spans: DVec(), var_spans: ~[],
values: empty_cell(), values: empty_cell(),
constraints: HashMap(), constraints: HashMap(),
lubs: CombineMap(), lubs: CombineMap(),