diff options
98 files changed, 1172 insertions, 758 deletions
diff --git a/src/librustc/back/archive.rs b/src/librustc/back/archive.rs index ef8c2ddf384..d297df1301e 100644 --- a/src/librustc/back/archive.rs +++ b/src/librustc/back/archive.rs @@ -98,9 +98,17 @@ impl Archive { let archive = os::make_absolute(&self.dst); run_ar(self.sess, "x", Some(loc.path()), [&archive, &Path::new(file)]); - fs::File::open(&loc.path().join(file)).read_to_end().unwrap() + let result: Vec<u8> = + fs::File::open(&loc.path().join(file)).read_to_end() + .unwrap() + .move_iter() + .collect(); + result } else { - run_ar(self.sess, "p", None, [&self.dst, &Path::new(file)]).output + run_ar(self.sess, + "p", + None, + [&self.dst, &Path::new(file)]).output.move_iter().collect() } } @@ -124,7 +132,7 @@ impl Archive { if lto { ignore.push(object.as_slice()); } - self.add_archive(rlib, name, ignore) + self.add_archive(rlib, name, ignore.as_slice()) } /// Adds an arbitrary file to this archive diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs index 5f65b6c156f..c15c55927a9 100644 --- a/src/librustc/back/link.rs +++ b/src/librustc/back/link.rs @@ -34,6 +34,7 @@ use std::str; use std::io; use std::io::Process; use std::io::fs; +use std::vec_ng::Vec; use flate; use serialize::hex::ToHex; use extra::tempfile::TempDir; @@ -106,6 +107,7 @@ pub mod write { use std::io::Process; use std::libc::{c_uint, c_int}; use std::str; + use std::vec_ng::Vec; // On android, we by default compile for armv7 processors. This enables // things like double word CAS instructions (rather than emulating them) @@ -222,7 +224,7 @@ pub mod write { if sess.lto() { time(sess.time_passes(), "all lto passes", (), |()| - lto::run(sess, llmod, tm, trans.reachable)); + lto::run(sess, llmod, tm, trans.reachable.as_slice())); if sess.opts.cg.save_temps { output.with_extension("lto.bc").with_c_str(|buf| { @@ -931,7 +933,8 @@ fn link_rlib(sess: Session, // the same filename for metadata (stomping over one another) let tmpdir = TempDir::new("rustc").expect("needs a temp dir"); let metadata = tmpdir.path().join(METADATA_FILENAME); - match fs::File::create(&metadata).write(trans.metadata) { + match fs::File::create(&metadata).write(trans.metadata + .as_slice()) { Ok(..) => {} Err(e) => { sess.err(format!("failed to write {}: {}", @@ -1035,7 +1038,7 @@ fn link_natively(sess: Session, dylib: bool, obj_filename: &Path, // Invoke the system linker debug!("{} {}", cc_prog, cc_args.connect(" ")); let prog = time(sess.time_passes(), "running linker", (), |()| - Process::output(cc_prog, cc_args)); + Process::output(cc_prog, cc_args.as_slice())); match prog { Ok(prog) => { if !prog.status.success() { @@ -1198,7 +1201,7 @@ fn link_args(sess: Session, // where extern libraries might live, based on the // addl_lib_search_paths if !sess.opts.cg.no_rpath { - args.push_all(rpath::get_rpath_flags(sess, out_filename)); + args.push_all(rpath::get_rpath_flags(sess, out_filename).as_slice()); } // Stack growth requires statically linking a __morestack function @@ -1210,7 +1213,7 @@ fn link_args(sess: Session, // Finally add all the linker arguments provided on the command line along // with any #[link_args] attributes found inside the crate - args.push_all(sess.opts.cg.link_args); + args.push_all(sess.opts.cg.link_args.as_slice()); let used_link_args = sess.cstore.get_used_link_args(); let used_link_args = used_link_args.borrow(); for arg in used_link_args.get().iter() { diff --git a/src/librustc/back/mips.rs b/src/librustc/back/mips.rs index c1f3abe23c6..bc24660e306 100644 --- a/src/librustc/back/mips.rs +++ b/src/librustc/back/mips.rs @@ -11,6 +11,7 @@ use back::target_strs; use driver::session::sess_os_to_meta_os; use metadata::loader::meta_section_name; +use std::vec_ng::Vec; use syntax::abi; pub fn get_target_strs(target_triple: ~str, target_os: abi::Os) -> target_strs::t { diff --git a/src/librustc/back/rpath.rs b/src/librustc/back/rpath.rs index df0160faaf8..9b543bb50cc 100644 --- a/src/librustc/back/rpath.rs +++ b/src/librustc/back/rpath.rs @@ -15,6 +15,7 @@ use metadata::filesearch; use collections::HashSet; use std::{os, vec}; +use std::vec_ng::Vec; use syntax::abi; fn not_win32(os: abi::Os) -> bool { @@ -49,7 +50,7 @@ pub fn get_rpath_flags(sess: session::Session, out_filename: &Path) -> Vec<~str> let rpaths = get_rpaths(os, sysroot, output, libs, sess.opts.target_triple); - flags.push_all(rpaths_to_flags(rpaths)); + flags.push_all(rpaths_to_flags(rpaths.as_slice()).as_slice()); flags } @@ -100,16 +101,16 @@ fn get_rpaths(os: abi::Os, } } - log_rpaths("relative", rel_rpaths); - log_rpaths("absolute", abs_rpaths); - log_rpaths("fallback", fallback_rpaths); + log_rpaths("relative", rel_rpaths.as_slice()); + log_rpaths("absolute", abs_rpaths.as_slice()); + log_rpaths("fallback", fallback_rpaths.as_slice()); let mut rpaths = rel_rpaths; - rpaths.push_all(abs_rpaths); - rpaths.push_all(fallback_rpaths); + rpaths.push_all(abs_rpaths.as_slice()); + rpaths.push_all(fallback_rpaths.as_slice()); // Remove duplicates - let rpaths = minimize_rpaths(rpaths); + let rpaths = minimize_rpaths(rpaths.as_slice()); return rpaths; } diff --git a/src/librustc/back/target_strs.rs b/src/librustc/back/target_strs.rs index 1528fff5113..c2a1a5598d5 100644 --- a/src/librustc/back/target_strs.rs +++ b/src/librustc/back/target_strs.rs @@ -10,6 +10,8 @@ #[allow(non_camel_case_types)]; +use std::vec_ng::Vec; + pub struct t { module_asm: ~str, meta_sect_name: ~str, diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs index af3970fcf7a..2a92ef496c7 100644 --- a/src/librustc/driver/driver.rs +++ b/src/librustc/driver/driver.rs @@ -11,8 +11,8 @@ use back::link; use back::{arm, x86, x86_64, mips}; -use driver::session::{Aggressive, CrateTypeExecutable, FullDebugInfo, LimitedDebugInfo, - NoDebugInfo}; +use driver::session::{Aggressive, CrateTypeExecutable, CrateType, + FullDebugInfo, LimitedDebugInfo, NoDebugInfo}; use driver::session::{Session, Session_, No, Less, Default}; use driver::session; use front; @@ -36,7 +36,6 @@ use std::io; use std::io::fs; use std::io::MemReader; use std::os; -use std::vec; use std::vec_ng::Vec; use std::vec_ng; use collections::HashMap; @@ -434,7 +433,7 @@ pub fn phase_5_run_llvm_passes(sess: Session, time(sess.time_passes(), "LLVM passes", (), |_| link::write::run_passes(sess, trans, - sess.opts.output_types, + sess.opts.output_types.as_slice(), outputs)); } } @@ -767,18 +766,21 @@ pub fn host_triple() -> ~str { pub fn build_session_options(matches: &getopts::Matches) -> @session::Options { - let crate_types = matches.opt_strs("crate-type").flat_map(|s| { - s.split(',').map(|part| { - match part { + let mut crate_types: Vec<CrateType> = Vec::new(); + let unparsed_crate_types = matches.opt_strs("crate-type"); + for unparsed_crate_type in unparsed_crate_types.iter() { + for part in unparsed_crate_type.split(',') { + let new_part = match part { "lib" => session::default_lib_output(), "rlib" => session::CrateTypeRlib, "staticlib" => session::CrateTypeStaticlib, "dylib" => session::CrateTypeDylib, "bin" => session::CrateTypeExecutable, _ => early_error(format!("unknown crate type: `{}`", part)) - } - }).collect() - }); + }; + crate_types.push(new_part) + } + } let parse_only = matches.opt_present("parse-only"); let no_trans = matches.opt_present("no-trans"); @@ -793,8 +795,10 @@ pub fn build_session_options(matches: &getopts::Matches) let level_short = level_name.slice_chars(0, 1); let level_short = level_short.to_ascii().to_upper().into_str(); - let flags = vec_ng::append(matches.opt_strs(level_short), - matches.opt_strs(level_name)); + let flags = vec_ng::append(matches.opt_strs(level_short) + .move_iter() + .collect(), + matches.opt_strs(level_name)); for lint_name in flags.iter() { let lint_name = lint_name.replace("-", "_"); match lint_dict.find_equiv(&lint_name) { @@ -828,23 +832,24 @@ pub fn build_session_options(matches: &getopts::Matches) unsafe { llvm::LLVMSetDebug(1); } } - let mut output_types = if parse_only || no_trans { - Vec::new() - } else { - matches.opt_strs("emit").flat_map(|s| { - s.split(',').map(|part| { - match part.as_slice() { + let mut output_types = Vec::new(); + if !parse_only && !no_trans { + let unparsed_output_types = matches.opt_strs("emit"); + for unparsed_output_type in unparsed_output_types.iter() { + for part in unparsed_output_type.split(',') { + let output_type = match part.as_slice() { "asm" => link::OutputTypeAssembly, "ir" => link::OutputTypeLlvmAssembly, "bc" => link::OutputTypeBitcode, "obj" => link::OutputTypeObject, "link" => link::OutputTypeExe, _ => early_error(format!("unknown emission type: `{}`", part)) - } - }).collect() - }) + }; + output_types.push(output_type) + } + } }; - output_types.sort(); + output_types.as_mut_slice().sort(); output_types.dedup(); if output_types.len() == 0 { output_types.push(link::OutputTypeExe); @@ -890,7 +895,7 @@ pub fn build_session_options(matches: &getopts::Matches) Path::new(s.as_slice()) }).move_iter().collect(); - let cfg = parse_cfgspecs(matches.opt_strs("cfg")); + let cfg = parse_cfgspecs(matches.opt_strs("cfg").move_iter().collect()); let test = matches.opt_present("test"); let write_dependency_info = (matches.opt_present("dep-info"), matches.opt_str("dep-info").map(|p| Path::new(p))); @@ -1187,7 +1192,7 @@ mod test { #[test] fn test_switch_implies_cfg_test() { let matches = - &match getopts([~"--test"], optgroups()) { + &match getopts([~"--test"], optgroups().as_slice()) { Ok(m) => m, Err(f) => fail!("test_switch_implies_cfg_test: {}", f.to_err_msg()) }; @@ -1202,7 +1207,8 @@ mod test { #[test] fn test_switch_implies_cfg_test_unless_cfg_test() { let matches = - &match getopts([~"--test", ~"--cfg=test"], optgroups()) { + &match getopts([~"--test", ~"--cfg=test"], + optgroups().as_slice()) { Ok(m) => m, Err(f) => { fail!("test_switch_implies_cfg_test_unless_cfg_test: {}", diff --git a/src/librustc/driver/session.rs b/src/librustc/driver/session.rs index 62d85af399d..4845060dd12 100644 --- a/src/librustc/driver/session.rs +++ b/src/librustc/driver/session.rs @@ -320,19 +320,9 @@ pub fn basic_options() -> @Options { crate_types: Vec::new(), gc: false, optimize: No, -<<<<<<< HEAD debuginfo: NoDebugInfo, - lint_opts: ~[], - output_types: ~[], -||||||| merged common ancestors - debuginfo: false, - lint_opts: ~[], - output_types: ~[], -======= - debuginfo: false, lint_opts: Vec::new(), output_types: Vec::new(), ->>>>>>> librustc: Automatically change uses of `~[T]` to `Vec<T>` in rustc. addl_lib_search_paths: @RefCell::new(HashSet::new()), maybe_sysroot: None, target_triple: host_triple(), @@ -403,7 +393,8 @@ macro_rules! cgoptions( } } - fn parse_list(slot: &mut Vec<~str> , v: Option<&str>) -> bool { + fn parse_list(slot: &mut ::std::vec_ng::Vec<~str>, v: Option<&str>) + -> bool { match v { Some(s) => { for s in s.words() { @@ -489,7 +480,7 @@ pub fn collect_crate_types(session: &Session, // If we're generating a test executable, then ignore all other output // styles at all other locations if session.opts.test { - return Vec<CrateTypeExecutable> ; + return vec!(CrateTypeExecutable) } let mut base = session.opts.crate_types.clone(); let mut iter = attrs.iter().filter_map(|a| { @@ -525,7 +516,7 @@ pub fn collect_crate_types(session: &Session, if base.len() == 0 { base.push(CrateTypeExecutable); } - base.sort(); + base.as_mut_slice().sort(); base.dedup(); return base; } diff --git a/src/librustc/front/config.rs b/src/librustc/front/config.rs index cf2c0d0775c..514d2a4a6e1 100644 --- a/src/librustc/front/config.rs +++ b/src/librustc/front/config.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. - +use std::vec_ng::Vec; use syntax::fold::Folder; use syntax::{ast, fold, attr}; use syntax::codemap; diff --git a/src/librustc/front/feature_gate.rs b/src/librustc/front/feature_gate.rs index 81aa48a6435..6246000074d 100644 --- a/src/librustc/front/feature_gate.rs +++ b/src/librustc/front/feature_gate.rs @@ -31,6 +31,7 @@ use syntax::parse::token; use driver::session::Session; use std::cell::Cell; +use std::vec_ng::Vec; /// This is a list of all known features since the beginning of time. This list /// can never shrink, it may only be expanded (in order to prevent old programs diff --git a/src/librustc/front/test.rs b/src/librustc/front/test.rs index 82fae11f873..703722ccb1c 100644 --- a/src/librustc/front/test.rs +++ b/src/librustc/front/test.rs @@ -93,7 +93,7 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> { path.get().push(i.ident); } debug!("current path: {}", - ast_util::path_name_i(self.cx.path.get())); + ast_util::path_name_i(self.cx.path.get().as_slice())); if is_test_fn(&self.cx, i) || is_bench_fn(i) { match i.node { @@ -432,11 +432,12 @@ fn mk_test_desc_and_fn_rec(cx: &TestCtxt, test: &Test) -> @ast::Expr { let span = test.span; let path = test.path.clone(); - debug!("encoding {}", ast_util::path_name_i(path)); + debug!("encoding {}", ast_util::path_name_i(path.as_slice())); let name_lit: ast::Lit = nospan(ast::LitStr(token::intern_and_get_ident( - ast_util::path_name_i(path)), ast::CookedStr)); + ast_util::path_name_i(path.as_slice())), + ast::CookedStr)); let name_expr = @ast::Expr { id: ast::DUMMY_NODE_ID, diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index 6ff0733e98b..af0acee07fd 100644 --- a/src/librustc/lib.rs +++ b/src/librustc/lib.rs @@ -53,8 +53,8 @@ use std::io; use std::os; use std::str; use std::task; -use std::vec; use std::vec_ng::Vec; +use std::vec_ng; use syntax::ast; use syntax::diagnostic::Emitter; use syntax::diagnostic; @@ -149,7 +149,7 @@ Additional help: -C help Print codegen options -W help Print 'lint' options and default settings -Z help Print internal options for debugging rustc\n", - getopts::usage(message, d::optgroups())); + getopts::usage(message, d::optgroups().as_slice())); } pub fn describe_warnings() { @@ -165,7 +165,7 @@ Available lint options: let mut lint_dict = lint_dict.move_iter() .map(|(k, v)| (v, k)) .collect::<Vec<(lint::LintSpec, &'static str)> >(); - lint_dict.sort(); + lint_dict.as_mut_slice().sort(); let mut max_key = 0; for &(_, name) in lint_dict.iter() { @@ -224,7 +224,7 @@ pub fn run_compiler(args: &[~str]) { if args.is_empty() { usage(binary); return; } let matches = - &match getopts::getopts(args, d::optgroups()) { + &match getopts::getopts(args, d::optgroups().as_slice()) { Ok(m) => m, Err(f) => { d::early_error(f.to_err_msg()); @@ -236,8 +236,10 @@ pub fn run_compiler(args: &[~str]) { return; } - let lint_flags = vec_ng::append(matches.opt_strs("W"), - matches.opt_strs("warn")); + let lint_flags = vec_ng::append(matches.opt_strs("W") + .move_iter() + .collect(), + matches.opt_strs("warn")); if lint_flags.iter().any(|x| x == &~"help") { describe_warnings(); return; @@ -312,8 +314,8 @@ pub fn run_compiler(args: &[~str]) { if crate_id || crate_name || crate_file_name { let attrs = parse_crate_attrs(sess, &input); let t_outputs = d::build_output_filenames(&input, &odir, &ofile, - attrs, sess); - let id = link::find_crate_id(attrs, &t_outputs); + attrs.as_slice(), sess); + let id = link::find_crate_id(attrs.as_slice(), &t_outputs); if crate_id { println!("{}", id.to_str()); @@ -322,7 +324,8 @@ pub fn run_compiler(args: &[~str]) { println!("{}", id.name); } if crate_file_name { - let crate_types = session::collect_crate_types(&sess, attrs); + let crate_types = session::collect_crate_types(&sess, + attrs.as_slice()); for &style in crate_types.iter() { let fname = link::filename_for_input(&sess, style, &id, &t_outputs.with_extension("")); diff --git a/src/librustc/metadata/creader.rs b/src/librustc/metadata/creader.rs index 36f5929ba26..7769d53865a 100644 --- a/src/librustc/metadata/creader.rs +++ b/src/librustc/metadata/creader.rs @@ -58,8 +58,10 @@ pub fn read_crates(sess: Session, visit::walk_crate(&mut v, krate, ()); } let crate_cache = e.crate_cache.borrow(); - dump_crates(*crate_cache.get()); - warn_if_multiple_versions(&mut e, sess.diagnostic(), *crate_cache.get()); + dump_crates(crate_cache.get().as_slice()); + warn_if_multiple_versions(&mut e, + sess.diagnostic(), + crate_cache.get().as_slice()); } struct ReadCrateVisitor<'a> { @@ -121,7 +123,7 @@ fn warn_if_multiple_versions(e: &mut Env, struct Env { sess: Session, os: loader::Os, - crate_cache: @RefCell<vec!(cache_entry)>, + crate_cache: @RefCell<Vec<cache_entry>>, next_crate_num: ast::CrateNum, intr: @IdentInterner } diff --git a/src/librustc/metadata/csearch.rs b/src/librustc/metadata/csearch.rs index fa00b3c69b2..360ab4eefe0 100644 --- a/src/librustc/metadata/csearch.rs +++ b/src/librustc/metadata/csearch.rs @@ -18,9 +18,10 @@ use metadata::decoder; use middle::ty; use middle::typeck; -use std::vec; use reader = serialize::ebml::reader; use std::rc::Rc; +use std::vec_ng::Vec; +use std::vec_ng; use syntax::ast; use syntax::ast_map; use syntax::diagnostic::expect; @@ -93,7 +94,8 @@ pub fn get_item_path(tcx: ty::ctxt, def: ast::DefId) -> Vec<ast_map::PathElem> { // FIXME #1920: This path is not always correct if the crate is not linked // into the root namespace. - vec_ng::append(vec!(ast_map::PathMod(token::intern(cdata.name))), path) + vec_ng::append(vec!(ast_map::PathMod(token::intern(cdata.name))), + path.as_slice()) } pub enum found_ast { diff --git a/src/librustc/metadata/cstore.rs b/src/librustc/metadata/cstore.rs index f0c67c4140a..1d683ec60da 100644 --- a/src/librustc/metadata/cstore.rs +++ b/src/librustc/metadata/cstore.rs @@ -18,6 +18,7 @@ use metadata::decoder; use metadata::loader; use std::cell::RefCell; +use std::vec_ng::Vec; use collections::HashMap; use extra::c_vec::CVec; use syntax::ast; diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index 0c0dcf340d8..caf4670b40a 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -33,7 +33,7 @@ use std::io; use std::io::extensions::u64_from_be_bytes; use std::option; use std::rc::Rc; -use std::vec; +use std::vec_ng::Vec; use serialize::ebml::reader; use serialize::ebml; use serialize::Decodable; @@ -304,7 +304,7 @@ fn item_path(item_doc: ebml::Doc) -> Vec<ast_map::PathElem> { let len_doc = reader::get_doc(path_doc, tag_path_len); let len = reader::doc_as_u32(len_doc) as uint; - let mut result = vec::with_capacity(len); + let mut result = Vec::with_capacity(len); reader::docs(path_doc, |tag, elt_doc| { if tag == tag_path_elem_mod { let s = elt_doc.as_str_slice(); @@ -682,7 +682,7 @@ pub fn maybe_get_item_ast(cdata: Cmd, tcx: ty::ctxt, id: ast::NodeId, -> csearch::found_ast { debug!("Looking up item: {}", id); let item_doc = lookup_item(id, cdata.data()); - let path = item_path(item_doc).init().to_owned(); + let path = Vec::from_slice(item_path(item_doc).init()); match decode_inlined_item(cdata, tcx, path, item_doc) { Ok(ref ii) => csearch::found(*ii), Err(path) => { @@ -1072,7 +1072,7 @@ fn get_attributes(md: ebml::Doc) -> Vec<ast::Attribute> { // Currently it's only possible to have a single meta item on // an attribute assert_eq!(meta_items.len(), 1u); - let meta_item = meta_items[0]; + let meta_item = *meta_items.get(0); attrs.push( codemap::Spanned { node: ast::Attribute_ { diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index c81ee348016..91c0d093653 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -32,6 +32,7 @@ use std::hash; use std::hash::Hash; use std::io::MemWriter; use std::str; +use std::vec_ng::Vec; use collections::HashMap; use syntax::abi::AbiSet; use syntax::ast::*; @@ -367,9 +368,9 @@ fn encode_enum_variant_info(ecx: &EncodeContext, encode_index(ebml_w, bkts, write_i64); } } - if vi[i].disr_val != disr_val { - encode_disr_val(ecx, ebml_w, vi[i].disr_val); - disr_val = vi[i].disr_val; + if vi.get(i).disr_val != disr_val { + encode_disr_val(ecx, ebml_w, vi.get(i).disr_val); + disr_val = vi.get(i).disr_val; } encode_bounds_and_type(ebml_w, ecx, &lookup_item_type(ecx.tcx, def_id)); @@ -1390,7 +1391,7 @@ fn create_index<T:Clone + Hash + 'static>( } for elt in index.iter() { let h = hash::hash(&elt.val) as uint; - let mut bucket = buckets[h % 256].borrow_mut(); + let mut bucket = buckets.get_mut(h % 256).borrow_mut(); bucket.get().push((*elt).clone()); } @@ -1770,7 +1771,7 @@ pub static metadata_encoding_version : &'static [u8] = pub fn encode_metadata(parms: EncodeParams, krate: &Crate) -> Vec<u8> { let mut wr = MemWriter::new(); encode_metadata_inner(&mut wr, parms, krate); - wr.unwrap() + wr.unwrap().move_iter().collect() } fn encode_metadata_inner(wr: &mut MemWriter, parms: EncodeParams, krate: &Crate) { @@ -1822,7 +1823,7 @@ fn encode_metadata_inner(wr: &mut MemWriter, parms: EncodeParams, krate: &Crate) let mut i = ebml_w.writer.tell().unwrap(); let crate_attrs = synthesize_crate_attrs(&ecx, krate); - encode_attributes(&mut ebml_w, crate_attrs); + encode_attributes(&mut ebml_w, crate_attrs.as_slice()); ecx.stats.attr_bytes.set(ebml_w.writer.tell().unwrap() - i); i = ebml_w.writer.tell().unwrap(); diff --git a/src/librustc/metadata/filesearch.rs b/src/librustc/metadata/filesearch.rs index c22caafab30..9f6b78354e2 100644 --- a/src/librustc/metadata/filesearch.rs +++ b/src/librustc/metadata/filesearch.rs @@ -14,6 +14,7 @@ use std::cell::RefCell; use std::option; use std::os; use std::io::fs; +use std::vec_ng::Vec; use collections::HashSet; pub enum FileMatch { FileMatches, FileDoesntMatch } diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs index e9b6d241b17..7628c90d95d 100644 --- a/src/librustc/metadata/loader.rs +++ b/src/librustc/metadata/loader.rs @@ -31,6 +31,7 @@ use std::io; use std::os::consts::{macos, freebsd, linux, android, win32}; use std::str; use std::vec; +use std::vec_ng::Vec; use collections::{HashMap, HashSet}; use flate; @@ -205,7 +206,7 @@ impl<'a> Context<'a> { // libraries or not. match libraries.len() { 0 => None, - 1 => Some(libraries[0]), + 1 => Some(libraries.move_iter().next().unwrap()), _ => { self.sess.span_err(self.span, format!("multiple matching crates for `{}`", diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index 0f7fcdc4791..17e334d05fb 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/src/librustc/metadata/tydecode.rs @@ -20,6 +20,7 @@ use middle::ty; use std::str; use std::uint; +use std::vec_ng::Vec; use syntax::abi::AbiSet; use syntax::abi; use syntax::ast; diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs index 1477a1fb951..be3180596e0 100644 --- a/src/librustc/metadata/tyencode.rs +++ b/src/librustc/metadata/tyencode.rs @@ -19,6 +19,7 @@ use std::io; use std::io::MemWriter; use std::str; use std::fmt; +use std::vec_ng::Vec; use middle::ty::param_ty; use middle::ty; diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index b3d26b2bb79..5959f5a9d02 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -654,7 +654,7 @@ pub fn encode_vtable_res(ecx: &e::EncodeContext, // ty::t doesn't work, and there is no way (atm) to have // hand-written encoding routines combine with auto-generated // ones. perhaps we should fix this. - ebml_w.emit_from_vec(*dr, |ebml_w, param_tables| { + ebml_w.emit_from_vec(dr.as_slice(), |ebml_w, param_tables| { encode_vtable_param_res(ecx, ebml_w, *param_tables); }) } @@ -662,7 +662,7 @@ pub fn encode_vtable_res(ecx: &e::EncodeContext, pub fn encode_vtable_param_res(ecx: &e::EncodeContext, ebml_w: &mut writer::Encoder, param_tables: typeck::vtable_param_res) { - ebml_w.emit_from_vec(*param_tables, |ebml_w, vtable_origin| { + ebml_w.emit_from_vec(param_tables.as_slice(), |ebml_w, vtable_origin| { encode_vtable_origin(ecx, ebml_w, vtable_origin) }) } @@ -679,7 +679,7 @@ pub fn encode_vtable_origin(ecx: &e::EncodeContext, ebml_w.emit_def_id(def_id) }); ebml_w.emit_enum_variant_arg(1u, |ebml_w| { - ebml_w.emit_tys(ecx, *tys); + ebml_w.emit_tys(ecx, tys.as_slice()); }); ebml_w.emit_enum_variant_arg(2u, |ebml_w| { encode_vtable_res(ecx, ebml_w, vtable_res); @@ -718,6 +718,8 @@ impl<'a> vtable_decoder_helpers for reader::Decoder<'a> { -> typeck::vtable_res { @self.read_to_vec(|this| this.read_vtable_param_res(tcx, cdata)) + .move_iter() + .collect() } fn read_vtable_param_res(&mut self, @@ -725,6 +727,8 @@ impl<'a> vtable_decoder_helpers for reader::Decoder<'a> { -> typeck::vtable_param_res { @self.read_to_vec(|this| this.read_vtable_origin(tcx, cdata)) + .move_iter() + .collect() } fn read_vtable_origin(&mut self, @@ -985,7 +989,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, ebml_w.tag(c::tag_table_node_type_subst, |ebml_w| { ebml_w.id(id); ebml_w.tag(c::tag_table_val, |ebml_w| { - ebml_w.emit_tys(ecx, **tys) + ebml_w.emit_tys(ecx, tys.as_slice()) }) }) } @@ -998,7 +1002,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, ebml_w.tag(c::tag_table_freevars, |ebml_w| { ebml_w.id(id); ebml_w.tag(c::tag_table_val, |ebml_w| { - ebml_w.emit_from_vec(**fv, |ebml_w, fv_entry| { + ebml_w.emit_from_vec(fv.as_slice(), |ebml_w, fv_entry| { encode_freevar_entry(ebml_w, *fv_entry) }) }) @@ -1077,7 +1081,8 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, ebml_w.tag(c::tag_table_capture_map, |ebml_w| { ebml_w.id(id); ebml_w.tag(c::tag_table_val, |ebml_w| { - ebml_w.emit_from_vec(*cap_vars.borrow(), |ebml_w, cap_var| { + ebml_w.emit_from_vec(cap_vars.borrow().as_slice(), + |ebml_w, cap_var| { cap_var.encode(ebml_w); }) }) @@ -1139,6 +1144,8 @@ impl<'a> ebml_decoder_decoder_helpers for reader::Decoder<'a> { tcx: ty::ctxt, cdata: @cstore::crate_metadata) -> Vec<ty::t> { self.read_to_vec(|this| this.read_ty_noxcx(tcx, cdata) ) + .move_iter() + .collect() } fn read_ty(&mut self, xcx: @ExtendedDecodeContext) -> ty::t { @@ -1170,7 +1177,7 @@ impl<'a> ebml_decoder_decoder_helpers for reader::Decoder<'a> { } fn read_tys(&mut self, xcx: @ExtendedDecodeContext) -> Vec<ty::t> { - self.read_to_vec(|this| this.read_ty(xcx) ) + self.read_to_vec(|this| this.read_ty(xcx)).move_iter().collect() } fn read_type_param_def(&mut self, xcx: @ExtendedDecodeContext) @@ -1197,7 +1204,9 @@ impl<'a> ebml_decoder_decoder_helpers for reader::Decoder<'a> { 0, |this| { Rc::new(this.read_to_vec(|this| - this.read_type_param_def(xcx))) + this.read_type_param_def(xcx)) + .move_iter() + .collect()) }), region_param_defs: this.read_struct_field("region_param_defs", @@ -1357,7 +1366,7 @@ fn decode_side_tables(xcx: @ExtendedDecodeContext, c::tag_table_freevars => { let fv_info = @val_dsr.read_to_vec(|val_dsr| { @val_dsr.read_freevar_entry(xcx) - }); + }).move_iter().collect(); let mut freevars = dcx.tcx.freevars.borrow_mut(); freevars.get().insert(id, fv_info); } @@ -1394,7 +1403,9 @@ fn decode_side_tables(xcx: @ExtendedDecodeContext, } c::tag_table_capture_map => { let cvars = - val_dsr.read_to_vec(|val_dsr| val_dsr.read_capture_var(xcx)); + val_dsr.read_to_vec(|val_dsr| val_dsr.read_capture_var(xcx)) + .move_iter() + .collect(); let mut capture_map = dcx.maps .capture_map .borrow_mut(); diff --git a/src/librustc/middle/borrowck/check_loans.rs b/src/librustc/middle/borrowck/check_loans.rs index a44d4f55cd0..53a363b44f8 100644 --- a/src/librustc/middle/borrowck/check_loans.rs +++ b/src/librustc/middle/borrowck/check_loans.rs @@ -22,6 +22,7 @@ use mc = middle::mem_categorization; use middle::borrowck::*; use middle::moves; use middle::ty; +use std::vec_ng::Vec; use syntax::ast; use syntax::ast_util; use syntax::codemap::Span; diff --git a/src/librustc/middle/borrowck/gather_loans/mod.rs b/src/librustc/middle/borrowck/gather_loans/mod.rs index 0583268b9e5..d6666eb6293 100644 --- a/src/librustc/middle/borrowck/gather_loans/mod.rs +++ b/src/librustc/middle/borrowck/gather_loans/mod.rs @@ -27,6 +27,7 @@ use util::common::indenter; use util::ppaux::{Repr}; use std::cell::RefCell; +use std::vec_ng::Vec; use syntax::ast; use syntax::ast_util; use syntax::ast_util::IdRange; diff --git a/src/librustc/middle/borrowck/gather_loans/restrictions.rs b/src/librustc/middle/borrowck/gather_loans/restrictions.rs index a21de25a76a..aa296bf0a62 100644 --- a/src/librustc/middle/borrowck/gather_loans/restrictions.rs +++ b/src/librustc/middle/borrowck/gather_loans/restrictions.rs @@ -12,7 +12,8 @@ * Computes the restrictions that result from a borrow. */ -use std::vec; +use std::vec_ng::Vec; +use std::vec_ng; use middle::borrowck::*; use mc = middle::mem_categorization; use middle::ty; @@ -173,9 +174,11 @@ impl<'a> RestrictionsContext<'a> { Safe => Safe, SafeIf(base_lp, base_vec) => { let lp = @LpExtend(base_lp, mc, elem); - SafeIf(lp, vec::append_one(base_vec, - Restriction {loan_path: lp, - set: restrictions})) + SafeIf(lp, vec_ng::append_one(base_vec, + Restriction { + loan_path: lp, + set: restrictions + })) } } } diff --git a/src/librustc/middle/borrowck/mod.rs b/src/librustc/middle/borrowck/mod.rs index 77c3af89894..9767b50ae96 100644 --- a/src/librustc/middle/borrowck/mod.rs +++ b/src/librustc/middle/borrowck/mod.rs @@ -24,6 +24,7 @@ use std::cell::{Cell, RefCell}; use collections::HashMap; use std::ops::{BitOr, BitAnd}; use std::result::{Result}; +use std::vec_ng::Vec; use syntax::ast; use syntax::ast_map; use syntax::ast_util; @@ -146,7 +147,7 @@ fn borrowck_fn(this: &mut BorrowckCtxt, body); check_loans::check_loans(this, &loan_dfcx, flowed_moves, - *all_loans.get(), body); + all_loans.get().as_slice(), body); visit::walk_fn(this, fk, decl, body, sp, id, ()); } diff --git a/src/librustc/middle/borrowck/move_data.rs b/src/librustc/middle/borrowck/move_data.rs index 2cc312cccdc..e1434a8ac4e 100644 --- a/src/librustc/middle/borrowck/move_data.rs +++ b/src/librustc/middle/borrowck/move_data.rs @@ -17,6 +17,7 @@ comments in the section "Moves and initialization" and in `doc.rs`. use std::cell::RefCell; use std::uint; +use std::vec_ng::Vec; use collections::{HashMap, HashSet}; use middle::borrowck::*; use middle::dataflow::DataFlowContext; @@ -184,47 +185,47 @@ impl MoveData { fn path_loan_path(&self, index: MovePathIndex) -> @LoanPath { let paths = self.paths.borrow(); - paths.get()[index.get()].loan_path + paths.get().get(index.get()).loan_path } fn path_parent(&self, index: MovePathIndex) -> MovePathIndex { let paths = self.paths.borrow(); - paths.get()[index.get()].parent + paths.get().get(index.get()).parent } fn path_first_move(&self, index: MovePathIndex) -> MoveIndex { let paths = self.paths.borrow(); - paths.get()[index.get()].first_move + paths.get().get(index.get()).first_move } fn path_first_child(&self, index: MovePathIndex) -> MovePathIndex { let paths = self.paths.borrow(); - paths.get()[index.get()].first_child + paths.get().get(index.get()).first_child } fn path_next_sibling(&self, index: MovePathIndex) -> MovePathIndex { let paths = self.paths.borrow(); - paths.get()[index.get()].next_sibling + paths.get().get(index.get()).next_sibling } fn set_path_first_move(&self, index: MovePathIndex, first_move: MoveIndex) { let mut paths = self.paths.borrow_mut(); - paths.get()[index.get()].first_move = first_move + paths.get().get_mut(index.get()).first_move = first_move } fn set_path_first_child(&self, index: MovePathIndex, first_child: MovePathIndex) { let mut paths = self.paths.borrow_mut(); - paths.get()[index.get()].first_child = first_child + paths.get().get_mut(index.get()).first_child = first_child } fn move_next_move(&self, index: MoveIndex) -> MoveIndex { //! Type safe indexing operator let moves = self.moves.borrow(); - moves.get()[index.get()].next_move + moves.get().get(index.get()).next_move } fn is_var_path(&self, index: MovePathIndex) -> bool { @@ -605,7 +606,7 @@ impl FlowedMoveData { self.dfcx_moves.each_gen_bit_frozen(id, |index| { let moves = self.move_data.moves.borrow(); - let move = &moves.get()[index]; + let move = moves.get().get(index); let moved_path = move.path; f(move, self.move_data.path_loan_path(moved_path)) }) @@ -644,7 +645,7 @@ impl FlowedMoveData { self.dfcx_moves.each_bit_on_entry_frozen(id, |index| { let moves = self.move_data.moves.borrow(); - let move = &moves.get()[index]; + let move = moves.get().get(index); let moved_path = move.path; if base_indices.iter().any(|x| x == &moved_path) { // Scenario 1 or 2: `loan_path` or some base path of @@ -702,7 +703,7 @@ impl FlowedMoveData { self.dfcx_assign.each_bit_on_entry_frozen(id, |index| { let var_assignments = self.move_data.var_assignments.borrow(); - let assignment = &var_assignments.get()[index]; + let assignment = var_assignments.get().get(index); if assignment.path == loan_path_index && !f(assignment) { false } else { diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs index 5e22f35a47f..ec1ddd99cc6 100644 --- a/src/librustc/middle/cfg/construct.rs +++ b/src/librustc/middle/cfg/construct.rs @@ -12,6 +12,7 @@ use middle::cfg::*; use middle::graph; use middle::typeck; use middle::ty; +use std::vec_ng::Vec; use syntax::ast; use syntax::ast_util; use syntax::opt_vec; @@ -328,7 +329,7 @@ impl CFGBuilder { ast::ExprRet(v) => { let v_exit = self.opt_expr(v, pred); - let loop_scope = self.loop_scopes[0]; + let loop_scope = *self.loop_scopes.get(0); self.add_exiting_edge(expr, v_exit, loop_scope, loop_scope.break_index); self.add_node(expr.id, []) @@ -377,7 +378,7 @@ impl CFGBuilder { let base_exit = self.opt_expr(base, pred); let field_exprs: Vec<@ast::Expr> = fields.iter().map(|f| f.expr).collect(); - self.straightline(expr, base_exit, field_exprs) + self.straightline(expr, base_exit, field_exprs.as_slice()) } ast::ExprRepeat(elem, count, _) => { diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs index 218a4b0a71b..680caf101bf 100644 --- a/src/librustc/middle/check_const.rs +++ b/src/librustc/middle/check_const.rs @@ -15,6 +15,7 @@ use middle::ty; use middle::typeck; use util::ppaux; +use std::vec_ng::Vec; use syntax::ast::*; use syntax::{ast_util, ast_map}; use syntax::visit::Visitor; diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index 5bc4cd878e1..fddad9214e8 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -21,7 +21,8 @@ use util::ppaux::ty_to_str; use std::cmp; use std::iter; -use std::vec; +use std::vec_ng::Vec; +use std::vec_ng; use syntax::ast::*; use syntax::ast_util::{unguarded_pat, walk_pat}; use syntax::codemap::{DUMMY_SP, Span}; @@ -152,7 +153,7 @@ fn check_arms(cx: &MatchCheckCtxt, arms: &[Arm]) { }); let v = vec!(*pat); - match is_useful(cx, &seen, v) { + match is_useful(cx, &seen, v.as_slice()) { not_useful => { cx.tcx.sess.span_err(pat.span, "unreachable pattern"); } @@ -250,10 +251,14 @@ enum ctor { // Note: is_useful doesn't work on empty types, as the paper notes. // So it assumes that v is non-empty. fn is_useful(cx: &MatchCheckCtxt, m: &matrix, v: &[@Pat]) -> useful { - if m.len() == 0u { return useful_; } - if m[0].len() == 0u { return not_useful; } - let real_pat = match m.iter().find(|r| r[0].id != 0) { - Some(r) => r[0], None => v[0] + if m.len() == 0u { + return useful_; + } + if m.get(0).len() == 0u { + return not_useful + } + let real_pat = match m.iter().find(|r| r.get(0).id != 0) { + Some(r) => *r.get(0), None => v[0] }; let left_ty = if real_pat.id == 0 { ty::mk_nil() } else { ty::node_id_to_type(cx.tcx, real_pat.id) }; @@ -290,7 +295,7 @@ fn is_useful(cx: &MatchCheckCtxt, m: &matrix, v: &[@Pat]) -> useful { } ty::ty_unboxed_vec(..) | ty::ty_vec(..) => { let max_len = m.rev_iter().fold(0, |max_len, r| { - match r[0].node { + match r.get(0).node { PatVec(ref before, _, ref after) => { cmp::max(before.len() + after.len(), max_len) } @@ -313,7 +318,9 @@ fn is_useful(cx: &MatchCheckCtxt, m: &matrix, v: &[@Pat]) -> useful { } Some(ref ctor) => { match is_useful(cx, - &m.iter().filter_map(|r| default(cx, *r)).collect::<matrix>(), + &m.iter().filter_map(|r| { + default(cx, r.as_slice()) + }).collect::<matrix>(), v.tail()) { useful_ => useful(left_ty, (*ctor).clone()), ref u => (*u).clone(), @@ -334,10 +341,12 @@ fn is_useful_specialized(cx: &MatchCheckCtxt, ctor: ctor, arity: uint, lty: ty::t) - -> useful { - let ms = m.iter().filter_map(|r| specialize(cx, *r, &ctor, arity, lty)).collect::<matrix>(); + -> useful { + let ms = m.iter().filter_map(|r| { + specialize(cx, r.as_slice(), &ctor, arity, lty) + }).collect::<matrix>(); let could_be_useful = is_useful( - cx, &ms, specialize(cx, v, &ctor, arity, lty).unwrap()); + cx, &ms, specialize(cx, v, &ctor, arity, lty).unwrap().as_slice()); match could_be_useful { useful_ => useful(lty, ctor), ref u => (*u).clone(), @@ -408,14 +417,14 @@ fn missing_ctor(cx: &MatchCheckCtxt, ty::ty_box(_) | ty::ty_uniq(_) | ty::ty_rptr(..) | ty::ty_tup(_) | ty::ty_struct(..) => { for r in m.iter() { - if !is_wild(cx, r[0]) { return None; } + if !is_wild(cx, *r.get(0)) { return None; } } return Some(single); } ty::ty_enum(eid, _) => { let mut found = Vec::new(); for r in m.iter() { - let r = pat_ctor_id(cx, r[0]); + let r = pat_ctor_id(cx, *r.get(0)); for id in r.iter() { if !found.contains(id) { found.push((*id).clone()); @@ -437,7 +446,7 @@ fn missing_ctor(cx: &MatchCheckCtxt, let mut true_found = false; let mut false_found = false; for r in m.iter() { - match pat_ctor_id(cx, r[0]) { + match pat_ctor_id(cx, *r.get(0)) { None => (), Some(val(const_bool(true))) => true_found = true, Some(val(const_bool(false))) => false_found = true, @@ -452,7 +461,7 @@ fn missing_ctor(cx: &MatchCheckCtxt, let mut missing = true; let mut wrong = false; for r in m.iter() { - match r[0].node { + match r.get(0).node { PatVec(ref before, ref slice, ref after) => { let count = before.len() + after.len(); if (count < n && slice.is_none()) || count > n { @@ -475,7 +484,7 @@ fn missing_ctor(cx: &MatchCheckCtxt, // Find the lengths and slices of all vector patterns. let mut vec_pat_lens = m.iter().filter_map(|r| { - match r[0].node { + match r.get(0).node { PatVec(ref before, ref slice, ref after) => { Some((before.len() + after.len(), slice.is_some())) } @@ -566,10 +575,11 @@ fn specialize(cx: &MatchCheckCtxt, Pat{id: pat_id, node: n, span: pat_span} => match n { PatWild => { - Some(vec_ng::append(vec::from_elem(arity, wild()), r.tail())) + Some(vec_ng::append(Vec::from_elem(arity, wild()), r.tail())) } PatWildMulti => { - Some(vec_ng::append(vec::from_elem(arity, wild_multi()), r.tail())) + Some(vec_ng::append(Vec::from_elem(arity, wild_multi()), + r.tail())) } PatIdent(_, _, _) => { let opt_def = { @@ -579,7 +589,7 @@ fn specialize(cx: &MatchCheckCtxt, match opt_def { Some(DefVariant(_, id, _)) => { if variant(id) == *ctor_id { - Some(r.tail().to_owned()) + Some(Vec::from_slice(r.tail())) } else { None } @@ -617,7 +627,7 @@ fn specialize(cx: &MatchCheckCtxt, _ => fail!("type error") }; if match_ { - Some(r.tail().to_owned()) + Some(Vec::from_slice(r.tail())) } else { None } @@ -625,7 +635,7 @@ fn specialize(cx: &MatchCheckCtxt, _ => { Some( vec_ng::append( - vec::from_elem(arity, wild()), + Vec::from_elem(arity, wild()), r.tail() ) ) @@ -668,7 +678,7 @@ fn specialize(cx: &MatchCheckCtxt, _ => fail!("type error") }; if match_ { - Some(r.tail().to_owned()) + Some(Vec::from_slice(r.tail())) } else { None } @@ -676,7 +686,7 @@ fn specialize(cx: &MatchCheckCtxt, DefVariant(_, id, _) if variant(id) == *ctor_id => { let args = match args { Some(args) => args.iter().map(|x| *x).collect(), - None => vec::from_elem(arity, wild()) + None => Vec::from_elem(arity, wild()) }; Some(vec_ng::append(args, r.tail())) } @@ -689,7 +699,7 @@ fn specialize(cx: &MatchCheckCtxt, Some(args) => { new_args = args.iter().map(|x| *x).collect() } - None => new_args = vec::from_elem(arity, wild()) + None => new_args = Vec::from_elem(arity, wild()) } Some(vec_ng::append(new_args, r.tail())) } @@ -781,13 +791,17 @@ fn specialize(cx: &MatchCheckCtxt, single => true, _ => fail!("type error") }; - if match_ { Some(r.tail().to_owned()) } else { None } + if match_ { + Some(Vec::from_slice(r.tail())) + } else { + None + } } PatRange(lo, hi) => { let (c_lo, c_hi) = match *ctor_id { val(ref v) => ((*v).clone(), (*v).clone()), range(ref lo, ref hi) => ((*lo).clone(), (*hi).clone()), - single => return Some(r.tail().to_owned()), + single => return Some(Vec::from_slice(r.tail())), _ => fail!("type error") }; let v_lo = eval_const_expr(cx.tcx, lo); @@ -797,7 +811,7 @@ fn specialize(cx: &MatchCheckCtxt, let m2 = compare_const_vals(&c_hi, &v_hi); match (m1, m2) { (Some(val1), Some(val2)) if val1 >= 0 && val2 <= 0 => { - Some(r.tail().to_owned()) + Some(Vec::from_slice(r.tail())) }, (Some(_), Some(_)) => None, _ => { @@ -850,8 +864,11 @@ fn specialize(cx: &MatchCheckCtxt, } fn default(cx: &MatchCheckCtxt, r: &[@Pat]) -> Option<Vec<@Pat> > { - if is_wild(cx, r[0]) { Some(r.tail().to_owned()) } - else { None } + if is_wild(cx, r[0]) { + Some(Vec::from_slice(r.tail())) + } else { + None + } } fn check_local(v: &mut CheckMatchVisitor, diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 9898be5532b..aaa623bd7b2 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -27,6 +27,7 @@ use syntax::{ast, ast_map, ast_util}; use std::cell::RefCell; use collections::HashMap; use std::rc::Rc; +use std::vec_ng::Vec; // // This pass classifies expressions by their constant-ness. diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs index e0a9d0080f6..ba3fc34023d 100644 --- a/src/librustc/middle/dataflow.rs +++ b/src/librustc/middle/dataflow.rs @@ -20,6 +20,7 @@ use std::io; use std::uint; use std::vec; +use std::vec_ng::Vec; use syntax::ast; use syntax::ast_util; use syntax::ast_util::IdRange; @@ -79,7 +80,8 @@ struct PropagationContext<'a, O> { struct LoopScope<'a> { loop_id: ast::NodeId, - break_bits: Vec<uint> } + break_bits: Vec<uint> +} impl<O:DataFlowOperator> pprust::PpAnn for DataFlowContext<O> { fn pre(&self, node: pprust::AnnNode) -> io::IoResult<()> { @@ -467,12 +469,12 @@ impl<'a, O:DataFlowOperator> PropagationContext<'a, O> { let mut body_bits = in_out.to_owned(); loop_scopes.push(LoopScope { loop_id: expr.id, - break_bits: in_out.to_owned() + break_bits: Vec::from_slice(in_out) }); self.walk_block(blk, body_bits, loop_scopes); self.add_to_entry_set(expr.id, body_bits); let new_loop_scope = loop_scopes.pop().unwrap(); - copy_bits(new_loop_scope.break_bits, in_out); + copy_bits(new_loop_scope.break_bits.as_slice(), in_out); } ast::ExprForLoop(..) => fail!("non-desugared expr_for_loop"), @@ -491,14 +493,14 @@ impl<'a, O:DataFlowOperator> PropagationContext<'a, O> { self.reset(in_out); loop_scopes.push(LoopScope { loop_id: expr.id, - break_bits: in_out.to_owned() + break_bits: Vec::from_slice(in_out) }); self.walk_block(blk, body_bits, loop_scopes); self.add_to_entry_set(expr.id, body_bits); let new_loop_scope = loop_scopes.pop().unwrap(); assert_eq!(new_loop_scope.loop_id, expr.id); - copy_bits(new_loop_scope.break_bits, in_out); + copy_bits(new_loop_scope.break_bits.as_slice(), in_out); } ast::ExprMatch(discr, ref arms) => { @@ -689,7 +691,9 @@ impl<'a, O:DataFlowOperator> PropagationContext<'a, O> { in_out: &mut [uint]) { self.pop_scopes(from_expr, to_scope, in_out); self.dfcx.apply_kill(from_expr.id, in_out); - join_bits(&self.dfcx.oper, in_out, to_scope.break_bits); + join_bits(&self.dfcx.oper, + in_out, + to_scope.break_bits.as_mut_slice()); debug!("break_from_to(from_expr={}, to_scope={}) final break_bits={}", from_expr.repr(self.tcx()), to_scope.loop_id, @@ -767,10 +771,12 @@ impl<'a, O:DataFlowOperator> PropagationContext<'a, O> { } } - fn find_scope<'a>(&self, - expr: &ast::Expr, - label: Option<ast::Ident>, - loop_scopes: &'a mut Vec<LoopScope> ) -> &'a mut LoopScope { + fn find_scope<'a,'b>( + &self, + expr: &ast::Expr, + label: Option<ast::Ident>, + loop_scopes: &'a mut Vec<LoopScope<'b>>) + -> &'a mut LoopScope<'b> { let index = match label { None => { let len = loop_scopes.len(); @@ -800,7 +806,7 @@ impl<'a, O:DataFlowOperator> PropagationContext<'a, O> { } }; - &mut loop_scopes[index] + loop_scopes.get_mut(index) } fn is_method_call(&self, expr: &ast::Expr) -> bool { diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs index 4b4820be3a7..d226f2561b7 100644 --- a/src/librustc/middle/dead.rs +++ b/src/librustc/middle/dead.rs @@ -19,6 +19,7 @@ use middle::typeck; use util::nodemap::NodeSet; use collections::HashSet; +use std::vec_ng::Vec; use syntax::ast; use syntax::ast_map; use syntax::ast_util::{local_def, def_id_of_def, is_local}; diff --git a/src/librustc/middle/entry.rs b/src/librustc/middle/entry.rs index a2716893430..a4ff72d55f2 100644 --- a/src/librustc/middle/entry.rs +++ b/src/librustc/middle/entry.rs @@ -11,6 +11,7 @@ use driver::session; use driver::session::Session; +use std::vec_ng::Vec; use syntax::ast::{Crate, Name, NodeId, Item, ItemFn}; use syntax::ast_map; use syntax::attr; diff --git a/src/librustc/middle/freevars.rs b/src/librustc/middle/freevars.rs index acafe550a70..8b8807e46f5 100644 --- a/src/librustc/middle/freevars.rs +++ b/src/librustc/middle/freevars.rs @@ -17,6 +17,7 @@ use middle::resolve; use middle::ty; use util::nodemap::{NodeMap, NodeSet}; +use std::vec_ng::Vec; use syntax::codemap::Span; use syntax::{ast, ast_util}; use syntax::visit; diff --git a/src/librustc/middle/graph.rs b/src/librustc/middle/graph.rs index f2973a7b09c..160a541bc34 100644 --- a/src/librustc/middle/graph.rs +++ b/src/librustc/middle/graph.rs @@ -35,7 +35,7 @@ be indexed by the direction (see the type `Direction`). */ use std::uint; -use std::vec; +use std::vec_ng::Vec; pub struct Graph<N,E> { priv nodes: Vec<Node<N>> , @@ -77,13 +77,18 @@ impl EdgeIndex { impl<N,E> Graph<N,E> { pub fn new() -> Graph<N,E> { - Graph {nodes: Vec::new(), edges: Vec::new()} + Graph { + nodes: Vec::new(), + edges: Vec::new(), + } } pub fn with_capacity(num_nodes: uint, num_edges: uint) -> Graph<N,E> { - Graph {nodes: vec::with_capacity(num_nodes), - edges: vec::with_capacity(num_edges)} + Graph { + nodes: Vec::with_capacity(num_nodes), + edges: Vec::with_capacity(num_edges), + } } /////////////////////////////////////////////////////////////////////////// @@ -91,13 +96,13 @@ impl<N,E> Graph<N,E> { #[inline] pub fn all_nodes<'a>(&'a self) -> &'a [Node<N>] { - let nodes: &'a [Node<N>] = self.nodes; + let nodes: &'a [Node<N>] = self.nodes.as_slice(); nodes } #[inline] pub fn all_edges<'a>(&'a self) -> &'a [Edge<E>] { - let edges: &'a [Edge<E>] = self.edges; + let edges: &'a [Edge<E>] = self.edges.as_slice(); edges } @@ -118,15 +123,15 @@ impl<N,E> Graph<N,E> { } pub fn mut_node_data<'a>(&'a mut self, idx: NodeIndex) -> &'a mut N { - &mut self.nodes[idx.get()].data + &mut self.nodes.get_mut(idx.get()).data } pub fn node_data<'a>(&'a self, idx: NodeIndex) -> &'a N { - &self.nodes[idx.get()].data + &self.nodes.get(idx.get()).data } pub fn node<'a>(&'a self, idx: NodeIndex) -> &'a Node<N> { - &self.nodes[idx.get()] + self.nodes.get(idx.get()) } /////////////////////////////////////////////////////////////////////////// @@ -143,8 +148,10 @@ impl<N,E> Graph<N,E> { let idx = self.next_edge_index(); // read current first of the list of edges from each node - let source_first = self.nodes[source.get()].first_edge[Outgoing.repr]; - let target_first = self.nodes[target.get()].first_edge[Incoming.repr]; + let source_first = self.nodes.get(source.get()) + .first_edge[Outgoing.repr]; + let target_first = self.nodes.get(target.get()) + .first_edge[Incoming.repr]; // create the new edge, with the previous firsts from each node // as the next pointers @@ -156,22 +163,22 @@ impl<N,E> Graph<N,E> { }); // adjust the firsts for each node target be the next object. - self.nodes[source.get()].first_edge[Outgoing.repr] = idx; - self.nodes[target.get()].first_edge[Incoming.repr] = idx; + self.nodes.get_mut(source.get()).first_edge[Outgoing.repr] = idx; + self.nodes.get_mut(target.get()).first_edge[Incoming.repr] = idx; return idx; } pub fn mut_edge_data<'a>(&'a mut self, idx: EdgeIndex) -> &'a mut E { - &mut self.edges[idx.get()].data + &mut self.edges.get_mut(idx.get()).data } pub fn edge_data<'a>(&'a self, idx: EdgeIndex) -> &'a E { - &self.edges[idx.get()].data + &self.edges.get(idx.get()).data } pub fn edge<'a>(&'a self, idx: EdgeIndex) -> &'a Edge<E> { - &self.edges[idx.get()] + self.edges.get(idx.get()) } pub fn first_adjacent(&self, node: NodeIndex, dir: Direction) -> EdgeIndex { @@ -179,7 +186,7 @@ impl<N,E> Graph<N,E> { //! This is useful if you wish to modify the graph while walking //! the linked list of edges. - self.nodes[node.get()].first_edge[dir.repr] + self.nodes.get(node.get()).first_edge[dir.repr] } pub fn next_adjacent(&self, edge: EdgeIndex, dir: Direction) -> EdgeIndex { @@ -187,7 +194,7 @@ impl<N,E> Graph<N,E> { //! This is useful if you wish to modify the graph while walking //! the linked list of edges. - self.edges[edge.get()].next_edge[dir.repr] + self.edges.get(edge.get()).next_edge[dir.repr] } /////////////////////////////////////////////////////////////////////////// @@ -231,7 +238,7 @@ impl<N,E> Graph<N,E> { let mut edge_idx = self.first_adjacent(node, dir); while edge_idx != InvalidEdgeIndex { - let edge = &self.edges[edge_idx.get()]; + let edge = self.edges.get(edge_idx.get()); if !f(edge_idx, edge) { return false; } diff --git a/src/librustc/middle/kind.rs b/src/librustc/middle/kind.rs index 392a95ee563..90c86cb5e74 100644 --- a/src/librustc/middle/kind.rs +++ b/src/librustc/middle/kind.rs @@ -16,6 +16,7 @@ use middle::typeck; use util::ppaux::{Repr, ty_to_str}; use util::ppaux::UserString; +use std::vec_ng::Vec; use syntax::ast::*; use syntax::attr; use syntax::codemap::Span; diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs index 2dde7003798..ccf81840a41 100644 --- a/src/librustc/middle/lang_items.rs +++ b/src/librustc/middle/lang_items.rs @@ -33,6 +33,7 @@ use syntax::visit; use collections::HashMap; use std::iter::Enumerate; use std::vec; +use std::vec_ng::Vec; // The actual lang items defined come at the end of this file in one handy table. // So you probably just want to nip down to the end. @@ -72,10 +73,12 @@ impl LanguageItems { } pub fn require(&self, it: LangItem) -> Result<ast::DefId, ~str> { - match self.items[it as uint] { - Some(id) => Ok(id), - None => Err(format!("requires `{}` lang_item", - LanguageItems::item_name(it as uint))) + match self.items.get(it as uint) { + &Some(id) => Ok(id), + &None => { + Err(format!("requires `{}` lang_item", + LanguageItems::item_name(it as uint))) + } } } @@ -95,7 +98,7 @@ impl LanguageItems { $( pub fn $method(&self) -> Option<ast::DefId> { - self.items[$variant as uint] + *self.items.get($variant as uint) } )* } @@ -147,18 +150,18 @@ impl LanguageItemCollector { pub fn collect_item(&mut self, item_index: uint, item_def_id: ast::DefId) { // Check for duplicates. - match self.items.items[item_index] { - Some(original_def_id) if original_def_id != item_def_id => { + match self.items.items.get(item_index) { + &Some(original_def_id) if original_def_id != item_def_id => { self.session.err(format!("duplicate entry for `{}`", LanguageItems::item_name(item_index))); } - Some(_) | None => { + &Some(_) | &None => { // OK. } } // Matched. - self.items.items[item_index] = Some(item_def_id); + *self.items.items.get_mut(item_index) = Some(item_def_id); } pub fn collect_local_language_items(&mut self, krate: &ast::Crate) { diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs index 6b7f25ea21e..ddf75d1f0b6 100644 --- a/src/librustc/middle/lint.rs +++ b/src/librustc/middle/lint.rs @@ -45,7 +45,6 @@ use middle::ty; use middle::typeck::astconv::{ast_ty_to_ty, AstConv}; use middle::typeck::infer; use middle::typeck; -use std::to_str::ToStr; use util::ppaux::{ty_to_str}; use std::cmp; @@ -54,10 +53,12 @@ use std::i16; use std::i32; use std::i64; use std::i8; +use std::to_str::ToStr; use std::u16; use std::u32; use std::u64; use std::u8; +use std::vec_ng::Vec; use collections::SmallIntMap; use syntax::ast_map; use syntax::ast_util::IdVisitingOperation; @@ -1091,7 +1092,7 @@ fn check_unused_result(cx: &Context, s: &ast::Stmt) { } } else { csearch::get_item_attrs(cx.tcx.sess.cstore, did, |attrs| { - if attr::contains_name(attrs, "must_use") { + if attr::contains_name(attrs.as_slice(), "must_use") { cx.span_lint(UnusedMustUse, s.span, "unused result which must be used"); warned = true; diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index df16a7fe2c7..04f2b2f2823 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -116,7 +116,7 @@ use std::fmt; use std::io; use std::str; use std::uint; -use std::vec; +use std::vec_ng::Vec; use syntax::ast::*; use syntax::codemap::Span; use syntax::parse::token::special_idents; @@ -260,7 +260,7 @@ pub struct IrMaps { num_vars: Cell<uint>, live_node_map: RefCell<NodeMap<LiveNode>>, variable_map: RefCell<NodeMap<Variable>>, - capture_info_map: RefCell<NodeMap<@~[CaptureInfo]>>, + capture_info_map: RefCell<NodeMap<@Vec<CaptureInfo> >>, var_kinds: RefCell<Vec<VarKind> >, lnks: RefCell<Vec<LiveNodeKind> >, } @@ -339,11 +339,11 @@ impl IrMaps { pub fn variable_name(&self, var: Variable) -> ~str { let var_kinds = self.var_kinds.borrow(); - match var_kinds.get()[var.get()] { - Local(LocalInfo { ident: nm, .. }) | Arg(_, nm) => { + match var_kinds.get().get(var.get()) { + &Local(LocalInfo { ident: nm, .. }) | &Arg(_, nm) => { token::get_ident(nm).get().to_str() }, - ImplicitRet => ~"<implicit-ret>" + &ImplicitRet => ~"<implicit-ret>" } } @@ -364,7 +364,7 @@ impl IrMaps { pub fn lnk(&self, ln: LiveNode) -> LiveNodeKind { let lnks = self.lnks.borrow(); - lnks.get()[ln.get()] + *lnks.get().get(ln.get()) } } @@ -607,9 +607,9 @@ fn Liveness(ir: @IrMaps, specials: Specials) -> Liveness { ir: ir, tcx: ir.tcx, s: specials, - successors: @RefCell::new(vec::from_elem(ir.num_live_nodes.get(), + successors: @RefCell::new(Vec::from_elem(ir.num_live_nodes.get(), invalid_node())), - users: @RefCell::new(vec::from_elem(ir.num_live_nodes.get() * + users: @RefCell::new(Vec::from_elem(ir.num_live_nodes.get() * ir.num_vars.get(), invalid_users())), loop_scope: @RefCell::new(Vec::new()), @@ -686,7 +686,7 @@ impl Liveness { -> Option<LiveNodeKind> { assert!(ln.is_valid()); let users = self.users.borrow(); - let reader = users.get()[self.idx(ln, var)].reader; + let reader = users.get().get(self.idx(ln, var)).reader; if reader.is_valid() {Some(self.ir.lnk(reader))} else {None} } @@ -697,7 +697,7 @@ impl Liveness { -> Option<LiveNodeKind> { let successor = { let successors = self.successors.borrow(); - successors.get()[ln.get()] + *successors.get().get(ln.get()) }; self.live_on_entry(successor, var) } @@ -705,14 +705,14 @@ impl Liveness { pub fn used_on_entry(&self, ln: LiveNode, var: Variable) -> bool { assert!(ln.is_valid()); let users = self.users.borrow(); - users.get()[self.idx(ln, var)].used + users.get().get(self.idx(ln, var)).used } pub fn assigned_on_entry(&self, ln: LiveNode, var: Variable) -> Option<LiveNodeKind> { assert!(ln.is_valid()); let users = self.users.borrow(); - let writer = users.get()[self.idx(ln, var)].writer; + let writer = users.get().get(self.idx(ln, var)).writer; if writer.is_valid() {Some(self.ir.lnk(writer))} else {None} } @@ -720,7 +720,7 @@ impl Liveness { -> Option<LiveNodeKind> { let successor = { let successors = self.successors.borrow(); - successors.get()[ln.get()] + *successors.get().get(ln.get()) }; self.assigned_on_entry(successor, var) } @@ -795,14 +795,14 @@ impl Liveness { write!(wr, "[ln({}) of kind {:?} reads", ln.get(), - lnks.and_then(|lnks| Some(lnks.get()[ln.get()]))); + lnks.and_then(|lnks| Some(*lnks.get().get(ln.get())))); } let users = self.users.try_borrow(); match users { Some(users) => { - self.write_vars(wr, ln, |idx| users.get()[idx].reader); + self.write_vars(wr, ln, |idx| users.get().get(idx).reader); write!(wr, " writes"); - self.write_vars(wr, ln, |idx| users.get()[idx].writer); + self.write_vars(wr, ln, |idx| users.get().get(idx).writer); } None => { write!(wr, " (users borrowed)"); @@ -811,7 +811,9 @@ impl Liveness { let successors = self.successors.try_borrow(); match successors { Some(successors) => { - write!(wr, " precedes {}]", successors.get()[ln.get()].to_str()); + write!(wr, + " precedes {}]", + successors.get().get(ln.get()).to_str()); } None => { write!(wr, " precedes (successors borrowed)]"); @@ -824,7 +826,7 @@ impl Liveness { pub fn init_empty(&self, ln: LiveNode, succ_ln: LiveNode) { { let mut successors = self.successors.borrow_mut(); - successors.get()[ln.get()] = succ_ln; + *successors.get().get_mut(ln.get()) = succ_ln; } // It is not necessary to initialize the @@ -841,12 +843,12 @@ impl Liveness { // more efficient version of init_empty() / merge_from_succ() { let mut successors = self.successors.borrow_mut(); - successors.get()[ln.get()] = succ_ln; + *successors.get().get_mut(ln.get()) = succ_ln; } self.indices2(ln, succ_ln, |idx, succ_idx| { let mut users = self.users.borrow_mut(); - users.get()[idx] = users.get()[succ_idx] + *users.get().get_mut(idx) = *users.get().get(succ_idx) }); debug!("init_from_succ(ln={}, succ={})", self.ln_str(ln), self.ln_str(succ_ln)); @@ -862,12 +864,12 @@ impl Liveness { let mut changed = false; self.indices2(ln, succ_ln, |idx, succ_idx| { let mut users = self.users.borrow_mut(); - changed |= copy_if_invalid(users.get()[succ_idx].reader, - &mut users.get()[idx].reader); - changed |= copy_if_invalid(users.get()[succ_idx].writer, - &mut users.get()[idx].writer); - if users.get()[succ_idx].used && !users.get()[idx].used { - users.get()[idx].used = true; + changed |= copy_if_invalid(users.get().get(succ_idx).reader, + &mut users.get().get_mut(idx).reader); + changed |= copy_if_invalid(users.get().get(succ_idx).writer, + &mut users.get().get_mut(idx).writer); + if users.get().get(succ_idx).used && !users.get().get(idx).used { + users.get().get_mut(idx).used = true; changed = true; } }); @@ -893,8 +895,8 @@ impl Liveness { pub fn define(&self, writer: LiveNode, var: Variable) { let idx = self.idx(writer, var); let mut users = self.users.borrow_mut(); - users.get()[idx].reader = invalid_node(); - users.get()[idx].writer = invalid_node(); + users.get().get_mut(idx).reader = invalid_node(); + users.get().get_mut(idx).writer = invalid_node(); debug!("{} defines {} (idx={}): {}", writer.to_str(), var.to_str(), idx, self.ln_str(writer)); @@ -904,7 +906,7 @@ impl Liveness { pub fn acc(&self, ln: LiveNode, var: Variable, acc: uint) { let idx = self.idx(ln, var); let mut users = self.users.borrow_mut(); - let user = &mut users.get()[idx]; + let user = users.get().get_mut(idx); if (acc & ACC_WRITE) != 0 { user.reader = invalid_node(); diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 609a8d712c8..ba93e52bc48 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -65,6 +65,7 @@ use middle::ty; use util::ppaux::{ty_to_str, region_ptr_to_str, Repr}; +use std::vec_ng::Vec; use syntax::ast::{MutImmutable, MutMutable}; use syntax::ast; use syntax::codemap::Span; diff --git a/src/librustc/middle/moves.rs b/src/librustc/middle/moves.rs index 92b663ff8db..16655474d3a 100644 --- a/src/librustc/middle/moves.rs +++ b/src/librustc/middle/moves.rs @@ -139,6 +139,7 @@ use util::nodemap::{NodeMap, NodeSet}; use std::cell::RefCell; use std::rc::Rc; +use std::vec_ng::Vec; use syntax::ast::*; use syntax::ast_util; use syntax::visit; diff --git a/src/librustc/middle/pat_util.rs b/src/librustc/middle/pat_util.rs index 36c6c190284..3e645491699 100644 --- a/src/librustc/middle/pat_util.rs +++ b/src/librustc/middle/pat_util.rs @@ -12,6 +12,7 @@ use middle::resolve; use collections::HashMap; +use std::vec_ng::Vec; use syntax::ast::*; use syntax::ast_util::{path_to_ident, walk_pat}; use syntax::codemap::Span; diff --git a/src/librustc/middle/reachable.rs b/src/librustc/middle/reachable.rs index 9deb51e412e..fac7e7a36e6 100644 --- a/src/librustc/middle/reachable.rs +++ b/src/librustc/middle/reachable.rs @@ -21,6 +21,7 @@ use middle::privacy; use util::nodemap::NodeSet; use std::cell::RefCell; +use std::vec_ng::Vec; use collections::HashSet; use syntax::ast; use syntax::ast_map; diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs index a575a8e3fcf..15d228662c7 100644 --- a/src/librustc/middle/region.rs +++ b/src/librustc/middle/region.rs @@ -27,6 +27,7 @@ use middle::ty; use util::nodemap::NodeMap; use std::cell::RefCell; +use std::vec_ng::Vec; use collections::{HashMap, HashSet}; use syntax::codemap::Span; use syntax::{ast, visit}; @@ -287,7 +288,7 @@ impl RegionMaps { let mut i = 0; while i < queue.len() { let free_region_map = self.free_region_map.borrow(); - match free_region_map.get().find(&queue[i]) { + match free_region_map.get().find(queue.get(i)) { Some(parents) => { for parent in parents.iter() { if *parent == sup { @@ -369,7 +370,7 @@ impl RegionMaps { // where they diverge. If one vector is a suffix of the other, // then the corresponding scope is a superscope of the other. - if a_ancestors[a_index] != b_ancestors[b_index] { + if *a_ancestors.get(a_index) != *b_ancestors.get(b_index) { return None; } @@ -380,8 +381,8 @@ impl RegionMaps { if b_index == 0u { return Some(scope_b); } a_index -= 1u; b_index -= 1u; - if a_ancestors[a_index] != b_ancestors[b_index] { - return Some(a_ancestors[a_index + 1u]); + if *a_ancestors.get(a_index) != *b_ancestors.get(b_index) { + return Some(*a_ancestors.get(a_index + 1u)); } } diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index f75b45f2b21..77e44c137a9 100644 --- a/src/librustc/middle/resolve.rs +++ b/src/librustc/middle/resolve.rs @@ -34,6 +34,7 @@ use syntax::visit::Visitor; use std::cell::{Cell, RefCell}; use std::uint; use std::mem::replace; +use std::vec_ng::Vec; use collections::{HashMap, HashSet}; // Definition mapping @@ -826,7 +827,7 @@ fn Resolver(session: Session, primitive_type_table: @PrimitiveTypeTable(), - namespaces: Vec<TypeNS, ValueNS > , + namespaces: vec!(TypeNS, ValueNS), def_map: @RefCell::new(NodeMap::new()), export_map2: @RefCell::new(NodeMap::new()), @@ -1972,7 +1973,7 @@ impl Resolver { SingleImport(target, _) => { debug!("(building import directive) building import \ directive: {}::{}", - self.idents_to_str(directive.module_path), + self.idents_to_str(directive.module_path.as_slice()), token::get_ident(target)); let mut import_resolutions = module_.import_resolutions @@ -2085,13 +2086,14 @@ impl Resolver { let import_count = imports.get().len(); while module.resolved_import_count.get() < import_count { let import_index = module.resolved_import_count.get(); - let import_directive = imports.get()[import_index]; + let import_directive = *imports.get().get(import_index); match self.resolve_import_for_module(module, import_directive) { Failed => { // We presumably emitted an error. Continue. let msg = format!("failed to resolve import `{}`", self.import_path_to_str( - import_directive.module_path, + import_directive.module_path + .as_slice(), *import_directive.subclass)); self.resolve_error(import_directive.span, msg); } @@ -2128,7 +2130,7 @@ impl Resolver { .iter() .map(|seg| seg.identifier) .collect(); - self.idents_to_str(identifiers) + self.idents_to_str(identifiers.as_slice()) } fn import_directive_subclass_to_str(&mut self, @@ -2169,7 +2171,7 @@ impl Resolver { debug!("(resolving import for module) resolving import `{}::...` in \ `{}`", - self.idents_to_str(*module_path), + self.idents_to_str(module_path.as_slice()), self.module_to_str(module_)); // First, resolve the module path for the directive, if necessary. @@ -2178,7 +2180,7 @@ impl Resolver { Some((self.graph_root.get_module(), LastMod(AllPublic))) } else { match self.resolve_module_path(module_, - *module_path, + module_path.as_slice(), DontUseLexicalScope, import_directive.span, ImportSearch) { @@ -3274,15 +3276,15 @@ impl Resolver { if index != import_count { let sn = self.session .codemap - .span_to_snippet(imports.get()[index].span) + .span_to_snippet(imports.get().get(index).span) .unwrap(); if sn.contains("::") { - self.resolve_error(imports.get()[index].span, + self.resolve_error(imports.get().get(index).span, "unresolved import"); } else { let err = format!("unresolved import (maybe you meant `{}::*`?)", sn.slice(0, sn.len())); - self.resolve_error(imports.get()[index].span, err); + self.resolve_error(imports.get().get(index).span, err); } } @@ -3520,7 +3522,7 @@ impl Resolver { let mut rib_index = rib_index + 1; while rib_index < ribs.len() { - match ribs[rib_index].kind { + match ribs.get(rib_index).kind { NormalRibKind => { // Nothing to do. Continue. } @@ -3621,7 +3623,7 @@ impl Resolver { while i != 0 { i -= 1; let binding_opt = { - let bindings = ribs[i].bindings.borrow(); + let bindings = ribs.get(i).bindings.borrow(); bindings.get().find_copy(&name) }; match binding_opt { @@ -4492,8 +4494,9 @@ impl Resolver { { let mut value_ribs = this.value_ribs.borrow_mut(); - let last_rib = value_ribs.get()[ - value_ribs.get().len() - 1]; + let length = value_ribs.get().len(); + let last_rib = value_ribs.get().get( + length - 1); let mut bindings = last_rib.bindings.borrow_mut(); bindings.get().insert(renamed, @@ -4518,8 +4521,9 @@ impl Resolver { { let mut value_ribs = this.value_ribs.borrow_mut(); - let last_rib = value_ribs.get()[ - value_ribs.get().len() - 1]; + let length = value_ribs.get().len(); + let last_rib = value_ribs.get().get( + length - 1); let mut bindings = last_rib.bindings.borrow_mut(); bindings.get().insert(renamed, @@ -5064,7 +5068,7 @@ impl Resolver { while j != 0 { j -= 1; let value_ribs = this.value_ribs.borrow(); - let bindings = value_ribs.get()[j].bindings.borrow(); + let bindings = value_ribs.get().get(j).bindings.borrow(); for (&k, _) in bindings.get().iter() { maybes.push(token::get_name(k)); values.push(uint::MAX); @@ -5073,20 +5077,20 @@ impl Resolver { let mut smallest = 0; for (i, other) in maybes.iter().enumerate() { - values[i] = name.lev_distance(other.get()); + *values.get_mut(i) = name.lev_distance(other.get()); - if values[i] <= values[smallest] { + if *values.get(i) <= *values.get(smallest) { smallest = i; } } if values.len() > 0 && - values[smallest] != uint::MAX && - values[smallest] < name.len() + 2 && - values[smallest] <= max_distance && - name != maybes[smallest].get() { + *values.get(smallest) != uint::MAX && + *values.get(smallest) < name.len() + 2 && + *values.get(smallest) <= max_distance && + name != maybes.get(smallest).get() { - Some(maybes[smallest].get().to_str()) + Some(maybes.get(smallest).get().to_str()) } else { None @@ -5212,8 +5216,8 @@ impl Resolver { let def_like = DlDef(DefLabel(expr.id)); { let mut label_ribs = this.label_ribs.borrow_mut(); - let rib = label_ribs.get()[label_ribs.get().len() - - 1]; + let length = label_ribs.get().len(); + let rib = label_ribs.get().get(length - 1); let mut bindings = rib.bindings.borrow_mut(); let renamed = mtwt::resolve(label); bindings.get().insert(renamed, def_like); @@ -5516,7 +5520,9 @@ impl Resolver { if idents.len() == 0 { return ~"???"; } - return self.idents_to_str(idents.move_rev_iter().collect::<Vec<ast::Ident> >()); + return self.idents_to_str(idents.move_rev_iter() + .collect::<Vec<ast::Ident>>() + .as_slice()); } #[allow(dead_code)] // useful for debugging diff --git a/src/librustc/middle/subst.rs b/src/librustc/middle/subst.rs index f19d168a729..6c48440421f 100644 --- a/src/librustc/middle/subst.rs +++ b/src/librustc/middle/subst.rs @@ -16,6 +16,7 @@ use middle::ty_fold::TypeFolder; use util::ppaux::Repr; use std::rc::Rc; +use std::vec_ng::Vec; use syntax::codemap::Span; use syntax::opt_vec::OptVec; @@ -88,7 +89,7 @@ impl<'a> TypeFolder for SubstFolder<'a> { match ty::get(t).sty { ty::ty_param(p) => { if p.idx < self.substs.tps.len() { - self.substs.tps[p.idx] + *self.substs.tps.get(p.idx) } else { let root_msg = match self.root_ty { Some(root) => format!(" in the substitution of `{}`", diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs index 93040a36c0e..4f190c5d697 100644 --- a/src/librustc/middle/trans/_match.rs +++ b/src/librustc/middle/trans/_match.rs @@ -223,9 +223,10 @@ use middle::ty; use util::common::indenter; use util::ppaux::{Repr, vec_map_to_str}; -use std::cell::Cell; use collections::HashMap; -use std::vec; +use std::cell::Cell; +use std::vec_ng::Vec; +use std::vec_ng; use syntax::ast; use syntax::ast::Ident; use syntax::ast_util::path_to_ident; @@ -438,9 +439,9 @@ impl<'a,'b> Repr for Match<'a,'b> { fn has_nested_bindings(m: &[Match], col: uint) -> bool { for br in m.iter() { - match br.pats[col].node { - ast::PatIdent(_, _, Some(_)) => return true, - _ => () + match br.pats.get(col).node { + ast::PatIdent(_, _, Some(_)) => return true, + _ => () } } return false; @@ -451,7 +452,7 @@ fn expand_nested_bindings<'r,'b>( m: &[Match<'r,'b>], col: uint, val: ValueRef) - -> vec!(Match<'r,'b>) { + -> Vec<Match<'r,'b>> { debug!("expand_nested_bindings(bcx={}, m={}, col={}, val={})", bcx.to_str(), m.repr(bcx.tcx()), @@ -459,14 +460,14 @@ fn expand_nested_bindings<'r,'b>( bcx.val_to_str(val)); let _indenter = indenter(); - m.map(|br| { - match br.pats[col].node { + m.iter().map(|br| { + match br.pats.get(col).node { ast::PatIdent(_, ref path, Some(inner)) => { let pats = vec_ng::append( - br.pats.slice(0u, col).to_owned(), + Vec::from_slice(br.pats.slice(0u, col)), vec_ng::append(vec!(inner), br.pats.slice(col + 1u, - br.pats.len()))); + br.pats.len())).as_slice()); let mut res = Match { pats: pats, @@ -478,7 +479,7 @@ fn expand_nested_bindings<'r,'b>( } _ => (*br).clone(), } - }) + }).collect() } fn assert_is_binding_or_wild(bcx: &Block, p: @ast::Pat) { @@ -499,7 +500,7 @@ fn enter_match<'r,'b>( col: uint, val: ValueRef, e: enter_pat) - -> vec!(Match<'r,'b>) { + -> Vec<Match<'r,'b>> { debug!("enter_match(bcx={}, m={}, col={}, val={})", bcx.to_str(), m.repr(bcx.tcx()), @@ -509,14 +510,14 @@ fn enter_match<'r,'b>( let mut result = Vec::new(); for br in m.iter() { - match e(br.pats[col]) { + match e(*br.pats.get(col)) { Some(sub) => { let pats = vec_ng::append( vec_ng::append(sub, br.pats.slice(0u, col)), br.pats.slice(col + 1u, br.pats.len())); - let this = br.pats[col]; + let this = *br.pats.get(col); let mut bound_ptrs = br.bound_ptrs.clone(); match this.node { ast::PatIdent(_, ref path, None) => { @@ -549,7 +550,7 @@ fn enter_default<'r,'b>( col: uint, val: ValueRef, chk: &FailureHandler) - -> vec!(Match<'r,'b>) { + -> Vec<Match<'r,'b>> { debug!("enter_default(bcx={}, m={}, col={}, val={})", bcx.to_str(), m.repr(bcx.tcx()), @@ -620,7 +621,7 @@ fn enter_opt<'r,'b>( col: uint, variant_size: uint, val: ValueRef) - -> vec!(Match<'r,'b>) { + -> Vec<Match<'r,'b>> { debug!("enter_opt(bcx={}, m={}, opt={:?}, col={}, val={})", bcx.to_str(), m.repr(bcx.tcx()), @@ -651,7 +652,7 @@ fn enter_opt<'r,'b>( if opt_eq(tcx, &variant_opt(bcx, p.id), opt) { // FIXME: Must we clone? match *subpats { - None => Some(vec::from_elem(variant_size, dummy)), + None => Some(Vec::from_elem(variant_size, dummy)), Some(ref subpats) => { Some((*subpats).iter().map(|x| *x).collect()) } @@ -761,7 +762,7 @@ fn enter_opt<'r,'b>( // cause the default match to fire spuriously. match *opt { vec_len(..) => None, - _ => Some(vec::from_elem(variant_size, dummy)) + _ => Some(Vec::from_elem(variant_size, dummy)) } } }; @@ -777,7 +778,7 @@ fn enter_rec_or_struct<'r,'b>( col: uint, fields: &[ast::Ident], val: ValueRef) - -> vec!(Match<'r,'b>) { + -> Vec<Match<'r,'b>> { debug!("enter_rec_or_struct(bcx={}, m={}, col={}, val={})", bcx.to_str(), m.repr(bcx.tcx()), @@ -800,7 +801,7 @@ fn enter_rec_or_struct<'r,'b>( } _ => { assert_is_binding_or_wild(bcx, p); - Some(vec::from_elem(fields.len(), dummy)) + Some(Vec::from_elem(fields.len(), dummy)) } } }) @@ -813,7 +814,7 @@ fn enter_tup<'r,'b>( col: uint, val: ValueRef, n_elts: uint) - -> vec!(Match<'r,'b>) { + -> Vec<Match<'r,'b>> { debug!("enter_tup(bcx={}, m={}, col={}, val={})", bcx.to_str(), m.repr(bcx.tcx()), @@ -833,7 +834,7 @@ fn enter_tup<'r,'b>( } _ => { assert_is_binding_or_wild(bcx, p); - Some(vec::from_elem(n_elts, dummy)) + Some(Vec::from_elem(n_elts, dummy)) } } }) @@ -846,7 +847,7 @@ fn enter_tuple_struct<'r,'b>( col: uint, val: ValueRef, n_elts: uint) - -> vec!(Match<'r,'b>) { + -> Vec<Match<'r,'b>> { debug!("enter_tuple_struct(bcx={}, m={}, col={}, val={})", bcx.to_str(), m.repr(bcx.tcx()), @@ -862,7 +863,7 @@ fn enter_tuple_struct<'r,'b>( } _ => { assert_is_binding_or_wild(bcx, p); - Some(vec::from_elem(n_elts, dummy)) + Some(Vec::from_elem(n_elts, dummy)) } } }) @@ -874,7 +875,7 @@ fn enter_uniq<'r,'b>( m: &[Match<'r,'b>], col: uint, val: ValueRef) - -> vec!(Match<'r,'b>) { + -> Vec<Match<'r,'b>> { debug!("enter_uniq(bcx={}, m={}, col={}, val={})", bcx.to_str(), m.repr(bcx.tcx()), @@ -903,7 +904,7 @@ fn enter_region<'r, m: &[Match<'r,'b>], col: uint, val: ValueRef) - -> vec!(Match<'r,'b>) { + -> Vec<Match<'r,'b>> { debug!("enter_region(bcx={}, m={}, col={}, val={})", bcx.to_str(), m.repr(bcx.tcx()), @@ -945,15 +946,18 @@ fn get_options(bcx: &Block, m: &[Match], col: uint) -> Vec<Opt> { // to add, then extend its range. Otherwise, make a new // vec_len with a range just covering the new entry. Some(&vec_len(len2, vlo2, (start, end))) - if len == len2 && vlo == vlo2 => - set[set.len() - 1] = vec_len(len, vlo, (start, end+1)), + if len == len2 && vlo == vlo2 => { + let length = set.len(); + *set.get_mut(length - 1) = + vec_len(len, vlo, (start, end+1)) + } _ => set.push(vec_len(len, vlo, (i, i))) } } let mut found = Vec::new(); for (i, br) in m.iter().enumerate() { - let cur = br.pats[col]; + let cur = *br.pats.get(col); match cur.node { ast::PatLit(l) => { add_to_set(ccx.tcx, &mut found, lit(ExprLit(l))); @@ -1030,7 +1034,7 @@ fn extract_variant_args<'a>( val: ValueRef) -> ExtractedBlock<'a> { let _icx = push_ctxt("match::extract_variant_args"); - let args = vec::from_fn(adt::num_args(repr, disr_val), |i| { + let args = Vec::from_fn(adt::num_args(repr, disr_val), |i| { adt::trans_field_ptr(bcx, repr, val, disr_val, i) }); @@ -1065,7 +1069,7 @@ fn extract_vec_elems<'a>( let (base, len) = vec_datum.get_vec_base_and_len(bcx); let vt = tvec::vec_types(bcx, node_id_type(bcx, pat_id)); - let mut elems = vec::from_fn(elem_count, |i| { + let mut elems = Vec::from_fn(elem_count, |i| { match slice { None => GEPi(bcx, base, [i]), Some(n) if i < n => GEPi(bcx, base, [i]), @@ -1091,7 +1095,7 @@ fn extract_vec_elems<'a>( Store(bcx, slice_begin, GEPi(bcx, scratch.val, [0u, abi::slice_elt_base])); Store(bcx, slice_len, GEPi(bcx, scratch.val, [0u, abi::slice_elt_len])); - elems[n] = scratch.val; + *elems.get_mut(n) = scratch.val; } ExtractedBlock { vals: elems, bcx: bcx } @@ -1111,9 +1115,9 @@ fn collect_record_or_struct_fields<'a>( let mut fields: Vec<ast::Ident> = Vec::new(); let mut found = false; for br in m.iter() { - match br.pats[col].node { + match br.pats.get(col).node { ast::PatStruct(_, ref fs, _) => { - match ty::get(node_id_type(bcx, br.pats[col].id)).sty { + match ty::get(node_id_type(bcx, br.pats.get(col).id)).sty { ty::ty_struct(..) => { extend(&mut fields, fs.as_slice()); found = true; @@ -1142,7 +1146,7 @@ fn collect_record_or_struct_fields<'a>( fn pats_require_rooting(bcx: &Block, m: &[Match], col: uint) -> bool { m.iter().any(|br| { - let pat_id = br.pats[col].id; + let pat_id = br.pats.get(col).id; let key = root_map_key {id: pat_id, derefs: 0u }; let root_map = bcx.ccx().maps.root_map.borrow(); root_map.get().contains_key(&key) @@ -1156,7 +1160,7 @@ fn pats_require_rooting(bcx: &Block, m: &[Match], col: uint) -> bool { macro_rules! any_pat ( ($m:expr, $pattern:pat) => ( ($m).iter().any(|br| { - match br.pats[col].node { + match br.pats.get(col).node { $pattern => true, _ => false } @@ -1178,7 +1182,7 @@ fn any_tup_pat(m: &[Match], col: uint) -> bool { fn any_tuple_struct_pat(bcx: &Block, m: &[Match], col: uint) -> bool { m.iter().any(|br| { - let pat = br.pats[col]; + let pat = *br.pats.get(col); match pat.node { ast::PatEnum(_, Some(_)) => { let def_map = bcx.tcx().def_map.borrow(); @@ -1255,10 +1259,10 @@ fn pick_col(m: &[Match]) -> uint { _ => 0u } } - let mut scores = vec::from_elem(m[0].pats.len(), 0u); + let mut scores = Vec::from_elem(m[0].pats.len(), 0u); for br in m.iter() { for (i, p) in br.pats.iter().enumerate() { - scores[i] += score(*p); + *scores.get_mut(i) += score(*p); } } let mut max_score = 0u; @@ -1511,7 +1515,12 @@ fn compile_submatch<'r, if has_nested_bindings(m, col) { let expanded = expand_nested_bindings(bcx, m, col, val); - compile_submatch_continue(bcx, expanded, vals, chk, col, val) + compile_submatch_continue(bcx, + expanded.as_slice(), + vals, + chk, + col, + val) } else { compile_submatch_continue(bcx, m, vals, chk, col, val) } @@ -1529,15 +1538,15 @@ fn compile_submatch_continue<'r, let tcx = bcx.tcx(); let dm = tcx.def_map; - let vals_left = vec_ng::append(vals.slice(0u, col).to_owned(), - vals.slice(col + 1u, vals.len())); + let vals_left = vec_ng::append(Vec::from_slice(vals.slice(0u, col)), + vals.slice(col + 1u, vals.len())); let ccx = bcx.fcx.ccx; let mut pat_id = 0; for br in m.iter() { // Find a real id (we're adding placeholder wildcard patterns, but // each column is guaranteed to have at least one real pattern) if pat_id == 0 { - pat_id = br.pats[col].id; + pat_id = br.pats.get(col).id; } } @@ -1556,8 +1565,14 @@ fn compile_submatch_continue<'r, }); compile_submatch( bcx, - enter_rec_or_struct(bcx, dm, m, col, *rec_fields, val), - vec_ng::append(rec_vals, vals_left), + enter_rec_or_struct(bcx, + dm, + m, + col, + rec_fields.as_slice(), + val).as_slice(), + vec_ng::append(rec_vals, + vals_left.as_slice()).as_slice(), chk); }); return; @@ -1572,11 +1587,19 @@ fn compile_submatch_continue<'r, ty::ty_tup(ref elts) => elts.len(), _ => ccx.sess.bug("non-tuple type in tuple pattern") }; - let tup_vals = vec::from_fn(n_tup_elts, |i| { + let tup_vals = Vec::from_fn(n_tup_elts, |i| { adt::trans_field_ptr(bcx, tup_repr, val, 0, i) }); - compile_submatch(bcx, enter_tup(bcx, dm, m, col, val, n_tup_elts), - vec_ng::append(tup_vals, vals_left), chk); + compile_submatch(bcx, + enter_tup(bcx, + dm, + m, + col, + val, + n_tup_elts).as_slice(), + vec_ng::append(tup_vals, + vals_left.as_slice()).as_slice(), + chk); return; } @@ -1594,28 +1617,35 @@ fn compile_submatch_continue<'r, } let struct_repr = adt::represent_type(bcx.ccx(), struct_ty); - let llstructvals = vec::from_fn(struct_element_count, |i| { + let llstructvals = Vec::from_fn(struct_element_count, |i| { adt::trans_field_ptr(bcx, struct_repr, val, 0, i) }); compile_submatch(bcx, enter_tuple_struct(bcx, dm, m, col, val, - struct_element_count), - vec_ng::append(llstructvals, vals_left), + struct_element_count).as_slice(), + vec_ng::append(llstructvals, + vals_left.as_slice()).as_slice(), chk); return; } if any_uniq_pat(m, col) { let llbox = Load(bcx, val); - compile_submatch(bcx, enter_uniq(bcx, dm, m, col, val), - vec_ng::append(vec!(llbox), vals_left), chk); + compile_submatch(bcx, + enter_uniq(bcx, dm, m, col, val).as_slice(), + vec_ng::append(vec!(llbox), + vals_left.as_slice()).as_slice(), + chk); return; } if any_region_pat(m, col) { let loaded_val = Load(bcx, val); - compile_submatch(bcx, enter_region(bcx, dm, m, col, val), - vec_ng::append(vec!(loaded_val), vals_left), chk); + compile_submatch(bcx, + enter_region(bcx, dm, m, col, val).as_slice(), + vec_ng::append(vec!(loaded_val), + vals_left.as_slice()).as_slice(), + chk); return; } @@ -1626,7 +1656,7 @@ fn compile_submatch_continue<'r, let mut test_val = val; debug!("test_val={}", bcx.val_to_str(test_val)); if opts.len() > 0u { - match opts[0] { + match *opts.get(0) { var(_, repr) => { let (the_kind, val_opt) = adt::trans_switch(bcx, repr, val); kind = the_kind; @@ -1795,12 +1825,20 @@ fn compile_submatch_continue<'r, lit(_) | range(_, _) => () } let opt_ms = enter_opt(opt_cx, m, opt, col, size, val); - let opt_vals = vec_ng::append(unpacked, vals_left); + let opt_vals = vec_ng::append(unpacked, vals_left.as_slice()); match branch_chk { - None => compile_submatch(opt_cx, opt_ms, opt_vals, chk), + None => { + compile_submatch(opt_cx, + opt_ms.as_slice(), + opt_vals.as_slice(), + chk) + } Some(branch_chk) => { - compile_submatch(opt_cx, opt_ms, opt_vals, &branch_chk) + compile_submatch(opt_cx, + opt_ms.as_slice(), + opt_vals.as_slice(), + &branch_chk) } } } @@ -1811,7 +1849,10 @@ fn compile_submatch_continue<'r, Br(bcx, else_cx.llbb); } if kind != single { - compile_submatch(else_cx, defaults, vals_left, chk); + compile_submatch(else_cx, + defaults.as_slice(), + vals_left.as_slice(), + chk); } } } @@ -1921,7 +1962,7 @@ fn trans_match_inner<'a>(scope_cx: &'a Block<'a>, } }; let lldiscr = discr_datum.val; - compile_submatch(bcx, matches, [lldiscr], &chk); + compile_submatch(bcx, matches.as_slice(), [lldiscr], &chk); let mut arm_cxs = Vec::new(); for arm_data in arm_datas.iter() { @@ -1944,7 +1985,7 @@ fn trans_match_inner<'a>(scope_cx: &'a Block<'a>, arm_cxs.push(bcx); } - bcx = scope_cx.fcx.join_blocks(match_id, arm_cxs); + bcx = scope_cx.fcx.join_blocks(match_id, arm_cxs.as_slice()); return bcx; } diff --git a/src/librustc/middle/trans/adt.rs b/src/librustc/middle/trans/adt.rs index c41783cc294..00a93b66ce0 100644 --- a/src/librustc/middle/trans/adt.rs +++ b/src/librustc/middle/trans/adt.rs @@ -53,17 +53,18 @@ use middle::trans::_match; use middle::trans::build::*; use middle::trans::common::*; use middle::trans::machine; +use middle::trans::type_::Type; use middle::trans::type_of; use middle::ty; use middle::ty::Disr; +use std::vec_ng::Vec; +use std::vec_ng; use syntax::abi::{X86, X86_64, Arm, Mips}; use syntax::ast; use syntax::attr; use syntax::attr::IntType; use util::ppaux::ty_to_str; -use middle::trans::type_::Type; - type Hint = attr::ReprAttr; @@ -136,7 +137,7 @@ pub fn represent_type(cx: &CrateContext, t: ty::t) -> @Repr { fn represent_type_uncached(cx: &CrateContext, t: ty::t) -> Repr { match ty::get(t).sty { ty::ty_tup(ref elems) => { - return Univariant(mk_struct(cx, *elems, false), false) + return Univariant(mk_struct(cx, elems.as_slice(), false), false) } ty::ty_struct(def_id, ref substs) => { let fields = ty::lookup_struct_fields(cx.tcx, def_id); @@ -147,7 +148,7 @@ fn represent_type_uncached(cx: &CrateContext, t: ty::t) -> Repr { let dtor = ty::ty_dtor(cx.tcx, def_id).has_drop_flag(); if dtor { ftys.push(ty::mk_bool()); } - return Univariant(mk_struct(cx, ftys, packed), dtor) + return Univariant(mk_struct(cx, ftys.as_slice(), packed), dtor) } ty::ty_enum(def_id, ref substs) => { let cases = get_cases(cx.tcx, def_id, substs); @@ -185,23 +186,29 @@ fn represent_type_uncached(cx: &CrateContext, t: ty::t) -> Repr { // Equivalent to a struct/tuple/newtype. // (Typechecking will reject discriminant-sizing attrs.) assert_eq!(hint, attr::ReprAny); - return Univariant(mk_struct(cx, cases[0].tys, false), false) + return Univariant(mk_struct(cx, + cases.get(0).tys.as_slice(), + false), + false) } if cases.len() == 2 && hint == attr::ReprAny { // Nullable pointer optimization let mut discr = 0; while discr < 2 { - if cases[1 - discr].is_zerolen(cx) { - match cases[discr].find_ptr() { + if cases.get(1 - discr).is_zerolen(cx) { + match cases.get(discr).find_ptr() { Some(ptrfield) => { return NullablePointer { - nndiscr: discr, + nndiscr: discr as u64, nonnull: mk_struct(cx, - cases[discr].tys, + cases.get(discr) + .tys + .as_slice(), false), ptrfield: ptrfield, - nullfields: cases[1 - discr].tys.clone() + nullfields: cases.get(1 - discr).tys + .clone() } } None => { } @@ -216,8 +223,12 @@ fn represent_type_uncached(cx: &CrateContext, t: ty::t) -> Repr { let bounds = IntBounds { ulo: 0, uhi: (cases.len() - 1) as u64, slo: 0, shi: (cases.len() - 1) as i64 }; let ity = range_to_inttype(cx, hint, &bounds); - let discr = vec!(ty_of_inttype(ity)); - return General(ity, cases.map(|c| mk_struct(cx, discr + c.tys, false))) + return General(ity, cases.map(|c| { + let discr = vec!(ty_of_inttype(ity)); + mk_struct(cx, + vec_ng::append(discr, c.tys.as_slice()).as_slice(), + false) + })) } _ => cx.sess.bug("adt::represent_type called on non-ADT type") } @@ -256,7 +267,7 @@ pub fn is_ffi_safe(tcx: ty::ctxt, def_id: ast::DefId) -> bool { struct Case { discr: Disr, tys: Vec<ty::t> } impl Case { fn is_zerolen(&self, cx: &CrateContext) -> bool { - mk_struct(cx, self.tys, false).size == 0 + mk_struct(cx, self.tys.as_slice(), false).size == 0 } fn find_ptr(&self) -> Option<uint> { self.tys.iter().position(|&ty| mono_data_classify(ty) == MonoNonNull) @@ -280,7 +291,7 @@ fn mk_struct(cx: &CrateContext, tys: &[ty::t], packed: bool) -> Struct { size: machine::llsize_of_alloc(cx, llty_rec) /*bad*/as u64, align: machine::llalign_of_min(cx, llty_rec) /*bad*/as u64, packed: packed, - fields: tys.to_owned(), + fields: Vec::from_slice(tys), } } @@ -393,7 +404,8 @@ pub fn finish_type_of(cx: &CrateContext, r: &Repr, llty: &mut Type) { match *r { CEnum(..) | General(..) => { } Univariant(ref st, _) | NullablePointer{ nonnull: ref st, .. } => - llty.set_struct_body(struct_llfields(cx, st, false), st.packed) + llty.set_struct_body(struct_llfields(cx, st, false).as_slice(), + st.packed) } } @@ -402,7 +414,10 @@ fn generic_type_of(cx: &CrateContext, r: &Repr, name: Option<&str>, sizing: bool CEnum(ity, _, _) => ll_inttype(cx, ity), Univariant(ref st, _) | NullablePointer{ nonnull: ref st, .. } => { match name { - None => Type::struct_(struct_llfields(cx, st, sizing), st.packed), + None => { + Type::struct_(struct_llfields(cx, st, sizing).as_slice(), + st.packed) + } Some(name) => { assert_eq!(sizing, false); Type::named_struct(name) } } } @@ -441,10 +456,10 @@ fn generic_type_of(cx: &CrateContext, r: &Repr, name: Option<&str>, sizing: bool Type::array(&discr_ty, align / discr_size - 1), pad_ty); match name { - None => Type::struct_(fields, false), + None => Type::struct_(fields.as_slice(), false), Some(name) => { let mut llty = Type::named_struct(name); - llty.set_struct_body(fields, false); + llty.set_struct_body(fields.as_slice(), false); llty } } @@ -517,7 +532,7 @@ fn nullable_bitdiscr(bcx: &Block, nonnull: &Struct, nndiscr: Disr, ptrfield: uin scrutinee: ValueRef) -> ValueRef { let cmp = if nndiscr == 0 { IntEQ } else { IntNE }; let llptr = Load(bcx, GEPi(bcx, scrutinee, [0, ptrfield])); - let llptrty = type_of::type_of(bcx.ccx(), nonnull.fields[ptrfield]); + let llptrty = type_of::type_of(bcx.ccx(), *nonnull.fields.get(ptrfield)); ICmp(bcx, cmp, llptr, C_null(llptrty)) } @@ -598,7 +613,8 @@ pub fn trans_start_init(bcx: &Block, r: &Repr, val: ValueRef, discr: Disr) { NullablePointer{ nonnull: ref nonnull, nndiscr, ptrfield, .. } => { if discr != nndiscr { let llptrptr = GEPi(bcx, val, [0, ptrfield]); - let llptrty = type_of::type_of(bcx.ccx(), nonnull.fields[ptrfield]); + let llptrty = type_of::type_of(bcx.ccx(), + *nonnull.fields.get(ptrfield)); Store(bcx, C_null(llptrty), llptrptr) } } @@ -623,7 +639,7 @@ pub fn num_args(r: &Repr, discr: Disr) -> uint { assert_eq!(discr, 0); st.fields.len() - (if dtor { 1 } else { 0 }) } - General(_, ref cases) => cases[discr].fields.len() - 1, + General(_, ref cases) => cases.get(discr as uint).fields.len() - 1, NullablePointer{ nonnull: ref nonnull, nndiscr, nullfields: ref nullfields, .. } => { if discr == nndiscr { nonnull.fields.len() } else { nullfields.len() } @@ -638,11 +654,11 @@ pub fn deref_ty(ccx: &CrateContext, r: &Repr) -> ty::t { ccx.sess.bug("deref of c-like enum") } Univariant(ref st, _) => { - st.fields[0] + *st.fields.get(0) } General(_, ref cases) => { assert!(cases.len() == 1); - cases[0].fields[0] + *cases.get(0).fields.get(0) } NullablePointer{ .. } => { ccx.sess.bug("deref of nullable ptr") @@ -665,7 +681,7 @@ pub fn trans_field_ptr(bcx: &Block, r: &Repr, val: ValueRef, discr: Disr, struct_field_ptr(bcx, st, val, ix, false) } General(_, ref cases) => { - struct_field_ptr(bcx, &cases[discr], val, ix + 1, true) + struct_field_ptr(bcx, cases.get(discr as uint), val, ix + 1, true) } NullablePointer{ nonnull: ref nonnull, nullfields: ref nullfields, nndiscr, .. } => { @@ -674,7 +690,7 @@ pub fn trans_field_ptr(bcx: &Block, r: &Repr, val: ValueRef, discr: Disr, } else { // The unit-like case might have a nonzero number of unit-like fields. // (e.g., Result or Either with () as one side.) - let ty = type_of::type_of(bcx.ccx(), nullfields[ix]); + let ty = type_of::type_of(bcx.ccx(), *nullfields.get(ix)); assert_eq!(machine::llsize_of_alloc(bcx.ccx(), ty), 0); // The contents of memory at this pointer can't matter, but use // the value that's "reasonable" in case of pointer comparison. @@ -690,7 +706,7 @@ fn struct_field_ptr(bcx: &Block, st: &Struct, val: ValueRef, ix: uint, let val = if needs_cast { let fields = st.fields.map(|&ty| type_of::type_of(ccx, ty)); - let real_ty = Type::struct_(fields, st.packed); + let real_ty = Type::struct_(fields.as_slice(), st.packed); PointerCast(bcx, val, real_ty.ptr_to()) } else { val @@ -737,27 +753,40 @@ pub fn trans_const(ccx: &CrateContext, r: &Repr, discr: Disr, C_integral(ll_inttype(ccx, ity), discr as u64, true) } General(ity, ref cases) => { - let case = &cases[discr]; + let case = cases.get(discr as uint); let max_sz = cases.iter().map(|x| x.size).max().unwrap(); let lldiscr = C_integral(ll_inttype(ccx, ity), discr as u64, true); - let contents = build_const_struct(ccx, case, vec!(lldiscr) + vals); - C_struct(contents + &[padding(max_sz - case.size)], false) + let contents = build_const_struct(ccx, + case, + vec_ng::append( + vec!(lldiscr), + vals).as_slice()); + C_struct(vec_ng::append( + contents, + &[padding(max_sz - case.size)]).as_slice(), + false) } Univariant(ref st, _dro) => { assert!(discr == 0); let contents = build_const_struct(ccx, st, vals); - C_struct(contents, st.packed) + C_struct(contents.as_slice(), st.packed) } NullablePointer{ nonnull: ref nonnull, nndiscr, .. } => { if discr == nndiscr { - C_struct(build_const_struct(ccx, nonnull, vals), false) + C_struct(build_const_struct(ccx, + nonnull, + vals.as_slice()).as_slice(), + false) } else { let vals = nonnull.fields.map(|&ty| { // Always use null even if it's not the `ptrfield`th // field; see #8506. C_null(type_of::sizing_type_of(ccx, ty)) - }).collect::<Vec<ValueRef> >(); - C_struct(build_const_struct(ccx, nonnull, vals), false) + }).move_iter().collect::<Vec<ValueRef> >(); + C_struct(build_const_struct(ccx, + nonnull, + vals.as_slice()).as_slice(), + false) } } } diff --git a/src/librustc/middle/trans/asm.rs b/src/librustc/middle/trans/asm.rs index 83d5420d5d3..adcef0278f8 100644 --- a/src/librustc/middle/trans/asm.rs +++ b/src/librustc/middle/trans/asm.rs @@ -12,8 +12,6 @@ # Translation of inline assembly. */ -use std::c_str::ToCStr; - use lib; use middle::trans::build::*; use middle::trans::callee; @@ -22,9 +20,10 @@ use middle::trans::cleanup; use middle::trans::cleanup::CleanupMethods; use middle::trans::expr; use middle::trans::type_of; - use middle::trans::type_::Type; +use std::c_str::ToCStr; +use std::vec_ng::Vec; use syntax::ast; // Take an inline assembly expression and splat it out via LLVM @@ -88,9 +87,9 @@ pub fn trans_inline_asm<'a>(bcx: &'a Block<'a>, ia: &ast::InlineAsm) let output_type = if num_outputs == 0 { Type::void() } else if num_outputs == 1 { - output_types[0] + *output_types.get(0) } else { - Type::struct_(output_types, false) + Type::struct_(output_types.as_slice(), false) }; let dialect = match ia.dialect { diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index f4540a07794..362f5fbacf0 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -73,11 +73,12 @@ use util::sha2::Sha256; use util::nodemap::NodeMap; use arena::TypedArena; +use collections::HashMap; use std::c_str::ToCStr; use std::cell::{Cell, RefCell}; -use collections::HashMap; use std::libc::c_uint; use std::local_data; +use std::vec_ng::Vec; use syntax::abi::{X86, X86_64, Arm, Mips, Rust, RustIntrinsic, OsWin32}; use syntax::ast_map::PathName; use syntax::ast_util::{local_def, is_local}; @@ -99,7 +100,7 @@ local_data_key!(task_local_insn_key: Vec<&'static str> ) pub fn with_insn_ctxt(blk: |&[&'static str]|) { local_data::get(task_local_insn_key, |c| { match c { - Some(ctx) => blk(*ctx), + Some(ctx) => blk(ctx.as_slice()), None => () } }) @@ -543,7 +544,7 @@ pub fn get_res_dtor(ccx: @CrateContext, let tsubsts = ty::substs { regions: ty::ErasedRegions, self_ty: None, - tps: substs.to_owned() + tps: Vec::from_slice(substs), }; let vtables = typeck::check::vtable::trans_resolve_method(ccx.tcx, did.node, &tsubsts); @@ -752,8 +753,8 @@ pub fn iter_structural_ty<'r, match adt::trans_switch(cx, repr, av) { (_match::single, None) => { - cx = iter_variant(cx, repr, av, variants[0], - substs.tps, f); + cx = iter_variant(cx, repr, av, *variants.get(0), + substs.tps.as_slice(), f); } (_match::switch, Some(lldiscrim_a)) => { cx = f(cx, lldiscrim_a, ty::mk_int()); @@ -775,8 +776,12 @@ pub fn iter_structural_ty<'r, in iter_structural_ty") } let variant_cx = - iter_variant(variant_cx, repr, av, *variant, - substs.tps, |x,y,z| f(x,y,z)); + iter_variant(variant_cx, + repr, + av, + *variant, + substs.tps.as_slice(), + |x,y,z| f(x,y,z)); Br(variant_cx, next_cx.llbb); } cx = next_cx; @@ -876,7 +881,11 @@ pub fn trans_external_path(ccx: &CrateContext, did: ast::DefId, t: ty::t) -> Val match fn_ty.abis.for_target(ccx.sess.targ_cfg.os, ccx.sess.targ_cfg.arch) { Some(Rust) | Some(RustIntrinsic) => { - get_extern_rust_fn(ccx, fn_ty.sig.inputs, fn_ty.sig.output, name, did) + get_extern_rust_fn(ccx, + fn_ty.sig.inputs.as_slice(), + fn_ty.sig.output, + name, + did) } Some(..) | None => { let c = foreign::llvm_calling_convention(ccx, fn_ty.abis); @@ -889,7 +898,11 @@ pub fn trans_external_path(ccx: &CrateContext, did: ast::DefId, t: ty::t) -> Val } } ty::ty_closure(ref f) => { - get_extern_rust_fn(ccx, f.sig.inputs, f.sig.output, name, did) + get_extern_rust_fn(ccx, + f.sig.inputs.as_slice(), + f.sig.output, + name, + did) } _ => { let llty = type_of(ccx, t); @@ -935,7 +948,7 @@ pub fn invoke<'a>( let llresult = Invoke(bcx, llfn, - llargs, + llargs.as_slice(), normal_bcx.llbb, landing_pad, attributes); @@ -951,7 +964,7 @@ pub fn invoke<'a>( None => debuginfo::clear_source_location(bcx.fcx) }; - let llresult = Call(bcx, llfn, llargs, attributes); + let llresult = Call(bcx, llfn, llargs.as_slice(), attributes); return (llresult, bcx); } } @@ -1231,7 +1244,10 @@ pub fn new_fn_ctxt<'a>(ccx: @CrateContext, let substd_output_type = match param_substs { None => output_type, Some(substs) => { - ty::subst_tps(ccx.tcx, substs.tys, substs.self_ty, output_type) + ty::subst_tps(ccx.tcx, + substs.tys.as_slice(), + substs.self_ty, + output_type) } }; let uses_outptr = type_of::return_uses_outptr(ccx, substd_output_type); @@ -1289,7 +1305,7 @@ pub fn init_function<'a>( None => output_type, Some(substs) => { ty::subst_tps(fcx.ccx.tcx, - substs.tys, + substs.tys.as_slice(), substs.self_ty, output_type) } @@ -1472,7 +1488,7 @@ pub fn trans_closure<'a>(ccx: @CrateContext, // Set up arguments to the function. let arg_tys = ty::ty_fn_args(node_id_type(bcx, id)); - let arg_datums = create_datums_for_fn_args(&fcx, arg_tys); + let arg_datums = create_datums_for_fn_args(&fcx, arg_tys.as_slice()); bcx = copy_args_to_allocas(&fcx, arg_scope, @@ -1583,7 +1599,7 @@ fn trans_enum_variant_or_tuple_like_struct(ccx: @CrateContext, let no_substs: &[ty::t] = []; let ty_param_substs = match param_substs { Some(ref substs) => { - let v: &[ty::t] = substs.tys; + let v: &[ty::t] = substs.tys.as_slice(); v } None => { @@ -1612,7 +1628,7 @@ fn trans_enum_variant_or_tuple_like_struct(ccx: @CrateContext, let arg_tys = ty::ty_fn_args(ctor_ty); - let arg_datums = create_datums_for_fn_args(&fcx, arg_tys); + let arg_datums = create_datums_for_fn_args(&fcx, arg_tys.as_slice()); let bcx = fcx.entry_bcx.get().unwrap(); @@ -1636,7 +1652,7 @@ pub fn trans_enum_def(ccx: @CrateContext, enum_definition: &ast::EnumDef, id: ast::NodeId, vi: @Vec<@ty::VariantInfo> , i: &mut uint) { for &variant in enum_definition.variants.iter() { - let disr_val = vi[*i].disr_val; + let disr_val = vi.get(*i).disr_val; *i += 1; match variant.node.kind { @@ -1801,7 +1817,11 @@ fn register_fn(ccx: @CrateContext, _ => fail!("expected bare rust fn or an intrinsic") }; - let llfn = decl_rust_fn(ccx, false, f.sig.inputs, f.sig.output, sym); + let llfn = decl_rust_fn(ccx, + false, + f.sig.inputs.as_slice(), + f.sig.output, + sym); finish_register_fn(ccx, sp, sym, node_id, llfn); llfn } @@ -1893,8 +1913,10 @@ pub fn create_entry_wrapper(ccx: @CrateContext, (rust_main, args) }; - let result = llvm::LLVMBuildCall(bld, start_fn, - args.as_ptr(), args.len() as c_uint, + let result = llvm::LLVMBuildCall(bld, + start_fn, + args.as_ptr(), + args.len() as c_uint, noname()); llvm::LLVMBuildRet(bld, result); @@ -2476,7 +2498,7 @@ pub fn create_module_map(ccx: &CrateContext) -> (ValueRef, uint) { elts.push(elt); } unsafe { - llvm::LLVMSetInitializer(map, C_array(elttype, elts)); + llvm::LLVMSetInitializer(map, C_array(elttype, elts.as_slice())); } return (map, keys.len()) } @@ -2564,7 +2586,8 @@ pub fn fill_crate_map(ccx: @CrateContext, map: ValueRef) { }); lib::llvm::SetLinkage(vec_elements, lib::llvm::InternalLinkage); - llvm::LLVMSetInitializer(vec_elements, C_array(ccx.int_type, subcrates)); + llvm::LLVMSetInitializer(vec_elements, + C_array(ccx.int_type, subcrates.as_slice())); let (mod_map, mod_count) = create_module_map(ccx); llvm::LLVMSetInitializer(map, C_struct( @@ -2613,7 +2636,7 @@ pub fn write_metadata(cx: &CrateContext, krate: &ast::Crate) -> Vec<u8> { let encode_parms = crate_ctxt_to_encode_parms(cx, encode_inlined_item); let metadata = encoder::encode_metadata(encode_parms, krate); let compressed = encoder::metadata_encoding_version + - flate::deflate_bytes(metadata).as_slice(); + flate::deflate_bytes(metadata.as_slice()).as_slice(); let llmeta = C_bytes(compressed); let llconst = C_struct([llmeta], false); let name = format!("rust_metadata_{}_{}_{}", cx.link_meta.crateid.name, @@ -2744,12 +2767,12 @@ pub fn trans_crate(sess: session::Session, let link_meta = ccx.link_meta.clone(); let llmod = ccx.llmod; - let mut reachable = { + let mut reachable: Vec<~str> = { let reachable_map = ccx.reachable.borrow(); reachable_map.get().iter().filter_map(|id| { let item_symbols = ccx.item_symbols.borrow(); item_symbols.get().find(id).map(|s| s.to_owned()) - }).to_owned_vec() + }).collect() }; // Make sure that some other crucial symbols are not eliminated from the diff --git a/src/librustc/middle/trans/builder.rs b/src/librustc/middle/trans/builder.rs index 74a6edf95e3..15e74b1b55d 100644 --- a/src/librustc/middle/trans/builder.rs +++ b/src/librustc/middle/trans/builder.rs @@ -17,8 +17,10 @@ use middle::trans::base; use middle::trans::common::*; use middle::trans::machine::llalign_of_pref; use middle::trans::type_::Type; -use std::libc::{c_uint, c_ulonglong, c_char}; + use collections::HashMap; +use std::libc::{c_uint, c_ulonglong, c_char}; +use std::vec_ng::Vec; use syntax::codemap::Span; pub struct Builder<'a> { @@ -542,7 +544,7 @@ impl<'a> Builder<'a> { } else { let v = ixs.iter().map(|i| C_i32(*i as i32)).collect::<Vec<ValueRef> >(); self.count_insn("gepi"); - self.inbounds_gep(base, v) + self.inbounds_gep(base, v.as_slice()) } } diff --git a/src/librustc/middle/trans/cabi.rs b/src/librustc/middle/trans/cabi.rs index df916d5800b..b8ab8d81d2f 100644 --- a/src/librustc/middle/trans/cabi.rs +++ b/src/librustc/middle/trans/cabi.rs @@ -16,6 +16,7 @@ use middle::trans::cabi_x86_64; use middle::trans::cabi_arm; use middle::trans::cabi_mips; use middle::trans::type_::Type; +use std::vec_ng::Vec; use syntax::abi::{X86, X86_64, Arm, Mips}; #[deriving(Clone, Eq)] diff --git a/src/librustc/middle/trans/cabi_arm.rs b/src/librustc/middle/trans/cabi_arm.rs index 5ae642a2404..341844a3be0 100644 --- a/src/librustc/middle/trans/cabi_arm.rs +++ b/src/librustc/middle/trans/cabi_arm.rs @@ -14,11 +14,11 @@ use lib::llvm::{llvm, Integer, Pointer, Float, Double, Struct, Array}; use lib::llvm::StructRetAttribute; use middle::trans::cabi::{FnType, ArgType}; use middle::trans::context::CrateContext; - use middle::trans::type_::Type; use std::cmp; use std::option::{None, Some}; +use std::vec_ng::Vec; fn align_up_to(off: uint, a: uint) -> uint { return (off + a - 1u) / a * a; diff --git a/src/librustc/middle/trans/cabi_mips.rs b/src/librustc/middle/trans/cabi_mips.rs index 1cc562c8f71..4bd695422a2 100644 --- a/src/librustc/middle/trans/cabi_mips.rs +++ b/src/librustc/middle/trans/cabi_mips.rs @@ -17,9 +17,10 @@ use lib::llvm::StructRetAttribute; use middle::trans::context::CrateContext; use middle::trans::context::task_llcx; use middle::trans::cabi::*; - use middle::trans::type_::Type; +use std::vec_ng::Vec; + fn align_up_to(off: uint, a: uint) -> uint { return (off + a - 1u) / a * a; } @@ -155,7 +156,7 @@ fn coerce_to_int(size: uint) -> Vec<Type> { fn struct_ty(ty: Type) -> Type { let size = ty_size(ty) * 8; let fields = coerce_to_int(size); - return Type::struct_(fields, false); + return Type::struct_(fields.as_slice(), false); } pub fn compute_abi_info(_ccx: &CrateContext, diff --git a/src/librustc/middle/trans/cabi_x86.rs b/src/librustc/middle/trans/cabi_x86.rs index 27501e370b5..194197e5011 100644 --- a/src/librustc/middle/trans/cabi_x86.rs +++ b/src/librustc/middle/trans/cabi_x86.rs @@ -15,6 +15,7 @@ use super::cabi::*; use super::common::*; use super::machine::*; use middle::trans::type_::Type; +use std::vec_ng::Vec; pub fn compute_abi_info(ccx: &CrateContext, atys: &[Type], diff --git a/src/librustc/middle/trans/cabi_x86_64.rs b/src/librustc/middle/trans/cabi_x86_64.rs index aaa32c2f4c0..d3ffa7865a2 100644 --- a/src/librustc/middle/trans/cabi_x86_64.rs +++ b/src/librustc/middle/trans/cabi_x86_64.rs @@ -18,11 +18,10 @@ use lib::llvm::{Struct, Array, Attribute}; use lib::llvm::{StructRetAttribute, ByValAttribute}; use middle::trans::cabi::*; use middle::trans::context::CrateContext; - use middle::trans::type_::Type; use std::cmp; -use std::vec; +use std::vec_ng::Vec; #[deriving(Clone, Eq)] enum RegClass { @@ -220,7 +219,7 @@ fn classify_ty(ty: Type) -> Vec<RegClass> { unify(cls, ix + off / 8u, SSEDs); } Struct => { - classify_struct(ty.field_types(), cls, ix, off); + classify_struct(ty.field_types().as_slice(), cls, ix, off); } Array => { let len = ty.array_length(); @@ -282,13 +281,13 @@ fn classify_ty(ty: Type) -> Vec<RegClass> { } let words = (ty_size(ty) + 7) / 8; - let mut cls = vec::from_elem(words, NoClass); + let mut cls = Vec::from_elem(words, NoClass); if words > 4 { - all_mem(cls); + all_mem(cls.as_mut_slice()); return cls; } - classify(ty, cls, 0, 0); - fixup(ty, cls); + classify(ty, cls.as_mut_slice(), 0, 0); + fixup(ty, cls.as_mut_slice()); return cls; } @@ -329,7 +328,7 @@ fn llreg_ty(cls: &[RegClass]) -> Type { } i += 1u; } - return Type::struct_(tys, false); + return Type::struct_(tys.as_slice(), false); } pub fn compute_abi_info(_ccx: &CrateContext, @@ -342,10 +341,13 @@ pub fn compute_abi_info(_ccx: &CrateContext, -> ArgType { if !ty.is_reg_ty() { let cls = classify_ty(ty); - if is_mem_cls(cls) { + if is_mem_cls(cls.as_slice()) { ArgType::indirect(ty, Some(attr)) } else { - ArgType::direct(ty, Some(llreg_ty(cls)), None, None) + ArgType::direct(ty, + Some(llreg_ty(cls.as_slice())), + None, + None) } } else { ArgType::direct(ty, None, None, None) diff --git a/src/librustc/middle/trans/callee.rs b/src/librustc/middle/trans/callee.rs index 97b2c0299b2..1ede187245e 100644 --- a/src/librustc/middle/trans/callee.rs +++ b/src/librustc/middle/trans/callee.rs @@ -48,6 +48,8 @@ use util::ppaux::Repr; use middle::trans::type_::Type; +use std::vec_ng::Vec; +use std::vec_ng; use syntax::ast; use syntax::abi::AbiSet; use syntax::ast_map; @@ -174,7 +176,12 @@ pub fn trans_fn_ref(bcx: &Block, def_id: ast::DefId, debug!("trans_fn_ref(def_id={}, ref_id={:?}, type_params={}, vtables={})", def_id.repr(bcx.tcx()), ref_id, type_params.repr(bcx.tcx()), vtables.repr(bcx.tcx())); - trans_fn_ref_with_vtables(bcx, def_id, ref_id, is_method, type_params, vtables) + trans_fn_ref_with_vtables(bcx, + def_id, + ref_id, + is_method, + type_params.as_slice(), + vtables) } fn trans_fn_ref_with_vtables_to_callee<'a>(bcx: &'a Block<'a>, @@ -221,7 +228,8 @@ fn resolve_default_method_vtables(bcx: &Block, None => vec::from_elem(num_method_vtables, @Vec::new()) }; - let param_vtables = @(*trait_vtables_fixed + method_vtables); + let param_vtables = @(vec_ng::append((*trait_vtables_fixed).clone(), + method_vtables)); let self_vtables = resolve_param_vtables_under_param_substs( bcx.tcx(), param_substs, impl_res.self_vtables); @@ -272,7 +280,7 @@ pub fn trans_fn_ref_with_vtables( let substs = ty::substs { regions: ty::ErasedRegions, self_ty: None, - tps: /*bad*/ type_params.to_owned() }; + tps: /*bad*/ Vec::from_slice(type_params) }; // Load the info for the appropriate trait if necessary. match ty::trait_of_method(tcx, def_id) { @@ -683,7 +691,11 @@ pub fn trans_call_inner<'a>( } // Invoke the actual rust fn and update bcx/llresult. - let (llret, b) = base::invoke(bcx, llfn, llargs, attrs, call_info); + let (llret, b) = base::invoke(bcx, + llfn, + llargs, + attrs.as_slice(), + call_info); bcx = b; llresult = llret; @@ -712,8 +724,12 @@ pub fn trans_call_inner<'a>( ArgExprs(a) => a.iter().map(|x| expr_ty(bcx, *x)).collect(), _ => fail!("expected arg exprs.") }; - bcx = foreign::trans_native_call(bcx, callee_ty, - llfn, opt_llretslot.unwrap(), llargs, arg_tys); + bcx = foreign::trans_native_call(bcx, + callee_ty, + llfn, + opt_llretslot.unwrap(), + llargs.as_slice(), + arg_tys); } // If the caller doesn't care about the result of this fn call, @@ -770,7 +786,7 @@ fn trans_args<'a>(cx: &'a Block<'a>, assert!(variadic); expr_ty_adjusted(cx, *arg_expr) } else { - arg_tys[i] + *arg_tys.get(i) }; llargs.push(unpack_result!(bcx, { trans_arg_expr(bcx, arg_ty, *arg_expr, @@ -783,7 +799,7 @@ fn trans_args<'a>(cx: &'a Block<'a>, assert!(!variadic); llargs.push(unpack_result!(bcx, { - trans_arg_expr(bcx, arg_tys[0], arg_expr, + trans_arg_expr(bcx, *arg_tys.get(0), arg_expr, arg_cleanup_scope, DontAutorefArg) })); @@ -793,7 +809,7 @@ fn trans_args<'a>(cx: &'a Block<'a>, assert_eq!(arg_tys.len(), 2); llargs.push(unpack_result!(bcx, { - trans_arg_expr(bcx, arg_tys[1], arg2_expr, + trans_arg_expr(bcx, *arg_tys.get(1), arg2_expr, arg_cleanup_scope, DoAutorefArg) })); diff --git a/src/librustc/middle/trans/cleanup.rs b/src/librustc/middle/trans/cleanup.rs index 2cf24ff123a..be5eab0e8ec 100644 --- a/src/librustc/middle/trans/cleanup.rs +++ b/src/librustc/middle/trans/cleanup.rs @@ -349,7 +349,7 @@ impl<'a> CleanupMethods<'a> for FunctionContext<'a> { assert!(self.is_valid_custom_scope(custom_scope)); let mut scopes = self.scopes.borrow_mut(); - let scope = &mut scopes.get()[custom_scope.index]; + let scope = scopes.get().get_mut(custom_scope.index); scope.cleanups.push(cleanup); scope.clear_cached_exits(); } @@ -433,7 +433,7 @@ impl<'a> CleanupHelperMethods<'a> for FunctionContext<'a> { fn is_valid_custom_scope(&self, custom_scope: CustomScopeIndex) -> bool { let scopes = self.scopes.borrow(); custom_scope.index < scopes.get().len() && - scopes.get()[custom_scope.index].kind.is_temp() + scopes.get().get(custom_scope.index).kind.is_temp() } fn trans_scope_cleanups(&self, // cannot borrow self, will recurse diff --git a/src/librustc/middle/trans/closure.rs b/src/librustc/middle/trans/closure.rs index 80cfe2f5690..f18456a674d 100644 --- a/src/librustc/middle/trans/closure.rs +++ b/src/librustc/middle/trans/closure.rs @@ -27,6 +27,7 @@ use util::ppaux::Repr; use util::ppaux::ty_to_str; use arena::TypedArena; +use std::vec_ng::Vec; use syntax::ast; use syntax::ast_util; @@ -139,12 +140,12 @@ pub fn mk_closure_tys(tcx: ty::ctxt, // is the actual types that will be stored in the map, not the // logical types as the user sees them, so by-ref upvars must be // converted to ptrs. - let bound_tys = bound_values.map(|bv| { + let bound_tys = bound_values.iter().map(|bv| { match bv.action { EnvCopy | EnvMove => bv.datum.ty, EnvRef => ty::mk_mut_ptr(tcx, bv.datum.ty) } - }); + }).collect(); let cdata_ty = ty::mk_tup(tcx, bound_tys); debug!("cdata_ty={}", ty_to_str(tcx, cdata_ty)); return cdata_ty; @@ -199,7 +200,7 @@ pub fn store_environment<'a>( let tcx = ccx.tcx; // compute the type of the closure - let cdata_ty = mk_closure_tys(tcx, bound_values); + let cdata_ty = mk_closure_tys(tcx, bound_values.as_slice()); // cbox_ty has the form of a tuple: (a, b, c) we want a ptr to a // tuple. This could be a ptr in uniq or a box or on stack, @@ -387,7 +388,11 @@ pub fn trans_expr_fn<'a>( let s = tcx.map.with_path(id, |path| { mangle_internal_name_by_path_and_seq(path, "closure") }); - let llfn = decl_internal_rust_fn(ccx, true, f.sig.inputs, f.sig.output, s); + let llfn = decl_internal_rust_fn(ccx, + true, + f.sig.inputs.as_slice(), + f.sig.output, + s); // set an inline hint for all closures set_inline_hint(llfn); @@ -396,11 +401,17 @@ pub fn trans_expr_fn<'a>( let capture_map = ccx.maps.capture_map.borrow(); capture_map.get().get_copy(&id) }; - let ClosureResult {llbox, cdata_ty, bcx} = build_closure(bcx, *cap_vars.borrow(), sigil); + let ClosureResult {llbox, cdata_ty, bcx} = + build_closure(bcx, cap_vars.borrow().as_slice(), sigil); trans_closure(ccx, decl, body, llfn, bcx.fcx.param_substs, id, [], ty::ty_fn_ret(fty), - |bcx| load_environment(bcx, cdata_ty, *cap_vars.borrow(), sigil)); + |bcx| { + load_environment(bcx, + cdata_ty, + cap_vars.borrow().as_slice(), + sigil) + }); fill_fn_pair(bcx, dest_addr, llfn, llbox); bcx @@ -447,9 +458,13 @@ pub fn get_wrapper_for_bare_fn(ccx: @CrateContext, mangle_internal_name_by_path_and_seq(path, "as_closure") }); let llfn = if is_local { - decl_internal_rust_fn(ccx, true, f.sig.inputs, f.sig.output, name) + decl_internal_rust_fn(ccx, + true, + f.sig.inputs.as_slice(), + f.sig.output, + name) } else { - decl_rust_fn(ccx, true, f.sig.inputs, f.sig.output, name) + decl_rust_fn(ccx, true, f.sig.inputs.as_slice(), f.sig.output, name) }; { @@ -470,7 +485,9 @@ pub fn get_wrapper_for_bare_fn(ccx: @CrateContext, init_function(&fcx, true, f.sig.output, None); let bcx = fcx.entry_bcx.get().unwrap(); - let args = create_datums_for_fn_args(&fcx, ty::ty_fn_args(closure_ty)); + let args = create_datums_for_fn_args(&fcx, + ty::ty_fn_args(closure_ty) + .as_slice()); let mut llargs = Vec::new(); match fcx.llretptr.get() { Some(llretptr) => { @@ -480,7 +497,7 @@ pub fn get_wrapper_for_bare_fn(ccx: @CrateContext, } llargs.extend(&mut args.iter().map(|arg| arg.val)); - let retval = Call(bcx, fn_ptr, llargs, []); + let retval = Call(bcx, fn_ptr, llargs.as_slice(), []); if type_is_zero_size(ccx, f.sig.output) || fcx.llretptr.get().is_some() { RetVoid(bcx); } else { diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs index 957b31553a2..4194f3ff57c 100644 --- a/src/librustc/middle/trans/common.rs +++ b/src/librustc/middle/trans/common.rs @@ -32,10 +32,11 @@ use util::ppaux::Repr; use util::nodemap::NodeMap; use arena::TypedArena; +use collections::HashMap; use std::c_str::ToCStr; use std::cell::{Cell, RefCell}; -use collections::HashMap; use std::libc::{c_uint, c_longlong, c_ulonglong, c_char}; +use std::vec_ng::Vec; use syntax::ast::Ident; use syntax::ast; use syntax::ast_map::{PathElem, PathName}; @@ -50,8 +51,9 @@ fn type_is_newtype_immediate(ccx: &CrateContext, ty: ty::t) -> bool { ty::ty_struct(def_id, ref substs) => { let fields = ty::struct_fields(ccx.tcx, def_id, substs); fields.len() == 1 && - fields[0].ident.name == token::special_idents::unnamed_field.name && - type_is_immediate(ccx, fields[0].mt.ty) + fields.get(0).ident.name == + token::special_idents::unnamed_field.name && + type_is_immediate(ccx, fields.get(0).mt.ty) } _ => false } @@ -781,7 +783,7 @@ pub fn align_to(cx: &Block, off: ValueRef, align: ValueRef) -> ValueRef { pub fn monomorphize_type(bcx: &Block, t: ty::t) -> ty::t { match bcx.fcx.param_substs { Some(substs) => { - ty::subst_tps(bcx.tcx(), substs.tys, substs.self_ty, t) + ty::subst_tps(bcx.tcx(), substs.tys.as_slice(), substs.self_ty, t) } _ => { assert!(!ty::type_has_params(t)); @@ -824,7 +826,7 @@ pub fn node_id_type_params(bcx: &Block, id: ast::NodeId, is_method: bool) -> Vec match bcx.fcx.param_substs { Some(substs) => { params.iter().map(|t| { - ty::subst_tps(tcx, substs.tys, substs.self_ty, *t) + ty::subst_tps(tcx, substs.tys.as_slice(), substs.self_ty, *t) }).collect() } _ => params @@ -881,10 +883,13 @@ pub fn resolve_vtable_under_param_substs(tcx: ty::ctxt, let tys = match param_substs { Some(substs) => { tys.iter().map(|t| { - ty::subst_tps(tcx, substs.tys, substs.self_ty, *t) + ty::subst_tps(tcx, + substs.tys.as_slice(), + substs.self_ty, + *t) }).collect() } - _ => tys.to_owned() + _ => Vec::from_slice(tys.as_slice()) }; typeck::vtable_static( trait_id, tys, @@ -918,10 +923,10 @@ pub fn find_vtable(tcx: ty::ctxt, typeck::param_numbered(n) => { let tables = ps.vtables .expect("vtables missing where they are needed"); - tables[n] + *tables.get(n) } }; - param_bounds[n_bound].clone() + param_bounds.get(n_bound).clone() } pub fn dummy_substs(tps: Vec<ty::t> ) -> ty::substs { diff --git a/src/librustc/middle/trans/consts.rs b/src/librustc/middle/trans/consts.rs index 62723c1c4de..f1e6fff5339 100644 --- a/src/librustc/middle/trans/consts.rs +++ b/src/librustc/middle/trans/consts.rs @@ -25,15 +25,16 @@ use middle::trans::consts; use middle::trans::expr; use middle::trans::inline; use middle::trans::machine; +use middle::trans::type_::Type; use middle::trans::type_of; use middle::ty; use util::ppaux::{Repr, ty_to_str}; -use middle::trans::type_::Type; - use std::c_str::ToCStr; use std::libc::c_uint; use std::vec; +use std::vec_ng::Vec; +use std::vec_ng; use syntax::{ast, ast_util}; pub fn const_lit(cx: &CrateContext, e: &ast::Expr, lit: ast::Lit) @@ -303,8 +304,8 @@ fn const_expr_unadjusted(cx: @CrateContext, e: &ast::Expr, let map_list = |exprs: &[@ast::Expr]| { exprs.iter().map(|&e| const_expr(cx, e, is_local)) .fold((Vec::new(), true), - |(L, all_inlineable), (val, inlineable)| { - (vec::append_one(L, val), all_inlineable && inlineable) + |(l, all_inlineable), (val, inlineable)| { + (vec_ng::append_one(l, val), all_inlineable && inlineable) }) }; unsafe { @@ -533,7 +534,7 @@ fn const_expr_unadjusted(cx: @CrateContext, e: &ast::Expr, let ety = ty::expr_ty(cx.tcx, e); let repr = adt::represent_type(cx, ety); let (vals, inlineable) = map_list(es.as_slice()); - (adt::trans_const(cx, repr, 0, vals), inlineable) + (adt::trans_const(cx, repr, 0, vals.as_slice()), inlineable) } ast::ExprStruct(_, ref fs, ref base_opt) => { let ety = ty::expr_ty(cx.tcx, e); @@ -667,7 +668,8 @@ fn const_expr_unadjusted(cx: @CrateContext, e: &ast::Expr, let ety = ty::expr_ty(cx.tcx, e); let repr = adt::represent_type(cx, ety); let (arg_vals, inlineable) = map_list(args.as_slice()); - (adt::trans_const(cx, repr, 0, arg_vals), inlineable) + (adt::trans_const(cx, repr, 0, arg_vals.as_slice()), + inlineable) } Some(ast::DefVariant(enum_did, variant_did, _)) => { let ety = ty::expr_ty(cx.tcx, e); @@ -676,8 +678,10 @@ fn const_expr_unadjusted(cx: @CrateContext, e: &ast::Expr, enum_did, variant_did); let (arg_vals, inlineable) = map_list(args.as_slice()); - (adt::trans_const(cx, repr, vinfo.disr_val, arg_vals), - inlineable) + (adt::trans_const(cx, + repr, + vinfo.disr_val, + arg_vals.as_slice()), inlineable) } _ => cx.sess.span_bug(e.span, "expected a struct or variant def") } diff --git a/src/librustc/middle/trans/context.rs b/src/librustc/middle/trans/context.rs index db6bca095b5..517bef52a99 100644 --- a/src/librustc/middle/trans/context.rs +++ b/src/librustc/middle/trans/context.rs @@ -33,6 +33,7 @@ use std::cell::{Cell, RefCell}; use std::c_str::ToCStr; use std::local_data; use std::libc::c_uint; +use std::vec_ng::Vec; use collections::{HashMap, HashSet}; use syntax::ast; use syntax::parse::token::InternedString; diff --git a/src/librustc/middle/trans/controlflow.rs b/src/librustc/middle/trans/controlflow.rs index 4def17bbea0..261660c13bb 100644 --- a/src/librustc/middle/trans/controlflow.rs +++ b/src/librustc/middle/trans/controlflow.rs @@ -343,7 +343,10 @@ pub fn trans_fail<'a>( let v_filename = PointerCast(bcx, v_filename, Type::i8p()); let args = vec!(v_str, v_filename, C_int(ccx, v_line)); let did = langcall(bcx, Some(sp), "", FailFnLangItem); - let bcx = callee::trans_lang_call(bcx, did, args, Some(expr::Ignore)).bcx; + let bcx = callee::trans_lang_call(bcx, + did, + args.as_slice(), + Some(expr::Ignore)).bcx; Unreachable(bcx); return bcx; } @@ -358,7 +361,10 @@ pub fn trans_fail_bounds_check<'a>( let (filename, line) = filename_and_line_num_from_span(bcx, sp); let args = vec!(filename, line, index, len); let did = langcall(bcx, Some(sp), "", FailBoundsCheckFnLangItem); - let bcx = callee::trans_lang_call(bcx, did, args, Some(expr::Ignore)).bcx; + let bcx = callee::trans_lang_call(bcx, + did, + args.as_slice(), + Some(expr::Ignore)).bcx; Unreachable(bcx); return bcx; } diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs index 76199e50ffa..0e7c371b43d 100644 --- a/src/librustc/middle/trans/debuginfo.rs +++ b/src/librustc/middle/trans/debuginfo.rs @@ -149,6 +149,7 @@ use std::libc::{c_uint, c_ulonglong, c_longlong}; use std::ptr; use std::sync::atomics; use std::vec; +use std::vec_ng::Vec; use syntax::codemap::{Span, Pos}; use syntax::{abi, ast, codemap, ast_util, ast_map, opt_vec}; use syntax::parse::token; @@ -725,7 +726,10 @@ pub fn create_function_debug_context(cx: &CrateContext, let return_type = match param_substs { None => return_type, Some(substs) => { - ty::subst_tps(cx.tcx, substs.tys, substs.self_ty, return_type) + ty::subst_tps(cx.tcx, + substs.tys.as_slice(), + substs.self_ty, + return_type) } }; @@ -740,7 +744,10 @@ pub fn create_function_debug_context(cx: &CrateContext, let arg_type = match param_substs { None => arg_type, Some(substs) => { - ty::subst_tps(cx.tcx, substs.tys, substs.self_ty, arg_type) + ty::subst_tps(cx.tcx, + substs.tys.as_slice(), + substs.self_ty, + arg_type) } }; @@ -771,7 +778,8 @@ pub fn create_function_debug_context(cx: &CrateContext, name_to_append_suffix_to.push_char('<'); // The list to be filled with template parameters: - let mut template_params: Vec<DIDescriptor> = vec::with_capacity(generics.ty_params.len() + 1); + let mut template_params: Vec<DIDescriptor> = + Vec::with_capacity(generics.ty_params.len() + 1); // Handle self type if has_self_type { @@ -814,12 +822,12 @@ pub fn create_function_debug_context(cx: &CrateContext, let actual_types = match param_substs { Some(param_substs) => ¶m_substs.tys, None => { - return create_DIArray(DIB(cx), template_params); + return create_DIArray(DIB(cx), template_params.as_slice()); } }; for (index, &ast::TyParam{ ident: ident, .. }) in generics.ty_params.iter().enumerate() { - let actual_type = actual_types[index]; + let actual_type = *actual_types.get(index); // Add actual type name to <...> clause of function name let actual_type_name = ppaux::ty_to_str(cx.tcx, actual_type); name_to_append_suffix_to.push_str(actual_type_name); @@ -850,7 +858,7 @@ pub fn create_function_debug_context(cx: &CrateContext, name_to_append_suffix_to.push_char('>'); - return create_DIArray(DIB(cx), template_params); + return create_DIArray(DIB(cx), template_params.as_slice()); } } @@ -1250,7 +1258,7 @@ impl RecursiveTypeDescription { set_members_of_composite_type(cx, metadata_stub, llvm_type, - member_descriptions, + member_descriptions.as_slice(), file_metadata, codemap::DUMMY_SP); return metadata_stub; @@ -1300,7 +1308,7 @@ fn prepare_tuple_metadata(cx: &CrateContext, llvm_type: tuple_llvm_type, file_metadata: file_metadata, member_description_factory: TupleMD(TupleMemberDescriptionFactory { - component_types: component_types.to_owned(), + component_types: Vec::from_slice(component_types), span: span, }) } @@ -1331,7 +1339,7 @@ impl GeneralMemberDescriptionFactory { let (variant_type_metadata, variant_llvm_type, member_desc_factory) = describe_enum_variant(cx, struct_def, - self.variants[i], + *self.variants.get(i), Some(self.discriminant_type_metadata), self.containing_scope, self.file_metadata, @@ -1343,7 +1351,7 @@ impl GeneralMemberDescriptionFactory { set_members_of_composite_type(cx, variant_type_metadata, variant_llvm_type, - member_descriptions, + member_descriptions.as_slice(), self.file_metadata, codemap::DUMMY_SP); MemberDescription { @@ -1387,8 +1395,11 @@ fn describe_enum_variant(cx: &CrateContext, file_metadata: DIFile, span: Span) -> (DICompositeType, Type, MemberDescriptionFactory) { - let variant_llvm_type = Type::struct_(struct_def.fields.map(|&t| type_of::type_of(cx, t)), - struct_def.packed); + let variant_llvm_type = + Type::struct_(struct_def.fields + .map(|&t| type_of::type_of(cx, t)) + .as_slice(), + struct_def.packed); // Could some consistency checks here: size, align, field count, discr type // Find the source code location of the variant's definition @@ -1491,7 +1502,7 @@ fn prepare_enum_metadata(cx: &CrateContext, loc.line as c_uint, bytes_to_bits(discriminant_size), bytes_to_bits(discriminant_align), - create_DIArray(DIB(cx), enumerators_metadata), + create_DIArray(DIB(cx), enumerators_metadata.as_slice()), discriminant_base_type_metadata) } }) @@ -1507,13 +1518,14 @@ fn prepare_enum_metadata(cx: &CrateContext, assert!(variants.len() == 1); let (metadata_stub, variant_llvm_type, - member_description_factory) = describe_enum_variant(cx, - struct_def, - variants[0], - None, - containing_scope, - file_metadata, - span); + member_description_factory) = + describe_enum_variant(cx, + struct_def, + *variants.get(0), + None, + containing_scope, + file_metadata, + span); UnfinishedMetadata { cache_id: cache_id_for_type(enum_type), metadata_stub: metadata_stub, @@ -1565,13 +1577,14 @@ fn prepare_enum_metadata(cx: &CrateContext, adt::NullablePointer { nonnull: ref struct_def, nndiscr, .. } => { let (metadata_stub, variant_llvm_type, - member_description_factory) = describe_enum_variant(cx, - struct_def, - variants[nndiscr], - None, - containing_scope, - file_metadata, - span); + member_description_factory) = + describe_enum_variant(cx, + struct_def, + *variants.get(nndiscr as uint), + None, + containing_scope, + file_metadata, + span); UnfinishedMetadata { cache_id: cache_id_for_type(enum_type), metadata_stub: metadata_stub, @@ -1679,7 +1692,7 @@ fn set_members_of_composite_type(cx: &CrateContext, .collect(); unsafe { - let type_array = create_DIArray(DIB(cx), member_metadata); + let type_array = create_DIArray(DIB(cx), member_metadata.as_slice()); llvm::LLVMDICompositeTypeSetTypeArray(composite_type_metadata, type_array); } } @@ -1739,7 +1752,9 @@ fn boxed_type_metadata(cx: &CrateContext, let box_llvm_type = Type::at_box(cx, content_llvm_type); let member_llvm_types = box_llvm_type.field_types(); - assert!(box_layout_is_correct(cx, member_llvm_types, content_llvm_type)); + assert!(box_layout_is_correct(cx, + member_llvm_types.as_slice(), + content_llvm_type)); let int_type = ty::mk_int(); let nil_pointer_type = ty::mk_nil_ptr(cx.tcx); @@ -1748,31 +1763,31 @@ fn boxed_type_metadata(cx: &CrateContext, let member_descriptions = [ MemberDescription { name: ~"refcnt", - llvm_type: member_llvm_types[0], + llvm_type: *member_llvm_types.get(0), type_metadata: type_metadata(cx, int_type, codemap::DUMMY_SP), offset: ComputedMemberOffset, }, MemberDescription { name: ~"drop_glue", - llvm_type: member_llvm_types[1], + llvm_type: *member_llvm_types.get(1), type_metadata: nil_pointer_type_metadata, offset: ComputedMemberOffset, }, MemberDescription { name: ~"prev", - llvm_type: member_llvm_types[2], + llvm_type: *member_llvm_types.get(2), type_metadata: nil_pointer_type_metadata, offset: ComputedMemberOffset, }, MemberDescription { name: ~"next", - llvm_type: member_llvm_types[3], + llvm_type: *member_llvm_types.get(3), type_metadata: nil_pointer_type_metadata, offset: ComputedMemberOffset, }, MemberDescription { name: ~"val", - llvm_type: member_llvm_types[4], + llvm_type: *member_llvm_types.get(4), type_metadata: content_type_metadata, offset: ComputedMemberOffset, } @@ -1859,19 +1874,19 @@ fn vec_metadata(cx: &CrateContext, let member_descriptions = [ MemberDescription { name: ~"fill", - llvm_type: member_llvm_types[0], + llvm_type: *member_llvm_types.get(0), type_metadata: int_type_metadata, offset: ComputedMemberOffset, }, MemberDescription { name: ~"alloc", - llvm_type: member_llvm_types[1], + llvm_type: *member_llvm_types.get(1), type_metadata: int_type_metadata, offset: ComputedMemberOffset, }, MemberDescription { name: ~"elements", - llvm_type: member_llvm_types[2], + llvm_type: *member_llvm_types.get(2), type_metadata: array_type_metadata, offset: ComputedMemberOffset, } @@ -1904,20 +1919,22 @@ fn vec_slice_metadata(cx: &CrateContext, let slice_type_name = ppaux::ty_to_str(cx.tcx, vec_type); let member_llvm_types = slice_llvm_type.field_types(); - assert!(slice_layout_is_correct(cx, member_llvm_types, element_type)); + assert!(slice_layout_is_correct(cx, + member_llvm_types.as_slice(), + element_type)); let data_ptr_type = ty::mk_ptr(cx.tcx, ty::mt { ty: element_type, mutbl: ast::MutImmutable }); let member_descriptions = [ MemberDescription { name: ~"data_ptr", - llvm_type: member_llvm_types[0], + llvm_type: *member_llvm_types.get(0), type_metadata: type_metadata(cx, data_ptr_type, span), offset: ComputedMemberOffset, }, MemberDescription { name: ~"length", - llvm_type: member_llvm_types[1], + llvm_type: *member_llvm_types.get(1), type_metadata: type_metadata(cx, ty::mk_uint(), span), offset: ComputedMemberOffset, }, @@ -1954,7 +1971,8 @@ fn subroutine_type_metadata(cx: &CrateContext, let loc = span_start(cx, span); let file_metadata = file_metadata(cx, loc.file.name); - let mut signature_metadata: Vec<DIType> = vec::with_capacity(signature.inputs.len() + 1); + let mut signature_metadata: Vec<DIType> = + Vec::with_capacity(signature.inputs.len() + 1); // return type signature_metadata.push(match ty::get(signature.output).sty { @@ -1971,7 +1989,7 @@ fn subroutine_type_metadata(cx: &CrateContext, llvm::LLVMDIBuilderCreateSubroutineType( DIB(cx), file_metadata, - create_DIArray(DIB(cx), signature_metadata)) + create_DIArray(DIB(cx), signature_metadata.as_slice())) }; } @@ -1993,7 +2011,7 @@ fn trait_metadata(cx: &CrateContext, ident_string.get(); // Add type and region parameters let name = ppaux::parameterized(cx.tcx, name, &substs.regions, - substs.tps, def_id, true); + substs.tps.as_slice(), def_id, true); let (containing_scope, definition_span) = get_namespace_and_span_for_item(cx, def_id); @@ -2121,7 +2139,10 @@ fn type_metadata(cx: &CrateContext, } }, ty::ty_tup(ref elements) => { - prepare_tuple_metadata(cx, t, *elements, usage_site_span).finalize(cx) + prepare_tuple_metadata(cx, + t, + elements.as_slice(), + usage_site_span).finalize(cx) } _ => cx.sess.bug(format!("debuginfo: unexpected type in type_metadata: {:?}", sty)) }; diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index 9dae8f435ec..be0faf2b644 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -71,6 +71,7 @@ use middle::trans::machine::llsize_of; use middle::trans::type_::Type; use std::vec; +use std::vec_ng::Vec; use syntax::ast; use syntax::ast_map; use syntax::codemap; @@ -743,7 +744,7 @@ fn trans_rvalue_dps_unadjusted<'a>(bcx: &'a Block<'a>, let repr = adt::represent_type(bcx.ccx(), expr_ty(bcx, expr)); let numbered_fields: Vec<(uint, @ast::Expr)> = args.iter().enumerate().map(|(i, arg)| (i, *arg)).collect(); - trans_adt(bcx, repr, 0, numbered_fields, None, dest) + trans_adt(bcx, repr, 0, numbered_fields.as_slice(), None, dest) } ast::ExprLit(lit) => { match lit.node { @@ -973,7 +974,7 @@ pub fn with_field_tys<R>(tcx: ty::ctxt, match ty::get(ty).sty { ty::ty_struct(did, ref substs) => { - op(0, struct_fields(tcx, did, substs)) + op(0, struct_fields(tcx, did, substs).as_slice()) } ty::ty_enum(_, ref substs) => { @@ -995,7 +996,9 @@ pub fn with_field_tys<R>(tcx: ty::ctxt, let variant_info = ty::enum_variant_with_id( tcx, enum_id, variant_id); op(variant_info.disr_val, - struct_fields(tcx, variant_id, substs)) + struct_fields(tcx, + variant_id, + substs).as_slice()) } _ => { tcx.sess.bug("resolve didn't map this expr to a \ diff --git a/src/librustc/middle/trans/foreign.rs b/src/librustc/middle/trans/foreign.rs index 1c794728c1e..374c85ffa6a 100644 --- a/src/librustc/middle/trans/foreign.rs +++ b/src/librustc/middle/trans/foreign.rs @@ -27,6 +27,7 @@ use middle::ty::FnSig; use middle::ty; use std::cmp; use std::libc::c_uint; +use std::vec_ng::Vec; use syntax::abi::{Cdecl, Aapcs, C, AbiSet, Win64}; use syntax::abi::{RustIntrinsic, Rust, Stdcall, Fastcall, System}; use syntax::codemap::Span; @@ -196,14 +197,14 @@ pub fn trans_native_call<'a>( ty::ty_bare_fn(ref fn_ty) => (fn_ty.abis, fn_ty.sig.clone()), _ => ccx.sess.bug("trans_native_call called on non-function type") }; - let llsig = foreign_signature(ccx, &fn_sig, passed_arg_tys); + let llsig = foreign_signature(ccx, &fn_sig, passed_arg_tys.as_slice()); let ret_def = !return_type_is_void(bcx.ccx(), fn_sig.output); let fn_type = cabi::compute_abi_info(ccx, - llsig.llarg_tys, + llsig.llarg_tys.as_slice(), llsig.llret_ty, ret_def); - let arg_tys: &[cabi::ArgType] = fn_type.arg_tys; + let arg_tys: &[cabi::ArgType] = fn_type.arg_tys.as_slice(); let mut llargs_foreign = Vec::new(); @@ -228,7 +229,8 @@ pub fn trans_native_call<'a>( let mut llarg_rust = llarg_rust; // Does Rust pass this argument by pointer? - let rust_indirect = type_of::arg_is_indirect(ccx, passed_arg_tys[i]); + let rust_indirect = type_of::arg_is_indirect(ccx, + *passed_arg_tys.get(i)); debug!("argument {}, llarg_rust={}, rust_indirect={}, arg_ty={}", i, @@ -239,7 +241,10 @@ pub fn trans_native_call<'a>( // Ensure that we always have the Rust value indirectly, // because it makes bitcasting easier. if !rust_indirect { - let scratch = base::alloca(bcx, type_of::type_of(ccx, passed_arg_tys[i]), "__arg"); + let scratch = + base::alloca(bcx, + type_of::type_of(ccx, *passed_arg_tys.get(i)), + "__arg"); Store(bcx, llarg_rust, scratch); llarg_rust = scratch; } @@ -295,7 +300,11 @@ pub fn trans_native_call<'a>( None }; let attrs = sret_attr.as_slice(); - let llforeign_retval = CallWithConv(bcx, llfn, llargs_foreign, cc, attrs); + let llforeign_retval = CallWithConv(bcx, + llfn, + llargs_foreign.as_slice(), + cc, + attrs); // If the function we just called does not use an outpointer, // store the result into the rust outpointer. Cast the outpointer @@ -466,7 +475,11 @@ pub fn trans_rust_fn_with_foreign_abi(ccx: @CrateContext, ccx.tcx.map.path_to_str(id), id, t.repr(tcx)); - let llfn = base::decl_internal_rust_fn(ccx, false, f.sig.inputs, f.sig.output, ps); + let llfn = base::decl_internal_rust_fn(ccx, + false, + f.sig.inputs.as_slice(), + f.sig.output, + ps); base::set_llvm_fn_attrs(attrs, llfn); base::trans_fn(ccx, decl, body, llfn, None, id, []); llfn @@ -579,10 +592,10 @@ pub fn trans_rust_fn_with_foreign_abi(ccx: @CrateContext, // Careful to adapt for cases where the native convention uses // a pointer and Rust does not or vice versa. for i in range(0, tys.fn_sig.inputs.len()) { - let rust_ty = tys.fn_sig.inputs[i]; - let llrust_ty = tys.llsig.llarg_tys[i]; + let rust_ty = *tys.fn_sig.inputs.get(i); + let llrust_ty = *tys.llsig.llarg_tys.get(i); let rust_indirect = type_of::arg_is_indirect(ccx, rust_ty); - let llforeign_arg_ty = tys.fn_ty.arg_tys[i]; + let llforeign_arg_ty = *tys.fn_ty.arg_tys.get(i); let foreign_indirect = llforeign_arg_ty.is_indirect(); // skip padding @@ -730,7 +743,7 @@ fn foreign_signature(ccx: &CrateContext, fn_sig: &ty::FnSig, arg_tys: &[ty::t]) * values by pointer like we do. */ - let llarg_tys = arg_tys.map(|&arg| type_of(ccx, arg)); + let llarg_tys = arg_tys.iter().map(|&arg| type_of(ccx, arg)).collect(); let llret_ty = type_of::type_of(ccx, fn_sig.output); LlvmSignature { llarg_tys: llarg_tys, @@ -750,10 +763,10 @@ fn foreign_types_for_fn_ty(ccx: &CrateContext, ty::ty_bare_fn(ref fn_ty) => fn_ty.sig.clone(), _ => ccx.sess.bug("foreign_types_for_fn_ty called on non-function type") }; - let llsig = foreign_signature(ccx, &fn_sig, fn_sig.inputs); + let llsig = foreign_signature(ccx, &fn_sig, fn_sig.inputs.as_slice()); let ret_def = !return_type_is_void(ccx, fn_sig.output); let fn_ty = cabi::compute_abi_info(ccx, - llsig.llarg_tys, + llsig.llarg_tys.as_slice(), llsig.llret_ty, ret_def); debug!("foreign_types_for_fn_ty(\ @@ -762,9 +775,9 @@ fn foreign_types_for_fn_ty(ccx: &CrateContext, fn_ty={} -> {}, \ ret_def={}", ty.repr(ccx.tcx), - ccx.tn.types_to_str(llsig.llarg_tys), + ccx.tn.types_to_str(llsig.llarg_tys.as_slice()), ccx.tn.type_to_str(llsig.llret_ty), - ccx.tn.types_to_str(fn_ty.arg_tys.map(|t| t.ty)), + ccx.tn.types_to_str(fn_ty.arg_tys.map(|t| t.ty).as_slice()), ccx.tn.type_to_str(fn_ty.ret_ty.ty), ret_def); @@ -810,9 +823,9 @@ fn lltype_for_fn_from_foreign_types(tys: &ForeignTypes) -> Type { } if tys.fn_sig.variadic { - Type::variadic_func(llargument_tys, &llreturn_ty) + Type::variadic_func(llargument_tys.as_slice(), &llreturn_ty) } else { - Type::func(llargument_tys, &llreturn_ty) + Type::func(llargument_tys.as_slice(), &llreturn_ty) } } diff --git a/src/librustc/middle/trans/glue.rs b/src/librustc/middle/trans/glue.rs index c48882f3f52..6d4737eeff1 100644 --- a/src/librustc/middle/trans/glue.rs +++ b/src/librustc/middle/trans/glue.rs @@ -245,7 +245,7 @@ fn trans_struct_drop<'a>(bcx: &'a Block<'a>, // Find and call the actual destructor let dtor_addr = get_res_dtor(bcx.ccx(), dtor_did, - class_did, substs.tps.clone()); + class_did, substs.tps.as_slice()); // The second argument is the "self" argument for drop let params = unsafe { @@ -262,7 +262,7 @@ fn trans_struct_drop<'a>(bcx: &'a Block<'a>, // destructors if the user destructor fails. let field_scope = bcx.fcx.push_custom_cleanup_scope(); - let self_arg = PointerCast(bcx, v0, params[0]); + let self_arg = PointerCast(bcx, v0, *params.get(0)); let args = vec!(self_arg); // Add all the fields as a value which needs to be cleaned at the end of diff --git a/src/librustc/middle/trans/intrinsic.rs b/src/librustc/middle/trans/intrinsic.rs index 7bd415b9d54..1a5d794c1a4 100644 --- a/src/librustc/middle/trans/intrinsic.rs +++ b/src/librustc/middle/trans/intrinsic.rs @@ -25,6 +25,7 @@ use middle::trans::machine; use middle::trans::machine::llsize_of; use middle::trans::type_::Type; use middle::ty; +use std::vec_ng::Vec; use syntax::ast; use syntax::ast_map; use syntax::parse::token; @@ -212,7 +213,7 @@ pub fn trans_intrinsic(ccx: @CrateContext, let order = if split.len() == 2 { lib::llvm::SequentiallyConsistent } else { - match split[2] { + match *split.get(2) { "relaxed" => lib::llvm::Monotonic, "acq" => lib::llvm::Acquire, "rel" => lib::llvm::Release, @@ -221,7 +222,7 @@ pub fn trans_intrinsic(ccx: @CrateContext, } }; - match split[1] { + match *split.get(1) { "cxchg" => { let old = AtomicCmpXchg(bcx, get_param(decl, first_real_arg), get_param(decl, first_real_arg + 1u), @@ -284,7 +285,7 @@ pub fn trans_intrinsic(ccx: @CrateContext, RetVoid(bcx); } "size_of" => { - let tp_ty = substs.tys[0]; + let tp_ty = *substs.tys.get(0); let lltp_ty = type_of::type_of(ccx, tp_ty); Ret(bcx, C_uint(ccx, machine::llsize_of_real(ccx, lltp_ty) as uint)); } @@ -294,7 +295,7 @@ pub fn trans_intrinsic(ccx: @CrateContext, // if the value is non-immediate. Note that, with // intrinsics, there are no argument cleanups to // concern ourselves with, so we can use an rvalue datum. - let tp_ty = substs.tys[0]; + let tp_ty = *substs.tys.get(0); let mode = appropriate_rvalue_mode(ccx, tp_ty); let src = Datum {val: get_param(decl, first_real_arg + 1u), ty: tp_ty, @@ -303,17 +304,17 @@ pub fn trans_intrinsic(ccx: @CrateContext, RetVoid(bcx); } "min_align_of" => { - let tp_ty = substs.tys[0]; + let tp_ty = *substs.tys.get(0); let lltp_ty = type_of::type_of(ccx, tp_ty); Ret(bcx, C_uint(ccx, machine::llalign_of_min(ccx, lltp_ty) as uint)); } "pref_align_of"=> { - let tp_ty = substs.tys[0]; + let tp_ty = *substs.tys.get(0); let lltp_ty = type_of::type_of(ccx, tp_ty); Ret(bcx, C_uint(ccx, machine::llalign_of_pref(ccx, lltp_ty) as uint)); } "get_tydesc" => { - let tp_ty = substs.tys[0]; + let tp_ty = *substs.tys.get(0); let static_ti = get_tydesc(ccx, tp_ty); glue::lazily_emit_visit_glue(ccx, static_ti); @@ -328,7 +329,7 @@ pub fn trans_intrinsic(ccx: @CrateContext, "type_id" => { let hash = ty::hash_crate_independent( ccx.tcx, - substs.tys[0], + *substs.tys.get(0), &ccx.link_meta.crate_hash); // NB: This needs to be kept in lockstep with the TypeId struct in // libstd/unstable/intrinsics.rs @@ -342,7 +343,7 @@ pub fn trans_intrinsic(ccx: @CrateContext, } } "init" => { - let tp_ty = substs.tys[0]; + let tp_ty = *substs.tys.get(0); let lltp_ty = type_of::type_of(ccx, tp_ty); match bcx.fcx.llretptr.get() { Some(ptr) => { Store(bcx, C_null(lltp_ty), ptr); RetVoid(bcx); } @@ -352,7 +353,7 @@ pub fn trans_intrinsic(ccx: @CrateContext, } "uninit" => { // Do nothing, this is effectively a no-op - let retty = substs.tys[0]; + let retty = *substs.tys.get(0); if type_is_immediate(ccx, retty) && !return_type_is_void(ccx, retty) { unsafe { Ret(bcx, lib::llvm::llvm::LLVMGetUndef(type_of(ccx, retty).to_ref())); @@ -365,7 +366,7 @@ pub fn trans_intrinsic(ccx: @CrateContext, RetVoid(bcx); } "transmute" => { - let (in_type, out_type) = (substs.tys[0], substs.tys[1]); + let (in_type, out_type) = (*substs.tys.get(0), *substs.tys.get(1)); let llintype = type_of::type_of(ccx, in_type); let llouttype = type_of::type_of(ccx, out_type); @@ -432,11 +433,11 @@ pub fn trans_intrinsic(ccx: @CrateContext, } } "needs_drop" => { - let tp_ty = substs.tys[0]; + let tp_ty = *substs.tys.get(0); Ret(bcx, C_bool(ty::type_needs_drop(ccx.tcx, tp_ty))); } "owns_managed" => { - let tp_ty = substs.tys[0]; + let tp_ty = *substs.tys.get(0); Ret(bcx, C_bool(ty::type_contents(ccx.tcx, tp_ty).owns_managed())); } "visit_tydesc" => { @@ -452,9 +453,11 @@ pub fn trans_intrinsic(ccx: @CrateContext, let lladdr = InBoundsGEP(bcx, ptr, [offset]); Ret(bcx, lladdr); } - "copy_nonoverlapping_memory" => copy_intrinsic(bcx, false, substs.tys[0]), - "copy_memory" => copy_intrinsic(bcx, true, substs.tys[0]), - "set_memory" => memset_intrinsic(bcx, substs.tys[0]), + "copy_nonoverlapping_memory" => { + copy_intrinsic(bcx, false, *substs.tys.get(0)) + } + "copy_memory" => copy_intrinsic(bcx, true, *substs.tys.get(0)), + "set_memory" => memset_intrinsic(bcx, *substs.tys.get(0)), "ctlz8" => count_zeros_intrinsic(bcx, "llvm.ctlz.i8"), "ctlz16" => count_zeros_intrinsic(bcx, "llvm.ctlz.i16"), "ctlz32" => count_zeros_intrinsic(bcx, "llvm.ctlz.i32"), diff --git a/src/librustc/middle/trans/meth.rs b/src/librustc/middle/trans/meth.rs index 16fa8e12f41..cfc88d163c0 100644 --- a/src/librustc/middle/trans/meth.rs +++ b/src/librustc/middle/trans/meth.rs @@ -25,16 +25,16 @@ use middle::trans::expr::{SaveIn, Ignore}; use middle::trans::expr; use middle::trans::glue; use middle::trans::monomorphize; +use middle::trans::type_::Type; use middle::trans::type_of::*; use middle::ty; use middle::typeck; use util::common::indenter; use util::ppaux::Repr; -use middle::trans::type_::Type; - use std::c_str::ToCStr; -use std::vec; +use std::vec_ng::Vec; +use std::vec_ng; use syntax::parse::token; use syntax::{ast, ast_map, visit}; @@ -202,18 +202,21 @@ pub fn trans_static_method_callee(bcx: &Block, let vtbls = ccx.maps.vtable_map.borrow().get().get_copy(&expr_id); let vtbls = resolve_vtables_in_fn_ctxt(bcx.fcx, vtbls); - match vtbls[bound_index][0] { - typeck::vtable_static(impl_did, ref rcvr_substs, rcvr_origins) => { + match vtbls.get(bound_index).get(0) { + &typeck::vtable_static(impl_did, ref rcvr_substs, rcvr_origins) => { assert!(rcvr_substs.iter().all(|t| !ty::type_needs_infer(*t))); let mth_id = method_with_name(ccx, impl_did, mname); let (callee_substs, callee_origins) = combine_impl_and_methods_tps( bcx, mth_id, expr_id, false, - *rcvr_substs, rcvr_origins); + rcvr_substs.as_slice(), rcvr_origins); - let llfn = trans_fn_ref_with_vtables(bcx, mth_id, expr_id, - false, callee_substs, + let llfn = trans_fn_ref_with_vtables(bcx, + mth_id, + expr_id, + false, + callee_substs.as_slice(), Some(callee_origins)); let callee_ty = node_id_type(bcx, expr_id); @@ -268,14 +271,14 @@ fn trans_monomorphized_callee<'a>(bcx: &'a Block<'a>, let (callee_substs, callee_origins) = combine_impl_and_methods_tps( bcx, mth_id, expr_id, true, - *rcvr_substs, rcvr_origins); + rcvr_substs.as_slice(), rcvr_origins); // translate the function let llfn = trans_fn_ref_with_vtables(bcx, mth_id, expr_id, true, - callee_substs, + callee_substs.as_slice(), Some(callee_origins)); Callee { bcx: bcx, data: Fn(llfn) } @@ -316,8 +319,8 @@ fn combine_impl_and_methods_tps(bcx: &Block, let node_substs = node_id_type_params(bcx, expr_id, is_method); debug!("rcvr_substs={:?}", rcvr_substs.repr(ccx.tcx)); let ty_substs - = vec_ng::append(rcvr_substs.to_owned(), - node_substs.tailn(node_substs.len() - n_m_tps)); + = vec_ng::append(Vec::from_slice(rcvr_substs), + node_substs.tailn(node_substs.len() - n_m_tps)); debug!("n_m_tps={:?}", n_m_tps); debug!("node_substs={:?}", node_substs.repr(ccx.tcx)); debug!("ty_substs={:?}", ty_substs.repr(ccx.tcx)); @@ -327,11 +330,11 @@ fn combine_impl_and_methods_tps(bcx: &Block, // exist, in which case we need to make them. let r_m_origins = match node_vtables(bcx, expr_id) { Some(vt) => vt, - None => @vec::from_elem(node_substs.len(), @Vec::new()) + None => @Vec::from_elem(node_substs.len(), @Vec::new()) }; let vtables - = @vec_ng::append(rcvr_origins.to_owned(), - r_m_origins.tailn(r_m_origins.len() - n_m_tps)); + = @vec_ng::append(Vec::from_slice(rcvr_origins.as_slice()), + r_m_origins.tailn(r_m_origins.len() - n_m_tps)); (ty_substs, vtables) } @@ -460,7 +463,7 @@ pub fn get_vtable(bcx: &Block, let _icx = push_ctxt("meth::get_vtable"); // Check the cache. - let hash_id = (self_ty, vtable_id(ccx, &origins[0])); + let hash_id = (self_ty, vtable_id(ccx, origins.get(0))); { let vtables = ccx.vtables.borrow(); match vtables.get().find(&hash_id) { @@ -470,18 +473,25 @@ pub fn get_vtable(bcx: &Block, } // Not in the cache. Actually build it. - let methods = origins.flat_map(|origin| { + let mut methods = Vec::new(); + for origin in origins.iter() { match *origin { typeck::vtable_static(id, ref substs, sub_vtables) => { - emit_vtable_methods(bcx, id, *substs, sub_vtables) + let vtable_methods = emit_vtable_methods(bcx, + id, + substs.as_slice(), + sub_vtables); + for vtable_method in vtable_methods.move_iter() { + methods.push(vtable_method) + } } _ => ccx.sess.bug("get_vtable: expected a static origin"), } - }); + } // Generate a destructor for the vtable. let drop_glue = glue::get_drop_glue(ccx, self_ty); - let vtable = make_vtable(ccx, drop_glue, methods); + let vtable = make_vtable(ccx, drop_glue, methods.as_slice()); let mut vtables = ccx.vtables.borrow_mut(); vtables.get().insert(hash_id, vtable); @@ -501,7 +511,7 @@ pub fn make_vtable(ccx: &CrateContext, components.push(ptr) } - let tbl = C_struct(components, false); + let tbl = C_struct(components.as_slice(), false); let sym = token::gensym("vtable"); let vt_gvar = format!("vtable{}", sym).with_c_str(|buf| { llvm::LLVMAddGlobal(ccx.llmod, val_ty(tbl).to_ref(), buf) @@ -589,7 +599,7 @@ pub fn trans_trait_cast<'a>(bcx: &'a Block<'a>, *vtable_map.get().get(&id) }; let res = resolve_vtables_in_fn_ctxt(bcx.fcx, res); - res[0] + *res.get(0) }; let vtable = get_vtable(bcx, v_ty, origins); let llvtabledest = GEPi(bcx, lldest, [0u, abi::trt_field_vtable]); diff --git a/src/librustc/middle/trans/monomorphize.rs b/src/librustc/middle/trans/monomorphize.rs index e5774a5cd6e..ecfc1aae3d9 100644 --- a/src/librustc/middle/trans/monomorphize.rs +++ b/src/librustc/middle/trans/monomorphize.rs @@ -23,6 +23,7 @@ use middle::ty; use middle::typeck; use util::ppaux::Repr; +use std::vec_ng::Vec; use syntax::ast; use syntax::ast_map; use syntax::ast_util::local_def; @@ -51,7 +52,7 @@ pub fn monomorphic_fn(ccx: @CrateContext, let mut must_cast = false; let psubsts = @param_substs { - tys: real_substs.tps.to_owned(), + tys: real_substs.tps.clone(), vtables: vtables, self_ty: real_substs.self_ty.clone(), self_vtables: self_vtables @@ -124,7 +125,7 @@ pub fn monomorphic_fn(ccx: @CrateContext, debug!("monomorphic_fn about to subst into {}", llitem_ty.repr(ccx.tcx)); let mono_ty = match is_static_provided { - None => ty::subst_tps(ccx.tcx, psubsts.tys, + None => ty::subst_tps(ccx.tcx, psubsts.tys.as_slice(), psubsts.self_ty, llitem_ty), Some(num_method_ty_params) => { // Static default methods are a little unfortunate, in @@ -186,7 +187,7 @@ pub fn monomorphic_fn(ccx: @CrateContext, let mk_lldecl = || { let lldecl = decl_internal_rust_fn(ccx, false, - f.sig.inputs, + f.sig.inputs.as_slice(), f.sig.output, s); let mut monomorphized = ccx.monomorphized.borrow_mut(); monomorphized.get().insert(hash_id, lldecl); diff --git a/src/librustc/middle/trans/reflect.rs b/src/librustc/middle/trans/reflect.rs index 00009424545..6c87ae94ba4 100644 --- a/src/librustc/middle/trans/reflect.rs +++ b/src/librustc/middle/trans/reflect.rs @@ -28,7 +28,8 @@ use util::ppaux::ty_to_str; use arena::TypedArena; use std::libc::c_uint; use std::option::{Some,None}; -use std::vec; +use std::vec_ng::Vec; +use std::vec_ng; use syntax::ast::DefId; use syntax::ast; use syntax::ast_map; @@ -93,12 +94,12 @@ impl<'a> Reflector<'a> { pub fn visit(&mut self, ty_name: &str, args: &[ValueRef]) { let fcx = self.bcx.fcx; let tcx = self.bcx.tcx(); - let mth_idx = ty::method_idx( - token::str_to_ident(~"visit_" + ty_name), - *self.visitor_methods).expect(format!("couldn't find visit method \ - for {}", ty_name)); + let mth_idx = ty::method_idx(token::str_to_ident(~"visit_" + ty_name), + self.visitor_methods.as_slice()).expect( + format!("couldn't find visit method for {}", ty_name)); let mth_ty = - ty::mk_bare_fn(tcx, self.visitor_methods[mth_idx].fty.clone()); + ty::mk_bare_fn(tcx, + self.visitor_methods.get(mth_idx).fty.clone()); let v = self.visitor_val; debug!("passing {} args:", args.len()); let mut bcx = self.bcx; @@ -134,7 +135,8 @@ impl<'a> Reflector<'a> { match vstore { ty::vstore_fixed(n) => { let extra = vec_ng::append(vec!(self.c_uint(n)), - self.c_size_and_align(t)); + self.c_size_and_align(t) + .as_slice()); (~"fixed", extra) } ty::vstore_slice(_) => (~"slice", Vec::new()), @@ -172,18 +174,18 @@ impl<'a> Reflector<'a> { ty::ty_unboxed_vec(ref mt) => { let values = self.c_mt(mt); - self.visit("vec", values) + self.visit("vec", values.as_slice()) } // Should rename to str_*/vec_*. ty::ty_str(vst) => { let (name, extra) = self.vstore_name_and_extra(t, vst); - self.visit(~"estr_" + name, extra) + self.visit(~"estr_" + name, extra.as_slice()) } ty::ty_vec(ref mt, vst) => { let (name, extra) = self.vstore_name_and_extra(t, vst); - let extra = extra + self.c_mt(mt); - self.visit(~"evec_" + name, extra) + let extra = vec_ng::append(extra, self.c_mt(mt).as_slice()); + self.visit(~"evec_" + name, extra.as_slice()) } // Should remove mt from box and uniq. ty::ty_box(typ) => { @@ -191,31 +193,31 @@ impl<'a> Reflector<'a> { ty: typ, mutbl: ast::MutImmutable, }); - self.visit("box", extra) + self.visit("box", extra.as_slice()) } ty::ty_uniq(typ) => { let extra = self.c_mt(&ty::mt { ty: typ, mutbl: ast::MutImmutable, }); - self.visit("uniq", extra) + self.visit("uniq", extra.as_slice()) } ty::ty_ptr(ref mt) => { let extra = self.c_mt(mt); - self.visit("ptr", extra) + self.visit("ptr", extra.as_slice()) } ty::ty_rptr(_, ref mt) => { let extra = self.c_mt(mt); - self.visit("rptr", extra) + self.visit("rptr", extra.as_slice()) } ty::ty_tup(ref tys) => { - let extra = vec!(self.c_uint(tys.len())) - + self.c_size_and_align(t); - self.bracketed("tup", extra, |this| { + let extra = vec_ng::append(vec!(self.c_uint(tys.len())), + self.c_size_and_align(t).as_slice()); + self.bracketed("tup", extra.as_slice(), |this| { for (i, t) in tys.iter().enumerate() { let extra = vec!(this.c_uint(i), this.c_tydesc(*t)); - this.visit("tup_field", extra); + this.visit("tup_field", extra.as_slice()); } }) } @@ -230,9 +232,9 @@ impl<'a> Reflector<'a> { self.c_uint(sigilval), self.c_uint(fty.sig.inputs.len()), self.c_uint(retval)); - self.visit("enter_fn", extra); + self.visit("enter_fn", extra.as_slice()); self.visit_sig(retval, &fty.sig); - self.visit("leave_fn", extra); + self.visit("leave_fn", extra.as_slice()); } // FIXME (#2594): fetch constants out of intrinsic:: for the @@ -245,33 +247,33 @@ impl<'a> Reflector<'a> { self.c_uint(sigilval), self.c_uint(fty.sig.inputs.len()), self.c_uint(retval)); - self.visit("enter_fn", extra); + self.visit("enter_fn", extra.as_slice()); self.visit_sig(retval, &fty.sig); - self.visit("leave_fn", extra); + self.visit("leave_fn", extra.as_slice()); } ty::ty_struct(did, ref substs) => { let fields = ty::struct_fields(tcx, did, substs); let mut named_fields = false; if !fields.is_empty() { - named_fields = - fields[0].ident.name != special_idents::unnamed_field.name; + named_fields = fields.get(0).ident.name != + special_idents::unnamed_field.name; } - let extra = vec!( + let extra = vec_ng::append(vec!( self.c_slice(token::intern_and_get_ident(ty_to_str(tcx, t))), self.c_bool(named_fields), self.c_uint(fields.len()) - ) + self.c_size_and_align(t); - self.bracketed("class", extra, |this| { + ), self.c_size_and_align(t).as_slice()); + self.bracketed("class", extra.as_slice(), |this| { for (i, field) in fields.iter().enumerate() { - let extra = vec!( + let extra = vec_ng::append(vec!( this.c_uint(i), this.c_slice(token::get_ident(field.ident)), this.c_bool(named_fields) - ) + this.c_mt(&field.mt); - this.visit("class_field", extra); + ), this.c_mt(&field.mt).as_slice()); + this.visit("class_field", extra.as_slice()); } }) } @@ -319,16 +321,20 @@ impl<'a> Reflector<'a> { llfdecl }; - let enum_args = vec!(self.c_uint(variants.len()), make_get_disr()) - + self.c_size_and_align(t); - self.bracketed("enum", enum_args, |this| { + let enum_args = vec_ng::append(vec!(self.c_uint(variants.len()), + make_get_disr()), + self.c_size_and_align(t) + .as_slice()); + self.bracketed("enum", enum_args.as_slice(), |this| { for (i, v) in variants.iter().enumerate() { let name = token::get_ident(v.name); let variant_args = vec!(this.c_uint(i), C_u64(v.disr_val), this.c_uint(v.args.len()), this.c_slice(name)); - this.bracketed("enum_variant", variant_args, |this| { + this.bracketed("enum_variant", + variant_args.as_slice(), + |this| { for (j, a) in v.args.iter().enumerate() { let bcx = this.bcx; let null = C_null(llptrty); @@ -337,7 +343,8 @@ impl<'a> Reflector<'a> { let field_args = vec!(this.c_uint(j), offset, this.c_tydesc(*a)); - this.visit("enum_variant_field", field_args); + this.visit("enum_variant_field", + field_args.as_slice()); } }) } @@ -356,7 +363,7 @@ impl<'a> Reflector<'a> { ty::ty_err => self.leaf("err"), ty::ty_param(ref p) => { let extra = vec!(self.c_uint(p.idx)); - self.visit("param", extra) + self.visit("param", extra.as_slice()) } ty::ty_self(..) => self.leaf("self") } @@ -368,12 +375,12 @@ impl<'a> Reflector<'a> { let extra = vec!(self.c_uint(i), self.c_uint(modeval), self.c_tydesc(*arg)); - self.visit("fn_input", extra); + self.visit("fn_input", extra.as_slice()); } let extra = vec!(self.c_uint(retval), self.c_bool(sig.variadic), self.c_tydesc(sig.output)); - self.visit("fn_output", extra); + self.visit("fn_output", extra.as_slice()); } } diff --git a/src/librustc/middle/trans/type_.rs b/src/librustc/middle/trans/type_.rs index 03114ca2842..3127231259d 100644 --- a/src/librustc/middle/trans/type_.rs +++ b/src/librustc/middle/trans/type_.rs @@ -20,8 +20,9 @@ use syntax::ast; use syntax::abi::{Architecture, X86, X86_64, Arm, Mips}; use std::c_str::ToCStr; -use std::vec; use std::cast; +use std::vec; +use std::vec_ng::Vec; use std::libc::{c_uint}; @@ -301,8 +302,8 @@ impl Type { if n_elts == 0 { return Vec::new(); } - let mut elts = vec::from_elem(n_elts, 0 as TypeRef); - llvm::LLVMGetStructElementTypes(self.to_ref(), &mut elts[0]); + let mut elts = Vec::from_elem(n_elts, 0 as TypeRef); + llvm::LLVMGetStructElementTypes(self.to_ref(), elts.get_mut(0)); cast::transmute(elts) } } @@ -314,7 +315,7 @@ impl Type { pub fn func_params(&self) -> Vec<Type> { unsafe { let n_args = llvm::LLVMCountParamTypes(self.to_ref()) as uint; - let args = vec::from_elem(n_args, 0 as TypeRef); + let args = Vec::from_elem(n_args, 0 as TypeRef); llvm::LLVMGetParamTypes(self.to_ref(), args.as_ptr()); cast::transmute(args) } diff --git a/src/librustc/middle/trans/type_of.rs b/src/librustc/middle/trans/type_of.rs index 36da8be0b5d..de3aff0fff6 100644 --- a/src/librustc/middle/trans/type_of.rs +++ b/src/librustc/middle/trans/type_of.rs @@ -19,6 +19,7 @@ use util::ppaux::Repr; use middle::trans::type_::Type; +use std::vec_ng::Vec; use syntax::ast; use syntax::opt_vec; @@ -62,9 +63,9 @@ pub fn type_of_rust_fn(cx: &CrateContext, has_env: bool, // Use the output as the actual return value if it's immediate. if use_out_pointer || return_type_is_void(cx, output) { - Type::func(atys, &Type::void()) + Type::func(atys.as_slice(), &Type::void()) } else { - Type::func(atys, &lloutputtype) + Type::func(atys.as_slice(), &lloutputtype) } } @@ -72,11 +73,14 @@ pub fn type_of_rust_fn(cx: &CrateContext, has_env: bool, pub fn type_of_fn_from_ty(cx: &CrateContext, fty: ty::t) -> Type { match ty::get(fty).sty { ty::ty_closure(ref f) => { - type_of_rust_fn(cx, true, f.sig.inputs, f.sig.output) + type_of_rust_fn(cx, true, f.sig.inputs.as_slice(), f.sig.output) } ty::ty_bare_fn(ref f) => { if f.abis.is_rust() || f.abis.is_intrinsic() { - type_of_rust_fn(cx, false, f.sig.inputs, f.sig.output) + type_of_rust_fn(cx, + false, + f.sig.inputs.as_slice(), + f.sig.output) } else { foreign::lltype_for_foreign_fn(cx, fty) } @@ -216,7 +220,7 @@ pub fn type_of(cx: &CrateContext, t: ty::t) -> Type { // avoids creating more than one copy of the enum when one // of the enum's variants refers to the enum itself. let repr = adt::represent_type(cx, t); - let name = llvm_type_name(cx, an_enum, did, substs.tps); + let name = llvm_type_name(cx, an_enum, did, substs.tps.as_slice()); adt::incomplete_type_of(cx, repr, name) } ty::ty_box(typ) => { @@ -277,7 +281,10 @@ pub fn type_of(cx: &CrateContext, t: ty::t) -> Type { // in *after* placing it into the type cache. This prevents // infinite recursion with recursive struct types. let repr = adt::represent_type(cx, t); - let name = llvm_type_name(cx, a_struct, did, substs.tps); + let name = llvm_type_name(cx, + a_struct, + did, + substs.tps.as_slice()); adt::incomplete_type_of(cx, repr, name) } } diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index ac1ac810555..4d0f6704379 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -40,7 +40,8 @@ use std::fmt; use std::hash::{Hash, sip}; use std::ops; use std::rc::Rc; -use std::vec; +use std::vec_ng::Vec; +use std::vec_ng; use collections::{HashMap, HashSet}; use syntax::ast::*; use syntax::ast_util::{is_local, lit_is_str}; @@ -279,7 +280,7 @@ pub struct ctxt_ { // of this node. This only applies to nodes that refer to entities // parameterized by type parameters, such as generic fns, types, or // other items. - node_type_substs: RefCell<NodeMap<vec!(t)>>, + node_type_substs: RefCell<NodeMap<Vec<t>>>, // Maps from a method to the method "descriptor" methods: RefCell<DefIdMap<@Method>>, @@ -460,7 +461,7 @@ pub struct ClosureTy { #[deriving(Clone, Eq, Hash)] pub struct FnSig { binder_id: ast::NodeId, - inputs: vec!(t), + inputs: Vec<t>, output: t, variadic: bool } @@ -683,7 +684,7 @@ pub enum RegionSubsts { #[deriving(Clone, Eq, Hash)] pub struct substs { self_ty: Option<ty::t>, - tps: vec!(t), + tps: Vec<t>, regions: RegionSubsts, } @@ -755,7 +756,7 @@ pub enum sty { ty_closure(ClosureTy), ty_trait(DefId, substs, TraitStore, ast::Mutability, BuiltinBounds), ty_struct(DefId, substs), - ty_tup(vec!(t)), + ty_tup(Vec<t>), ty_param(param_ty), // type parameter ty_self(DefId), /* special, implicit `self` type parameter; @@ -1410,7 +1411,7 @@ pub fn mk_mut_unboxed_vec(cx: ctxt, ty: t) -> t { mk_t(cx, ty_unboxed_vec(mt {ty: ty, mutbl: ast::MutImmutable})) } -pub fn mk_tup(cx: ctxt, ts: vec!(t)) -> t { mk_t(cx, ty_tup(ts)) } +pub fn mk_tup(cx: ctxt, ts: Vec<t>) -> t { mk_t(cx, ty_tup(ts)) } pub fn mk_closure(cx: ctxt, fty: ClosureTy) -> t { mk_t(cx, ty_closure(fty)) @@ -1431,7 +1432,7 @@ pub fn mk_ctor_fn(cx: ctxt, abis: AbiSet::Rust(), sig: FnSig { binder_id: binder_id, - inputs: input_args, + inputs: Vec::from_slice(input_args), output: output, variadic: false } @@ -1665,7 +1666,7 @@ pub fn simd_type(cx: ctxt, ty: t) -> t { match get(ty).sty { ty_struct(did, ref substs) => { let fields = lookup_struct_fields(cx, did); - lookup_field_type(cx, did, fields[0].id, substs) + lookup_field_type(cx, did, fields.get(0).id, substs) } _ => fail!("simd_type called on invalid type") } @@ -1683,7 +1684,7 @@ pub fn simd_size(cx: ctxt, ty: t) -> uint { pub fn get_element_type(ty: t, i: uint) -> t { match get(ty).sty { - ty_tup(ref ts) => return ts[i], + ty_tup(ref ts) => return *ts.get(i), _ => fail!("get_element_type called on invalid type") } } @@ -2196,7 +2197,8 @@ pub fn type_contents(cx: ctxt, ty: t) -> TypeContents { ty_struct(did, ref substs) => { let flds = struct_fields(cx, did, substs); let mut res = - TypeContents::union(flds, |f| tc_mt(cx, f.mt, cache)); + TypeContents::union(flds.as_slice(), + |f| tc_mt(cx, f.mt, cache)); if ty::has_dtor(cx, did) { res = res | TC::OwnsDtor; } @@ -2204,14 +2206,16 @@ pub fn type_contents(cx: ctxt, ty: t) -> TypeContents { } ty_tup(ref tys) => { - TypeContents::union(*tys, |ty| tc_ty(cx, *ty, cache)) + TypeContents::union(tys.as_slice(), + |ty| tc_ty(cx, *ty, cache)) } ty_enum(did, ref substs) => { let variants = substd_enum_variants(cx, did, substs); let res = - TypeContents::union(variants, |variant| { - TypeContents::union(variant.args, |arg_ty| { + TypeContents::union(variants.as_slice(), |variant| { + TypeContents::union(variant.args.as_slice(), + |arg_ty| { tc_ty(cx, *arg_ty, cache) }) }); @@ -2231,7 +2235,7 @@ pub fn type_contents(cx: ctxt, ty: t) -> TypeContents { let tp_def = ty_param_defs.get().get(&p.def_id.node); kind_bounds_to_contents(cx, tp_def.bounds.builtin_bounds, - tp_def.bounds.trait_bounds) + tp_def.bounds.trait_bounds.as_slice()) } ty_self(def_id) => { @@ -2924,7 +2928,7 @@ pub fn replace_closure_return_type(tcx: ctxt, fn_type: t, ret_type: t) -> t { // Returns a vec of all the input and output types of fty. pub fn tys_in_fn_sig(sig: &FnSig) -> Vec<t> { - vec::append_one(sig.inputs.map(|a| *a), sig.output) + vec_ng::append_one(sig.inputs.map(|a| *a), sig.output) } // Type accessors for AST nodes @@ -3211,7 +3215,7 @@ impl AutoRef { } pub struct ParamsTy { - params: vec!(t), + params: Vec<t>, ty: t } @@ -3249,7 +3253,7 @@ pub fn method_call_type_param_defs(tcx: ctxt, origin: typeck::MethodOrigin) let trait_type_param_defs = lookup_trait_def(tcx, trt_id).generics.type_param_defs(); Rc::new(vec_ng::append( - trait_type_param_defs.to_owned(), + Vec::from_slice(trait_type_param_defs), ty::trait_method(tcx, trt_id, n_mth).generics.type_param_defs())) @@ -3430,9 +3434,11 @@ pub fn expr_kind(tcx: ctxt, None => fail!("no def for place"), }; let def_id = ast_util::def_id_of_def(definition); - match tcx.lang_items.items[ExchangeHeapLangItem as uint] { - Some(item_def_id) if def_id == item_def_id => RvalueDatumExpr, - Some(_) | None => RvalueDpsExpr, + match tcx.lang_items.items.get(ExchangeHeapLangItem as uint) { + &Some(item_def_id) if def_id == item_def_id => { + RvalueDatumExpr + } + &Some(_) | &None => RvalueDpsExpr, } } @@ -3829,7 +3835,7 @@ fn lookup_locally_or_in_crate_store<V:Clone>( } pub fn trait_method(cx: ctxt, trait_did: ast::DefId, idx: uint) -> @Method { - let method_def_id = ty::trait_method_def_ids(cx, trait_did)[idx]; + let method_def_id = *ty::trait_method_def_ids(cx, trait_did).get(idx); ty::method(cx, method_def_id) } @@ -3932,7 +3938,7 @@ pub fn ty_to_def_id(ty: t) -> Option<ast::DefId> { // Enum information #[deriving(Clone)] pub struct VariantInfo { - args: vec!(t), + args: Vec<t>, arg_names: Option<Vec<ast::Ident> >, ctor_ty: t, name: ast::Ident, @@ -3953,7 +3959,11 @@ impl VariantInfo { match ast_variant.node.kind { ast::TupleVariantKind(ref args) => { - let arg_tys = if args.len() > 0 { ty_fn_args(ctor_ty).map(|a| *a) } else { Vec::new() }; + let arg_tys = if args.len() > 0 { + ty_fn_args(ctor_ty).map(|a| *a) + } else { + Vec::new() + }; return VariantInfo { args: arg_tys, @@ -3972,13 +3982,13 @@ impl VariantInfo { assert!(fields.len() > 0); let arg_tys = ty_fn_args(ctor_ty).map(|a| *a); - let arg_names = fields.map(|field| { + let arg_names = fields.iter().map(|field| { match field.node.kind { NamedField(ident, _) => ident, UnnamedField => cx.sess.bug( "enum_variants: all fields in struct must have a name") } - }); + }).collect(); return VariantInfo { args: arg_tys, @@ -4168,8 +4178,10 @@ pub fn enum_variant_with_id(cx: ctxt, let variants = enum_variants(cx, enum_id); let mut i = 0; while i < variants.len() { - let variant = variants[i]; - if variant.id == variant_id { return variant; } + let variant = *variants.get(i); + if variant.id == variant_id { + return variant + } i += 1; } cx.sess.bug("enum_variant_with_id(): no variant exists with that ID"); @@ -4341,7 +4353,7 @@ pub fn lookup_struct_field(cx: ctxt, } fn struct_field_tys(fields: &[StructField]) -> Vec<field_ty> { - fields.map(|field| { + fields.iter().map(|field| { match field.node.kind { NamedField(ident, visibility) => { field_ty { @@ -4358,7 +4370,7 @@ fn struct_field_tys(fields: &[StructField]) -> Vec<field_ty> { } } } - }) + }).collect() } // Returns a list of fields corresponding to the struct's items. trans uses @@ -4450,7 +4462,7 @@ pub fn is_binopable(cx: ctxt, ty: t, op: ast::BinOp) -> bool { } pub fn ty_params_to_tys(tcx: ty::ctxt, generics: &ast::Generics) -> Vec<t> { - vec::from_fn(generics.ty_params.len(), |i| { + Vec::from_fn(generics.ty_params.len(), |i| { let id = generics.ty_params.get(i).id; ty::mk_param(tcx, i, ast_util::local_def(id)) }) @@ -4502,7 +4514,7 @@ pub fn normalize_ty(cx: ctxt, t: t) -> t { -> substs { substs { regions: ErasedRegions, self_ty: ty_fold::fold_opt_ty(self, substs.self_ty), - tps: ty_fold::fold_ty_vec(self, substs.tps) } + tps: ty_fold::fold_ty_vec(self, substs.tps.as_slice()) } } fn fold_sig(&mut self, @@ -4510,10 +4522,12 @@ pub fn normalize_ty(cx: ctxt, t: t) -> t { -> ty::FnSig { // The binder-id is only relevant to bound regions, which // are erased at trans time. - ty::FnSig { binder_id: ast::DUMMY_NODE_ID, - inputs: ty_fold::fold_ty_vec(self, sig.inputs), - output: self.fold_ty(sig.output), - variadic: sig.variadic } + ty::FnSig { + binder_id: ast::DUMMY_NODE_ID, + inputs: ty_fold::fold_ty_vec(self, sig.inputs.as_slice()), + output: self.fold_ty(sig.output), + variadic: sig.variadic, + } } } } @@ -4615,14 +4629,15 @@ pub fn each_bound_trait_and_supertraits(tcx: ctxt, // Add the given trait ty to the hash map while i < trait_refs.len() { debug!("each_bound_trait_and_supertraits(i={:?}, trait_ref={})", - i, trait_refs[i].repr(tcx)); + i, trait_refs.get(i).repr(tcx)); - if !f(trait_refs[i]) { + if !f(*trait_refs.get(i)) { return false; } // Add supertraits to supertrait_set - let supertrait_refs = trait_ref_supertraits(tcx, trait_refs[i]); + let supertrait_refs = trait_ref_supertraits(tcx, + *trait_refs.get(i)); for &supertrait_ref in supertrait_refs.iter() { debug!("each_bound_trait_and_supertraits(supertrait_ref={})", supertrait_ref.repr(tcx)); @@ -4646,7 +4661,7 @@ pub fn count_traits_and_supertraits(tcx: ctxt, let mut total = 0; for type_param_def in type_param_defs.iter() { each_bound_trait_and_supertraits( - tcx, type_param_def.bounds.trait_bounds, |_| { + tcx, type_param_def.bounds.trait_bounds.as_slice(), |_| { total += 1; true }); @@ -5078,7 +5093,7 @@ pub fn construct_parameter_environment( let num_item_type_params = item_type_params.len(); let num_method_type_params = method_type_params.len(); let num_type_params = num_item_type_params + num_method_type_params; - let type_params = vec::from_fn(num_type_params, |i| { + let type_params = Vec::from_fn(num_type_params, |i| { let def_id = if i < num_item_type_params { item_type_params[i].def_id } else { @@ -5106,7 +5121,7 @@ pub fn construct_parameter_environment( // let self_bound_substd = self_bound.map(|b| b.subst(tcx, &free_substs)); - let type_param_bounds_substd = vec::from_fn(num_type_params, |i| { + let type_param_bounds_substd = Vec::from_fn(num_type_params, |i| { if i < num_item_type_params { (*item_type_params[i].bounds).subst(tcx, &free_substs) } else { diff --git a/src/librustc/middle/ty_fold.rs b/src/librustc/middle/ty_fold.rs index 859423d9523..769924c02c8 100644 --- a/src/librustc/middle/ty_fold.rs +++ b/src/librustc/middle/ty_fold.rs @@ -13,6 +13,8 @@ use middle::ty; use util::ppaux::Repr; +use std::vec_ng::Vec; + pub trait TypeFolder { fn tcx(&self) -> ty::ctxt; @@ -84,10 +86,8 @@ pub fn fold_opt_ty<T:TypeFolder>(this: &mut T, t.map(|t| this.fold_ty(t)) } -pub fn fold_ty_vec<T:TypeFolder>(this: &mut T, - tys: &[ty::t]) - -> Vec<ty::t> { - tys.map(|t| this.fold_ty(*t)) +pub fn fold_ty_vec<T:TypeFolder>(this: &mut T, tys: &[ty::t]) -> Vec<ty::t> { + tys.iter().map(|t| this.fold_ty(*t)).collect() } pub fn super_fold_ty<T:TypeFolder>(this: &mut T, @@ -110,14 +110,14 @@ pub fn super_fold_substs<T:TypeFolder>(this: &mut T, ty::substs { regions: regions, self_ty: fold_opt_ty(this, substs.self_ty), - tps: fold_ty_vec(this, substs.tps), } + tps: fold_ty_vec(this, substs.tps.as_slice()), } } pub fn super_fold_sig<T:TypeFolder>(this: &mut T, sig: &ty::FnSig) -> ty::FnSig { ty::FnSig { binder_id: sig.binder_id, - inputs: fold_ty_vec(this, sig.inputs), + inputs: fold_ty_vec(this, sig.inputs.as_slice()), output: this.fold_ty(sig.output), variadic: sig.variadic } } @@ -166,7 +166,7 @@ pub fn super_fold_sty<T:TypeFolder>(this: &mut T, bounds) } ty::ty_tup(ref ts) => { - ty::ty_tup(fold_ty_vec(this, *ts)) + ty::ty_tup(fold_ty_vec(this, ts.as_slice())) } ty::ty_bare_fn(ref f) => { ty::ty_bare_fn(this.fold_bare_fn_ty(f)) diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs index e1157d29d9d..40e836ac0d9 100644 --- a/src/librustc/middle/typeck/astconv.rs +++ b/src/librustc/middle/typeck/astconv.rs @@ -136,7 +136,7 @@ fn opt_ast_region_to_region<AC:AstConv,RS:RegionScope>( } Ok(rs) => { - rs[0] + *rs.get(0) } } } @@ -791,7 +791,11 @@ pub fn ty_of_closure<AC:AstConv,RS:RegionScope>( let expected_arg_ty = expected_sig.as_ref().and_then(|e| { // no guarantee that the correct number of expected args // were supplied - if i < e.inputs.len() {Some(e.inputs[i])} else {None} + if i < e.inputs.len() { + Some(*e.inputs.get(i)) + } else { + None + } }); ty_of_arg(this, &rb, a, expected_arg_ty) }).collect(); diff --git a/src/librustc/middle/typeck/check/_match.rs b/src/librustc/middle/typeck/check/_match.rs index f1c8b121b4c..6c59ce09e05 100644 --- a/src/librustc/middle/typeck/check/_match.rs +++ b/src/librustc/middle/typeck/check/_match.rs @@ -319,7 +319,7 @@ pub fn check_struct_pat_fields(pcx: &pat_ctxt, } Some(&(index, ref mut used)) => { *used = true; - let class_field = class_fields[index]; + let class_field = *class_fields.get(index); let field_type = ty::lookup_field_type(tcx, class_id, class_field.id, @@ -585,7 +585,7 @@ pub fn check_pat(pcx: &pat_ctxt, pat: &ast::Pat, expected: ty::t) { match *s { ty::ty_tup(ref ex_elts) if e_count == ex_elts.len() => { for (i, elt) in elts.iter().enumerate() { - check_pat(pcx, *elt, ex_elts[i]); + check_pat(pcx, *elt, *ex_elts.get(i)); } fcx.write_ty(pat.id, expected); } diff --git a/src/librustc/middle/typeck/check/method.rs b/src/librustc/middle/typeck/check/method.rs index e563e6b2415..0cf0fa5897a 100644 --- a/src/librustc/middle/typeck/check/method.rs +++ b/src/librustc/middle/typeck/check/method.rs @@ -100,7 +100,8 @@ use util::ppaux::Repr; use std::cell::RefCell; use collections::HashSet; use std::result; -use std::vec; +use std::vec_ng::Vec; +use std::vec_ng; use syntax::ast::{DefId, SelfValue, SelfRegion}; use syntax::ast::{SelfUniq, SelfStatic}; use syntax::ast::{MutMutable, MutImmutable}; @@ -450,7 +451,7 @@ impl<'a> LookupContext<'a> { self.get_method_index(new_trait_ref, trait_ref, method_num); let mut m = (*m).clone(); // We need to fix up the transformed self type. - m.fty.sig.inputs[0] = + *m.fty.sig.inputs.get_mut(0) = self.construct_transformed_self_ty_for_object( did, &rcvr_substs, &m); @@ -476,7 +477,13 @@ impl<'a> LookupContext<'a> { param_ty); self.push_inherent_candidates_from_bounds( rcvr_ty, - self.fcx.inh.param_env.type_param_bounds[param_ty.idx].trait_bounds, + self.fcx + .inh + .param_env + .type_param_bounds + .get(param_ty.idx) + .trait_bounds + .as_slice(), restrict_to, param_numbered(param_ty.idx)); } @@ -541,10 +548,9 @@ impl<'a> LookupContext<'a> { let trait_methods = ty::trait_methods(tcx, bound_trait_ref.def_id); match trait_methods.iter().position(|m| { m.explicit_self != ast::SelfStatic && - m.ident.name == self.m_name }) - { + m.ident.name == self.m_name }) { Some(pos) => { - let method = trait_methods[pos]; + let method = *trait_methods.get(pos); match mk_cand(bound_trait_ref, method, pos, this_bound_idx) { Some(cand) => { @@ -599,13 +605,16 @@ impl<'a> LookupContext<'a> { impl_info.methods.map(|m| m.ident).repr(self.tcx())); let idx = { - match impl_info.methods.iter().position(|m| m.ident.name == self.m_name) { + match impl_info.methods + .iter() + .position(|m| m.ident.name == self.m_name) { Some(idx) => idx, None => { return; } // No method with the right name. } }; - let method = ty::method(self.tcx(), impl_info.methods[idx].def_id); + let method = ty::method(self.tcx(), + impl_info.methods.get(idx).def_id); // determine the `self` of the impl with fresh // variables for each parameter: @@ -899,7 +908,8 @@ impl<'a> LookupContext<'a> { candidates.iter().map(|c| (*c).clone()). filter(|c| self.is_relevant(rcvr_ty, c)).collect(); - let relevant_candidates = self.merge_candidates(relevant_candidates); + let relevant_candidates = + self.merge_candidates(relevant_candidates.as_slice()); if relevant_candidates.len() == 0 { return None; @@ -914,7 +924,7 @@ impl<'a> LookupContext<'a> { } } - Some(self.confirm_candidate(rcvr_ty, &relevant_candidates[0])) + Some(self.confirm_candidate(rcvr_ty, relevant_candidates.get(0))) } fn merge_candidates(&self, candidates: &[Candidate]) -> Vec<Candidate> { @@ -1004,14 +1014,15 @@ impl<'a> LookupContext<'a> { parameters given for this method"); self.fcx.infcx().next_ty_vars(num_method_tps) } else { - self.supplied_tps.to_owned() + Vec::from_slice(self.supplied_tps) } }; // Construct the full set of type parameters for the method, // which is equal to the class tps + the method tps. let all_substs = substs { - tps: vec_ng::append(candidate.rcvr_substs.tps.clone(), m_substs), + tps: vec_ng::append(candidate.rcvr_substs.tps.clone(), + m_substs.as_slice()), regions: candidate.rcvr_substs.regions.clone(), self_ty: candidate.rcvr_substs.self_ty, }; @@ -1031,7 +1042,7 @@ impl<'a> LookupContext<'a> { let args = fn_sig.inputs.slice_from(1).iter().map(|t| { t.subst(tcx, &all_substs) }); - Some(fn_sig.inputs[0]).move_iter().chain(args).collect() + Some(*fn_sig.inputs.get(0)).move_iter().chain(args).collect() } _ => fn_sig.inputs.subst(tcx, &all_substs) }; @@ -1050,7 +1061,7 @@ impl<'a> LookupContext<'a> { self.fcx.infcx().next_region_var( infer::BoundRegionInFnCall(self.expr.span, br)) }); - let transformed_self_ty = fn_sig.inputs[0]; + let transformed_self_ty = *fn_sig.inputs.get(0); let fty = ty::mk_bare_fn(tcx, ty::BareFnTy { sig: fn_sig, purity: bare_fn_ty.purity, @@ -1118,7 +1129,7 @@ impl<'a> LookupContext<'a> { ty::mk_err() // error reported in `enforce_object_limitations()` } ast::SelfRegion(..) | ast::SelfUniq => { - let transformed_self_ty = method_ty.fty.sig.inputs[0]; + let transformed_self_ty = *method_ty.fty.sig.inputs.get(0); match ty::get(transformed_self_ty).sty { ty::ty_rptr(r, mt) => { // must be SelfRegion ty::mk_trait(self.tcx(), trait_def_id, diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index ec2a68d2ae9..3c98f3defd6 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -118,6 +118,8 @@ use collections::HashMap; use std::mem::replace; use std::result; use std::vec; +use std::vec_ng::Vec; +use std::vec_ng; use syntax::abi::AbiSet; use syntax::ast::{Provided, Required}; use syntax::ast; @@ -902,7 +904,7 @@ fn compare_impl_method(tcx: ty::ctxt, bound_region: ty::BrNamed(l.def_id, l.ident)})). collect(); let dummy_substs = ty::substs { - tps: vec_ng::append(dummy_impl_tps, dummy_method_tps), + tps: vec_ng::append(dummy_impl_tps, dummy_method_tps.as_slice()), regions: ty::NonerasedRegions(dummy_impl_regions), self_ty: None }; @@ -929,7 +931,7 @@ fn compare_impl_method(tcx: ty::ctxt, self_ty: self_ty } = trait_substs.subst(tcx, &dummy_substs); let substs = substs { regions: trait_regions, - tps: vec_ng::append(trait_tps, dummy_method_tps), + tps: vec_ng::append(trait_tps, dummy_method_tps.as_slice()), self_ty: self_ty, }; debug!("trait_fty (pre-subst): {} substs={}", @@ -988,7 +990,7 @@ impl FnCtxt { impl RegionScope for infer::InferCtxt { fn anon_regions(&self, span: Span, count: uint) -> Result<Vec<ty::Region> , ()> { - Ok(vec::from_fn(count, |_| { + Ok(Vec::from_fn(count, |_| { self.next_region_var(infer::MiscVariable(span)) })) } @@ -1672,7 +1674,7 @@ fn check_expr_with_unifier(fcx: @FnCtxt, let args = args.slice_from(1); if ty::type_is_error(method_fn_ty) { let err_inputs = err_args(args.len()); - check_argument_types(fcx, sp, err_inputs, callee_expr, + check_argument_types(fcx, sp, err_inputs.as_slice(), callee_expr, args, deref_args, false); method_fn_ty } else { @@ -1713,10 +1715,10 @@ fn check_expr_with_unifier(fcx: @FnCtxt, let supplied_arg_count = args.len(); let expected_arg_count = fn_inputs.len(); let formal_tys = if expected_arg_count == supplied_arg_count { - fn_inputs.map(|a| *a) + fn_inputs.iter().map(|a| *a).collect() } else if variadic { if supplied_arg_count >= expected_arg_count { - fn_inputs.map(|a| *a) + fn_inputs.iter().map(|a| *a).collect() } else { let msg = format!( "this function takes at least {nexpected, plural, =1{# parameter} \ @@ -1782,7 +1784,7 @@ fn check_expr_with_unifier(fcx: @FnCtxt, if is_block == check_blocks { debug!("checking the argument"); - let mut formal_ty = formal_tys[i]; + let mut formal_ty = *formal_tys.get(i); match deref_args { DoDerefArgs => { @@ -1841,7 +1843,7 @@ fn check_expr_with_unifier(fcx: @FnCtxt, } fn err_args(len: uint) -> Vec<ty::t> { - vec::from_fn(len, |_| ty::mk_err()) + Vec::from_fn(len, |_| ty::mk_err()) } fn write_call(fcx: @FnCtxt, call_expr: &ast::Expr, output: ty::t) { @@ -1892,7 +1894,7 @@ fn check_expr_with_unifier(fcx: @FnCtxt, }); // Call the generic checker. - check_argument_types(fcx, call_expr.span, fn_sig.inputs, f, + check_argument_types(fcx, call_expr.span, fn_sig.inputs.as_slice(), f, args, DontDerefArgs, fn_sig.variadic); write_call(fcx, call_expr, fn_sig.output); @@ -2310,7 +2312,7 @@ fn check_expr_with_unifier(fcx: @FnCtxt, // field debug!("class named {}", ppaux::ty_to_str(tcx, base_t)); let cls_items = ty::lookup_struct_fields(tcx, base_id); - match lookup_field_ty(tcx, base_id, cls_items, + match lookup_field_ty(tcx, base_id, cls_items.as_slice(), field, &(*substs)) { Some(field_ty) => { // (2) look up what field's type is, and return it @@ -2330,7 +2332,7 @@ fn check_expr_with_unifier(fcx: @FnCtxt, base, field, expr_t, - tps, + tps.as_slice(), DontDerefArgs, CheckTraitsAndInherentMethods, AutoderefReceiver) { @@ -2484,7 +2486,7 @@ fn check_expr_with_unifier(fcx: @FnCtxt, class_id, id, substitutions, - class_fields, + class_fields.as_slice(), fields, base_expr.is_none()); if ty::type_is_error(fcx.node_ty(id)) { @@ -2542,7 +2544,7 @@ fn check_expr_with_unifier(fcx: @FnCtxt, variant_id, id, substitutions, - variant_fields, + variant_fields.as_slice(), fields, true); fcx.write_ty(id, enum_type); @@ -2621,18 +2623,21 @@ fn check_expr_with_unifier(fcx: @FnCtxt, // places: the exchange heap and the managed heap. let definition = lookup_def(fcx, path.span, place.id); let def_id = ast_util::def_id_of_def(definition); - match tcx.lang_items.items[ExchangeHeapLangItem as uint] { - Some(item_def_id) if def_id == item_def_id => { + match tcx.lang_items + .items + .get(ExchangeHeapLangItem as uint) { + &Some(item_def_id) if def_id == item_def_id => { fcx.write_ty(id, ty::mk_uniq(tcx, fcx.expr_ty(subexpr))); checked = true } - Some(_) | None => {} + &Some(_) | &None => {} } if !checked { match tcx.lang_items - .items[ManagedHeapLangItem as uint] { - Some(item_def_id) if def_id == item_def_id => { + .items + .get(ManagedHeapLangItem as uint) { + &Some(item_def_id) if def_id == item_def_id => { // Assign the magic `Gc<T>` struct. let gc_struct_id = match tcx.lang_items @@ -2661,7 +2666,7 @@ fn check_expr_with_unifier(fcx: @FnCtxt, fcx.write_ty(id, sty); checked = true } - Some(_) | None => {} + &Some(_) | &None => {} } } } @@ -2750,7 +2755,8 @@ fn check_expr_with_unifier(fcx: @FnCtxt, ty::ty_struct(did, ref substs) => { let fields = ty::struct_fields(fcx.tcx(), did, substs); fields.len() == 1 - && fields[0].ident == token::special_idents::unnamed_field + && fields.get(0).ident == + token::special_idents::unnamed_field } _ => false }; @@ -3129,7 +3135,7 @@ fn check_expr_with_unifier(fcx: @FnCtxt, let elt_ts = elts.iter().enumerate().map(|(i, e)| { let opt_hint = match flds { - Some(ref fs) if i < fs.len() => Some(fs[i]), + Some(ref fs) if i < fs.len() => Some(*fs.get(i)), _ => None }; check_expr_with_opt_hint(fcx, *e, opt_hint); @@ -3492,7 +3498,7 @@ pub fn check_simd(tcx: ty::ctxt, sp: Span, id: ast::NodeId) { tcx.sess.span_err(sp, "SIMD vector cannot be empty"); return; } - let e = ty::lookup_field_type(tcx, did, fields[0].id, substs); + let e = ty::lookup_field_type(tcx, did, fields.get(0).id, substs); if !fields.iter().all( |f| ty::lookup_field_type(tcx, did, f.id, substs) == e) { tcx.sess.span_err(sp, "SIMD vector should be homogeneous"); @@ -3805,7 +3811,7 @@ pub fn instantiate_path(fcx: @FnCtxt, .enumerate() { match self_parameter_index { Some(index) if index == i => { - tps.push(fcx.infcx().next_ty_vars(1)[0]); + tps.push(*fcx.infcx().next_ty_vars(1).get(0)); pushed = true; } _ => {} @@ -3829,7 +3835,7 @@ pub fn instantiate_path(fcx: @FnCtxt, for (i, default) in defaults.skip(ty_substs_len).enumerate() { match self_parameter_index { Some(index) if index == i + ty_substs_len => { - substs.tps.push(fcx.infcx().next_ty_vars(1)[0]); + substs.tps.push(*fcx.infcx().next_ty_vars(1).get(0)); pushed = true; } _ => {} @@ -3848,7 +3854,7 @@ pub fn instantiate_path(fcx: @FnCtxt, // If the self parameter goes at the end, insert it there. if !pushed && self_parameter_index.is_some() { - substs.tps.push(fcx.infcx().next_ty_vars(1)[0]) + substs.tps.push(*fcx.infcx().next_ty_vars(1).get(0)) } assert_eq!(substs.tps.len(), ty_param_count) @@ -4028,7 +4034,7 @@ pub fn check_intrinsic_type(ccx: @CrateCtxt, it: &ast::ForeignItem) { assert!(split.len() >= 2, "Atomic intrinsic not correct format"); //We only care about the operation here - match split[1] { + match *split.get(1) { "cxchg" => (1, vec!(ty::mk_mut_rptr(tcx, ty::ReLateBound(it.id, ty::BrAnon(0)), param(ccx, 0)), diff --git a/src/librustc/middle/typeck/check/regionmanip.rs b/src/librustc/middle/typeck/check/regionmanip.rs index b05a876ec7a..d0bb1f32fb8 100644 --- a/src/librustc/middle/typeck/check/regionmanip.rs +++ b/src/librustc/middle/typeck/check/regionmanip.rs @@ -13,7 +13,9 @@ use middle::ty; use middle::ty_fold; use middle::ty_fold::TypeFolder; + use collections::HashMap; +use std::vec_ng::Vec; use util::ppaux::Repr; use util::ppaux; diff --git a/src/librustc/middle/typeck/check/vtable.rs b/src/librustc/middle/typeck/check/vtable.rs index 1905e1e387b..32e1dfd98db 100644 --- a/src/librustc/middle/typeck/check/vtable.rs +++ b/src/librustc/middle/typeck/check/vtable.rs @@ -26,9 +26,10 @@ use util::common::indenter; use util::ppaux; use util::ppaux::Repr; -use std::cell::RefCell; use collections::HashSet; +use std::cell::RefCell; use std::result; +use std::vec_ng::Vec; use syntax::ast; use syntax::ast_util; use syntax::codemap::Span; @@ -100,13 +101,13 @@ fn lookup_vtables(vcx: &VtableContext, // We do this backwards for reasons discussed above. assert_eq!(substs.tps.len(), type_param_defs.len()); - let mut result = + let mut result: Vec<vtable_param_res> = substs.tps.rev_iter() .zip(type_param_defs.rev_iter()) .map(|(ty, def)| lookup_vtables_for_param(vcx, location_info, Some(substs), &*def.bounds, *ty, is_early)) - .to_owned_vec(); + .collect(); result.reverse(); assert_eq!(substs.tps.len(), result.len()); @@ -134,7 +135,10 @@ fn lookup_vtables_for_param(vcx: &VtableContext, // ty is the value supplied for the type parameter A... let mut param_result = Vec::new(); - ty::each_bound_trait_and_supertraits(tcx, type_param_bounds.trait_bounds, |trait_ref| { + ty::each_bound_trait_and_supertraits(tcx, + type_param_bounds.trait_bounds + .as_slice(), + |trait_ref| { // ...and here trait_ref is each bound that was declared on A, // expressed in terms of the type parameters. @@ -252,7 +256,11 @@ fn lookup_vtable(vcx: &VtableContext, let vtable_opt = match ty::get(ty).sty { ty::ty_param(param_ty {idx: n, ..}) => { let type_param_bounds: &[@ty::TraitRef] = - vcx.param_env.type_param_bounds[n].trait_bounds; + vcx.param_env + .type_param_bounds + .get(n) + .trait_bounds + .as_slice(); lookup_vtable_from_bounds(vcx, location_info, type_param_bounds, @@ -392,7 +400,7 @@ fn search_for_vtable(vcx: &VtableContext, // the type self_ty, and substs is bound to [T]. debug!("The self ty is {} and its substs are {}", vcx.infcx.ty_to_str(for_ty), - vcx.infcx.tys_to_str(substs.tps)); + vcx.infcx.tys_to_str(substs.tps.as_slice())); // Next, we unify trait_ref -- the type that we want to cast // to -- with of_trait_ref -- the trait that im implements. At @@ -445,7 +453,7 @@ fn search_for_vtable(vcx: &VtableContext, debug!("The fixed-up substs are {} - \ they will be unified with the bounds for \ the target ty, {}", - vcx.infcx.tys_to_str(substs_f.tps), + vcx.infcx.tys_to_str(substs_f.tps.as_slice()), vcx.infcx.trait_ref_to_str(trait_ref)); // Next, we unify the fixed-up substitutions for the impl self @@ -465,14 +473,14 @@ fn search_for_vtable(vcx: &VtableContext, match found.len() { 0 => { return None } - 1 => return Some(found[0].clone()), + 1 => return Some(found.get(0).clone()), _ => { if !is_early { vcx.tcx().sess.span_err( location_info.span, "multiple applicable methods in scope"); } - return Some(found[0].clone()); + return Some(found.get(0).clone()); } } } @@ -701,11 +709,15 @@ pub fn early_resolve_expr(ex: &ast::Expr, fcx: &FnCtxt, is_early: bool) { debug!("vtable resolution on parameter bounds for method call {}", ex.repr(fcx.tcx())); let type_param_defs = ty::method_call_type_param_defs(cx.tcx, method.origin); - if has_trait_bounds(*type_param_defs.borrow()) { + if has_trait_bounds(type_param_defs.borrow().as_slice()) { let substs = fcx.method_ty_substs(ex.id); let vcx = fcx.vtable_context(); - let vtbls = lookup_vtables(&vcx, &location_info_for_expr(ex), - *type_param_defs.borrow(), &substs, is_early); + let vtbls = lookup_vtables(&vcx, + &location_info_for_expr(ex), + type_param_defs.borrow() + .as_slice(), + &substs, + is_early); if !is_early { insert_vtables(fcx, ex.id, vtbls); } @@ -817,7 +829,7 @@ pub fn trans_resolve_method(tcx: ty::ctxt, id: ast::NodeId, substs: &ty::substs) -> Option<vtable_res> { let generics = ty::lookup_item_type(tcx, ast_util::local_def(id)).generics; let type_param_defs = generics.type_param_defs.borrow(); - if has_trait_bounds(*type_param_defs) { + if has_trait_bounds(type_param_defs.as_slice()) { let vcx = VtableContext { infcx: &infer::new_infer_ctxt(tcx), param_env: &ty::construct_parameter_environment(tcx, None, [], [], [], id) @@ -827,7 +839,11 @@ pub fn trans_resolve_method(tcx: ty::ctxt, id: ast::NodeId, span: tcx.map.span(id) }; - Some(lookup_vtables(&vcx, &loc_info, *type_param_defs, substs, false)) + Some(lookup_vtables(&vcx, + &loc_info, + type_param_defs.as_slice(), + substs, + false)) } else { None } diff --git a/src/librustc/middle/typeck/check/writeback.rs b/src/librustc/middle/typeck/check/writeback.rs index c22b06996ff..ced9db06954 100644 --- a/src/librustc/middle/typeck/check/writeback.rs +++ b/src/librustc/middle/typeck/check/writeback.rs @@ -28,6 +28,7 @@ use middle::typeck::write_ty_to_tcx; use util::ppaux; use util::ppaux::Repr; +use std::vec_ng::Vec; use syntax::ast; use syntax::codemap::Span; use syntax::print::pprust::pat_to_str; @@ -54,12 +55,12 @@ fn resolve_type_vars_in_type(fcx: @FnCtxt, sp: Span, typ: ty::t) fn resolve_type_vars_in_types(fcx: @FnCtxt, sp: Span, tys: &[ty::t]) -> Vec<ty::t> { - tys.map(|t| { + tys.iter().map(|t| { match resolve_type_vars_in_type(fcx, sp, *t) { Some(t1) => t1, None => ty::mk_err() } - }) + }).collect() } fn resolve_method_map_entry(wbcx: &mut WbCtxt, sp: Span, id: ast::NodeId) { @@ -122,7 +123,9 @@ fn resolve_vtable_map_entry(fcx: @FnCtxt, sp: Span, id: ast::NodeId) { origin: &vtable_origin) -> vtable_origin { match origin { &vtable_static(def_id, ref tys, origins) => { - let r_tys = resolve_type_vars_in_types(fcx, sp, *tys); + let r_tys = resolve_type_vars_in_types(fcx, + sp, + tys.as_slice()); let r_origins = resolve_origins(fcx, sp, origins); vtable_static(def_id, r_tys, r_origins) } diff --git a/src/librustc/middle/typeck/coherence.rs b/src/librustc/middle/typeck/coherence.rs index e64dbed1b35..e85d71fa982 100644 --- a/src/librustc/middle/typeck/coherence.rs +++ b/src/librustc/middle/typeck/coherence.rs @@ -46,10 +46,11 @@ use syntax::opt_vec; use syntax::parse::token; use syntax::visit; -use std::cell::RefCell; use collections::HashSet; +use std::cell::RefCell; use std::rc::Rc; -use std::vec; +use std::vec_ng::Vec; +use std::vec_ng; struct UniversalQuantificationResult { monotype: t, @@ -355,7 +356,8 @@ impl CoherenceChecker { let new_generics = ty::Generics { type_param_defs: Rc::new(vec_ng::append( - impl_poly_type.generics.type_param_defs().to_owned(), + Vec::from_slice(impl_poly_type.generics + .type_param_defs()), new_method_ty.generics.type_param_defs())), region_param_defs: impl_poly_type.generics.region_param_defs.clone() @@ -722,7 +724,7 @@ impl CoherenceChecker { // We'll error out later. For now, just don't ICE. continue; } - let method_def_id = impl_info.methods[0].def_id; + let method_def_id = impl_info.methods.get(0).def_id; let self_type = self.get_self_type_for_implementation(*impl_info); match ty::get(self_type.ty).sty { @@ -789,10 +791,10 @@ pub fn make_substs_for_receiver_types(tcx: ty::ctxt, num_trait_type_parameters + method.generics.type_param_defs().len(); // the new method type will have the type parameters from the impl + method - let combined_tps = vec::from_fn(num_method_type_parameters, |i| { + let combined_tps = Vec::from_fn(num_method_type_parameters, |i| { if i < num_trait_type_parameters { // replace type parameters that come from trait with new value - trait_ref.substs.tps[i] + *trait_ref.substs.tps.get(i) } else { // replace type parameters that belong to method with another // type parameter, this time with the index adjusted diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs index 9bfa89819ae..18fbb47aad1 100644 --- a/src/librustc/middle/typeck/collect.rs +++ b/src/librustc/middle/typeck/collect.rs @@ -46,6 +46,8 @@ use util::ppaux::Repr; use std::rc::Rc; use std::vec; +use std::vec_ng::Vec; +use std::vec_ng; use syntax::abi::AbiSet; use syntax::ast::{RegionTyParamBound, TraitTyParamBound}; use syntax::ast; @@ -324,7 +326,8 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt, trait_id: ast::NodeId) { let substs = substs { regions: ty::NonerasedRegions(rps_from_trait), self_ty: Some(self_param), - tps: non_shifted_trait_tps + shifted_method_tps + tps: vec_ng::append(Vec::from_slice(non_shifted_trait_tps), + shifted_method_tps) }; // create the type of `foo`, applying the substitution above @@ -339,7 +342,8 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt, trait_id: ast::NodeId) { let mut new_type_param_defs = Vec::new(); let substd_type_param_defs = trait_ty_generics.type_param_defs.subst(tcx, &substs); - new_type_param_defs.push_all(*substd_type_param_defs.borrow()); + new_type_param_defs.push_all(substd_type_param_defs.borrow() + .as_slice()); // add in the "self" type parameter let self_trait_def = get_trait_def(ccx, local_def(trait_id)); @@ -356,7 +360,8 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt, trait_id: ast::NodeId) { // add in the type parameters from the method let substd_type_param_defs = m.generics.type_param_defs.subst(tcx, &substs); - new_type_param_defs.push_all(*substd_type_param_defs.borrow()); + new_type_param_defs.push_all(substd_type_param_defs.borrow() + .as_slice()); debug!("static method {} type_param_defs={} ty={}, substs={}", m.def_id.repr(tcx), @@ -495,7 +500,8 @@ fn convert_methods(ccx: &CrateCtxt, ty_param_bounds_and_ty { generics: ty::Generics { type_param_defs: Rc::new(vec_ng::append( - rcvr_ty_generics.type_param_defs().to_owned(), + Vec::from_slice( + rcvr_ty_generics.type_param_defs()), m_ty_generics.type_param_defs())), region_param_defs: rcvr_ty_generics.region_param_defs.clone(), }, diff --git a/src/librustc/middle/typeck/infer/combine.rs b/src/librustc/middle/typeck/infer/combine.rs index 076a10fcbfd..32b6da40b08 100644 --- a/src/librustc/middle/typeck/infer/combine.rs +++ b/src/librustc/middle/typeck/infer/combine.rs @@ -63,6 +63,7 @@ use util::common::indent; use util::ppaux::Repr; use std::result; +use std::vec_ng::Vec; use syntax::ast::{Onceness, Purity}; use syntax::ast; use syntax::opt_vec; @@ -92,7 +93,7 @@ pub trait Combine { if as_.len() == bs.len() { result::fold_(as_.iter().zip(bs.iter()) .map(|(a, b)| eq_tys(self, *a, *b))) - .then(|| Ok(as_.to_owned())) + .then(|| Ok(Vec::from_slice(as_))) } else { Err(ty::terr_ty_param_size(expected_found(self, as_.len(), @@ -180,7 +181,7 @@ pub trait Combine { } } - let tps = if_ok!(self.tps(as_.tps, bs.tps)); + let tps = if_ok!(self.tps(as_.tps.as_slice(), bs.tps.as_slice())); let self_ty = if_ok!(self.self_tys(as_.self_ty, bs.self_ty)); let regions = if_ok!(relate_region_params(self, item_def_id, @@ -409,7 +410,9 @@ pub fn super_fn_sigs<C:Combine>(this: &C, a: &ty::FnSig, b: &ty::FnSig) -> cres< return Err(ty::terr_variadic_mismatch(expected_found(this, a.variadic, b.variadic))); } - let inputs = if_ok!(argvecs(this, a.inputs, b.inputs)); + let inputs = if_ok!(argvecs(this, + a.inputs.as_slice(), + b.inputs.as_slice())); let output = if_ok!(this.tys(a.output, b.output)); Ok(FnSig {binder_id: a.binder_id, inputs: inputs, diff --git a/src/librustc/middle/typeck/infer/glb.rs b/src/librustc/middle/typeck/infer/glb.rs index 039ea995821..68b609000f4 100644 --- a/src/librustc/middle/typeck/infer/glb.rs +++ b/src/librustc/middle/typeck/infer/glb.rs @@ -155,10 +155,16 @@ impl<'f> Combine for Glb<'f> { fold_regions_in_sig( self.get_ref().infcx.tcx, &sig0, - |r| generalize_region(self, snapshot, - new_vars, sig0.binder_id, - &a_map, a_vars, b_vars, - r)); + |r| { + generalize_region(self, + snapshot, + new_vars.as_slice(), + sig0.binder_id, + &a_map, + a_vars.as_slice(), + b_vars.as_slice(), + r) + }); debug!("sig1 = {}", sig1.inf_str(self.get_ref().infcx)); return Ok(sig1); diff --git a/src/librustc/middle/typeck/infer/lattice.rs b/src/librustc/middle/typeck/infer/lattice.rs index 48bd7845709..a97f1561c8d 100644 --- a/src/librustc/middle/typeck/infer/lattice.rs +++ b/src/librustc/middle/typeck/infer/lattice.rs @@ -43,9 +43,11 @@ use middle::typeck::infer::lub::Lub; use middle::typeck::infer::unify::*; use middle::typeck::infer::sub::Sub; use middle::typeck::infer::to_str::InferStr; -use collections::HashMap; use util::common::indenter; +use collections::HashMap; +use std::vec_ng::Vec; + pub trait LatticeValue { fn sub(cf: &CombineFields, a: &Self, b: &Self) -> ures; fn lub(cf: &CombineFields, a: &Self, b: &Self) -> cres<Self>; diff --git a/src/librustc/middle/typeck/infer/lub.rs b/src/librustc/middle/typeck/infer/lub.rs index fd6950ee49e..0f2b2da397e 100644 --- a/src/librustc/middle/typeck/infer/lub.rs +++ b/src/librustc/middle/typeck/infer/lub.rs @@ -143,7 +143,7 @@ impl<'f> Combine for Lub<'f> { fold_regions_in_sig( self.get_ref().infcx.tcx, &sig0, - |r| generalize_region(self, snapshot, new_vars, + |r| generalize_region(self, snapshot, new_vars.as_slice(), sig0.binder_id, &a_map, r)); return Ok(sig1); diff --git a/src/librustc/middle/typeck/infer/mod.rs b/src/librustc/middle/typeck/infer/mod.rs index 03db6882a79..5500d9afc67 100644 --- a/src/librustc/middle/typeck/infer/mod.rs +++ b/src/librustc/middle/typeck/infer/mod.rs @@ -21,6 +21,7 @@ pub use middle::typeck::infer::resolve::{resolve_ivar, resolve_all}; pub use middle::typeck::infer::resolve::{resolve_nested_tvar}; pub use middle::typeck::infer::resolve::{resolve_rvar}; +use collections::HashMap; use collections::SmallIntMap; use middle::ty::{TyVid, IntVid, FloatVid, RegionVid, Vid}; use middle::ty; @@ -37,9 +38,8 @@ use middle::typeck::infer::to_str::InferStr; use middle::typeck::infer::unify::{ValsAndBindings, Root}; use middle::typeck::infer::error_reporting::ErrorReporting; use std::cell::{Cell, RefCell}; -use collections::HashMap; use std::result; -use std::vec; +use std::vec_ng::Vec; use syntax::ast::{MutImmutable, MutMutable}; use syntax::ast; use syntax::codemap; @@ -623,7 +623,7 @@ impl InferCtxt { } pub fn next_ty_vars(&self, n: uint) -> Vec<ty::t> { - vec::from_fn(n, |_i| self.next_ty_var()) + Vec::from_fn(n, |_i| self.next_ty_var()) } pub fn next_int_var_id(&self) -> IntVid { @@ -660,7 +660,7 @@ impl InferCtxt { origin: RegionVariableOrigin, count: uint) -> Vec<ty::Region> { - vec::from_fn(count, |_| self.next_region_var(origin)) + Vec::from_fn(count, |_| self.next_region_var(origin)) } pub fn fresh_bound_region(&self, binder_id: ast::NodeId) -> ty::Region { diff --git a/src/librustc/middle/typeck/infer/region_inference/mod.rs b/src/librustc/middle/typeck/infer/region_inference/mod.rs index 88c234eb10f..57168eaec89 100644 --- a/src/librustc/middle/typeck/infer/region_inference/mod.rs +++ b/src/librustc/middle/typeck/infer/region_inference/mod.rs @@ -27,6 +27,7 @@ use util::ppaux::{Repr}; use std::cell::{Cell, RefCell}; use std::uint; use std::vec; +use std::vec_ng::Vec; use collections::{HashMap, HashSet}; use syntax::ast; use syntax::opt_vec; @@ -354,11 +355,11 @@ impl RegionVarBindings { None => { let var_origins = self.var_origins.borrow(); self.tcx.sess.span_bug( - var_origins.get()[rid.to_uint()].span(), + var_origins.get().get(rid.to_uint()).span(), format!("attempt to resolve region variable before \ values have been computed!")) } - Some(ref values) => values[rid.to_uint()] + Some(ref values) => *values.get(rid.to_uint()) }; debug!("RegionVarBindings: resolve_var({:?}={})={:?}", @@ -457,7 +458,7 @@ impl RegionVarBindings { let mut result_index = 0; while result_index < result_set.len() { // nb: can't use uint::range() here because result_set grows - let r = result_set[result_index]; + let r = *result_set.get(result_index); debug!("result_index={}, r={:?}", result_index, r); @@ -466,18 +467,18 @@ impl RegionVarBindings { // nb: can't use uint::range() here as we move result_set let regs = { let undo_log = self.undo_log.borrow(); - match undo_log.get()[undo_index] { - AddConstraint(ConstrainVarSubVar(ref a, ref b)) => { + match undo_log.get().get(undo_index) { + &AddConstraint(ConstrainVarSubVar(ref a, ref b)) => { Some((ReInfer(ReVar(*a)), ReInfer(ReVar(*b)))) } - AddConstraint(ConstrainRegSubVar(ref a, ref b)) => { + &AddConstraint(ConstrainRegSubVar(ref a, ref b)) => { Some((*a, ReInfer(ReVar(*b)))) } - AddConstraint(ConstrainVarSubReg(ref a, ref b)) => { + &AddConstraint(ConstrainVarSubReg(ref a, ref b)) => { Some((ReInfer(ReVar(*a)), *b)) } - AddConstraint(ConstrainRegSubReg(a, b)) => { + &AddConstraint(ConstrainRegSubReg(a, b)) => { Some((a, b)) } _ => { @@ -563,7 +564,7 @@ impl RegionVarBindings { (ReInfer(ReVar(v_id)), _) | (_, ReInfer(ReVar(v_id))) => { let var_origins = self.var_origins.borrow(); self.tcx.sess.span_bug( - var_origins.get()[v_id.to_uint()].span(), + var_origins.get().get(v_id.to_uint()).span(), format!("lub_concrete_regions invoked with \ non-concrete regions: {:?}, {:?}", a, b)); } @@ -668,7 +669,7 @@ impl RegionVarBindings { (_, ReInfer(ReVar(v_id))) => { let var_origins = self.var_origins.borrow(); self.tcx.sess.span_bug( - var_origins.get()[v_id.to_uint()].span(), + var_origins.get().get(v_id.to_uint()).span(), format!("glb_concrete_regions invoked with \ non-concrete regions: {:?}, {:?}", a, b)); } @@ -782,14 +783,14 @@ impl RegionVarBindings { errors: &mut OptVec<RegionResolutionError>) -> Vec<VarValue> { let mut var_data = self.construct_var_data(); - self.expansion(var_data); - self.contraction(var_data); - self.collect_concrete_region_errors(errors); - self.extract_values_and_collect_conflicts(var_data, errors) + self.expansion(var_data.as_mut_slice()); + self.contraction(var_data.as_mut_slice()); + self.collect_concrete_region_errors(&mut *errors); + self.extract_values_and_collect_conflicts(var_data.as_slice(), errors) } fn construct_var_data(&self) -> Vec<VarData> { - vec::from_fn(self.num_vars(), |_| { + Vec::from_fn(self.num_vars(), |_| { VarData { // All nodes are initially classified as contracting; during // the expansion phase, we will shift the classification for @@ -1071,7 +1072,7 @@ impl RegionVarBindings { } } - vec::from_fn(self.num_vars(), |idx| var_data[idx].value) + Vec::from_fn(self.num_vars(), |idx| var_data[idx].value) } fn construct_graph(&self) -> RegionGraph { @@ -1143,7 +1144,7 @@ impl RegionVarBindings { { let var_origins = self.var_origins.borrow(); errors.push(SubSupConflict( - var_origins.get()[node_idx.to_uint()], + *var_origins.get().get(node_idx.to_uint()), lower_bound.origin, lower_bound.region, upper_bound.origin, @@ -1156,7 +1157,7 @@ impl RegionVarBindings { let var_origins = self.var_origins.borrow(); self.tcx.sess.span_bug( - var_origins.get()[node_idx.to_uint()].span(), + var_origins.get().get(node_idx.to_uint()).span(), format!("collect_error_for_expanding_node() could not find error \ for var {:?}, lower_bounds={}, upper_bounds={}", node_idx, @@ -1190,7 +1191,7 @@ impl RegionVarBindings { Err(_) => { let var_origins = self.var_origins.borrow(); errors.push(SupSupConflict( - var_origins.get()[node_idx.to_uint()], + *var_origins.get().get(node_idx.to_uint()), upper_bound_1.origin, upper_bound_1.region, upper_bound_2.origin, @@ -1203,7 +1204,7 @@ impl RegionVarBindings { let var_origins = self.var_origins.borrow(); self.tcx.sess.span_bug( - var_origins.get()[node_idx.to_uint()].span(), + var_origins.get().get(node_idx.to_uint()).span(), format!("collect_error_for_contracting_node() could not find error \ for var {:?}, upper_bounds={}", node_idx, diff --git a/src/librustc/middle/typeck/infer/resolve.rs b/src/librustc/middle/typeck/infer/resolve.rs index f698f988c40..d4ee567ba41 100644 --- a/src/librustc/middle/typeck/infer/resolve.rs +++ b/src/librustc/middle/typeck/infer/resolve.rs @@ -58,6 +58,7 @@ use middle::typeck::infer::unify::{Root, UnifyInferCtxtMethods}; use util::common::{indent, indenter}; use util::ppaux::ty_to_str; +use std::vec_ng::Vec; use syntax::ast; pub static resolve_nested_tvar: uint = 0b0000000001; diff --git a/src/librustc/middle/typeck/infer/unify.rs b/src/librustc/middle/typeck/infer/unify.rs index 5241830ec77..b58fa905ca4 100644 --- a/src/librustc/middle/typeck/infer/unify.rs +++ b/src/librustc/middle/typeck/infer/unify.rs @@ -17,6 +17,7 @@ use middle::typeck::infer::{Bounds, uok, ures}; use middle::typeck::infer::InferCtxt; use middle::typeck::infer::to_str::InferStr; use std::cell::RefCell; +use std::vec_ng::Vec; use syntax::ast; #[deriving(Clone)] diff --git a/src/librustc/middle/typeck/mod.rs b/src/librustc/middle/typeck/mod.rs index a21ba0b7a2c..86f642a228d 100644 --- a/src/librustc/middle/typeck/mod.rs +++ b/src/librustc/middle/typeck/mod.rs @@ -72,6 +72,7 @@ use util::nodemap::{DefIdMap, NodeMap}; use std::cell::RefCell; use std::rc::Rc; +use std::vec_ng::Vec; use collections::List; use syntax::codemap::Span; use syntax::print::pprust::*; diff --git a/src/librustc/middle/typeck/rscope.rs b/src/librustc/middle/typeck/rscope.rs index fb391fe6fc8..eb633eb2eee 100644 --- a/src/librustc/middle/typeck/rscope.rs +++ b/src/librustc/middle/typeck/rscope.rs @@ -12,7 +12,7 @@ use middle::ty; use std::cell::Cell; -use std::vec; +use std::vec_ng::Vec; use syntax::ast; use syntax::codemap::Span; use syntax::opt_vec::OptVec; @@ -69,7 +69,7 @@ impl RegionScope for BindingRscope { -> Result<Vec<ty::Region> , ()> { let idx = self.anon_bindings.get(); self.anon_bindings.set(idx + count); - Ok(vec::from_fn(count, |i| ty::ReLateBound(self.binder_id, + Ok(Vec::from_fn(count, |i| ty::ReLateBound(self.binder_id, ty::BrAnon(idx + i)))) } } diff --git a/src/librustc/middle/typeck/variance.rs b/src/librustc/middle/typeck/variance.rs index 829a4c2f316..3712f046358 100644 --- a/src/librustc/middle/typeck/variance.rs +++ b/src/librustc/middle/typeck/variance.rs @@ -196,8 +196,8 @@ use collections::HashMap; use arena; use arena::Arena; use middle::ty; -use std::vec; use std::fmt; +use std::vec_ng::Vec; use syntax::ast; use syntax::ast_util; use syntax::opt_vec; @@ -561,7 +561,7 @@ impl<'a> ConstraintContext<'a> { // variance not yet inferred, so return a symbolic // variance. let InferredIndex(index) = self.inferred_index(param_def_id.node); - self.terms_cx.inferred_infos[index].term + self.terms_cx.inferred_infos.get(index).term } else { // Parameter on an item defined within another crate: // variance already inferred, just look it up. @@ -749,7 +749,7 @@ impl<'a> ConstraintContext<'a> { let variance_decl = self.declared_variance(p.def_id, def_id, TypeParam, i); let variance_i = self.xform(variance, variance_decl); - self.add_constraints_from_ty(substs.tps[i], variance_i); + self.add_constraints_from_ty(*substs.tps.get(i), variance_i); } match substs.regions { @@ -842,7 +842,7 @@ struct SolveContext<'a> { fn solve_constraints(constraints_cx: ConstraintContext) { let ConstraintContext { terms_cx, constraints, .. } = constraints_cx; - let solutions = vec::from_elem(terms_cx.num_inferred(), ty::Bivariant); + let solutions = Vec::from_elem(terms_cx.num_inferred(), ty::Bivariant); let mut solutions_cx = SolveContext { terms_cx: terms_cx, constraints: constraints, @@ -867,18 +867,21 @@ impl<'a> SolveContext<'a> { let Constraint { inferred, variance: term } = *constraint; let InferredIndex(inferred) = inferred; let variance = self.evaluate(term); - let old_value = self.solutions[inferred]; + let old_value = *self.solutions.get(inferred); let new_value = glb(variance, old_value); if old_value != new_value { debug!("Updating inferred {} (node {}) \ from {:?} to {:?} due to {}", inferred, - self.terms_cx.inferred_infos[inferred].param_id, + self.terms_cx + .inferred_infos + .get(inferred) + .param_id, old_value, new_value, term.to_str()); - self.solutions[inferred] = new_value; + *self.solutions.get_mut(inferred) = new_value; changed = true; } } @@ -901,25 +904,28 @@ impl<'a> SolveContext<'a> { let mut index = 0; let num_inferred = self.terms_cx.num_inferred(); while index < num_inferred { - let item_id = inferred_infos[index].item_id; + let item_id = inferred_infos.get(index).item_id; let mut item_variances = ty::ItemVariances { self_param: None, type_params: opt_vec::Empty, region_params: opt_vec::Empty }; while index < num_inferred && - inferred_infos[index].item_id == item_id { - let info = &inferred_infos[index]; + inferred_infos.get(index).item_id == item_id { + let info = inferred_infos.get(index); match info.kind { SelfParam => { assert!(item_variances.self_param.is_none()); - item_variances.self_param = Some(solutions[index]); + item_variances.self_param = + Some(*solutions.get(index)); } TypeParam => { - item_variances.type_params.push(solutions[index]); + item_variances.type_params + .push(*solutions.get(index)); } RegionParam => { - item_variances.region_params.push(solutions[index]); + item_variances.region_params + .push(*solutions.get(index)); } } index += 1; @@ -958,7 +964,7 @@ impl<'a> SolveContext<'a> { } InferredTerm(InferredIndex(index)) => { - self.solutions[index] + *self.solutions.get(index) } } } diff --git a/src/librustc/util/common.rs b/src/librustc/util/common.rs index 732723fec9c..fb417390905 100644 --- a/src/librustc/util/common.rs +++ b/src/librustc/util/common.rs @@ -16,6 +16,7 @@ use syntax::visit; use syntax::visit::Visitor; use std::local_data; +use std::vec_ng::Vec; use time; diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index c6ccb4275ad..ecba394b88e 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -22,6 +22,8 @@ use middle::ty::{ty_nil, ty_param, ty_ptr, ty_rptr, ty_self, ty_tup}; use middle::ty::{ty_uniq, ty_trait, ty_int, ty_uint, ty_unboxed_vec, ty_infer}; use middle::ty; use middle::typeck; + +use std::vec_ng::Vec; use syntax::abi::AbiSet; use syntax::ast_map; use syntax::codemap::{Span, Pos}; @@ -476,12 +478,17 @@ pub fn ty_to_str(cx: ctxt, typ: t) -> ~str { ty_self(..) => ~"Self", ty_enum(did, ref substs) | ty_struct(did, ref substs) => { let base = ty::item_path_str(cx, did); - parameterized(cx, base, &substs.regions, substs.tps, did, false) + parameterized(cx, + base, + &substs.regions, + substs.tps.as_slice(), + did, + false) } ty_trait(did, ref substs, s, mutbl, ref bounds) => { let base = ty::item_path_str(cx, did); let ty = parameterized(cx, base, &substs.regions, - substs.tps, did, true); + substs.tps.as_slice(), did, true); let bound_sep = if bounds.is_empty() { "" } else { ":" }; let bound_str = bounds.repr(cx); format!("{}{}{}{}{}", trait_store_to_str(cx, s), mutability_to_str(mutbl), ty, @@ -521,7 +528,7 @@ pub fn parameterized(cx: ctxt, let num_defaults = if has_defaults { // We should have a borrowed version of substs instead of cloning. let mut substs = ty::substs { - tps: tps.to_owned(), + tps: Vec::from_slice(tps), regions: regions.clone(), self_ty: None }; @@ -612,7 +619,7 @@ impl<T:Repr> Repr for OptVec<T> { // autoderef cannot convert the &[T] handler impl<T:Repr> Repr for Vec<T> { fn repr(&self, tcx: ctxt) -> ~str { - repr_vec(tcx, *self) + repr_vec(tcx, self.as_slice()) } } @@ -989,10 +996,10 @@ impl UserString for ty::TraitRef { let mut all_tps = self.substs.tps.clone(); for &t in self.substs.self_ty.iter() { all_tps.push(t); } parameterized(tcx, base, &self.substs.regions, - all_tps, self.def_id, true) + all_tps.as_slice(), self.def_id, true) } else { parameterized(tcx, base, &self.substs.regions, - self.substs.tps, self.def_id, true) + self.substs.tps.as_slice(), self.def_id, true) } } } diff --git a/src/librustc/util/sha2.rs b/src/librustc/util/sha2.rs index 8b0b08d9cc3..c5e75b52bf3 100644 --- a/src/librustc/util/sha2.rs +++ b/src/librustc/util/sha2.rs @@ -14,8 +14,8 @@ use std::iter::range_step; use std::num::Zero; -use std::vec; use std::vec::bytes::{MutableByteVector, copy_memory}; +use std::vec_ng::Vec; use serialize::hex::ToHex; /// Write a u32 into a vector, which must be 4 bytes long. The value is written in big-endian @@ -254,15 +254,15 @@ pub trait Digest { /// Convenience function that retrieves the result of a digest as a /// newly allocated vec of bytes. fn result_bytes(&mut self) -> Vec<u8> { - let mut buf = vec::from_elem((self.output_bits()+7)/8, 0u8); - self.result(buf); + let mut buf = Vec::from_elem((self.output_bits()+7)/8, 0u8); + self.result(buf.as_mut_slice()); buf } /// Convenience function that retrieves the result of a digest as a /// ~str in hexadecimal format. fn result_str(&mut self) -> ~str { - self.result_bytes().to_hex() + self.result_bytes().as_slice().to_hex() } } @@ -527,6 +527,7 @@ mod tests { use super::{Digest, Sha256, FixedBuffer}; use std::num::Bounded; use std::vec; + use std::vec_ng::Vec; use std::rand::isaac::IsaacRng; use std::rand::Rng; use serialize::hex::FromHex; @@ -594,7 +595,7 @@ mod tests { let mut sh = ~Sha256::new(); - test_hash(sh, tests); + test_hash(sh, tests.as_slice()); } /// Feed 1,000,000 'a's into the digest with varying input sizes and check that the result is @@ -619,7 +620,12 @@ mod tests { let result_bytes = digest.result_bytes(); assert_eq!(expected, result_str.as_slice()); - assert_eq!(expected.from_hex().unwrap(), result_bytes); + + let expected_vec: Vec<u8> = expected.from_hex() + .unwrap() + .move_iter() + .collect(); + assert_eq!(expected_vec, result_bytes); } #[test] |