}
fn parse_tts(cx: &ExtCtxt, tts: &[ast::TokenTree]) -> (@ast::Expr, Option<Ident>) {
- let p = &mut parse::new_parser_from_tts(cx.parse_sess(), cx.cfg(), tts.to_owned());
+ let p = &mut parse::new_parser_from_tts(cx.parse_sess(),
+ cx.cfg(),
+ tts.iter()
+ .map(|x| (*x).clone())
+ .collect());
let ex = p.parse_expr();
let id = if p.token == token::EOF {
None
fn target_endian_little(cx: &ExtCtxt, sp: Span) -> bool {
let meta = cx.meta_name_value(sp, InternedString::new("target_endian"),
ast::LitStr(InternedString::new("little"), ast::CookedStr));
- contains(cx.cfg(), meta)
+ contains(cx.cfg().as_slice(), meta)
}
// FIXME (10872): This is required to prevent an LLVM assert on Windows
pub fn build_link_meta(krate: &ast::Crate,
output: &OutputFilenames) -> LinkMeta {
let r = LinkMeta {
- crateid: find_crate_id(krate.attrs, output),
+ crateid: find_crate_id(krate.attrs.as_slice(), output),
crate_hash: Svh::calculate(krate),
};
info!("{}", r);
use std::io::MemReader;
use std::os;
use std::vec;
+use std::vec_ng::Vec;
+use std::vec_ng;
use collections::{HashMap, HashSet};
use getopts::{optopt, optmulti, optflag, optflagopt};
use getopts;
};
let mk = attr::mk_name_value_item_str;
- return ~[ // Target bindings.
+ return vec!(// Target bindings.
attr::mk_word_item(fam.clone()),
mk(InternedString::new("target_os"), tos),
mk(InternedString::new("target_family"), fam),
mk(InternedString::new("target_arch"), InternedString::new(arch)),
mk(InternedString::new("target_endian"), InternedString::new(end)),
mk(InternedString::new("target_word_size"),
- InternedString::new(wordsz)),
- ];
+ InternedString::new(wordsz))
+ );
}
pub fn append_configuration(cfg: &mut ast::CrateConfig,
}
}
-pub fn build_configuration(sess: Session) ->
- ast::CrateConfig {
+pub fn build_configuration(sess: Session) -> ast::CrateConfig {
// Combine the configuration requested by the session (command line) with
// some default and generated configuration items
let default_cfg = default_configuration(sess);
} else {
InternedString::new("nogc")
});
- return vec::append(user_cfg, default_cfg);
+ return vec_ng::append(user_cfg.move_iter().collect(),
+ default_cfg.as_slice());
}
// Convert strings provided as --cfg [cfgspec] into a crate_cfg
-> ast::CrateConfig {
cfgspecs.move_iter().map(|s| {
let sess = parse::new_parse_sess();
- parse::parse_meta_from_source_str("cfgspec".to_str(), s, ~[], sess)
+ parse::parse_meta_from_source_str("cfgspec".to_str(),
+ s,
+ Vec::new(),
+ sess)
}).collect::<ast::CrateConfig>()
}
let time_passes = sess.time_passes();
sess.building_library.set(session::building_library(sess.opts, &krate));
- sess.crate_types.set(session::collect_crate_types(&sess, krate.attrs));
+ sess.crate_types.set(session::collect_crate_types(&sess,
+ krate.attrs
+ .as_slice()));
time(time_passes, "gated feature checking", (), |_|
front::feature_gate::check_crate(sess, &krate));
input: &Input,
outputs: &OutputFilenames,
krate: &ast::Crate) -> io::IoResult<()> {
- let id = link::find_crate_id(krate.attrs, outputs);
+ let id = link::find_crate_id(krate.attrs.as_slice(), outputs);
let mut out_filenames = ~[];
for output_type in sess.opts.output_types.iter() {
let loader = &mut Loader::new(sess);
phase_2_configure_and_expand(sess, loader, krate)
};
- let outputs = build_output_filenames(input, outdir, output,
- expanded_crate.attrs, sess);
+ let outputs = build_output_filenames(input,
+ outdir,
+ output,
+ expanded_crate.attrs.as_slice(),
+ sess);
write_out_deps(sess, input, &outputs, &expanded_crate).unwrap();
let sessopts = build_session_options(matches);
let sess = build_session(sessopts, None);
let cfg = build_configuration(sess);
- assert!((attr::contains_name(cfg, "test")));
+ assert!((attr::contains_name(cfg.as_slice(), "test")));
}
// When the user supplies --test and --cfg test, don't implicitly add
use syntax;
use std::cell::{Cell, RefCell};
+use std::vec_ng::Vec;
use collections::{HashMap,HashSet};
pub struct Config {
addl_lib_search_paths: @RefCell::new(HashSet::new()),
maybe_sysroot: None,
target_triple: host_triple(),
- cfg: ~[],
+ cfg: Vec::new(),
test: false,
parse_only: false,
no_trans: false,
CrateTypeStaticlib | CrateTypeDylib | CrateTypeRlib => return true
}
}
- match syntax::attr::first_attr_value_str_by_name(krate.attrs, "crate_type") {
+ match syntax::attr::first_attr_value_str_by_name(krate.attrs.as_slice(),
+ "crate_type") {
Some(s) => {
s.equiv(&("lib")) ||
s.equiv(&("rlib")) ||
// any items that do not belong in the current configuration
pub fn strip_unconfigured_items(krate: ast::Crate) -> ast::Crate {
let config = krate.config.clone();
- strip_items(krate, |attrs| in_cfg(config, attrs))
+ strip_items(krate, |attrs| in_cfg(config.as_slice(), attrs))
}
impl<'a> fold::Folder for Context<'a> {
ast::ItemEnum(ref def, ref generics) => {
let mut variants = def.variants.iter().map(|c| c.clone()).
filter_map(|v| {
- if !(cx.in_cfg)(v.node.attrs) {
+ if !(cx.in_cfg)(v.node.attrs.as_slice()) {
None
} else {
Some(match v.node.kind {
fn fold_struct(cx: &Context, def: &ast::StructDef) -> @ast::StructDef {
let mut fields = def.fields.iter().map(|c| c.clone()).filter(|m| {
- (cx.in_cfg)(m.node.attrs)
+ (cx.in_cfg)(m.node.attrs.as_slice())
});
@ast::StructDef {
fields: fields.collect(),
}
fn item_in_cfg(cx: &Context, item: &ast::Item) -> bool {
- return (cx.in_cfg)(item.attrs);
+ return (cx.in_cfg)(item.attrs.as_slice());
}
fn foreign_item_in_cfg(cx: &Context, item: &ast::ForeignItem) -> bool {
- return (cx.in_cfg)(item.attrs);
+ return (cx.in_cfg)(item.attrs.as_slice());
}
fn view_item_in_cfg(cx: &Context, item: &ast::ViewItem) -> bool {
- return (cx.in_cfg)(item.attrs);
+ return (cx.in_cfg)(item.attrs.as_slice());
}
fn method_in_cfg(cx: &Context, meth: &ast::Method) -> bool {
- return (cx.in_cfg)(meth.attrs);
+ return (cx.in_cfg)(meth.attrs.as_slice());
}
fn trait_method_in_cfg(cx: &Context, meth: &ast::TraitMethod) -> bool {
match *meth {
- ast::Required(ref meth) => (cx.in_cfg)(meth.attrs),
- ast::Provided(meth) => (cx.in_cfg)(meth.attrs)
+ ast::Required(ref meth) => (cx.in_cfg)(meth.attrs.as_slice()),
+ ast::Provided(meth) => (cx.in_cfg)(meth.attrs.as_slice())
}
}
}
ast::ItemForeignMod(..) => {
- if attr::contains_name(i.attrs, "link_args") {
+ if attr::contains_name(i.attrs.as_slice(), "link_args") {
self.gate_feature("link_args", i.span,
"the `link_args` attribute is not portable \
across platforms, it is recommended to \
}
ast::ItemFn(..) => {
- if attr::contains_name(i.attrs, "macro_registrar") {
+ if attr::contains_name(i.attrs.as_slice(), "macro_registrar") {
self.gate_feature("macro_registrar", i.span,
"cross-crate macro exports are \
experimental and possibly buggy");
}
ast::ItemStruct(..) => {
- if attr::contains_name(i.attrs, "simd") {
+ if attr::contains_name(i.attrs.as_slice(), "simd") {
self.gate_feature("simd", i.span,
"SIMD types are experimental and possibly buggy");
}
use driver::session::Session;
-use std::vec;
+use std::vec_ng::Vec;
+use std::vec_ng;
use syntax::ast;
use syntax::attr;
use syntax::codemap::DUMMY_SP;
}
fn use_std(krate: &ast::Crate) -> bool {
- !attr::contains_name(krate.attrs, "no_std")
+ !attr::contains_name(krate.attrs.as_slice(), "no_std")
}
fn use_uv(krate: &ast::Crate) -> bool {
- !attr::contains_name(krate.attrs, "no_uv")
+ !attr::contains_name(krate.attrs.as_slice(), "no_uv")
}
fn no_prelude(attrs: &[ast::Attribute]) -> bool {
impl fold::Folder for StandardLibraryInjector {
fn fold_crate(&mut self, krate: ast::Crate) -> ast::Crate {
- let mut vis = ~[ast::ViewItem {
+ let mut vis = vec!(ast::ViewItem {
node: ast::ViewItemExternMod(token::str_to_ident("std"),
with_version("std"),
ast::DUMMY_NODE_ID),
- attrs: ~[
+ attrs: vec!(
attr::mk_attr(attr::mk_list_item(
InternedString::new("phase"),
- ~[
+ vec!(
attr::mk_word_item(InternedString::new("syntax")),
attr::mk_word_item(InternedString::new("link")
- )]))
- ],
+ ))))),
vis: ast::Inherited,
span: DUMMY_SP
- }];
+ });
if use_uv(&krate) && !self.sess.building_library.get() {
vis.push(ast::ViewItem {
node: ast::ViewItemExternMod(token::str_to_ident("green"),
with_version("green"),
ast::DUMMY_NODE_ID),
- attrs: ~[],
+ attrs: Vec::new(),
vis: ast::Inherited,
span: DUMMY_SP
});
node: ast::ViewItemExternMod(token::str_to_ident("rustuv"),
with_version("rustuv"),
ast::DUMMY_NODE_ID),
- attrs: ~[],
+ attrs: Vec::new(),
vis: ast::Inherited,
span: DUMMY_SP
});
}
- vis.push_all(krate.module.view_items);
+ vis.push_all_move(krate.module.view_items.clone());
let new_module = ast::Mod {
view_items: vis,
..krate.module.clone()
impl fold::Folder for PreludeInjector {
fn fold_crate(&mut self, krate: ast::Crate) -> ast::Crate {
- if !no_prelude(krate.attrs) {
+ if !no_prelude(krate.attrs.as_slice()) {
// only add `use std::prelude::*;` if there wasn't a
// `#[no_implicit_prelude];` at the crate level.
ast::Crate {
}
fn fold_item(&mut self, item: @ast::Item) -> SmallVector<@ast::Item> {
- if !no_prelude(item.attrs) {
+ if !no_prelude(item.attrs.as_slice()) {
// only recur if there wasn't `#[no_implicit_prelude];`
// on this item, i.e. this means that the prelude is not
// implicitly imported though the whole subtree
let prelude_path = ast::Path {
span: DUMMY_SP,
global: false,
- segments: ~[
+ segments: vec!(
ast::PathSegment {
identifier: token::str_to_ident("std"),
lifetimes: opt_vec::Empty,
identifier: token::str_to_ident("prelude"),
lifetimes: opt_vec::Empty,
types: opt_vec::Empty,
- },
- ],
+ }),
};
let vp = @codemap::dummy_spanned(ast::ViewPathGlob(prelude_path, ast::DUMMY_NODE_ID));
let vi2 = ast::ViewItem {
- node: ast::ViewItemUse(~[vp]),
- attrs: ~[],
+ node: ast::ViewItemUse(vec!(vp)),
+ attrs: Vec::new(),
vis: ast::Inherited,
span: DUMMY_SP,
};
- let vis = vec::append(~[vi2], module.view_items);
+ let vis = vec_ng::append(vec!(vi2), module.view_items.as_slice());
// FIXME #2543: Bad copy.
let new_module = ast::Mod {
// Code that generates a test runner to run all the tests in a crate
+#[allow(dead_code)];
+#[allow(unused_imports)];
use driver::session;
use front::config;
use std::cell::RefCell;
use std::vec;
+use std::vec_ng::Vec;
+use std::vec_ng;
use syntax::ast_util::*;
use syntax::attr::AttrMetaMethods;
use syntax::attr;
// We generate the test harness when building in the 'test'
// configuration, either with the '--test' or '--cfg test'
// command line options.
- let should_test = attr::contains_name(krate.config, "test");
+ let should_test = attr::contains_name(krate.config.as_slice(), "test");
if should_test {
generate_test_harness(sess, krate)
// When not compiling with --test we should not compile the
// #[test] functions
config::strip_items(krate, |attrs| {
- !attr::contains_name(attrs, "test") &&
- !attr::contains_name(attrs, "bench")
+ !attr::contains_name(attrs.as_slice(), "test") &&
+ !attr::contains_name(attrs.as_slice(), "bench")
})
}
fn is_test_fn(cx: &TestCtxt, i: @ast::Item) -> bool {
- let has_test_attr = attr::contains_name(i.attrs, "test");
+ let has_test_attr = attr::contains_name(i.attrs.as_slice(), "test");
fn has_test_signature(i: @ast::Item) -> bool {
match &i.node {
}
fn is_bench_fn(i: @ast::Item) -> bool {
- let has_bench_attr = attr::contains_name(i.attrs, "bench");
+ let has_bench_attr = attr::contains_name(i.attrs.as_slice(), "bench");
fn has_test_signature(i: @ast::Item) -> bool {
match i.node {
i.attrs.iter().any(|attr| {
// check ignore(cfg(foo, bar))
attr.name().equiv(&("ignore")) && match attr.meta_item_list() {
- Some(ref cfgs) => attr::test_cfg(cx.config, cfgs.iter().map(|x| *x)),
+ Some(ref cfgs) => {
+ attr::test_cfg(cx.config.as_slice(), cfgs.iter().map(|x| *x))
+ }
None => true
}
})
}
fn should_fail(i: @ast::Item) -> bool {
- attr::contains_name(i.attrs, "should_fail")
+ attr::contains_name(i.attrs.as_slice(), "should_fail")
}
fn add_test_module(cx: &TestCtxt, m: &ast::Mod) -> ast::Mod {
let testmod = mk_test_module(cx);
ast::Mod {
- items: vec::append_one(m.items.clone(), testmod),
+ items: vec_ng::append_one(m.items.clone(), testmod),
..(*m).clone()
}
}
let id_test = token::str_to_ident("test");
let vi = if cx.is_test_crate {
ast::ViewItemUse(
- ~[@nospan(ast::ViewPathSimple(id_test,
- path_node(~[id_test]),
- ast::DUMMY_NODE_ID))])
+ vec!(@nospan(ast::ViewPathSimple(id_test,
+ path_node(~[id_test]),
+ ast::DUMMY_NODE_ID))))
} else {
ast::ViewItemExternMod(id_test,
with_version("test"),
};
ast::ViewItem {
node: vi,
- attrs: ~[],
+ attrs: Vec::new(),
vis: ast::Inherited,
span: DUMMY_SP
}
}
-fn mk_test_module(cx: &TestCtxt) -> @ast::Item {
+#[cfg(stage0)]
+fn mk_test_module(_: &TestCtxt) -> @ast::Item {
+ fail!("test disabled in this stage due to quasiquoter")
+}
+#[cfg(not(stage0))]
+fn mk_test_module(cx: &TestCtxt) -> @ast::Item {
// Link to test crate
- let view_items = ~[mk_std(cx)];
+ let view_items = vec!(mk_std(cx));
// A constant vector of test descriptors.
let tests = mk_tests(cx);
let testmod = ast::Mod {
view_items: view_items,
- items: ~[mainfn, tests],
+ items: vec!(mainfn, tests),
};
let item_ = ast::ItemMod(testmod);
let item = ast::Item {
ident: token::str_to_ident("__test"),
- attrs: ~[resolve_unexported_attr],
+ attrs: vec!(resolve_unexported_attr),
id: ast::DUMMY_NODE_ID,
node: item_,
vis: ast::Public,
}
}
+#[cfg(stage0)]
+fn mk_tests(_: &TestCtxt) -> @ast::Item {
+ fail!("tests disabled in this stage due to quasiquoter")
+}
+
+#[cfg(not(stage0))]
fn mk_tests(cx: &TestCtxt) -> @ast::Item {
// The vector of test_descs for this crate
let test_descs = mk_test_descs(cx);
}
fn is_test_crate(krate: &ast::Crate) -> bool {
- match attr::find_crateid(krate.attrs) {
+ match attr::find_crateid(krate.attrs.as_slice()) {
Some(ref s) if "test" == s.name => true,
_ => false
}
}
fn mk_test_descs(cx: &TestCtxt) -> @ast::Expr {
- let mut descs = ~[];
+ let mut descs = Vec::new();
{
let testfns = cx.testfns.borrow();
debug!("building test vector from {} tests", testfns.get().len());
}
}
+#[cfg(stage0)]
+fn mk_test_desc_and_fn_rec(_: &TestCtxt, _: &Test) -> @ast::Expr {
+ fail!("tests disabled in this stage due to quasiquoter")
+}
+
+#[cfg(not(stage0))]
fn mk_test_desc_and_fn_rec(cx: &TestCtxt, test: &Test) -> @ast::Expr {
let span = test.span;
let path = test.path.clone();
use std::str;
use std::task;
use std::vec;
+use std::vec_ng::Vec;
use syntax::ast;
use syntax::diagnostic::Emitter;
use syntax::diagnostic;
d::compile_input(sess, cfg, &input, &odir, &ofile);
}
-fn parse_crate_attrs(sess: session::Session,
- input: &d::Input) -> ~[ast::Attribute] {
- match *input {
+fn parse_crate_attrs(sess: session::Session, input: &d::Input) ->
+ ~[ast::Attribute] {
+ let result = match *input {
d::FileInput(ref ifile) => {
- parse::parse_crate_attrs_from_file(ifile, ~[], sess.parse_sess)
+ parse::parse_crate_attrs_from_file(ifile,
+ Vec::new(),
+ sess.parse_sess)
}
d::StrInput(ref src) => {
parse::parse_crate_attrs_from_source_str(d::anon_src(),
(*src).clone(),
- ~[],
+ Vec::new(),
sess.parse_sess)
}
- }
+ };
+ result.move_iter().collect()
}
/// Run a procedure which will detect failures in the compiler and print nicer
use metadata::loader::Os;
use std::cell::RefCell;
+use std::vec_ng::Vec;
use collections::HashMap;
use syntax::ast;
use syntax::abi;
let should_load = i.attrs.iter().all(|attr| {
attr.name().get() != "phase" ||
attr.meta_item_list().map_or(false, |phases| {
- attr::contains_name(phases, "link")
+ attr::contains_name(phases.as_slice(), "link")
})
});
}
}
- fn get_exported_macros(&mut self, cnum: ast::CrateNum) -> ~[~str] {
- csearch::get_exported_macros(self.env.sess.cstore, cnum)
+ fn get_exported_macros(&mut self, cnum: ast::CrateNum) -> Vec<~str> {
+ csearch::get_exported_macros(self.env.sess.cstore, cnum).move_iter()
+ .collect()
}
fn get_registrar_symbol(&mut self, cnum: ast::CrateNum) -> Option<~str> {
let nd = reader::get_doc(meta_item_doc, tag_meta_item_name);
let n = token::intern_and_get_ident(nd.as_str_slice());
let subitems = get_meta_items(meta_item_doc);
- items.push(attr::mk_list_item(n, subitems));
+ items.push(attr::mk_list_item(n, subitems.move_iter().collect()));
true
});
return items;
encode_name(ebml_w, variant.node.name.name);
encode_parent_item(ebml_w, local_def(id));
encode_visibility(ebml_w, variant.node.vis);
- encode_attributes(ebml_w, variant.node.attrs);
+ encode_attributes(ebml_w, variant.node.attrs.as_slice());
match variant.node.kind {
ast::TupleVariantKind(ref args)
if args.len() > 0 && generics.ty_params.len() == 0 => {
}
ast::TupleVariantKind(_) => {},
ast::StructVariantKind(def) => {
- let idx = encode_info_for_struct(ecx, ebml_w, def.fields, index);
+ let idx = encode_info_for_struct(ecx,
+ ebml_w,
+ def.fields.as_slice(),
+ index);
encode_struct_fields(ebml_w, def);
let bkts = create_index(idx);
encode_index(ebml_w, bkts, write_i64);
// If this is a newtype struct, return the constructor.
match struct_def.ctor_id {
Some(ctor_id) if struct_def.fields.len() > 0 &&
- struct_def.fields[0].node.kind ==
+ struct_def.fields.get(0).node.kind ==
ast::UnnamedField => {
continue_ = callback(ctor_id);
}
let elem = ast_map::PathName(m.ident.name);
encode_path(ebml_w, impl_path.chain(Some(elem).move_iter()));
match ast_method_opt {
- Some(ast_method) => encode_attributes(ebml_w, ast_method.attrs),
+ Some(ast_method) => {
+ encode_attributes(ebml_w, ast_method.attrs.as_slice())
+ }
None => ()
}
for &ast_method in ast_method_opt.iter() {
let num_params = tpt.generics.type_param_defs().len();
- if num_params > 0u || is_default_impl || should_inline(ast_method.attrs) {
+ if num_params > 0u ||
+ is_default_impl ||
+ should_inline(ast_method.attrs.as_slice()) {
(ecx.encode_inlined_item)(
ecx, ebml_w, IIMethodRef(local_def(parent_id), false, ast_method));
} else {
encode_bounds_and_type(ebml_w, ecx, &lookup_item_type(tcx, def_id));
encode_name(ebml_w, item.ident.name);
encode_path(ebml_w, path);
- encode_attributes(ebml_w, item.attrs);
- if tps_len > 0u || should_inline(item.attrs) {
+ encode_attributes(ebml_w, item.attrs.as_slice());
+ if tps_len > 0u || should_inline(item.attrs.as_slice()) {
(ecx.encode_inlined_item)(ecx, ebml_w, IIItemRef(item));
} else {
encode_symbol(ecx, ebml_w, item.id);
encode_item_variances(ebml_w, ecx, item.id);
encode_bounds_and_type(ebml_w, ecx, &lookup_item_type(tcx, def_id));
encode_name(ebml_w, item.ident.name);
- encode_attributes(ebml_w, item.attrs);
+ encode_attributes(ebml_w, item.attrs.as_slice());
for v in (*enum_definition).variants.iter() {
encode_variant_id(ebml_w, local_def(v.node.id));
}
encode_enum_variant_info(ecx,
ebml_w,
item.id,
- (*enum_definition).variants,
+ (*enum_definition).variants.as_slice(),
index,
generics);
}
the index, and the index needs to be in the item for the
class itself */
let idx = encode_info_for_struct(ecx, ebml_w,
- struct_def.fields, index);
+ struct_def.fields.as_slice(), index);
/* Index the class*/
add_to_index(item, ebml_w, index);
encode_item_variances(ebml_w, ecx, item.id);
encode_name(ebml_w, item.ident.name);
- encode_attributes(ebml_w, item.attrs);
+ encode_attributes(ebml_w, item.attrs.as_slice());
encode_path(ebml_w, path.clone());
encode_visibility(ebml_w, vis);
encode_family(ebml_w, 'i');
encode_bounds_and_type(ebml_w, ecx, &lookup_item_type(tcx, def_id));
encode_name(ebml_w, item.ident.name);
- encode_attributes(ebml_w, item.attrs);
+ encode_attributes(ebml_w, item.attrs.as_slice());
match ty.node {
ast::TyPath(ref path, ref bounds, _) if path.segments
.len() == 1 => {
let num_implemented_methods = ast_methods.len();
for (i, m) in imp.methods.iter().enumerate() {
let ast_method = if i < num_implemented_methods {
- Some(ast_methods[i])
+ Some(*ast_methods.get(i))
} else { None };
{
encode_region_param_defs(ebml_w, trait_def.generics.region_param_defs());
encode_trait_ref(ebml_w, ecx, trait_def.trait_ref, tag_item_trait_ref);
encode_name(ebml_w, item.ident.name);
- encode_attributes(ebml_w, item.attrs);
+ encode_attributes(ebml_w, item.attrs.as_slice());
encode_visibility(ebml_w, vis);
for &method_def_id in ty::trait_method_def_ids(tcx, def_id).iter() {
ebml_w.start_tag(tag_item_trait_method);
}
}
- match ms[i] {
- Required(ref tm) => {
- encode_attributes(ebml_w, tm.attrs);
+ match ms.get(i) {
+ &Required(ref tm) => {
+ encode_attributes(ebml_w, tm.attrs.as_slice());
encode_method_sort(ebml_w, 'r');
}
- Provided(m) => {
- encode_attributes(ebml_w, m.attrs);
+ &Provided(m) => {
+ encode_attributes(ebml_w, m.attrs.as_slice());
// If this is a static method, we've already encoded
// this.
if method_ty.explicit_self != SelfStatic {
use std::cast;
use std::io::Seek;
use std::rc::Rc;
+use std::vec_ng::Vec;
use serialize::ebml::reader;
use serialize::ebml;
}
}).collect();
let blk_sans_items = ast::P(ast::Block {
- view_items: ~[], // I don't know if we need the view_items here,
- // but it doesn't break tests!
+ view_items: Vec::new(), // I don't know if we need the view_items
+ // here, but it doesn't break tests!
stmts: stmts_sans_items,
expr: blk.expr,
id: blk.id,
map: &ast_map::Map,
path: ~[ast_map::PathElem],
ii: ast::InlinedItem) -> ast::InlinedItem {
- ast_map::map_decoded_item(map, path, AstRenumberer { xcx: xcx }, |fld| {
+ ast_map::map_decoded_item(map,
+ path.move_iter().collect(),
+ AstRenumberer { xcx: xcx },
+ |fld| {
match ii {
ast::IIItem(i) => {
ast::IIItem(fld.fold_item(i).expect_one("expected one item"))
#[cfg(test)]
impl fake_ext_ctxt for @parse::ParseSess {
- fn cfg(&self) -> ast::CrateConfig { ~[] }
+ fn cfg(&self) -> ast::CrateConfig {
+ Vec::new()
+ }
fn parse_sess(&self) -> @parse::ParseSess { *self }
fn call_site(&self) -> Span {
codemap::Span {
this.check_assignment(dest);
}
ast::ExprCall(f, ref args) => {
- this.check_call(expr, Some(f), f.span, *args);
+ this.check_call(expr, Some(f), f.span, args.as_slice());
}
ast::ExprMethodCall(_, _, ref args) => {
- this.check_call(expr, None, expr.span, *args);
+ this.check_call(expr, None, expr.span, args.as_slice());
}
ast::ExprIndex(_, rval) | ast::ExprBinary(_, _, rval)
if method_map.get().contains_key(&expr.id) => {
let mut guard_exit = discr_exit;
for arm in arms.iter() {
guard_exit = self.opt_expr(arm.guard, guard_exit); // 2
- let pats_exit = self.pats_any(arm.pats, guard_exit); // 3
+ let pats_exit = self.pats_any(arm.pats.as_slice(),
+ guard_exit); // 3
let body_exit = self.block(arm.body, pats_exit); // 4
self.add_contained_edge(body_exit, expr_exit); // 5
}
}
ast::ExprVec(ref elems, _) => {
- self.straightline(expr, pred, *elems)
+ self.straightline(expr, pred, elems.as_slice())
}
ast::ExprCall(func, ref args) => {
- self.call(expr, pred, func, *args)
+ self.call(expr, pred, func, args.as_slice())
}
ast::ExprMethodCall(_, _, ref args) => {
- self.call(expr, pred, args[0], args.slice_from(1))
+ self.call(expr, pred, *args.get(0), args.slice_from(1))
}
ast::ExprIndex(l, r) |
}
ast::ExprTup(ref exprs) => {
- self.straightline(expr, pred, *exprs)
+ self.straightline(expr, pred, exprs.as_slice())
}
ast::ExprStruct(_, ref fields, base) => {
for arm in arms.iter() {
check_legality_of_move_bindings(cx,
arm.guard.is_some(),
- arm.pats);
+ arm.pats.as_slice());
}
- check_arms(cx, *arms);
+ check_arms(cx, arms.as_slice());
/* Check for exhaustiveness */
// Check for empty enum, because is_useful only works on inhabited
// types.
}
_ => { /* We assume only enum types can be uninhabited */ }
}
- let arms = arms.iter().filter_map(unguarded_pat).collect::<~[~[@Pat]]>().concat_vec();
- if arms.is_empty() {
+
+ let pats: ~[@Pat] = arms.iter()
+ .filter_map(unguarded_pat)
+ .flat_map(|pats| pats.move_iter())
+ .collect();
+ if pats.is_empty() {
cx.tcx.sess.span_err(ex.span, "non-exhaustive patterns");
} else {
- check_exhaustive(cx, ex.span, arms);
+ check_exhaustive(cx, ex.span, pats);
}
}
_ => ()
}
DefVariant(_, id, _) if variant(id) == *ctor_id => {
let args = match args {
- Some(args) => args,
+ Some(args) => args.iter().map(|x| *x).collect(),
None => vec::from_elem(arity, wild())
};
Some(vec::append(args, r.tail()))
DefStruct(..) => {
let new_args;
match args {
- Some(args) => new_args = args,
+ Some(args) => {
+ new_args = args.iter().map(|x| *x).collect()
+ }
None => new_args = vec::from_elem(arity, wild())
}
Some(vec::append(new_args, r.tail()))
}
}
}
- PatTup(args) => Some(vec::append(args, r.tail())),
+ PatTup(args) => {
+ Some(vec::append(args.iter().map(|x| *x).collect(), r.tail()))
+ }
PatUniq(a) | PatRegion(a) => {
Some(vec::append(~[a], r.tail()))
}
vec(_) => {
let num_elements = before.len() + after.len();
if num_elements < arity && slice.is_some() {
- Some(vec::append(
- [
- before,
- vec::from_elem(
- arity - num_elements, wild()),
- after
- ].concat_vec(),
- r.tail()
- ))
+ let mut result = ~[];
+ for pat in before.iter() {
+ result.push((*pat).clone());
+ }
+ for _ in iter::range(0, arity - num_elements) {
+ result.push(wild())
+ }
+ for pat in after.iter() {
+ result.push((*pat).clone());
+ }
+ for pat in r.tail().iter() {
+ result.push((*pat).clone());
+ }
+ Some(result)
} else if num_elements == arity {
- Some(vec::append(
- vec::append(before, after),
- r.tail()
- ))
+ let mut result = ~[];
+ for pat in before.iter() {
+ result.push((*pat).clone());
+ }
+ for pat in after.iter() {
+ result.push((*pat).clone());
+ }
+ for pat in r.tail().iter() {
+ result.push((*pat).clone());
+ }
+ Some(result)
} else {
None
}
None => None,
Some(ast_map::NodeItem(it)) => match it.node {
ItemEnum(ast::EnumDef { variants: ref variants }, _) => {
- variant_expr(*variants, variant_def.node)
+ variant_expr(variants.as_slice(), variant_def.node)
}
_ => None
},
c, d)) {
csearch::found(ast::IIItem(item)) => match item.node {
ItemEnum(ast::EnumDef { variants: ref variants }, _) => {
- variant_expr(*variants, variant_def.node)
+ variant_expr(variants.as_slice(), variant_def.node)
}
_ => None
},
pub fn lit_to_const(lit: &Lit) -> const_val {
match lit.node {
LitStr(ref s, _) => const_str((*s).clone()),
- LitBinary(ref data) => const_binary(data.clone()),
+ LitBinary(ref data) => {
+ const_binary(Rc::new(data.borrow().iter().map(|x| *x).collect()))
+ }
LitChar(n) => const_uint(n as u64),
LitInt(n, _) => const_int(n),
LitUint(n, _) => const_uint(n),
// determine the bits for the body and then union
// them into `in_out`, which reflects all bodies to date
let mut body = guards.to_owned();
- self.walk_pat_alternatives(arm.pats, body, loop_scopes);
+ self.walk_pat_alternatives(arm.pats.as_slice(),
+ body,
+ loop_scopes);
self.walk_block(arm.body, body, loop_scopes);
join_bits(&self.dfcx.oper, body, in_out);
}
}
ast::ExprVec(ref exprs, _) => {
- self.walk_exprs(*exprs, in_out, loop_scopes)
+ self.walk_exprs(exprs.as_slice(), in_out, loop_scopes)
}
ast::ExprRepeat(l, r, _) => {
ast::ExprCall(f, ref args) => {
self.walk_expr(f, in_out, loop_scopes);
- self.walk_call(expr.id, *args, in_out, loop_scopes);
+ self.walk_call(expr.id, args.as_slice(), in_out, loop_scopes);
}
ast::ExprMethodCall(_, _, ref args) => {
- self.walk_call(expr.id, *args, in_out, loop_scopes);
+ self.walk_call(expr.id, args.as_slice(), in_out, loop_scopes);
}
ast::ExprIndex(l, r) |
}
ast::ExprTup(ref exprs) => {
- self.walk_exprs(*exprs, in_out, loop_scopes);
+ self.walk_exprs(exprs.as_slice(), in_out, loop_scopes);
}
ast::ExprBinary(op, l, r) if ast_util::lazy_binop(op) => {
fn has_allow_dead_code_or_lang_attr(attrs: &[ast::Attribute]) -> bool {
contains_lint(attrs, allow, DEAD_CODE_LINT_STR)
- || attr::contains_name(attrs, "lang")
+ || attr::contains_name(attrs.as_slice(), "lang")
}
// This visitor seeds items that
impl Visitor<()> for LifeSeeder {
fn visit_item(&mut self, item: &ast::Item, _: ()) {
- if has_allow_dead_code_or_lang_attr(item.attrs) {
+ if has_allow_dead_code_or_lang_attr(item.attrs.as_slice()) {
self.worklist.push(item.id);
}
match item.node {
// Check for method here because methods are not ast::Item
match *fk {
visit::FkMethod(_, _, method) => {
- if has_allow_dead_code_or_lang_attr(method.attrs) {
+ if has_allow_dead_code_or_lang_attr(method.attrs.as_slice()) {
self.worklist.push(id);
}
}
}
// If the user wants no main function at all, then stop here.
- if attr::contains_name(krate.attrs, "no_main") {
+ if attr::contains_name(krate.attrs.as_slice(), "no_main") {
session.entry_type.set(Some(session::EntryNone));
return
}
});
}
- if attr::contains_name(item.attrs, "main") {
+ if attr::contains_name(item.attrs.as_slice(), "main") {
if ctxt.attr_main_fn.is_none() {
ctxt.attr_main_fn = Some((item.id, item.span));
} else {
}
}
- if attr::contains_name(item.attrs, "start") {
+ if attr::contains_name(item.attrs.as_slice(), "start") {
if ctxt.start_fn.is_none() {
ctxt.start_fn = Some((item.id, item.span));
} else {
}
fn check_item(cx: &mut Context, item: &Item) {
- if !attr::contains_name(item.attrs, "unsafe_destructor") {
+ if !attr::contains_name(item.attrs.as_slice(), "unsafe_destructor") {
match item.node {
ItemImpl(_, Some(ref trait_ref), self_type, _) => {
check_impl_of_trait(cx, item, trait_ref, self_type);
impl<'a> Visitor<()> for LanguageItemVisitor<'a> {
fn visit_item(&mut self, item: &ast::Item, _: ()) {
- match extract(item.attrs) {
+ match extract(item.attrs.as_slice()) {
Some(value) => {
let item_index = self.this.item_refs.find_equiv(&value).map(|x| *x);
attr.name().equiv(&("doc")) &&
match attr.meta_item_list() {
None => false,
- Some(l) => attr::contains_name(l, "hidden")
+ Some(l) => {
+ attr::contains_name(l.as_slice(), "hidden")
+ }
}
});
if ast_util::is_local(did) {
match cx.tcx.map.get(did.node) {
ast_map::NodeItem(it) => {
- if attr::contains_name(it.attrs, "must_use") {
+ if attr::contains_name(it.attrs.as_slice(),
+ "must_use") {
cx.span_lint(UnusedMustUse, s.span,
"unused result which must be used");
warned = true;
ref path, _) if pat_util::pat_is_binding(cx.tcx.def_map, p)=> {
// `let mut _a = 1;` doesn't need a warning.
let initial_underscore = if path.segments.len() == 1 {
- token::get_ident(path.segments[0].identifier).get()
- .starts_with("_")
+ token::get_ident(path.segments
+ .get(0)
+ .identifier).get().starts_with("_")
} else {
cx.tcx.sess.span_bug(p.span,
"mutable binding that doesn't consist \
ast::ItemTrait(..) => "a trait",
_ => return
};
- check_missing_doc_attrs(cx, Some(it.id), it.attrs, it.span, desc);
+ check_missing_doc_attrs(cx,
+ Some(it.id),
+ it.attrs.as_slice(),
+ it.span,
+ desc);
}
fn check_missing_doc_method(cx: &Context, m: &ast::Method) {
}
}
}
- check_missing_doc_attrs(cx, Some(m.id), m.attrs, m.span, "a method");
+ check_missing_doc_attrs(cx,
+ Some(m.id),
+ m.attrs.as_slice(),
+ m.span,
+ "a method");
}
fn check_missing_doc_ty_method(cx: &Context, tm: &ast::TypeMethod) {
- check_missing_doc_attrs(cx, Some(tm.id), tm.attrs, tm.span, "a type method");
+ check_missing_doc_attrs(cx,
+ Some(tm.id),
+ tm.attrs.as_slice(),
+ tm.span,
+ "a type method");
}
fn check_missing_doc_struct_field(cx: &Context, sf: &ast::StructField) {
match sf.node.kind {
ast::NamedField(_, vis) if vis != ast::Private =>
- check_missing_doc_attrs(cx, Some(cx.cur_struct_def_id), sf.node.attrs,
- sf.span, "a struct field"),
+ check_missing_doc_attrs(cx,
+ Some(cx.cur_struct_def_id),
+ sf.node.attrs.as_slice(),
+ sf.span,
+ "a struct field"),
_ => {}
}
}
fn check_missing_doc_variant(cx: &Context, v: &ast::Variant) {
- check_missing_doc_attrs(cx, Some(v.node.id), v.node.attrs, v.span, "a variant");
+ check_missing_doc_attrs(cx,
+ Some(v.node.id),
+ v.node.attrs.as_slice(),
+ v.span,
+ "a variant");
}
/// Checks for use of items with #[deprecated], #[experimental] and
impl<'a> Visitor<()> for Context<'a> {
fn visit_item(&mut self, it: &ast::Item, _: ()) {
- self.with_lint_attrs(it.attrs, |cx| {
+ self.with_lint_attrs(it.attrs.as_slice(), |cx| {
check_item_ctypes(cx, it);
check_item_non_camel_case_types(cx, it);
check_item_non_uppercase_statics(cx, it);
check_heap_item(cx, it);
check_missing_doc_item(cx, it);
- check_attrs_usage(cx, it.attrs);
+ check_attrs_usage(cx, it.attrs.as_slice());
cx.visit_ids(|v| v.visit_item(it, ()));
}
fn visit_foreign_item(&mut self, it: &ast::ForeignItem, _: ()) {
- self.with_lint_attrs(it.attrs, |cx| {
- check_attrs_usage(cx, it.attrs);
+ self.with_lint_attrs(it.attrs.as_slice(), |cx| {
+ check_attrs_usage(cx, it.attrs.as_slice());
visit::walk_foreign_item(cx, it, ());
})
}
fn visit_view_item(&mut self, i: &ast::ViewItem, _: ()) {
- self.with_lint_attrs(i.attrs, |cx| {
- check_attrs_usage(cx, i.attrs);
+ self.with_lint_attrs(i.attrs.as_slice(), |cx| {
+ check_attrs_usage(cx, i.attrs.as_slice());
visit::walk_view_item(cx, i, ());
})
}
match *fk {
visit::FkMethod(_, _, m) => {
- self.with_lint_attrs(m.attrs, |cx| {
+ self.with_lint_attrs(m.attrs.as_slice(), |cx| {
check_missing_doc_method(cx, m);
- check_attrs_usage(cx, m.attrs);
+ check_attrs_usage(cx, m.attrs.as_slice());
cx.visit_ids(|v| {
v.visit_fn(fk, decl, body, span, id, ());
fn visit_ty_method(&mut self, t: &ast::TypeMethod, _: ()) {
- self.with_lint_attrs(t.attrs, |cx| {
+ self.with_lint_attrs(t.attrs.as_slice(), |cx| {
check_missing_doc_ty_method(cx, t);
- check_attrs_usage(cx, t.attrs);
+ check_attrs_usage(cx, t.attrs.as_slice());
visit::walk_ty_method(cx, t, ());
})
}
fn visit_struct_field(&mut self, s: &ast::StructField, _: ()) {
- self.with_lint_attrs(s.node.attrs, |cx| {
+ self.with_lint_attrs(s.node.attrs.as_slice(), |cx| {
check_missing_doc_struct_field(cx, s);
- check_attrs_usage(cx, s.node.attrs);
+ check_attrs_usage(cx, s.node.attrs.as_slice());
visit::walk_struct_field(cx, s, ());
})
}
fn visit_variant(&mut self, v: &ast::Variant, g: &ast::Generics, _: ()) {
- self.with_lint_attrs(v.node.attrs, |cx| {
+ self.with_lint_attrs(v.node.attrs.as_slice(), |cx| {
check_missing_doc_variant(cx, v);
- check_attrs_usage(cx, v.node.attrs);
+ check_attrs_usage(cx, v.node.attrs.as_slice());
visit::walk_variant(cx, v, g, ());
})
for &(lint, level) in tcx.sess.opts.lint_opts.iter() {
cx.set_level(lint, level, CommandLine);
}
- cx.with_lint_attrs(krate.attrs, |cx| {
+ cx.with_lint_attrs(krate.attrs.as_slice(), |cx| {
cx.visit_id(ast::CRATE_NODE_ID);
cx.visit_ids(|v| {
v.visited_outermost = true;
visit::walk_crate(v, krate, ());
});
- check_crate_attrs_usage(cx, krate.attrs);
+ check_crate_attrs_usage(cx, krate.attrs.as_slice());
// since the root module isn't visited as an item (because it isn't an item), warn for it
// here.
- check_missing_doc_attrs(cx, None, krate.attrs, krate.span, "crate");
+ check_missing_doc_attrs(cx,
+ None,
+ krate.attrs.as_slice(),
+ krate.span,
+ "crate");
visit::walk_crate(cx, krate, ());
});
let guard_succ =
self.propagate_through_opt_expr(arm.guard, body_succ);
let arm_succ =
- self.define_bindings_in_arm_pats(arm.pats, guard_succ);
+ self.define_bindings_in_arm_pats(arm.pats.as_slice(),
+ guard_succ);
self.merge_from_succ(ln, arm_succ, first_merge);
first_merge = false;
};
}
ExprVec(ref exprs, _) => {
- self.propagate_through_exprs(*exprs, succ)
+ self.propagate_through_exprs(exprs.as_slice(), succ)
}
ExprRepeat(element, count, _) => {
let t_ret = ty::ty_fn_ret(ty::expr_ty(self.tcx, f));
let succ = if ty::type_is_bot(t_ret) {self.s.exit_ln}
else {succ};
- let succ = self.propagate_through_exprs(*args, succ);
+ let succ = self.propagate_through_exprs(args.as_slice(), succ);
self.propagate_through_expr(f, succ)
}
let t_ret = ty::node_id_to_type(self.tcx, expr.id);
let succ = if ty::type_is_bot(t_ret) {self.s.exit_ln}
else {succ};
- self.propagate_through_exprs(*args, succ)
+ self.propagate_through_exprs(args.as_slice(), succ)
}
ExprTup(ref exprs) => {
- self.propagate_through_exprs(*exprs, succ)
+ self.propagate_through_exprs(exprs.as_slice(), succ)
}
ExprBinary(op, l, r) if ast_util::lazy_binop(op) => {
}
fn check_arm(this: &mut Liveness, arm: &Arm) {
- this.arm_pats_bindings(arm.pats, |ln, var, sp, id| {
+ this.arm_pats_bindings(arm.pats.as_slice(), |ln, var, sp, id| {
this.warn_about_unused(sp, id, ln, var);
});
visit::walk_arm(this, arm, ());
}
}
self.use_expr(callee, mode);
- self.use_fn_args(*args);
+ self.use_fn_args(args.as_slice());
}
ExprMethodCall(_, _, ref args) => { // callee.m(args)
- self.use_fn_args(*args);
+ self.use_fn_args(args.as_slice());
}
ExprStruct(_, ref fields, opt_with) => {
}
ExprTup(ref exprs) => {
- self.consume_exprs(*exprs);
+ self.consume_exprs(exprs.as_slice());
}
ExprIf(cond_expr, then_blk, opt_else_expr) => {
}
ExprVec(ref exprs, _) => {
- self.consume_exprs(*exprs);
+ self.consume_exprs(exprs.as_slice());
}
ExprAddrOf(_, base) => { // &base
fn visit_item(&mut self, item: &ast::Item, _: ()) {
// Do not check privacy inside items with the resolve_unexported
// attribute. This is used for the test runner.
- if attr::contains_name(item.attrs, "!resolve_unexported") {
+ if attr::contains_name(item.attrs.as_slice(), "!resolve_unexported") {
return;
}
}
ast::ExprMethodCall(ident, _, ref args) => {
// see above
- let t = ty::type_autoderef(ty::expr_ty(self.tcx, args[0]));
+ let t = ty::type_autoderef(ty::expr_ty(self.tcx,
+ *args.get(0)));
match ty::get(t).sty {
ty::ty_enum(_, _) | ty::ty_struct(_, _) => {
match self.method_map.borrow().get().find(&expr.id) {
lifetimes: opt_vec::Empty,
types: opt_vec::Empty,
};
- let segs = ~[seg];
+ let segs = vec!(seg);
let path = ast::Path {
global: false,
span: pid.span,
// monomorphized or it was marked with `#[inline]`. This will only return
// true for functions.
fn item_might_be_inlined(item: &ast::Item) -> bool {
- if attributes_specify_inlining(item.attrs) {
+ if attributes_specify_inlining(item.attrs.as_slice()) {
return true
}
fn method_might_be_inlined(tcx: ty::ctxt, method: &ast::Method,
impl_src: ast::DefId) -> bool {
- if attributes_specify_inlining(method.attrs) ||
+ if attributes_specify_inlining(method.attrs.as_slice()) ||
generics_require_inlining(&method.generics) {
return true
}
}
Some(ast_map::NodeMethod(method)) => {
if generics_require_inlining(&method.generics) ||
- attributes_specify_inlining(method.attrs) {
+ attributes_specify_inlining(method.attrs.as_slice()) {
true
} else {
let impl_did = tcx.map.get_parent_did(node_id);
// Statics with insignificant addresses are not reachable
// because they're inlined specially into all other crates.
ast::ItemStatic(..) => {
- if attr::contains_name(item.attrs,
+ if attr::contains_name(item.attrs.as_slice(),
"address_insignificant") {
let mut reachable_symbols =
self.reachable_symbols.borrow_mut();
generics,
implemented_traits,
self_type,
- *methods);
+ methods.as_slice());
}
ItemTrait(ref generics, ref traits, ref methods) => {
ItemStruct(ref struct_def, ref generics) => {
self.resolve_struct(item.id,
generics,
- struct_def.fields);
+ struct_def.fields.as_slice());
}
ItemMod(ref module_) => {
// check that all of the arms in an or-pattern have exactly the
// same set of bindings, with the same binding modes for each.
fn check_consistent_bindings(&mut self, arm: &Arm) {
- if arm.pats.len() == 0 { return; }
- let map_0 = self.binding_mode_map(arm.pats[0]);
+ if arm.pats.len() == 0 {
+ return
+ }
+ let map_0 = self.binding_mode_map(*arm.pats.get(0));
for (i, p) in arm.pats.iter().enumerate() {
let map_i = self.binding_mode_map(*p);
// such a value is simply disallowed (since it's rarely
// what you want).
- let ident = path.segments[0].identifier;
+ let ident = path.segments.get(0).identifier;
let renamed = mtwt_resolve(ident);
match self.resolve_bare_identifier_pattern(ident) {
// FIXME: Must we clone?
match *subpats {
None => Some(vec::from_elem(variant_size, dummy)),
- _ => (*subpats).clone(),
+ Some(ref subpats) => {
+ Some((*subpats).iter().map(|x| *x).collect())
+ }
}
} else {
None
let this_opt = vec_len(n, vec_len_ge(before.len()),
(lo, hi));
if opt_eq(tcx, &this_opt, opt) {
- Some(vec::append_one((*before).clone(), slice) +
- *after)
+ let mut new_before = ~[];
+ for pat in before.iter() {
+ new_before.push(*pat);
+ }
+ new_before.push(slice);
+ for pat in after.iter() {
+ new_before.push(*pat);
+ }
+ Some(new_before)
} else {
None
}
None if i >= lo && i <= hi => {
let n = before.len();
if opt_eq(tcx, &vec_len(n, vec_len_eq, (lo,hi)), opt) {
- Some((*before).clone())
+ let mut new_before = ~[];
+ for pat in before.iter() {
+ new_before.push(*pat);
+ }
+ Some(new_before)
} else {
None
}
let dummy = @ast::Pat {id: 0, node: ast::PatWild, span: DUMMY_SP};
enter_match(bcx, dm, m, col, val, |p| {
match p.node {
- ast::PatTup(ref elts) => Some((*elts).clone()),
+ ast::PatTup(ref elts) => {
+ let mut new_elts = ~[];
+ for elt in elts.iter() {
+ new_elts.push((*elt).clone())
+ }
+ Some(new_elts)
+ }
_ => {
assert_is_binding_or_wild(bcx, p);
Some(vec::from_elem(n_elts, dummy))
let dummy = @ast::Pat {id: 0, node: ast::PatWild, span: DUMMY_SP};
enter_match(bcx, dm, m, col, val, |p| {
match p.node {
- ast::PatEnum(_, Some(ref elts)) => Some((*elts).clone()),
+ ast::PatEnum(_, Some(ref elts)) => {
+ Some(elts.iter().map(|x| (*x)).collect())
+ }
_ => {
assert_is_binding_or_wild(bcx, p);
Some(vec::from_elem(n_elts, dummy))
ast::PatStruct(_, ref fs, _) => {
match ty::get(node_id_type(bcx, br.pats[col].id)).sty {
ty::ty_struct(..) => {
- extend(&mut fields, *fs);
+ extend(&mut fields, fs.as_slice());
found = true;
}
_ => ()
let mut matches = ~[];
for arm in arms.iter() {
let body = fcx.new_id_block("case_body", arm.body.id);
- let bindings_map = create_bindings_map(bcx, arm.pats[0]);
+ let bindings_map = create_bindings_map(bcx, *arm.pats.get(0));
let arm_data = ArmData {
bodycx: body,
arm: arm,
val);
for sub_pat in sub_pats.iter() {
for (i, argval) in args.vals.iter().enumerate() {
- bcx = bind_irrefutable_pat(bcx, sub_pat[i],
+ bcx = bind_irrefutable_pat(bcx, *sub_pat.get(i),
*argval, binding_mode,
cleanup_scope);
}
let r = ia.asm.get().with_c_str(|a| {
constraints.with_c_str(|c| {
- InlineAsmCall(bcx, a, c, inputs, output_type, ia.volatile, ia.alignstack, dialect)
+ InlineAsmCall(bcx,
+ a,
+ c,
+ inputs.as_slice(),
+ output_type,
+ ia.volatile,
+ ia.alignstack,
+ dialect)
})
});
// Again, based on how many outputs we have
if numOutputs == 1 {
- Store(bcx, r, outputs[0]);
+ Store(bcx, r, *outputs.get(0));
} else {
for (i, o) in outputs.iter().enumerate() {
let v = ExtractValue(bcx, r, i);
let arg_tys = ty::ty_fn_args(node_id_type(bcx, id));
let arg_datums = create_datums_for_fn_args(&fcx, arg_tys);
- bcx = copy_args_to_allocas(&fcx, arg_scope, bcx, decl.inputs, arg_datums);
+ bcx = copy_args_to_allocas(&fcx,
+ arg_scope,
+ bcx,
+ decl.inputs.as_slice(),
+ arg_datums);
bcx = maybe_load_env(bcx);
match variant.node.kind {
ast::TupleVariantKind(ref args) if args.len() > 0 => {
let llfn = get_item_val(ccx, variant.node.id);
- trans_enum_variant(ccx, id, variant, *args,
+ trans_enum_variant(ccx, id, variant, args.as_slice(),
disr_val, None, llfn);
}
ast::TupleVariantKind(_) => {
if purity == ast::ExternFn {
let llfndecl = get_item_val(ccx, item.id);
foreign::trans_rust_fn_with_foreign_abi(
- ccx, decl, body, item.attrs, llfndecl, item.id);
+ ccx, decl, body, item.attrs.as_slice(), llfndecl, item.id);
} else if !generics.is_type_parameterized() {
let llfn = get_item_val(ccx, item.id);
- trans_fn(ccx, decl, body, llfn, None, item.id, item.attrs);
+ trans_fn(ccx,
+ decl,
+ body,
+ llfn,
+ None,
+ item.id,
+ item.attrs.as_slice());
} else {
// Be sure to travel more than just one layer deep to catch nested
// items in blocks and such.
}
}
ast::ItemImpl(ref generics, _, _, ref ms) => {
- meth::trans_impl(ccx, item.ident, *ms, generics, item.id);
+ meth::trans_impl(ccx, item.ident, ms.as_slice(), generics, item.id);
}
ast::ItemMod(ref m) => {
trans_mod(ccx, m);
consts::trans_const(ccx, m, item.id);
// Do static_assert checking. It can't really be done much earlier
// because we need to get the value of the bool out of LLVM
- if attr::contains_name(item.attrs, "static_assert") {
+ if attr::contains_name(item.attrs.as_slice(), "static_assert") {
if m == ast::MutMutable {
ccx.sess.span_fatal(expr.span,
"cannot have static_assert on a mutable \
// otherwise this is a unit-like struct.
Some(ctor_id) if struct_def.fields.len() > 0 => {
let llfndecl = get_item_val(ccx, ctor_id);
- trans_tuple_struct(ccx, struct_def.fields,
+ trans_tuple_struct(ccx, struct_def.fields.as_slice(),
ctor_id, None, llfndecl);
}
Some(_) | None => {}
let val = match item {
ast_map::NodeItem(i) => {
let ty = ty::node_id_to_type(ccx.tcx, i.id);
- let sym = exported_name(ccx, id, ty, i.attrs);
+ let sym = exported_name(ccx, id, ty, i.attrs.as_slice());
let v = match i.node {
ast::ItemStatic(_, _, expr) => {
// Apply the `unnamed_addr` attribute if
// requested
- if attr::contains_name(i.attrs,
+ if attr::contains_name(i.attrs.as_slice(),
"address_insignificant"){
{
let reachable =
inlineable = true;
}
- if attr::contains_name(i.attrs, "thread_local") {
+ if attr::contains_name(i.attrs.as_slice(),
+ "thread_local") {
lib::llvm::set_thread_local(g, true);
}
sym,
i.id)
};
- set_llvm_fn_attrs(i.attrs, llfn);
+ set_llvm_fn_attrs(i.attrs.as_slice(), llfn);
llfn
}
_ => fail!("get_item_val: weird result in table")
};
- match attr::first_attr_value_str_by_name(i.attrs, "link_section") {
+ match attr::first_attr_value_str_by_name(i.attrs
+ .as_slice(),
+ "link_section") {
Some(sect) => unsafe {
sect.get().with_c_str(|buf| {
llvm::LLVMSetSection(v, buf);
// with weak linkage, but if we're building a
// library then we've already declared the crate map
// so use that instead.
- if attr::contains_name(ni.attrs, "crate_map") {
+ if attr::contains_name(ni.attrs.as_slice(),
+ "crate_map") {
if ccx.sess.building_library.get() {
let s = "_rust_crate_map_toplevel";
let g = unsafe {
let ty = ty::node_id_to_type(ccx.tcx, id);
let parent = ccx.tcx.map.get_parent(id);
let enm = ccx.tcx.map.expect_item(parent);
- let sym = exported_name(ccx, id, ty, enm.attrs);
+ let sym = exported_name(ccx,
+ id,
+ ty,
+ enm.attrs.as_slice());
llfn = match enm.node {
ast::ItemEnum(_, _) => {
let parent = ccx.tcx.map.get_parent(id);
let struct_item = ccx.tcx.map.expect_item(parent);
let ty = ty::node_id_to_type(ccx.tcx, ctor_id);
- let sym = exported_name(ccx, id, ty, struct_item.attrs);
+ let sym = exported_name(ccx,
+ id,
+ ty,
+ struct_item.attrs
+ .as_slice());
let llfn = register_fn(ccx, struct_item.span,
sym, ctor_id, ty);
set_inline_hint(llfn);
m: &ast::Method) -> ValueRef {
let mty = ty::node_id_to_type(ccx.tcx, id);
- let sym = exported_name(ccx, id, mty, m.attrs);
+ let sym = exported_name(ccx, id, mty, m.attrs.as_slice());
let llfn = register_fn(ccx, m.span, sym, id, mty);
- set_llvm_fn_attrs(m.attrs, llfn);
+ set_llvm_fn_attrs(m.attrs.as_slice(), llfn);
llfn
}
ast::LitBool(b) => C_bool(b),
ast::LitNil => C_nil(),
ast::LitStr(ref s, _) => C_str_slice(cx, (*s).clone()),
- ast::LitBinary(ref data) => C_binary_slice(cx, *data.borrow()),
+ ast::LitBinary(ref data) => {
+ C_binary_slice(cx, data.borrow().as_slice())
+ }
}
}
ast::ExprTup(ref es) => {
let ety = ty::expr_ty(cx.tcx, e);
let repr = adt::represent_type(cx, ety);
- let (vals, inlineable) = map_list(*es);
+ let (vals, inlineable) = map_list(es.as_slice());
(adt::trans_const(cx, repr, 0, vals), inlineable)
}
ast::ExprStruct(_, ref fs, ref base_opt) => {
})
}
ast::ExprVec(ref es, ast::MutImmutable) => {
- let (v, _, inlineable) = const_vec(cx, e, *es, is_local);
+ let (v, _, inlineable) = const_vec(cx,
+ e,
+ es.as_slice(),
+ is_local);
(v, inlineable)
}
ast::ExprVstore(sub, ast::ExprVstoreSlice) => {
}
}
ast::ExprVec(ref es, ast::MutImmutable) => {
- let (cv, llunitty, _) = const_vec(cx, e, *es, is_local);
+ let (cv, llunitty, _) = const_vec(cx,
+ e,
+ es.as_slice(),
+ is_local);
let llty = val_ty(cv);
let gv = "const".with_c_str(|name| {
llvm::LLVMAddGlobal(cx.llmod, llty.to_ref(), name)
Some(ast::DefStruct(_)) => {
let ety = ty::expr_ty(cx.tcx, e);
let repr = adt::represent_type(cx, ety);
- let (arg_vals, inlineable) = map_list(*args);
+ let (arg_vals, inlineable) = map_list(args.as_slice());
(adt::trans_const(cx, repr, 0, arg_vals), inlineable)
}
Some(ast::DefVariant(enum_did, variant_did, _)) => {
let vinfo = ty::enum_variant_with_id(cx.tcx,
enum_did,
variant_did);
- let (arg_vals, inlineable) = map_list(*args);
+ let (arg_vals, inlineable) = map_list(args.as_slice());
(adt::trans_const(cx, repr, vinfo.disr_val, arg_vals),
inlineable)
}
{
let mut scope_map = fn_debug_context.scope_map.borrow_mut();
populate_scope_map(cx,
- arg_pats,
+ arg_pats.as_slice(),
top_level_block,
fn_metadata,
scope_map.get());
// they all must contain the same binding names
for arm_ref in arms.iter() {
- let arm_span = arm_ref.pats[0].span;
+ let arm_span = arm_ref.pats.get(0).span;
with_new_scope(cx,
arm_span,
controlflow::trans_if(bcx, expr.id, cond, thn, els, dest)
}
ast::ExprMatch(discr, ref arms) => {
- _match::trans_match(bcx, expr, discr, *arms, dest)
+ _match::trans_match(bcx, expr, discr, arms.as_slice(), dest)
}
ast::ExprBlock(blk) => {
controlflow::trans_block(bcx, blk, dest)
}
ast::ExprStruct(_, ref fields, base) => {
- trans_rec_or_struct(bcx, (*fields), base, expr.span, expr.id, dest)
+ trans_rec_or_struct(bcx,
+ fields.as_slice(),
+ base,
+ expr.span,
+ expr.id,
+ dest)
}
ast::ExprTup(ref args) => {
let repr = adt::represent_type(bcx.ccx(), expr_ty(bcx, expr));
closure::trans_expr_fn(bcx, sigil, decl, body, expr.id, dest)
}
ast::ExprCall(f, ref args) => {
- callee::trans_call(bcx, expr, f, callee::ArgExprs(*args), expr.id, dest)
+ callee::trans_call(bcx,
+ expr,
+ f,
+ callee::ArgExprs(args.as_slice()),
+ expr.id,
+ dest)
}
ast::ExprMethodCall(_, _, ref args) => {
- callee::trans_method_call(bcx, expr, args[0], callee::ArgExprs(*args), dest)
+ callee::trans_method_call(bcx,
+ expr,
+ *args.get(0),
+ callee::ArgExprs(args.as_slice()),
+ dest)
}
ast::ExprBinary(_, lhs, rhs) => {
// if not overloaded, would be RvalueDatumExpr
// the massive simplifications that have occurred.
pub fn link_name(i: @ast::ForeignItem) -> InternedString {
- match attr::first_attr_value_str_by_name(i.attrs, "link_name") {
+ match attr::first_attr_value_str_by_name(i.attrs.as_slice(),
+ "link_name") {
None => token::get_ident(i.ident),
Some(ln) => ln.clone(),
}
let g = get_item_val(ccx, item.id);
// see the comment in get_item_val() as to why this check is
// performed here.
- if !attr::contains_name(item.attrs,
+ if !attr::contains_name(item.attrs.as_slice(),
"address_insignificant") {
SetLinkage(g, AvailableExternallyLinkage);
}
..
} => {
let d = mk_lldecl();
- set_llvm_fn_attrs(i.attrs, d);
+ set_llvm_fn_attrs(i.attrs.as_slice(), d);
trans_fn(ccx, decl, body, d, Some(psubsts), fn_id.node, []);
d
}
trans_enum_variant(ccx,
parent,
v,
- (*args).clone(),
+ args.as_slice(),
this_tv.disr_val,
Some(psubsts),
d);
}
ast_map::NodeMethod(mth) => {
let d = mk_lldecl();
- set_llvm_fn_attrs(mth.attrs, d);
+ set_llvm_fn_attrs(mth.attrs.as_slice(), d);
trans_fn(ccx, mth.decl, mth.body, d, Some(psubsts), mth.id, []);
d
}
match *method {
ast::Provided(mth) => {
let d = mk_lldecl();
- set_llvm_fn_attrs(mth.attrs, d);
+ set_llvm_fn_attrs(mth.attrs.as_slice(), d);
trans_fn(ccx, mth.decl, mth.body, d, Some(psubsts), mth.id, []);
d
}
let d = mk_lldecl();
set_inline_hint(d);
base::trans_tuple_struct(ccx,
- struct_def.fields,
+ struct_def.fields.as_slice(),
struct_def.ctor_id.expect("ast-mapped tuple struct \
didn't have a ctor id"),
Some(psubsts),
Some(ast_map::NodeItem(item)) => {
match item.node {
ItemTrait(_, _, ref ms) => {
- let (_, p) = ast_util::split_trait_methods(*ms);
- p.map(|m| method(cx, ast_util::local_def(m.id)))
+ let (_, p) =
+ ast_util::split_trait_methods(ms.as_slice());
+ p.iter()
+ .map(|m| method(cx, ast_util::local_def(m.id)))
+ .collect()
}
_ => {
cx.sess.bug(format!("provided_trait_methods: \
},
ast::StructVariantKind(ref struct_def) => {
- let fields: &[StructField] = struct_def.fields;
+ let fields: &[StructField] = struct_def.fields.as_slice();
assert!(fields.len() > 0);
Some(ast_map::NodeItem(i)) => {
match i.node {
ast::ItemStruct(struct_def, _) => {
- struct_field_tys(struct_def.fields)
+ struct_field_tys(struct_def.fields.as_slice())
}
_ => cx.sess.bug("struct ID bound to non-struct")
}
Some(ast_map::NodeVariant(ref variant)) => {
match (*variant).node.kind {
ast::StructVariantKind(struct_def) => {
- struct_field_tys(struct_def.fields)
+ struct_field_tys(struct_def.fields.as_slice())
}
_ => {
cx.sess.bug("struct ID bound to enum variant that isn't \
use middle::typeck::lookup_def_tcx;
use util::ppaux::Repr;
-use std::vec;
+use std::vec_ng::Vec;
use syntax::abi::AbiSet;
use syntax::{ast, ast_util};
use syntax::codemap::Span;
}
match anon_regions {
- Ok(v) => opt_vec::from(v),
- Err(()) => opt_vec::from(vec::from_fn(expected_num_region_params,
+ Ok(v) => opt_vec::from(v.move_iter().collect()),
+ Err(()) => opt_vec::from(Vec::from_fn(expected_num_region_params,
|_| ty::ReStatic)) // hokey
}
};
|tmt| ty::mk_rptr(tcx, r, tmt))
}
ast::TyTup(ref fields) => {
- let flds = fields.map(|&t| ast_ty_to_ty(this, rscope, t));
+ let flds = fields.iter()
+ .map(|&t| ast_ty_to_ty(this, rscope, t))
+ .collect();
ty::mk_tup(tcx, flds)
}
ast::TyBareFn(ref bf) => {
use middle::typeck::require_same_types;
use collections::{HashMap, HashSet};
+use std::vec_ng::Vec;
use syntax::ast;
use syntax::ast_util;
use syntax::parse::token;
for arm in arms.iter() {
let mut pcx = pat_ctxt {
fcx: fcx,
- map: pat_id_map(tcx.def_map, arm.pats[0]),
+ map: pat_id_map(tcx.def_map, *arm.pats.get(0)),
};
for p in arm.pats.iter() { check_pat(&mut pcx, *p, discrim_ty);}
}
pub fn check_pat_variant(pcx: &pat_ctxt, pat: &ast::Pat, path: &ast::Path,
- subpats: &Option<~[@ast::Pat]>, expected: ty::t) {
+ subpats: &Option<Vec<@ast::Pat>>, expected: ty::t) {
// Typecheck the path.
let fcx = pcx.fcx;
let tcx = pcx.fcx.ccx.tcx;
- let arg_types;
+ let arg_types: ~[ty::t];
let kind_name;
// structure_of requires type variables to be resolved.
fcx.write_error(pat.id);
kind_name = "[error]";
arg_types = subpats.clone()
- .unwrap_or_default()
- .map(|_| ty::mk_err());
+ .unwrap_or_default()
+ .move_iter()
+ .map(|_| ty::mk_err())
+ .collect();
}
}
}
fcx.write_error(pat.id);
kind_name = "[error]";
arg_types = subpats.clone()
- .unwrap_or_default()
- .map(|_| ty::mk_err());
+ .unwrap_or_default()
+ .iter()
+ .map(|_| ty::mk_err())
+ .collect();
}
}
}
}
ast::PatIdent(_, ref path, _) => {
- check_pat_variant(pcx, pat, path, &Some(~[]), expected);
+ check_pat_variant(pcx, pat, path, &Some(Vec::new()), expected);
}
ast::PatEnum(ref path, ref subpats) => {
check_pat_variant(pcx, pat, path, subpats, expected);
match *structure {
ty::ty_struct(cid, ref substs) => {
check_struct_pat(pcx, pat.id, pat.span, expected, path,
- *fields, etc, cid, substs);
+ fields.as_slice(), etc, cid, substs);
}
ty::ty_enum(eid, ref substs) => {
- check_struct_like_enum_variant_pat(
- pcx, pat.id, pat.span, expected, path, *fields, etc, eid,
- substs);
+ check_struct_like_enum_variant_pat(pcx,
+ pat.id,
+ pat.span,
+ expected,
+ path,
+ fields.as_slice(),
+ etc,
+ eid,
+ substs);
}
_ => {
// See [Note-Type-error-reporting] in middle/typeck/infer/mod.rs
let def_map = tcx.def_map.borrow();
match def_map.get().find(&pat.id) {
Some(&ast::DefStruct(supplied_def_id)) => {
- check_struct_pat(pcx, pat.id, pat.span, ty::mk_err(), path, *fields, etc,
- supplied_def_id,
- &ty::substs { self_ty: None, tps: ~[], regions: ty::ErasedRegions} );
+ check_struct_pat(pcx,
+ pat.id,
+ pat.span,
+ ty::mk_err(),
+ path,
+ fields.as_slice(),
+ etc,
+ supplied_def_id,
+ &ty::substs {
+ self_ty: None,
+ tps: ~[],
+ regions: ty::ErasedRegions,
+ });
}
_ => () // Error, but we're already in an error case
}
{
let locals = self.fcx.inh.locals.borrow();
debug!("Pattern binding {} is assigned to {}",
- token::get_ident(path.segments[0].identifier),
+ token::get_ident(path.segments.get(0).identifier),
self.fcx.infcx().ty_to_str(
locals.get().get_copy(&p.id)));
}
ast::ItemEnum(ref enum_definition, _) => {
check_enum_variants(ccx,
it.span,
- enum_definition.variants,
+ enum_definition.variants.as_slice(),
it.id);
}
ast::ItemFn(decl, _, _, _, body) => {
&impl_tpt.generics,
ast_trait_ref,
impl_trait_ref,
- *ms);
+ ms.as_slice());
vtable::resolve_impl(ccx.tcx, it, &impl_tpt.generics, impl_trait_ref);
}
None => { }
n_rps);
let tps = vcx.infcx.next_ty_vars(n_tps);
- let substs = substs {regions: ty::NonerasedRegions(opt_vec::from(rps)),
- self_ty: None,
- tps: tps};
+ let substs = substs {
+ regions: ty::NonerasedRegions(opt_vec::from(rps.move_iter()
+ .collect())),
+ self_ty: None,
+ tps: tps,
+ };
let substd_ty = ty::subst(tcx, &substs, raw_ty);
ty_param_substs_and_ty { substs: substs, ty: substd_ty }
// Verify that no lifetimes or type parameters are present anywhere
// except the final two elements of the path.
for i in range(0, path.segments.len() - 2) {
- for lifetime in path.segments[i].lifetimes.iter() {
+ for lifetime in path.segments.get(i).lifetimes.iter() {
function_context.tcx()
.sess
.span_err(lifetime.span,
break;
}
- for typ in path.segments[i].types.iter() {
+ for typ in path.segments.get(i).types.iter() {
function_context.tcx()
.sess
.span_err(typ.span,
ast::FromImpl(_) => "impl",
};
- let trait_segment = &path.segments[path.segments.len() - 2];
+ let trait_segment = &path.segments.get(path.segments.len() - 2);
// Make sure lifetime parameterization agrees with the trait or
// implementation type.
_ => {
// Verify that no lifetimes or type parameters are present on
// the penultimate segment of the path.
- let segment = &path.segments[path.segments.len() - 2];
+ let segment = &path.segments.get(path.segments.len() - 2);
for lifetime in segment.lifetimes.iter() {
function_context.tcx()
.sess
// Generate the struct type.
let regions = fcx.infcx().next_region_vars(
infer::BoundRegionInTypeOrImpl(span),
- region_parameter_count);
+ region_parameter_count).move_iter().collect();
let type_parameters = fcx.infcx().next_ty_vars(type_parameter_count);
let substitutions = substs {
regions: ty::NonerasedRegions(opt_vec::from(regions)),
// Generate the enum type.
let regions = fcx.infcx().next_region_vars(
infer::BoundRegionInTypeOrImpl(span),
- region_parameter_count);
+ region_parameter_count).move_iter().collect();
let type_parameters = fcx.infcx().next_ty_vars(type_parameter_count);
let substitutions = substs {
regions: ty::NonerasedRegions(opt_vec::from(regions)),
}
}
ast::ExprMatch(discrim, ref arms) => {
- _match::check_match(fcx, expr, discrim, *arms);
+ _match::check_match(fcx, expr, discrim, arms.as_slice());
}
ast::ExprFnBlock(decl, body) => {
check_expr_fn(fcx,
fcx.write_ty(id, fcx.node_ty(b.id));
}
ast::ExprCall(f, ref args) => {
- check_call(fcx, expr, f, *args);
+ check_call(fcx, expr, f, args.as_slice());
let f_ty = fcx.expr_ty(f);
let (args_bot, args_err) = args.iter().fold((false, false),
|(rest_bot, rest_err), a| {
}
}
ast::ExprMethodCall(ident, ref tps, ref args) => {
- check_method_call(fcx, expr, ident, *args, *tps);
+ check_method_call(fcx, expr, ident, args.as_slice(), tps.as_slice());
let arg_tys = args.map(|a| fcx.expr_ty(*a));
let (args_bot, args_err) = arg_tys.iter().fold((false, false),
|(rest_bot, rest_err), a| {
match def_map.get().find(&id) {
Some(&ast::DefStruct(type_def_id)) => {
check_struct_constructor(fcx, id, expr.span, type_def_id,
- *fields, base_expr);
+ fields.as_slice(), base_expr);
}
Some(&ast::DefVariant(enum_id, variant_id, _)) => {
check_struct_enum_variant(fcx, id, expr.span, enum_id,
- variant_id, *fields);
+ variant_id, fields.as_slice());
}
_ => {
tcx.sess.span_bug(path.span,
}
}
ast::ExprField(base, field, ref tys) => {
- check_field(fcx, expr, base, field.name, *tys);
+ check_field(fcx, expr, base, field.name, tys.as_slice());
}
ast::ExprIndex(base, idx) => {
check_expr(fcx, base);
opt_vec::from(fcx.infcx().next_region_vars(
infer::BoundRegionInTypeOrImpl(span),
- num_expected_regions))
+ num_expected_regions).move_iter().collect())
};
let regions = ty::NonerasedRegions(regions);
match expr.node {
ast::ExprCall(callee, ref args) => {
constrain_callee(rcx, callee.id, expr, callee);
- constrain_call(rcx, Some(callee.id), expr, None, *args, false);
+ constrain_call(rcx,
+ Some(callee.id),
+ expr,
+ None,
+ args.as_slice(),
+ false);
visit::walk_expr(rcx, expr, ());
}
ast::ExprMethodCall(_, _, ref args) => {
- constrain_call(rcx, None, expr, Some(args[0]),
+ constrain_call(rcx, None, expr, Some(*args.get(0)),
args.slice_from(1), false);
visit::walk_expr(rcx, expr, ());
}
ast::ExprMatch(discr, ref arms) => {
- link_match(rcx, discr, *arms);
+ link_match(rcx, discr, arms.as_slice());
visit::walk_expr(rcx, expr, ());
}
let type_parameters = self.inference_context.next_ty_vars(bounds_count);
let substitutions = substs {
- regions: ty::NonerasedRegions(opt_vec::from(region_parameters)),
+ regions: ty::NonerasedRegions(opt_vec::from(
+ region_parameters.move_iter().collect())),
self_ty: None,
tps: type_parameters
};
ast::TupleVariantKind(ref args) if args.len() > 0 => {
let rs = ExplicitRscope;
let input_tys = args.map(|va| ccx.to_ty(&rs, va.ty));
- ty::mk_ctor_fn(tcx, scope, input_tys, enum_ty)
+ ty::mk_ctor_fn(tcx, scope, input_tys.as_slice(), enum_ty)
}
ast::TupleVariantKind(_) => {
let input_tys = struct_def.fields.map(
|f| ty::node_id_to_type(ccx.tcx, f.node.id));
- ty::mk_ctor_fn(tcx, scope, input_tys, enum_ty)
+ ty::mk_ctor_fn(tcx, scope, input_tys.as_slice(), enum_ty)
}
};
let trait_def_id = local_def(trait_id);
let mut trait_method_def_ids = tcx.trait_method_def_ids
.borrow_mut();
- trait_method_def_ids.get().insert(trait_def_id,
- method_def_ids);
+ trait_method_def_ids.get()
+ .insert(trait_def_id,
+ @method_def_ids.iter()
+ .map(|x| *x)
+ .collect());
}
_ => {} // Ignore things that aren't traits.
}
write_ty_to_tcx(tcx, it.id, tpt.ty);
get_enum_variant_types(ccx,
tpt.ty,
- enum_definition.variants,
+ enum_definition.variants.as_slice(),
generics);
},
ast::ItemImpl(ref generics, ref opt_trait_ref, selfty, ref ms) => {
convert_methods(ccx,
ImplContainer(local_def(it.id)),
- *ms,
+ ms.as_slice(),
selfty,
&i_ty_generics,
generics,
// Run convert_methods on the provided methods.
let (_, provided_methods) =
- split_trait_methods(*trait_methods);
+ split_trait_methods(trait_methods.as_slice());
let untransformed_rcvr_ty = ty::mk_self(tcx, local_def(it.id));
convert_methods(ccx,
TraitContainer(local_def(it.id)),
- provided_methods,
+ provided_methods.as_slice(),
untransformed_rcvr_ty,
&trait_def.generics,
generics,
let mut tcache = tcx.tcache.borrow_mut();
tcache.get().insert(local_def(ctor_id), tpt);
}
- } else if struct_def.fields[0].node.kind == ast::UnnamedField {
+ } else if struct_def.fields.get(0).node.kind ==
+ ast::UnnamedField {
// Tuple-like.
let inputs = {
let tcache = tcx.tcache.borrow();
|field| tcache.get().get(
&local_def(field.node.id)).ty)
};
- let ctor_fn_ty = ty::mk_ctor_fn(tcx, ctor_id, inputs, selfty);
+ let ctor_fn_ty = ty::mk_ctor_fn(tcx,
+ ctor_id,
+ inputs.as_slice(),
+ selfty);
write_ty_to_tcx(tcx, ctor_id, ctor_fn_ty);
{
let mut tcache = tcx.tcache.borrow_mut();
let self_ty = ty::mk_self(tcx, def_id);
let ty_generics = ty_generics(ccx, generics, 0);
let substs = mk_item_substs(ccx, &ty_generics, Some(self_ty));
- let bounds = ensure_supertraits(ccx, it.id, it.span, *supertraits);
+ let bounds = ensure_supertraits(ccx,
+ it.id,
+ it.span,
+ supertraits.as_slice());
let trait_ref = @ty::TraitRef {def_id: def_id,
substs: substs};
let trait_def = @ty::TraitDef {generics: ty_generics,
def
}
}
- }))
+ }).move_iter().collect())
};
fn compute_bounds(
-> ty::ty_param_bounds_and_ty {
let ty_generics = ty_generics(ccx, ast_generics, 0);
let rb = BindingRscope::new(def_id.node);
- let input_tys = decl.inputs.map(|a| ty_of_arg(ccx, &rb, a, None) );
+ let input_tys = decl.inputs
+ .iter()
+ .map(|a| ty_of_arg(ccx, &rb, a, None))
+ .collect();
let output_ty = ast_ty_to_ty(ccx, &rb, decl.output);
let t_fn = ty::mk_bare_fn(
fn repr(&self, tcx: ctxt) -> ~str {
match *self {
opt_vec::Empty => ~"[]",
- opt_vec::Vec(ref v) => repr_vec(tcx, *v)
+ opt_vec::Vec(ref v) => repr_vec(tcx, v.as_slice())
}
}
}
use doctree;
use visit_ast;
use std::local_data;
+use std::vec_ng::Vec;
pub trait Clean<T> {
fn clean(&self) -> T;
self.iter().map(|x| x.clean()).collect()
}
}
+
+impl<T: Clean<U>, U> Clean<Vec<U>> for Vec<T> {
+ fn clean(&self) -> Vec<U> {
+ self.iter().map(|x| x.clean()).collect()
+ }
+}
+
impl<T: Clean<U>, U> Clean<U> for @T {
fn clean(&self) -> U {
(**self).clean()
}
}
-impl<T: Clean<U>, U> Clean<~[U]> for syntax::opt_vec::OptVec<T> {
- fn clean(&self) -> ~[U] {
+impl<T: Clean<U>, U> Clean<Vec<U>> for syntax::opt_vec::OptVec<T> {
+ fn clean(&self) -> Vec<U> {
match self {
- &syntax::opt_vec::Empty => ~[],
+ &syntax::opt_vec::Empty => Vec::new(),
&syntax::opt_vec::Vec(ref v) => v.clean()
}
}
} else {
~""
};
+ let mut foreigns = ~[];
+ for subforeigns in self.foreigns.clean().move_iter() {
+ for foreign in subforeigns.move_iter() {
+ foreigns.push(foreign)
+ }
+ }
+ let items: ~[~[Item]] = ~[
+ self.structs.clean().move_iter().collect(),
+ self.enums.clean().move_iter().collect(),
+ self.fns.clean().move_iter().collect(),
+ foreigns,
+ self.mods.clean().move_iter().collect(),
+ self.typedefs.clean().move_iter().collect(),
+ self.statics.clean().move_iter().collect(),
+ self.traits.clean().move_iter().collect(),
+ self.impls.clean().move_iter().collect(),
+ self.view_items.clean().move_iter().collect(),
+ self.macros.clean().move_iter().collect()
+ ];
Item {
name: Some(name),
attrs: self.attrs.clean(),
id: self.id,
inner: ModuleItem(Module {
is_crate: self.is_crate,
- items: [self.structs.clean(), self.enums.clean(),
- self.fns.clean(), self.foreigns.clean().concat_vec(),
- self.mods.clean(), self.typedefs.clean(),
- self.statics.clean(), self.traits.clean(),
- self.impls.clean(), self.view_items.clean(),
- self.macros.clean()].concat_vec()
+ items: items.concat_vec(),
})
}
}
match self.node {
ast::MetaWord(ref s) => Word(s.get().to_owned()),
ast::MetaList(ref s, ref l) => {
- List(s.get().to_owned(), l.clean())
+ List(s.get().to_owned(), l.clean().move_iter().collect())
}
ast::MetaNameValue(ref s, ref v) => {
NameValue(s.get().to_owned(), lit_to_str(v))
TyParam {
name: self.ident.clean(),
id: self.id,
- bounds: self.bounds.clean(),
+ bounds: self.bounds.clean().move_iter().collect(),
}
}
}
impl Clean<Generics> for ast::Generics {
fn clean(&self) -> Generics {
Generics {
- lifetimes: self.lifetimes.clean(),
- type_params: self.ty_params.clean(),
+ lifetimes: self.lifetimes.clean().move_iter().collect(),
+ type_params: self.ty_params.clean().move_iter().collect(),
}
}
}
};
Item {
name: Some(self.ident.clean()),
- attrs: self.attrs.clean(),
+ attrs: self.attrs.clean().move_iter().collect(),
source: self.span.clean(),
id: self.id.clone(),
visibility: self.vis.clean(),
};
Item {
name: Some(self.ident.clean()),
- attrs: self.attrs.clean(),
+ attrs: self.attrs.clean().move_iter().collect(),
source: self.span.clean(),
id: self.id,
visibility: None,
ClosureDecl {
sigil: self.sigil,
region: self.region.clean(),
- lifetimes: self.lifetimes.clean(),
+ lifetimes: self.lifetimes.clean().move_iter().collect(),
decl: self.decl.clean(),
onceness: self.onceness,
purity: self.purity,
bounds: match self.bounds {
- Some(ref x) => x.clean(),
+ Some(ref x) => x.clean().move_iter().collect(),
None => ~[]
},
}
TyFixedLengthVec(ty, ref e) => FixedVector(~ty.clean(),
e.span.to_src()),
TyTup(ref tys) => Tuple(tys.iter().map(|x| x.clean()).collect()),
- TyPath(ref p, ref tpbs, id) =>
- resolve_type(p.clean(), tpbs.clean(), id),
+ TyPath(ref p, ref tpbs, id) => {
+ resolve_type(p.clean(),
+ tpbs.clean().map(|x| x.move_iter().collect()),
+ id)
+ }
TyClosure(ref c) => Closure(~c.clean()),
TyBareFn(ref barefn) => BareFunction(~barefn.clean()),
TyBot => Bottom,
};
Item {
name: name.clean(),
- attrs: self.node.attrs.clean(),
+ attrs: self.node.attrs.clean().move_iter().collect(),
source: self.span.clean(),
visibility: vis,
id: self.node.id,
fn clean(&self) -> VariantStruct {
VariantStruct {
struct_type: doctree::struct_type_from_def(self),
- fields: self.fields.clean(),
+ fields: self.fields.clean().move_iter().collect(),
fields_stripped: false,
}
}
fn clean(&self) -> Path {
Path {
global: self.global,
- segments: self.segments.clean()
+ segments: self.segments.clean().move_iter().collect(),
}
}
}
fn clean(&self) -> PathSegment {
PathSegment {
name: self.identifier.clean(),
- lifetimes: self.lifetimes.clean(),
- types: self.types.clean()
+ lifetimes: self.lifetimes.clean().move_iter().collect(),
+ types: self.types.clean().move_iter().collect()
}
}
}
BareFunctionDecl {
purity: self.purity,
generics: Generics {
- lifetimes: self.lifetimes.clean(),
+ lifetimes: self.lifetimes.clean().move_iter().collect(),
type_params: ~[],
},
decl: self.decl.clean(),
fn clean(&self) -> Item {
Item {
name: None,
- attrs: self.attrs.clean(),
+ attrs: self.attrs.clean().move_iter().collect(),
source: self.span.clean(),
id: 0,
visibility: self.vis.clean(),
};
ExternMod(i.clean(), string, *id)
}
- &ast::ViewItemUse(ref vp) => Import(vp.clean())
+ &ast::ViewItemUse(ref vp) => {
+ Import(vp.clean().move_iter().collect())
+ }
}
}
}
SimpleImport(i.clean(), resolve_use_source(p.clean(), id)),
ast::ViewPathGlob(ref p, id) =>
GlobImport(resolve_use_source(p.clean(), id)),
- ast::ViewPathList(ref p, ref pl, id) =>
- ImportList(resolve_use_source(p.clean(), id), pl.clean()),
+ ast::ViewPathList(ref p, ref pl, id) => {
+ ImportList(resolve_use_source(p.clean(), id),
+ pl.clean().move_iter().collect())
+ }
}
}
}
}
}
-impl Clean<~[Item]> for ast::ForeignMod {
- fn clean(&self) -> ~[Item] {
+impl Clean<Vec<Item>> for ast::ForeignMod {
+ fn clean(&self) -> Vec<Item> {
self.items.clean()
}
}
};
Item {
name: Some(self.ident.clean()),
- attrs: self.attrs.clean(),
+ attrs: self.attrs.clean().move_iter().collect(),
source: self.span.clean(),
id: self.id,
visibility: self.vis.clean(),
//! Rust AST Visitor. Extracts useful information and massages it into a form
//! usable for clean
+use std::vec_ng::Vec;
use syntax::abi::AbiSet;
use syntax::ast;
use syntax::ast_util;
}
pub fn visit(&mut self, krate: &ast::Crate) {
- self.attrs = krate.attrs.clone();
+ self.attrs = krate.attrs.iter().map(|x| (*x).clone()).collect();
- self.module = self.visit_mod_contents(krate.span, krate.attrs.clone(),
- ast::Public, ast::CRATE_NODE_ID,
- &krate.module, None);
+ self.module = self.visit_mod_contents(krate.span,
+ krate.attrs
+ .iter()
+ .map(|x| *x)
+ .collect(),
+ ast::Public,
+ ast::CRATE_NODE_ID,
+ &krate.module,
+ None);
self.module.is_crate = true;
}
struct_type: struct_type,
name: item.ident,
vis: item.vis,
- attrs: item.attrs.clone(),
+ attrs: item.attrs.iter().map(|x| *x).collect(),
generics: generics.clone(),
- fields: sd.fields.clone(),
+ fields: sd.fields.iter().map(|x| (*x).clone()).collect(),
where: item.span
}
}
for x in def.variants.iter() {
vars.push(Variant {
name: x.node.name,
- attrs: x.node.attrs.clone(),
+ attrs: x.node.attrs.iter().map(|x| *x).collect(),
vis: x.node.vis,
id: x.node.id,
kind: x.node.kind.clone(),
variants: vars,
vis: it.vis,
generics: params.clone(),
- attrs: it.attrs.clone(),
+ attrs: it.attrs.iter().map(|x| *x).collect(),
id: it.id,
where: it.span,
}
Function {
id: item.id,
vis: item.vis,
- attrs: item.attrs.clone(),
+ attrs: item.attrs.iter().map(|x| *x).collect(),
decl: fd.clone(),
name: item.ident,
where: item.span,
ast::ViewItemUse(ref paths) => {
// rustc no longer supports "use foo, bar;"
assert_eq!(paths.len(), 1);
- match self.visit_view_path(paths[0], om) {
+ match self.visit_view_path(*paths.get(0), om) {
None => return,
Some(path) => {
ast::ViewItem {
- node: ast::ViewItemUse(~[path]),
+ node: ast::ViewItemUse(vec!(path)),
.. item.clone()
}
}
if self.resolve_id(id, false, om) { return None }
}
ast::ViewPathList(ref p, ref paths, ref b) => {
- let mut mine = ~[];
+ let mut mine = Vec::new();
for path in paths.iter() {
if !self.resolve_id(path.node.id, false, om) {
mine.push(path.clone());
debug!("Visiting item {:?}", item);
match item.node {
ast::ItemMod(ref m) => {
- om.mods.push(self.visit_mod_contents(item.span, item.attrs.clone(),
- item.vis, item.id, m,
- Some(item.ident)));
+ om.mods.push(self.visit_mod_contents(item.span,
+ item.attrs
+ .iter()
+ .map(|x| *x)
+ .collect(),
+ item.vis,
+ item.id,
+ m,
+ Some(item.ident)));
},
ast::ItemEnum(ref ed, ref gen) =>
om.enums.push(self.visit_enum_def(item, ed, gen)),
gen: gen.clone(),
name: item.ident,
id: item.id,
- attrs: item.attrs.clone(),
+ attrs: item.attrs.iter().map(|x| *x).collect(),
where: item.span,
vis: item.vis,
};
expr: exp.clone(),
id: item.id,
name: item.ident,
- attrs: item.attrs.clone(),
+ attrs: item.attrs.iter().map(|x| *x).collect(),
where: item.span,
vis: item.vis,
};
ast::ItemTrait(ref gen, ref tr, ref met) => {
let t = Trait {
name: item.ident,
- methods: met.clone(),
+ methods: met.iter().map(|x| (*x).clone()).collect(),
generics: gen.clone(),
- parents: tr.clone(),
+ parents: tr.iter().map(|x| (*x).clone()).collect(),
id: item.id,
- attrs: item.attrs.clone(),
+ attrs: item.attrs.iter().map(|x| *x).collect(),
where: item.span,
vis: item.vis,
};
generics: gen.clone(),
trait_: tr.clone(),
for_: ty,
- methods: meths.clone(),
- attrs: item.attrs.clone(),
+ methods: meths.iter().map(|x| *x).collect(),
+ attrs: item.attrs.iter().map(|x| *x).collect(),
id: item.id,
where: item.span,
vis: item.vis,
ast::ItemMac(ref _m) => {
om.macros.push(Macro {
id: item.id,
- attrs: item.attrs.clone(),
+ attrs: item.attrs.iter().map(|x| *x).collect(),
name: item.ident,
where: item.span,
})
use rc::Rc;
use str::{Str, StrSlice};
use vec::{Vector, ImmutableVector};
+use vec_ng::Vec;
/// Reexport the `sip::hash` function as our default hasher.
pub use hash = self::sip::hash;
}
}
+impl<S: Writer, T: Hash<S>> Hash<S> for Vec<T> {
+ #[inline]
+ fn hash(&self, state: &mut S) {
+ self.as_slice().hash(state);
+ }
+}
+
impl<'a, S: Writer, T: Hash<S>> Hash<S> for &'a T {
#[inline]
fn hash(&self, state: &mut S) {
use clone::Clone;
use cmp::{Eq, Ordering, TotalEq, TotalOrd};
use container::Container;
+use default::Default;
+use fmt;
use iter::{DoubleEndedIterator, FromIterator, Iterator};
use libc::{free, c_void};
use mem::{size_of, move_val_init};
use ptr;
use rt::global_heap::{malloc_raw, realloc_raw};
use raw::Slice;
-use vec::{ImmutableVector, Items, MutItems, MutableVector, RevItems};
+use vec::{ImmutableEqVector, ImmutableVector, Items, MutItems, MutableVector};
+use vec::{RevItems};
pub struct Vec<T> {
priv len: uint,
self.push((*element).clone())
}
}
+
+
+ pub fn grow(&mut self, n: uint, initval: &T) {
+ let new_len = self.len() + n;
+ self.reserve(new_len);
+ let mut i: uint = 0u;
+
+ while i < n {
+ self.push((*initval).clone());
+ i += 1u;
+ }
+ }
+
+ pub fn grow_set(&mut self, index: uint, initval: &T, val: T) {
+ let l = self.len();
+ if index >= l {
+ self.grow(index - l + 1u, initval);
+ }
+ *self.get_mut(index) = val;
+ }
}
impl<T:Clone> Clone for Vec<T> {
pub fn slice_from<'a>(&'a self, start: uint) -> &'a [T] {
self.as_slice().slice_from(start)
}
+
+ #[inline]
+ pub fn init<'a>(&'a self) -> &'a [T] {
+ self.slice(0, self.len() - 1)
+ }
+}
+
+impl<T:Eq> Vec<T> {
+ /// Return true if a vector contains an element with the given value
+ pub fn contains(&self, x: &T) -> bool {
+ self.as_slice().contains(x)
+ }
}
#[inline]
first
}
+/// Appends one element to the vector provided. The vector itself is then
+/// returned for use again.
+#[inline]
+pub fn append_one<T>(mut lhs: Vec<T>, x: T) -> Vec<T> {
+ lhs.push(x);
+ lhs
+}
+
#[unsafe_destructor]
impl<T> Drop for Vec<T> {
fn drop(&mut self) {
}
}
+impl<T> Default for Vec<T> {
+ fn default() -> Vec<T> {
+ Vec::new()
+ }
+}
+
+impl<T:fmt::Show> fmt::Show for Vec<T> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ self.as_slice().fmt(f)
+ }
+}
+
pub struct MoveItems<T> {
priv allocation: *mut c_void, // the block of memory allocated for the vector
priv iter: Items<'static, T>
// except according to those terms.
use std::fmt;
+use std::vec_ng::Vec;
use std::fmt::Show;
#[deriving(Eq)]
res
}
-pub fn all_names() -> ~[&'static str] {
- AbiDatas.map(|d| d.name)
+pub fn all_names() -> Vec<&'static str> {
+ AbiDatas.iter().map(|d| d.name).collect()
}
impl Abi {
}
pub fn check_valid(&self) -> Option<(Abi, Abi)> {
- let mut abis = ~[];
+ let mut abis = Vec::new();
self.each(|abi| { abis.push(abi); true });
for (i, abi) in abis.iter().enumerate() {
use collections::HashMap;
use std::option::Option;
use std::rc::Rc;
+use std::vec_ng::Vec;
use serialize::{Encodable, Decodable, Encoder, Decoder};
/// A pointer abstraction. FIXME(eddyb) #10676 use Rc<T> in the future.
// it should cut down on memory use *a lot*; applying a mark
// to a tree containing 50 identifiers would otherwise generate
pub struct SCTable {
- table: RefCell<~[SyntaxContext_]>,
+ table: RefCell<Vec<SyntaxContext_> >,
mark_memo: RefCell<HashMap<(SyntaxContext,Mrk),SyntaxContext>>,
rename_memo: RefCell<HashMap<(SyntaxContext,Ident,Name),SyntaxContext>>,
}
/// module (like paths in an import).
global: bool,
/// The segments in the path: the things separated by `::`.
- segments: ~[PathSegment],
+ segments: Vec<PathSegment> ,
}
/// A segment of a path: an identifier, an optional lifetime, and a set of
// The set of MetaItems that define the compilation environment of the crate,
// used to drive conditional compilation
-pub type CrateConfig = ~[@MetaItem];
+pub type CrateConfig = Vec<@MetaItem> ;
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Crate {
module: Mod,
- attrs: ~[Attribute],
+ attrs: Vec<Attribute> ,
config: CrateConfig,
span: Span,
}
#[deriving(Clone, Encodable, Decodable, Hash)]
pub enum MetaItem_ {
MetaWord(InternedString),
- MetaList(InternedString, ~[@MetaItem]),
+ MetaList(InternedString, Vec<@MetaItem> ),
MetaNameValue(InternedString, Lit),
}
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Block {
- view_items: ~[ViewItem],
- stmts: ~[@Stmt],
+ view_items: Vec<ViewItem> ,
+ stmts: Vec<@Stmt> ,
expr: Option<@Expr>,
id: NodeId,
rules: BlockCheckMode,
// records this pattern's NodeId in an auxiliary
// set (of "pat_idents that refer to nullary enums")
PatIdent(BindingMode, Path, Option<@Pat>),
- PatEnum(Path, Option<~[@Pat]>), /* "none" means a * pattern where
+ PatEnum(Path, Option<Vec<@Pat> >), /* "none" means a * pattern where
* we don't bind the fields to names */
- PatStruct(Path, ~[FieldPat], bool),
- PatTup(~[@Pat]),
+ PatStruct(Path, Vec<FieldPat> , bool),
+ PatTup(Vec<@Pat> ),
PatUniq(@Pat),
PatRegion(@Pat), // reference pattern
PatLit(@Expr),
PatRange(@Expr, @Expr),
// [a, b, ..i, y, z] is represented as
// PatVec(~[a, b], Some(i), ~[y, z])
- PatVec(~[@Pat], Option<@Pat>, ~[@Pat])
+ PatVec(Vec<@Pat> , Option<@Pat>, Vec<@Pat> )
}
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Arm {
- pats: ~[@Pat],
+ pats: Vec<@Pat> ,
guard: Option<@Expr>,
body: P<Block>,
}
ExprVstore(@Expr, ExprVstore),
// First expr is the place; second expr is the value.
ExprBox(@Expr, @Expr),
- ExprVec(~[@Expr], Mutability),
- ExprCall(@Expr, ~[@Expr]),
- ExprMethodCall(Ident, ~[P<Ty>], ~[@Expr]),
- ExprTup(~[@Expr]),
+ ExprVec(Vec<@Expr> , Mutability),
+ ExprCall(@Expr, Vec<@Expr> ),
+ ExprMethodCall(Ident, Vec<P<Ty>> , Vec<@Expr> ),
+ ExprTup(Vec<@Expr> ),
ExprBinary(BinOp, @Expr, @Expr),
ExprUnary(UnOp, @Expr),
ExprLit(@Lit),
// Conditionless loop (can be exited with break, cont, or ret)
// FIXME #6993: change to Option<Name>
ExprLoop(P<Block>, Option<Ident>),
- ExprMatch(@Expr, ~[Arm]),
+ ExprMatch(@Expr, Vec<Arm> ),
ExprFnBlock(P<FnDecl>, P<Block>),
ExprProc(P<FnDecl>, P<Block>),
ExprBlock(P<Block>),
ExprAssign(@Expr, @Expr),
ExprAssignOp(BinOp, @Expr, @Expr),
- ExprField(@Expr, Ident, ~[P<Ty>]),
+ ExprField(@Expr, Ident, Vec<P<Ty>> ),
ExprIndex(@Expr, @Expr),
/// Expression that looks like a "name". For example,
ExprMac(Mac),
// A struct literal expression.
- ExprStruct(Path, ~[Field], Option<@Expr> /* base */),
+ ExprStruct(Path, Vec<Field> , Option<@Expr> /* base */),
// A vector literal constructed from one repeated element.
ExprRepeat(@Expr /* element */, @Expr /* count */, Mutability),
TTTok(Span, ::parse::token::Token),
// a delimited sequence (the delimiters appear as the first
// and last elements of the vector)
- TTDelim(@~[TokenTree]),
+ TTDelim(@Vec<TokenTree> ),
// These only make sense for right-hand-sides of MBE macros:
// a kleene-style repetition sequence with a span, a TTForest,
// an optional separator, and a boolean where true indicates
// zero or more (..), and false indicates one or more (+).
- TTSeq(Span, @~[TokenTree], Option<::parse::token::Token>, bool),
+ TTSeq(Span, @Vec<TokenTree> , Option<::parse::token::Token>, bool),
// a syntactic variable that will be filled in by macro expansion.
TTNonterminal(Span, Ident)
MatchTok(::parse::token::Token),
// match repetitions of a sequence: body, separator, zero ok?,
// lo, hi position-in-match-array used:
- MatchSeq(~[Matcher], Option<::parse::token::Token>, bool, uint, uint),
+ MatchSeq(Vec<Matcher> , Option<::parse::token::Token>, bool, uint, uint),
// parse a Rust NT: name to bind, name of NT, position in match array:
MatchNonterminal(Ident, Ident, uint)
}
// There's only one flavor, now, so this could presumably be simplified.
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum Mac_ {
- MacInvocTT(Path, ~[TokenTree], SyntaxContext), // new macro-invocation
+ MacInvocTT(Path, Vec<TokenTree> , SyntaxContext), // new macro-invocation
}
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum Lit_ {
LitStr(InternedString, StrStyle),
- LitBinary(Rc<~[u8]>),
+ LitBinary(Rc<Vec<u8> >),
LitChar(u32),
LitInt(i64, IntTy),
LitUint(u64, UintTy),
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct TypeMethod {
ident: Ident,
- attrs: ~[Attribute],
+ attrs: Vec<Attribute> ,
purity: Purity,
decl: P<FnDecl>,
generics: Generics,
TyRptr(Option<Lifetime>, MutTy),
TyClosure(@ClosureTy),
TyBareFn(@BareFnTy),
- TyTup(~[P<Ty>]),
+ TyTup(Vec<P<Ty>> ),
TyPath(Path, Option<OptVec<TyParamBound>>, NodeId), // for #7264; see above
TyTypeof(@Expr),
// TyInfer means the type should be inferred instead of it having been
asm: InternedString,
asm_str_style: StrStyle,
clobbers: InternedString,
- inputs: ~[(InternedString, @Expr)],
- outputs: ~[(InternedString, @Expr)],
+ inputs: Vec<(InternedString, @Expr)> ,
+ outputs: Vec<(InternedString, @Expr)> ,
volatile: bool,
alignstack: bool,
dialect: AsmDialect
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct FnDecl {
- inputs: ~[Arg],
+ inputs: Vec<Arg> ,
output: P<Ty>,
cf: RetStyle,
variadic: bool
#[deriving(Eq, Encodable, Decodable, Hash)]
pub struct Method {
ident: Ident,
- attrs: ~[Attribute],
+ attrs: Vec<Attribute> ,
generics: Generics,
explicit_self: ExplicitSelf,
purity: Purity,
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Mod {
- view_items: ~[ViewItem],
- items: ~[@Item],
+ view_items: Vec<ViewItem> ,
+ items: Vec<@Item> ,
}
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct ForeignMod {
abis: AbiSet,
- view_items: ~[ViewItem],
- items: ~[@ForeignItem],
+ view_items: Vec<ViewItem> ,
+ items: Vec<@ForeignItem> ,
}
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum VariantKind {
- TupleVariantKind(~[VariantArg]),
+ TupleVariantKind(Vec<VariantArg> ),
StructVariantKind(@StructDef),
}
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct EnumDef {
- variants: ~[P<Variant>],
+ variants: Vec<P<Variant>> ,
}
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Variant_ {
name: Ident,
- attrs: ~[Attribute],
+ attrs: Vec<Attribute> ,
kind: VariantKind,
id: NodeId,
disr_expr: Option<@Expr>,
ViewPathGlob(Path, NodeId),
// foo::bar::{a,b,c}
- ViewPathList(Path, ~[PathListIdent], NodeId)
+ ViewPathList(Path, Vec<PathListIdent> , NodeId)
}
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct ViewItem {
node: ViewItem_,
- attrs: ~[Attribute],
+ attrs: Vec<Attribute> ,
vis: Visibility,
span: Span,
}
// (containing arbitrary characters) from which to fetch the crate sources
// For example, extern crate whatever = "github.com/mozilla/rust"
ViewItemExternMod(Ident, Option<(InternedString,StrStyle)>, NodeId),
- ViewItemUse(~[@ViewPath]),
+ ViewItemUse(Vec<@ViewPath> ),
}
// Meta-data associated with an item
kind: StructFieldKind,
id: NodeId,
ty: P<Ty>,
- attrs: ~[Attribute],
+ attrs: Vec<Attribute> ,
}
pub type StructField = Spanned<StructField_>;
#[deriving(Eq, Encodable, Decodable, Hash)]
pub struct StructDef {
- fields: ~[StructField], /* fields, not including ctor */
+ fields: Vec<StructField> , /* fields, not including ctor */
/* ID of the constructor. This is only used for tuple- or enum-like
* structs. */
ctor_id: Option<NodeId>
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Item {
ident: Ident,
- attrs: ~[Attribute],
+ attrs: Vec<Attribute> ,
id: NodeId,
node: Item_,
vis: Visibility,
ItemTy(P<Ty>, Generics),
ItemEnum(EnumDef, Generics),
ItemStruct(@StructDef, Generics),
- ItemTrait(Generics, ~[TraitRef], ~[TraitMethod]),
+ ItemTrait(Generics, Vec<TraitRef> , Vec<TraitMethod> ),
ItemImpl(Generics,
Option<TraitRef>, // (optional) trait this impl implements
P<Ty>, // self
- ~[@Method]),
+ Vec<@Method> ),
// a macro invocation (which includes macro definition)
ItemMac(Mac),
}
#[deriving(Eq, Encodable, Decodable, Hash)]
pub struct ForeignItem {
ident: Ident,
- attrs: ~[Attribute],
+ attrs: Vec<Attribute> ,
node: ForeignItem_,
id: NodeId,
span: Span,
use codemap::*;
use super::*;
+ use std::vec_ng::Vec;
+
fn is_freeze<T: Freeze>() {}
// Assert that the AST remains Freeze (#10693).
#[test]
fn check_asts_encodable() {
let e = Crate {
- module: Mod {view_items: ~[], items: ~[]},
- attrs: ~[],
- config: ~[],
+ module: Mod {view_items: Vec::new(), items: Vec::new()},
+ attrs: Vec::new(),
+ config: Vec::new(),
span: Span {
lo: BytePos(10),
hi: BytePos(20),
use std::iter;
use std::vec;
use std::fmt;
+use std::vec_ng::Vec;
#[deriving(Clone, Eq)]
pub enum PathElem {
}
struct InlinedParent {
- path: ~[PathElem],
+ path: Vec<PathElem> ,
// Required by NodeTraitMethod and NodeMethod.
def_id: DefId
}
///
/// Also, indexing is pretty quick when you've got a vector and
/// plain old integers.
- priv map: RefCell<~[MapEntry]>
+ priv map: RefCell<Vec<MapEntry> >
}
impl Map {
fn find_entry(&self, id: NodeId) -> Option<MapEntry> {
let map = self.map.borrow();
- map.get().get(id as uint).map(|x| *x)
+ if map.get().len() > id as uint {
+ Some(*map.get().get(id as uint))
+ } else {
+ None
+ }
}
/// Retrieve the Node corresponding to `id`, failing if it cannot
}
pub fn map_crate<F: FoldOps>(krate: Crate, fold_ops: F) -> (Crate, Map) {
- let map = Map { map: RefCell::new(~[]) };
+ let map = Map { map: RefCell::new(Vec::new()) };
let krate = {
let mut cx = Ctx {
map: &map,
// crate. The `path` should be the path to the item but should not include
// the item itself.
pub fn map_decoded_item<F: FoldOps>(map: &Map,
- path: ~[PathElem],
+ path: Vec<PathElem> ,
fold_ops: F,
fold: |&mut Ctx<F>| -> InlinedItem)
-> InlinedItem {
use collections::HashMap;
use std::u32;
use std::local_data;
+use std::vec_ng::Vec;
pub fn path_name_i(idents: &[Ident]) -> ~str {
// FIXME: Bad copies (#2543 -- same for everything else that says "bad")
pub fn block_from_expr(e: @Expr) -> P<Block> {
P(Block {
- view_items: ~[],
- stmts: ~[],
+ view_items: Vec::new(),
+ stmts: Vec::new(),
expr: Some(e),
id: e.id,
rules: DefaultBlock,
ast::Path {
span: s,
global: false,
- segments: ~[
+ segments: vec!(
ast::PathSegment {
identifier: identifier,
lifetimes: opt_vec::Empty,
types: opt_vec::Empty,
}
- ],
+ ),
}
}
}
}
-pub fn unguarded_pat(a: &Arm) -> Option<~[@Pat]> {
+pub fn unguarded_pat(a: &Arm) -> Option<Vec<@Pat> > {
if is_unguarded(a) {
Some(/* FIXME (#2543) */ a.pats.clone())
} else {
token::gensym_ident(pretty)
}
-pub fn public_methods(ms: ~[@Method]) -> ~[@Method] {
+pub fn public_methods(ms: Vec<@Method> ) -> Vec<@Method> {
ms.move_iter().filter(|m| {
match m.vis {
Public => true,
}
pub fn split_trait_methods(trait_methods: &[TraitMethod])
- -> (~[TypeMethod], ~[@Method]) {
- let mut reqd = ~[];
- let mut provd = ~[];
+ -> (Vec<TypeMethod> , Vec<@Method> ) {
+ let mut reqd = Vec::new();
+ let mut provd = Vec::new();
for trt_method in trait_methods.iter() {
match *trt_method {
Required(ref tm) => reqd.push((*tm).clone()),
// FIXME #8215 : currently pub to allow testing
pub fn new_sctable_internal() -> SCTable {
SCTable {
- table: RefCell::new(~[EmptyCtxt,IllegalCtxt]),
+ table: RefCell::new(vec!(EmptyCtxt,IllegalCtxt)),
mark_memo: RefCell::new(HashMap::new()),
rename_memo: RefCell::new(HashMap::new()),
}
/// Add a value to the end of a vec, return its index
-fn idx_push<T>(vec: &mut ~[T], val: T) -> u32 {
+fn idx_push<T>(vec: &mut Vec<T> , val: T) -> u32 {
vec.push(val);
(vec.len() - 1) as u32
}
let resolved = {
let result = {
let table = table.table.borrow();
- table.get()[id.ctxt]
+ *table.get().get(id.ctxt as uint)
};
match result {
EmptyCtxt => id.name,
}
/// Compute the marks associated with a syntax context.
-pub fn mtwt_marksof(ctxt: SyntaxContext, stopname: Name) -> ~[Mrk] {
+pub fn mtwt_marksof(ctxt: SyntaxContext, stopname: Name) -> Vec<Mrk> {
marksof(ctxt, stopname, get_sctable())
}
// the internal function for computing marks
// it's not clear to me whether it's better to use a [] mutable
// vector or a cons-list for this.
-pub fn marksof(ctxt: SyntaxContext, stopname: Name, table: &SCTable) -> ~[Mrk] {
- let mut result = ~[];
+pub fn marksof(ctxt: SyntaxContext, stopname: Name, table: &SCTable) -> Vec<Mrk> {
+ let mut result = Vec::new();
let mut loopvar = ctxt;
loop {
let table_entry = {
let table = table.table.borrow();
- table.get()[loopvar]
+ *table.get().get(loopvar as uint)
};
match table_entry {
EmptyCtxt => {
pub fn mtwt_outer_mark(ctxt: SyntaxContext) -> Mrk {
let sctable = get_sctable();
let table = sctable.table.borrow();
- match table.get()[ctxt] {
+ match *table.get().get(ctxt as uint) {
ast::Mark(mrk,_) => mrk,
_ => fail!("can't retrieve outer mark when outside is not a mark")
}
/// Push a name... unless it matches the one on top, in which
/// case pop and discard (so two of the same marks cancel)
-pub fn xorPush(marks: &mut ~[Mrk], mark: Mrk) {
+pub fn xorPush(marks: &mut Vec<Mrk> , mark: Mrk) {
if (marks.len() > 0) && (getLast(marks) == mark) {
marks.pop().unwrap();
} else {
// get the last element of a mutable array.
// FIXME #4903: , must be a separate procedure for now.
-pub fn getLast(arr: &~[Mrk]) -> Mrk {
+pub fn getLast(arr: &Vec<Mrk> ) -> Mrk {
*arr.last().unwrap()
}
pub fn path_name_eq(a : &ast::Path, b : &ast::Path) -> bool {
(a.span == b.span)
&& (a.global == b.global)
- && (segments_name_eq(a.segments, b.segments))
+ && (segments_name_eq(a.segments.as_slice(), b.segments.as_slice()))
}
// are two arrays of segments equal when compared unhygienically?
use opt_vec;
use collections::HashMap;
+ use std::vec_ng::Vec;
+
fn ident_to_segment(id : &Ident) -> PathSegment {
PathSegment {identifier:id.clone(),
lifetimes: opt_vec::Empty,
}
#[test] fn xorpush_test () {
- let mut s = ~[];
+ let mut s = Vec::new();
xorPush(&mut s, 14);
- assert_eq!(s.clone(), ~[14]);
+ assert_eq!(s.clone(), vec!(14));
xorPush(&mut s, 14);
- assert_eq!(s.clone(), ~[]);
+ assert_eq!(s.clone(), Vec::new());
xorPush(&mut s, 14);
- assert_eq!(s.clone(), ~[14]);
+ assert_eq!(s.clone(), vec!(14));
xorPush(&mut s, 15);
- assert_eq!(s.clone(), ~[14, 15]);
+ assert_eq!(s.clone(), vec!(14, 15));
xorPush(&mut s, 16);
- assert_eq!(s.clone(), ~[14, 15, 16]);
+ assert_eq!(s.clone(), vec!(14, 15, 16));
xorPush(&mut s, 16);
- assert_eq!(s.clone(), ~[14, 15]);
+ assert_eq!(s.clone(), vec!(14, 15));
xorPush(&mut s, 15);
- assert_eq!(s.clone(), ~[14]);
+ assert_eq!(s.clone(), vec!(14));
}
fn id(n: Name, s: SyntaxContext) -> Ident {
// unfold a vector of TestSC values into a SCTable,
// returning the resulting index
- fn unfold_test_sc(tscs : ~[TestSC], tail: SyntaxContext, table: &SCTable)
+ fn unfold_test_sc(tscs : Vec<TestSC> , tail: SyntaxContext, table: &SCTable)
-> SyntaxContext {
tscs.rev_iter().fold(tail, |tail : SyntaxContext, tsc : &TestSC|
{match *tsc {
}
// gather a SyntaxContext back into a vector of TestSCs
- fn refold_test_sc(mut sc: SyntaxContext, table : &SCTable) -> ~[TestSC] {
- let mut result = ~[];
+ fn refold_test_sc(mut sc: SyntaxContext, table : &SCTable) -> Vec<TestSC> {
+ let mut result = Vec::new();
loop {
let table = table.table.borrow();
- match table.get()[sc] {
+ match *table.get().get(sc as uint) {
EmptyCtxt => {return result;},
Mark(mrk,tail) => {
result.push(M(mrk));
#[test] fn test_unfold_refold(){
let mut t = new_sctable_internal();
- let test_sc = ~[M(3),R(id(101,0),14),M(9)];
+ let test_sc = vec!(M(3),R(id(101,0),14),M(9));
assert_eq!(unfold_test_sc(test_sc.clone(),EMPTY_CTXT,&mut t),4);
{
let table = t.table.borrow();
- assert!(table.get()[2] == Mark(9,0));
- assert!(table.get()[3] == Rename(id(101,0),14,2));
- assert!(table.get()[4] == Mark(3,3));
+ assert!(*table.get().get(2) == Mark(9,0));
+ assert!(*table.get().get(3) == Rename(id(101,0),14,2));
+ assert!(*table.get().get(4) == Mark(3,3));
}
assert_eq!(refold_test_sc(4,&t),test_sc);
}
// extend a syntax context with a sequence of marks given
// in a vector. v[0] will be the outermost mark.
- fn unfold_marks(mrks: ~[Mrk], tail: SyntaxContext, table: &SCTable)
+ fn unfold_marks(mrks: Vec<Mrk> , tail: SyntaxContext, table: &SCTable)
-> SyntaxContext {
mrks.rev_iter().fold(tail, |tail:SyntaxContext, mrk:&Mrk|
{new_mark_internal(*mrk,tail,table)})
#[test] fn unfold_marks_test() {
let mut t = new_sctable_internal();
- assert_eq!(unfold_marks(~[3,7],EMPTY_CTXT,&mut t),3);
+ assert_eq!(unfold_marks(vec!(3,7),EMPTY_CTXT,&mut t),3);
{
let table = t.table.borrow();
- assert!(table.get()[2] == Mark(7,0));
- assert!(table.get()[3] == Mark(3,2));
+ assert!(*table.get().get(2) == Mark(7,0));
+ assert!(*table.get().get(3) == Mark(3,2));
}
}
let stopname = 242;
let name1 = 243;
let mut t = new_sctable_internal();
- assert_eq!(marksof (EMPTY_CTXT,stopname,&t),~[]);
+ assert_eq!(marksof (EMPTY_CTXT,stopname,&t),Vec::new());
// FIXME #5074: ANF'd to dodge nested calls
- { let ans = unfold_marks(~[4,98],EMPTY_CTXT,&mut t);
- assert_eq! (marksof (ans,stopname,&t),~[4,98]);}
+ { let ans = unfold_marks(vec!(4,98),EMPTY_CTXT,&mut t);
+ assert_eq! (marksof (ans,stopname,&t),vec!(4,98));}
// does xoring work?
- { let ans = unfold_marks(~[5,5,16],EMPTY_CTXT,&mut t);
- assert_eq! (marksof (ans,stopname,&t), ~[16]);}
+ { let ans = unfold_marks(vec!(5,5,16),EMPTY_CTXT,&mut t);
+ assert_eq! (marksof (ans,stopname,&t), vec!(16));}
// does nested xoring work?
- { let ans = unfold_marks(~[5,10,10,5,16],EMPTY_CTXT,&mut t);
- assert_eq! (marksof (ans, stopname,&t), ~[16]);}
+ { let ans = unfold_marks(vec!(5,10,10,5,16),EMPTY_CTXT,&mut t);
+ assert_eq! (marksof (ans, stopname,&t), vec!(16));}
// rename where stop doesn't match:
- { let chain = ~[M(9),
+ { let chain = vec!(M(9),
R(id(name1,
new_mark_internal (4, EMPTY_CTXT,&mut t)),
100101102),
- M(14)];
+ M(14));
let ans = unfold_test_sc(chain,EMPTY_CTXT,&mut t);
- assert_eq! (marksof (ans, stopname, &t), ~[9,14]);}
+ assert_eq! (marksof (ans, stopname, &t), vec!(9,14));}
// rename where stop does match
{ let name1sc = new_mark_internal(4, EMPTY_CTXT, &mut t);
- let chain = ~[M(9),
+ let chain = vec!(M(9),
R(id(name1, name1sc),
stopname),
- M(14)];
+ M(14));
let ans = unfold_test_sc(chain,EMPTY_CTXT,&mut t);
- assert_eq! (marksof (ans, stopname, &t), ~[9]); }
+ assert_eq! (marksof (ans, stopname, &t), vec!(9)); }
}
// - ctxt is MT
assert_eq!(resolve_internal(id(a,EMPTY_CTXT),&mut t, &mut rt),a);
// - simple ignored marks
- { let sc = unfold_marks(~[1,2,3],EMPTY_CTXT,&mut t);
+ { let sc = unfold_marks(vec!(1,2,3),EMPTY_CTXT,&mut t);
assert_eq!(resolve_internal(id(a,sc),&mut t, &mut rt),a);}
// - orthogonal rename where names don't match
- { let sc = unfold_test_sc(~[R(id(50,EMPTY_CTXT),51),M(12)],EMPTY_CTXT,&mut t);
+ { let sc = unfold_test_sc(vec!(R(id(50,EMPTY_CTXT),51),M(12)),EMPTY_CTXT,&mut t);
assert_eq!(resolve_internal(id(a,sc),&mut t, &mut rt),a);}
// - rename where names do match, but marks don't
{ let sc1 = new_mark_internal(1,EMPTY_CTXT,&mut t);
- let sc = unfold_test_sc(~[R(id(a,sc1),50),
+ let sc = unfold_test_sc(vec!(R(id(a,sc1),50),
M(1),
- M(2)],
+ M(2)),
EMPTY_CTXT,&mut t);
assert_eq!(resolve_internal(id(a,sc),&mut t, &mut rt), a);}
// - rename where names and marks match
- { let sc1 = unfold_test_sc(~[M(1),M(2)],EMPTY_CTXT,&mut t);
- let sc = unfold_test_sc(~[R(id(a,sc1),50),M(1),M(2)],EMPTY_CTXT,&mut t);
+ { let sc1 = unfold_test_sc(vec!(M(1),M(2)),EMPTY_CTXT,&mut t);
+ let sc = unfold_test_sc(vec!(R(id(a,sc1),50),M(1),M(2)),EMPTY_CTXT,&mut t);
assert_eq!(resolve_internal(id(a,sc),&mut t, &mut rt), 50); }
// - rename where names and marks match by literal sharing
- { let sc1 = unfold_test_sc(~[M(1),M(2)],EMPTY_CTXT,&mut t);
- let sc = unfold_test_sc(~[R(id(a,sc1),50)],sc1,&mut t);
+ { let sc1 = unfold_test_sc(vec!(M(1),M(2)),EMPTY_CTXT,&mut t);
+ let sc = unfold_test_sc(vec!(R(id(a,sc1),50)),sc1,&mut t);
assert_eq!(resolve_internal(id(a,sc),&mut t, &mut rt), 50); }
// - two renames of the same var.. can only happen if you use
// local-expand to prevent the inner binding from being renamed
// during the rename-pass caused by the first:
println!("about to run bad test");
- { let sc = unfold_test_sc(~[R(id(a,EMPTY_CTXT),50),
- R(id(a,EMPTY_CTXT),51)],
+ { let sc = unfold_test_sc(vec!(R(id(a,EMPTY_CTXT),50),
+ R(id(a,EMPTY_CTXT),51)),
EMPTY_CTXT,&mut t);
assert_eq!(resolve_internal(id(a,sc),&mut t, &mut rt), 51); }
// the simplest double-rename:
let sc = new_mark_internal(9,a50_to_a51,&mut t);
assert_eq!(resolve_internal(id(a,sc),&mut t, &mut rt),51);
// but mark on the inside does:
- let a50_to_a51_b = unfold_test_sc(~[R(id(a,a_to_a50),51),
- M(9)],
+ let a50_to_a51_b = unfold_test_sc(vec!(R(id(a,a_to_a50),51),
+ M(9)),
a_to_a50,
&mut t);
assert_eq!(resolve_internal(id(a,a50_to_a51_b),&mut t, &mut rt),50);}
use crateid::CrateId;
use collections::HashSet;
+use std::vec_ng::Vec;
pub trait AttrMetaMethods {
// This could be changed to `fn check_name(&self, name: InternedString) ->
@dummy_spanned(MetaNameValue(name, value))
}
-pub fn mk_list_item(name: InternedString, items: ~[@MetaItem]) -> @MetaItem {
+pub fn mk_list_item(name: InternedString, items: Vec<@MetaItem> ) -> @MetaItem {
@dummy_spanned(MetaList(name, items))
}
/* Higher-level applications */
-pub fn sort_meta_items(items: &[@MetaItem]) -> ~[@MetaItem] {
+pub fn sort_meta_items(items: &[@MetaItem]) -> Vec<@MetaItem> {
// This is sort of stupid here, but we need to sort by
// human-readable strings.
let mut v = items.iter()
.map(|&mi| (mi.name(), mi))
- .collect::<~[(InternedString, @MetaItem)]>();
+ .collect::<Vec<(InternedString, @MetaItem)> >();
v.sort_by(|&(ref a, _), &(ref b, _)| a.cmp(b));
match m.node {
MetaList(ref n, ref mis) => {
@Spanned {
- node: MetaList((*n).clone(), sort_meta_items(*mis)),
+ node: MetaList((*n).clone(),
+ sort_meta_items(mis.as_slice())),
.. /*bad*/ (*m).clone()
}
}
* From a list of crate attributes get only the meta_items that affect crate
* linkage
*/
-pub fn find_linkage_metas(attrs: &[Attribute]) -> ~[@MetaItem] {
- let mut result = ~[];
+pub fn find_linkage_metas(attrs: &[Attribute]) -> Vec<@MetaItem> {
+ let mut result = Vec::new();
for attr in attrs.iter().filter(|at| at.name().equiv(&("link"))) {
match attr.meta().node {
- MetaList(_, ref items) => result.push_all(*items),
+ MetaList(_, ref items) => result.push_all(items.as_slice()),
_ => ()
}
}
match attr.node.value.node {
MetaWord(ref n) if n.equiv(&("inline")) => InlineHint,
MetaList(ref n, ref items) if n.equiv(&("inline")) => {
- if contains_name(*items, "always") {
+ if contains_name(items.as_slice(), "always") {
InlineAlways
- } else if contains_name(*items, "never") {
+ } else if contains_name(items.as_slice(), "never") {
InlineNever
} else {
InlineHint
use std::cell::RefCell;
use std::cmp;
+use std::vec_ng::Vec;
use serialize::{Encodable, Decodable, Encoder, Decoder};
pub trait Pos {
pub struct FileLines
{
file: @FileMap,
- lines: ~[uint]
-}
+ lines: Vec<uint> }
/// Identifies an offset of a multi-byte character in a FileMap
pub struct MultiByteChar {
/// The start position of this source in the CodeMap
start_pos: BytePos,
/// Locations of lines beginnings in the source code
- lines: RefCell<~[BytePos]>,
+ lines: RefCell<Vec<BytePos> >,
/// Locations of multi-byte characters in the source code
- multibyte_chars: RefCell<~[MultiByteChar]>,
+ multibyte_chars: RefCell<Vec<MultiByteChar> >,
}
impl FileMap {
// the new charpos must be > the last one (or it's the first one).
let mut lines = self.lines.borrow_mut();;
let line_len = lines.get().len();
- assert!(line_len == 0 || (lines.get()[line_len - 1] < pos))
+ assert!(line_len == 0 || (*lines.get().get(line_len - 1) < pos))
lines.get().push(pos);
}
// get a line from the list of pre-computed line-beginnings
pub fn get_line(&self, line: int) -> ~str {
let mut lines = self.lines.borrow_mut();
- let begin: BytePos = lines.get()[line] - self.start_pos;
+ let begin: BytePos = *lines.get().get(line as uint) - self.start_pos;
let begin = begin.to_uint();
let slice = self.src.slice_from(begin);
match slice.find('\n') {
}
pub struct CodeMap {
- files: RefCell<~[@FileMap]>
+ files: RefCell<Vec<@FileMap> >
}
impl CodeMap {
pub fn new() -> CodeMap {
CodeMap {
- files: RefCell::new(~[]),
+ files: RefCell::new(Vec::new()),
}
}
name: filename,
src: src,
start_pos: Pos::from_uint(start_pos),
- lines: RefCell::new(~[]),
- multibyte_chars: RefCell::new(~[]),
+ lines: RefCell::new(Vec::new()),
+ multibyte_chars: RefCell::new(Vec::new()),
};
files.get().push(filemap);
pub fn span_to_lines(&self, sp: Span) -> @FileLines {
let lo = self.lookup_char_pos(sp.lo);
let hi = self.lookup_char_pos(sp.hi);
- let mut lines = ~[];
+ let mut lines = Vec::new();
for i in range(lo.line - 1u, hi.line as uint) {
lines.push(i);
};
let mut b = len;
while b - a > 1u {
let m = (a + b) / 2u;
- if files[m].start_pos > pos {
+ if files.get(m).start_pos > pos {
b = m;
} else {
a = m;
// filemap, but are not the filemaps we want (because they are length 0, they cannot
// contain what we are looking for). So, rewind until we find a useful filemap.
loop {
- let lines = files[a].lines.borrow();
+ let lines = files.get(a).lines.borrow();
let lines = lines.get();
if lines.len() > 0 {
break;
let idx = self.lookup_filemap_idx(pos);
let files = self.files.borrow();
- let f = files.get()[idx];
+ let f = *files.get().get(idx);
let mut a = 0u;
let mut lines = f.lines.borrow_mut();
let mut b = lines.get().len();
while b - a > 1u {
let m = (a + b) / 2u;
- if lines.get()[m] > pos { b = m; } else { a = m; }
+ if *lines.get().get(m) > pos { b = m; } else { a = m; }
}
return FileMapAndLine {fm: f, line: a};
}
let line = a + 1u; // Line numbers start at 1
let chpos = self.bytepos_to_file_charpos(pos);
let lines = f.lines.borrow();
- let linebpos = lines.get()[a];
+ let linebpos = *lines.get().get(a);
let linechpos = self.bytepos_to_file_charpos(linebpos);
debug!("codemap: byte pos {:?} is on the line at byte pos {:?}",
pos, linebpos);
-> FileMapAndBytePos {
let idx = self.lookup_filemap_idx(bpos);
let files = self.files.borrow();
- let fm = files.get()[idx];
+ let fm = *files.get().get(idx);
let offset = bpos - fm.start_pos;
return FileMapAndBytePos {fm: fm, pos: offset};
}
debug!("codemap: converting {:?} to char pos", bpos);
let idx = self.lookup_filemap_idx(bpos);
let files = self.files.borrow();
- let map = files.get()[idx];
+ let map = files.get().get(idx);
// The number of extra bytes due to multibyte chars in the FileMap
let mut total_extra_bytes = 0;
/// to be `0.0`.
use std::from_str::FromStr;
+use std::vec_ng::Vec;
#[deriving(Clone, Eq)]
pub struct CrateId {
impl FromStr for CrateId {
fn from_str(s: &str) -> Option<CrateId> {
- let pieces: ~[&str] = s.splitn('#', 1).collect();
- let path = pieces[0].to_owned();
+ let pieces: Vec<&str> = s.splitn('#', 1).collect();
+ let path = pieces.get(0).to_owned();
if path.starts_with("/") || path.ends_with("/") ||
path.starts_with(".") || path.is_empty() {
return None;
}
- let path_pieces: ~[&str] = path.rsplitn('/', 1).collect();
- let inferred_name = path_pieces[0];
+ let path_pieces: Vec<&str> = path.rsplitn('/', 1).collect();
+ let inferred_name = *path_pieces.get(0);
let (name, version) = if pieces.len() == 1 {
(inferred_name.to_owned(), None)
} else {
- let hash_pieces: ~[&str] = pieces[1].splitn(':', 1).collect();
+ let hash_pieces: Vec<&str> = pieces.get(1)
+ .splitn(':', 1)
+ .collect();
let (hash_name, hash_version) = if hash_pieces.len() == 1 {
- ("", hash_pieces[0])
+ ("", *hash_pieces.get(0))
} else {
- (hash_pieces[0], hash_pieces[1])
+ (*hash_pieces.get(0), *hash_pieces.get(1))
};
let name = if !hash_name.is_empty() {
};
Some(CrateId {
- path: path,
+ path: path.clone(),
name: name,
version: version,
})
if lines.lines.len() == 1u {
let lo = cm.lookup_char_pos(sp.lo);
let mut digits = 0u;
- let mut num = (lines.lines[0] + 1u) / 10u;
+ let mut num = (*lines.lines.get(0) + 1u) / 10u;
// how many digits must be indent past?
while num > 0u { num /= 10u; digits += 1u; }
// part of the 'filename:line ' part of the previous line.
let skip = fm.name.len() + digits + 3u;
for _ in range(0, skip) { s.push_char(' '); }
- let orig = fm.get_line(lines.lines[0] as int);
+ let orig = fm.get_line(*lines.lines.get(0) as int);
for pos in range(0u, left-skip) {
let curChar = orig[pos] as char;
// Whenever a tab occurs on the previous line, we insert one on
use parse::token::InternedString;
use parse::token;
+use std::vec_ng::Vec;
+
enum State {
Asm,
Outputs,
-> base::MacResult {
let mut p = parse::new_parser_from_tts(cx.parse_sess(),
cx.cfg(),
- tts.to_owned());
+ tts.iter()
+ .map(|x| (*x).clone())
+ .collect());
let mut asm = InternedString::new("");
let mut asm_str_style = None;
- let mut outputs = ~[];
- let mut inputs = ~[];
+ let mut outputs = Vec::new();
+ let mut inputs = Vec::new();
let mut cons = ~"";
let mut volatile = false;
let mut alignstack = false;
}
}
Clobbers => {
- let mut clobs = ~[];
+ let mut clobs = Vec::new();
while p.token != token::EOF &&
p.token != token::COLON &&
p.token != token::MOD_SEP {
use util::small_vector::SmallVector;
use collections::HashMap;
+use std::vec_ng::Vec;
// new-style macro! tt code:
//
cx: &mut ExtCtxt,
sp: Span,
ident: ast::Ident,
- token_tree: ~[ast::TokenTree])
+ token_tree: Vec<ast::TokenTree> )
-> MacResult;
}
cx: &mut ExtCtxt,
sp: Span,
ident: ast::Ident,
- token_tree: ~[ast::TokenTree])
+ token_tree: Vec<ast::TokenTree> )
-> MacResult {
(self.expander)(cx, sp, ident, token_tree)
}
}
pub type IdentMacroExpanderFn =
- fn(&mut ExtCtxt, Span, ast::Ident, ~[ast::TokenTree]) -> MacResult;
+ fn(&mut ExtCtxt, Span, ast::Ident, Vec<ast::TokenTree> ) -> MacResult;
pub type MacroCrateRegistrationFun =
fn(|ast::Name, SyntaxExtension|);
pub fn new() -> BlockInfo {
BlockInfo {
macros_escape: false,
- pending_renames: ~[],
+ pending_renames: Vec::new(),
}
}
}
// a list of ident->name renamings
-pub type RenameList = ~[(ast::Ident,Name)];
+pub type RenameList = Vec<(ast::Ident,Name)> ;
// The base map of methods for expanding syntax extension
// AST nodes into full ASTs
pub trait CrateLoader {
fn load_crate(&mut self, krate: &ast::ViewItem) -> MacroCrate;
- fn get_exported_macros(&mut self, crate_num: ast::CrateNum) -> ~[~str];
+ fn get_exported_macros(&mut self, crate_num: ast::CrateNum) -> Vec<~str> ;
fn get_registrar_symbol(&mut self, crate_num: ast::CrateNum) -> Option<~str>;
}
backtrace: Option<@ExpnInfo>,
loader: &'a mut CrateLoader,
- mod_path: ~[ast::Ident],
+ mod_path: Vec<ast::Ident> ,
trace_mac: bool
}
cfg: cfg,
backtrace: None,
loader: loader,
- mod_path: ~[],
+ mod_path: Vec::new(),
trace_mac: false
}
}
pub fn backtrace(&self) -> Option<@ExpnInfo> { self.backtrace }
pub fn mod_push(&mut self, i: ast::Ident) { self.mod_path.push(i); }
pub fn mod_pop(&mut self) { self.mod_path.pop().unwrap(); }
- pub fn mod_path(&self) -> ~[ast::Ident] { self.mod_path.clone() }
+ pub fn mod_path(&self) -> Vec<ast::Ident> { self.mod_path.clone() }
pub fn bt_push(&mut self, ei: codemap::ExpnInfo) {
match ei {
ExpnInfo {call_site: cs, callee: ref callee} => {
/// parsing error, emit a non-fatal error and return None.
pub fn get_exprs_from_tts(cx: &ExtCtxt,
sp: Span,
- tts: &[ast::TokenTree]) -> Option<~[@ast::Expr]> {
+ tts: &[ast::TokenTree]) -> Option<Vec<@ast::Expr> > {
let mut p = parse::new_parser_from_tts(cx.parse_sess(),
cx.cfg(),
- tts.to_owned());
- let mut es = ~[];
+ tts.iter()
+ .map(|x| (*x).clone())
+ .collect());
+ let mut es = Vec::new();
while p.token != token::EOF {
if es.len() != 0 && !p.eat(&token::COMMA) {
cx.span_err(sp, "expected token: `,`");
// Only generic to make it easy to test
pub struct SyntaxEnv {
- priv chain: ~[MapChainFrame],
+ priv chain: Vec<MapChainFrame> ,
}
impl SyntaxEnv {
pub fn new() -> SyntaxEnv {
- let mut map = SyntaxEnv { chain: ~[] };
+ let mut map = SyntaxEnv { chain: Vec::new() };
map.push_frame();
map
}
}
pub fn info<'a>(&'a mut self) -> &'a mut BlockInfo {
- &mut self.chain[self.chain.len()-1].info
+ let last_chain_index = self.chain.len() - 1;
+ &mut self.chain.get_mut(last_chain_index).info
}
}
use parse::token::special_idents;
use parse::token;
+use std::vec_ng::Vec;
+
pub struct Field {
ident: ast::Ident,
ex: @ast::Expr
pub trait AstBuilder {
// paths
- fn path(&self, span: Span, strs: ~[ast::Ident]) -> ast::Path;
+ fn path(&self, span: Span, strs: Vec<ast::Ident> ) -> ast::Path;
fn path_ident(&self, span: Span, id: ast::Ident) -> ast::Path;
- fn path_global(&self, span: Span, strs: ~[ast::Ident]) -> ast::Path;
+ fn path_global(&self, span: Span, strs: Vec<ast::Ident> ) -> ast::Path;
fn path_all(&self, sp: Span,
global: bool,
- idents: ~[ast::Ident],
+ idents: Vec<ast::Ident> ,
lifetimes: OptVec<ast::Lifetime>,
- types: ~[P<ast::Ty>])
+ types: Vec<P<ast::Ty>> )
-> ast::Path;
// types
fn ty_infer(&self, sp: Span) -> P<ast::Ty>;
fn ty_nil(&self) -> P<ast::Ty>;
- fn ty_vars(&self, ty_params: &OptVec<ast::TyParam>) -> ~[P<ast::Ty>];
- fn ty_vars_global(&self, ty_params: &OptVec<ast::TyParam>) -> ~[P<ast::Ty>];
+ fn ty_vars(&self, ty_params: &OptVec<ast::TyParam>) -> Vec<P<ast::Ty>> ;
+ fn ty_vars_global(&self, ty_params: &OptVec<ast::TyParam>) -> Vec<P<ast::Ty>> ;
fn ty_field_imm(&self, span: Span, name: Ident, ty: P<ast::Ty>) -> ast::TypeField;
fn strip_bounds(&self, bounds: &Generics) -> Generics;
-> @ast::Stmt;
// blocks
- fn block(&self, span: Span, stmts:
~[@ast::Stmt], expr: Option<@ast::Expr>) -> P<ast::Block>;
+ fn block(&self, span: Span, stmts:
Vec<@ast::Stmt> , expr: Option<@ast::Expr>) -> P<ast::Block>;
fn block_expr(&self, expr: @ast::Expr) -> P<ast::Block>;
fn block_all(&self, span: Span,
- view_items: ~[ast::ViewItem],
- stmts: ~[@ast::Stmt],
+ view_items: Vec<ast::ViewItem> ,
+ stmts: Vec<@ast::Stmt> ,
expr: Option<@ast::Expr>) -> P<ast::Block>;
// expressions
fn expr_addr_of(&self, sp: Span, e: @ast::Expr) -> @ast::Expr;
fn expr_mut_addr_of(&self, sp: Span, e: @ast::Expr) -> @ast::Expr;
fn expr_field_access(&self, span: Span, expr: @ast::Expr, ident: ast::Ident) -> @ast::Expr;
- fn expr_call(&self, span: Span, expr: @ast::Expr, args: ~[@ast::Expr]) -> @ast::Expr;
- fn expr_call_ident(&self, span: Span, id: ast::Ident, args: ~[@ast::Expr]) -> @ast::Expr;
- fn expr_call_global(&self, sp: Span, fn_path: ~[ast::Ident],
- args: ~[@ast::Expr]) -> @ast::Expr;
+ fn expr_call(&self, span: Span, expr: @ast::Expr, args: Vec<@ast::Expr> ) -> @ast::Expr;
+ fn expr_call_ident(&self, span: Span, id: ast::Ident, args: Vec<@ast::Expr> ) -> @ast::Expr;
+ fn expr_call_global(&self, sp: Span, fn_path: Vec<ast::Ident> ,
+ args: Vec<@ast::Expr> ) -> @ast::Expr;
fn expr_method_call(&self, span: Span,
expr: @ast::Expr, ident: ast::Ident,
- args: ~[@ast::Expr]) -> @ast::Expr;
+ args: Vec<@ast::Expr> ) -> @ast::Expr;
fn expr_block(&self, b: P<ast::Block>) -> @ast::Expr;
fn expr_cast(&self, sp: Span, expr: @ast::Expr, ty: P<ast::Ty>) -> @ast::Expr;
fn field_imm(&self, span: Span, name: Ident, e: @ast::Expr) -> ast::Field;
- fn expr_struct(&self, span: Span, path: ast::Path, fields: ~[ast::Field]) -> @ast::Expr;
- fn expr_struct_ident(&self, span: Span, id: ast::Ident, fields: ~[ast::Field]) -> @ast::Expr;
+ fn expr_struct(&self, span: Span, path: ast::Path, fields: Vec<ast::Field> ) -> @ast::Expr;
+ fn expr_struct_ident(&self, span: Span, id: ast::Ident, fields: Vec<ast::Field> ) -> @ast::Expr;
fn expr_lit(&self, sp: Span, lit: ast::Lit_) -> @ast::Expr;
fn expr_bool(&self, sp: Span, value: bool) -> @ast::Expr;
fn expr_vstore(&self, sp: Span, expr: @ast::Expr, vst: ast::ExprVstore) -> @ast::Expr;
- fn expr_vec(&self, sp: Span, exprs: ~[@ast::Expr]) -> @ast::Expr;
- fn expr_vec_uniq(&self, sp: Span, exprs: ~[@ast::Expr]) -> @ast::Expr;
- fn expr_vec_slice(&self, sp: Span, exprs: ~[@ast::Expr]) -> @ast::Expr;
+ fn expr_vec(&self, sp: Span, exprs: Vec<@ast::Expr> ) -> @ast::Expr;
+ fn expr_vec_ng(&self, sp: Span) -> @ast::Expr;
+ fn expr_vec_slice(&self, sp: Span, exprs: Vec<@ast::Expr> ) -> @ast::Expr;
fn expr_str(&self, sp: Span, s: InternedString) -> @ast::Expr;
fn expr_str_uniq(&self, sp: Span, s: InternedString) -> @ast::Expr;
span: Span,
ident: ast::Ident,
bm: ast::BindingMode) -> @ast::Pat;
- fn pat_enum(&self, span: Span, path: ast::Path, subpats: ~[@ast::Pat]) -> @ast::Pat;
+ fn pat_enum(&self, span: Span, path: ast::Path, subpats: Vec<@ast::Pat> ) -> @ast::Pat;
fn pat_struct(&self, span: Span,
- path: ast::Path, field_pats: ~[ast::FieldPat]) -> @ast::Pat;
+ path: ast::Path, field_pats: Vec<ast::FieldPat> ) -> @ast::Pat;
- fn arm(&self, span: Span, pats: ~[@ast::Pat], expr: @ast::Expr) -> ast::Arm;
+ fn arm(&self, span: Span, pats: Vec<@ast::Pat> , expr: @ast::Expr) -> ast::Arm;
fn arm_unreachable(&self, span: Span) -> ast::Arm;
- fn expr_match(&self, span: Span, arg: @ast::Expr, arms: ~[ast::Arm]) -> @ast::Expr;
+ fn expr_match(&self, span: Span, arg: @ast::Expr, arms: Vec<ast::Arm> ) -> @ast::Expr;
fn expr_if(&self, span: Span,
cond: @ast::Expr, then: @ast::Expr, els: Option<@ast::Expr>) -> @ast::Expr;
fn lambda_fn_decl(&self, span: Span,
fn_decl: P<ast::FnDecl>, blk: P<ast::Block>) -> @ast::Expr;
- fn lambda(&self, span: Span, ids:
~[ast::Ident], blk: P<ast::Block>) -> @ast::Expr;
+ fn lambda(&self, span: Span, ids:
Vec<ast::Ident> , blk: P<ast::Block>) -> @ast::Expr;
fn lambda0(&self, span: Span, blk: P<ast::Block>) -> @ast::Expr;
fn lambda1(&self, span: Span, blk: P<ast::Block>, ident: ast::Ident) -> @ast::Expr;
- fn lambda_expr(&self, span: Span, ids: ~[ast::Ident], blk: @ast::Expr) -> @ast::Expr;
+ fn lambda_expr(&self, span: Span, ids: Vec<ast::Ident> , blk: @ast::Expr) -> @ast::Expr;
fn lambda_expr_0(&self, span: Span, expr: @ast::Expr) -> @ast::Expr;
fn lambda_expr_1(&self, span: Span, expr: @ast::Expr, ident: ast::Ident) -> @ast::Expr;
- fn lambda_stmts(&self, span: Span, ids: ~[ast::Ident], blk: ~[@ast::Stmt]) -> @ast::Expr;
- fn lambda_stmts_0(&self, span: Span, stmts: ~[@ast::Stmt]) -> @ast::Expr;
- fn lambda_stmts_1(&self, span: Span, stmts: ~[@ast::Stmt], ident: ast::Ident) -> @ast::Expr;
+ fn lambda_stmts(&self, span: Span, ids: Vec<ast::Ident> , blk: Vec<@ast::Stmt> ) -> @ast::Expr;
+ fn lambda_stmts_0(&self, span: Span, stmts: Vec<@ast::Stmt> ) -> @ast::Expr;
+ fn lambda_stmts_1(&self, span: Span, stmts: Vec<@ast::Stmt> , ident: ast::Ident) -> @ast::Expr;
// items
fn item(&self, span: Span,
- name: Ident, attrs: ~[ast::Attribute], node: ast::Item_) -> @ast::Item;
+ name: Ident, attrs: Vec<ast::Attribute> , node: ast::Item_) -> @ast::Item;
fn arg(&self, span: Span, name: Ident, ty: P<ast::Ty>) -> ast::Arg;
// FIXME unused self
- fn fn_decl(&self, inputs:
~[ast::Arg], output: P<ast::Ty>) -> P<ast::FnDecl>;
+ fn fn_decl(&self, inputs:
Vec<ast::Arg> , output: P<ast::Ty>) -> P<ast::FnDecl>;
fn item_fn_poly(&self,
span: Span,
name: Ident,
- inputs: ~[ast::Arg],
+ inputs: Vec<ast::Arg> ,
output: P<ast::Ty>,
generics: Generics,
body: P<ast::Block>) -> @ast::Item;
fn item_fn(&self,
span: Span,
name: Ident,
- inputs: ~[ast::Arg],
+ inputs: Vec<ast::Arg> ,
output: P<ast::Ty>,
body: P<ast::Block>) -> @ast::Item;
- fn variant(&self, span: Span, name: Ident, tys: ~[P<ast::Ty>]) -> ast::Variant;
+ fn variant(&self, span: Span, name: Ident, tys: Vec<P<ast::Ty>> ) -> ast::Variant;
fn item_enum_poly(&self,
span: Span,
name: Ident,
fn item_struct(&self, span: Span, name: Ident, struct_def: ast::StructDef) -> @ast::Item;
fn item_mod(&self, span: Span,
- name: Ident, attrs: ~[ast::Attribute],
- vi: ~[ast::ViewItem], items: ~[@ast::Item]) -> @ast::Item;
+ name: Ident, attrs: Vec<ast::Attribute> ,
+ vi: Vec<ast::ViewItem> , items: Vec<@ast::Item> ) -> @ast::Item;
fn item_ty_poly(&self,
span: Span,
fn meta_list(&self,
sp: Span,
name: InternedString,
- mis: ~[@ast::MetaItem])
+ mis: Vec<@ast::MetaItem> )
-> @ast::MetaItem;
fn meta_name_value(&self,
sp: Span,
-> @ast::MetaItem;
fn view_use(&self, sp: Span,
- vis: ast::Visibility, vp: ~[@ast::ViewPath]) -> ast::ViewItem;
+ vis: ast::Visibility, vp: Vec<@ast::ViewPath> ) -> ast::ViewItem;
fn view_use_simple(&self, sp: Span, vis: ast::Visibility, path: ast::Path) -> ast::ViewItem;
fn view_use_simple_(&self, sp: Span, vis: ast::Visibility,
ident: ast::Ident, path: ast::Path) -> ast::ViewItem;
fn view_use_list(&self, sp: Span, vis: ast::Visibility,
- path: ~[ast::Ident], imports: &[ast::Ident]) -> ast::ViewItem;
+ path: Vec<ast::Ident> , imports: &[ast::Ident]) -> ast::ViewItem;
fn view_use_glob(&self, sp: Span,
- vis: ast::Visibility, path: ~[ast::Ident]) -> ast::ViewItem;
+ vis: ast::Visibility, path: Vec<ast::Ident> ) -> ast::ViewItem;
}
impl<'a> AstBuilder for ExtCtxt<'a> {
- fn path(&self, span: Span, strs: ~[ast::Ident]) -> ast::Path {
- self.path_all(span, false, strs, opt_vec::Empty, ~[])
+ fn path(&self, span: Span, strs: Vec<ast::Ident> ) -> ast::Path {
+ self.path_all(span, false, strs, opt_vec::Empty, Vec::new())
}
fn path_ident(&self, span: Span, id: ast::Ident) -> ast::Path {
- self.path(span, ~[id])
+ self.path(span, vec!(id))
}
- fn path_global(&self, span: Span, strs: ~[ast::Ident]) -> ast::Path {
- self.path_all(span, true, strs, opt_vec::Empty, ~[])
+ fn path_global(&self, span: Span, strs: Vec<ast::Ident> ) -> ast::Path {
+ self.path_all(span, true, strs, opt_vec::Empty, Vec::new())
}
fn path_all(&self,
sp: Span,
global: bool,
- mut idents: ~[ast::Ident],
+ mut idents: Vec<ast::Ident> ,
lifetimes: OptVec<ast::Lifetime>,
- types: ~[P<ast::Ty>])
+ types: Vec<P<ast::Ty>> )
-> ast::Path {
let last_identifier = idents.pop().unwrap();
- let mut segments: ~[ast::PathSegment] = idents.move_iter()
+ let mut segments: Vec<ast::PathSegment> = idents.move_iter()
.map(|ident| {
ast::PathSegment {
identifier: ident,
self.ty_path(
self.path_all(DUMMY_SP,
true,
- ~[
+ vec!(
self.ident_of("std"),
self.ident_of("option"),
self.ident_of("Option")
- ],
+ ),
opt_vec::Empty,
- ~[ ty ]), None)
+ vec!( ty )), None)
}
fn ty_field_imm(&self, span: Span, name: Ident, ty: P<ast::Ty>) -> ast::TypeField {
// these are strange, and probably shouldn't be used outside of
// pipes. Specifically, the global version possible generates
// incorrect code.
- fn ty_vars(&self, ty_params: &OptVec<ast::TyParam>) -> ~[P<ast::Ty>] {
+ fn ty_vars(&self, ty_params: &OptVec<ast::TyParam>) -> Vec<P<ast::Ty>> {
opt_vec::take_vec(
ty_params.map(|p| self.ty_ident(DUMMY_SP, p.ident)))
}
- fn ty_vars_global(&self, ty_params: &OptVec<ast::TyParam>) -> ~[P<ast::Ty>] {
+ fn ty_vars_global(&self, ty_params: &OptVec<ast::TyParam>) -> Vec<P<ast::Ty>> {
opt_vec::take_vec(
ty_params.map(|p| self.ty_path(
- self.path_global(DUMMY_SP, ~[p.ident]), None)))
+ self.path_global(DUMMY_SP, vec!(p.ident)), None)))
}
fn strip_bounds(&self, generics: &Generics) -> Generics {
@respan(sp, ast::StmtDecl(@decl, ast::DUMMY_NODE_ID))
}
- fn block(&self, span: Span, stmts:
~[@ast::Stmt], expr: Option<@Expr>) -> P<ast::Block> {
- self.block_all(span, ~[], stmts, expr)
+ fn block(&self, span: Span, stmts:
Vec<@ast::Stmt> , expr: Option<@Expr>) -> P<ast::Block> {
+ self.block_all(span, Vec::new(), stmts, expr)
}
fn block_expr(&self, expr: @ast::Expr) -> P<ast::Block> {
- self.block_all(expr.span, ~[], ~[], Some(expr))
+ self.block_all(expr.span, Vec::new(), Vec::new(), Some(expr))
}
fn block_all(&self,
span: Span,
- view_items: ~[ast::ViewItem],
- stmts: ~[@ast::Stmt],
+ view_items: Vec<ast::ViewItem> ,
+ stmts: Vec<@ast::Stmt> ,
expr: Option<@ast::Expr>) -> P<ast::Block> {
P(ast::Block {
view_items: view_items,
}
fn expr_field_access(&self, sp: Span, expr: @ast::Expr, ident: ast::Ident) -> @ast::Expr {
- self.expr(sp, ast::ExprField(expr, ident, ~[]))
+ self.expr(sp, ast::ExprField(expr, ident, Vec::new()))
}
fn expr_addr_of(&self, sp: Span, e: @ast::Expr) -> @ast::Expr {
self.expr(sp, ast::ExprAddrOf(ast::MutImmutable, e))
self.expr(sp, ast::ExprAddrOf(ast::MutMutable, e))
}
- fn expr_call(&self, span: Span, expr: @ast::Expr, args: ~[@ast::Expr]) -> @ast::Expr {
+ fn expr_call(&self, span: Span, expr: @ast::Expr, args: Vec<@ast::Expr> ) -> @ast::Expr {
self.expr(span, ast::ExprCall(expr, args))
}
- fn expr_call_ident(&self, span: Span, id: ast::Ident, args: ~[@ast::Expr]) -> @ast::Expr {
+ fn expr_call_ident(&self, span: Span, id: ast::Ident, args: Vec<@ast::Expr> ) -> @ast::Expr {
self.expr(span, ast::ExprCall(self.expr_ident(span, id), args))
}
- fn expr_call_global(&self, sp: Span, fn_path: ~[ast::Ident],
- args: ~[@ast::Expr]) -> @ast::Expr {
+ fn expr_call_global(&self, sp: Span, fn_path: Vec<ast::Ident> ,
+ args: Vec<@ast::Expr> ) -> @ast::Expr {
let pathexpr = self.expr_path(self.path_global(sp, fn_path));
self.expr_call(sp, pathexpr, args)
}
fn expr_method_call(&self, span: Span,
expr: @ast::Expr,
ident: ast::Ident,
- mut args: ~[@ast::Expr]) -> @ast::Expr {
+ mut args: Vec<@ast::Expr> ) -> @ast::Expr {
args.unshift(expr);
- self.expr(span, ast::ExprMethodCall(ident, ~[], args))
+ self.expr(span, ast::ExprMethodCall(ident, Vec::new(), args))
}
fn expr_block(&self, b: P<ast::Block>) -> @ast::Expr {
self.expr(b.span, ast::ExprBlock(b))
fn field_imm(&self, span: Span, name: Ident, e: @ast::Expr) -> ast::Field {
ast::Field { ident: respan(span, name), expr: e, span: span }
}
- fn expr_struct(&self, span: Span, path: ast::Path, fields: ~[ast::Field]) -> @ast::Expr {
+ fn expr_struct(&self, span: Span, path: ast::Path, fields: Vec<ast::Field> ) -> @ast::Expr {
self.expr(span, ast::ExprStruct(path, fields, None))
}
fn expr_struct_ident(&self, span: Span,
- id: ast::Ident, fields: ~[ast::Field]) -> @ast::Expr {
+ id: ast::Ident, fields: Vec<ast::Field> ) -> @ast::Expr {
self.expr_struct(span, self.path_ident(span, id), fields)
}
fn expr_vstore(&self, sp: Span, expr: @ast::Expr, vst: ast::ExprVstore) -> @ast::Expr {
self.expr(sp, ast::ExprVstore(expr, vst))
}
- fn expr_vec(&self, sp: Span, exprs: ~[@ast::Expr]) -> @ast::Expr {
+ fn expr_vec(&self, sp: Span, exprs: Vec<@ast::Expr> ) -> @ast::Expr {
self.expr(sp, ast::ExprVec(exprs, ast::MutImmutable))
}
- fn expr_vec_uniq(&self, sp: Span, exprs: ~[@ast::Expr]) -> @ast::Expr {
- self.expr_vstore(sp, self.expr_vec(sp, exprs), ast::ExprVstoreUniq)
+ fn expr_vec_ng(&self, sp: Span) -> @ast::Expr {
+ self.expr_call_global(sp,
+ vec!(self.ident_of("std"),
+ self.ident_of("vec_ng"),
+ self.ident_of("Vec"),
+ self.ident_of("new")),
+ Vec::new())
}
- fn expr_vec_slice(&self, sp: Span, exprs: ~[@ast::Expr]) -> @ast::Expr {
+ fn expr_vec_slice(&self, sp: Span, exprs: Vec<@ast::Expr> ) -> @ast::Expr {
self.expr_vstore(sp, self.expr_vec(sp, exprs), ast::ExprVstoreSlice)
}
fn expr_str(&self, sp: Span, s: InternedString) -> @ast::Expr {
fn expr_some(&self, sp: Span, expr: @ast::Expr) -> @ast::Expr {
- let some = ~[
+ let some = vec!(
self.ident_of("std"),
self.ident_of("option"),
- self.ident_of("Some"),
- ];
- self.expr_call_global(sp, some, ~[expr])
+ self.ident_of("Some"));
+ self.expr_call_global(sp, some, vec!(expr))
}
fn expr_none(&self, sp: Span) -> @ast::Expr {
- let none = self.path_global(sp, ~[
+ let none = self.path_global(sp, vec!(
self.ident_of("std"),
self.ident_of("option"),
- self.ident_of("None"),
- ]);
+ self.ident_of("None")));
self.expr_path(none)
}
let loc = self.codemap().lookup_char_pos(span.lo);
self.expr_call_global(
span,
- ~[
+ vec!(
self.ident_of("std"),
self.ident_of("rt"),
- self.ident_of("begin_unwind"),
- ],
- ~[
+ self.ident_of("begin_unwind")),
+ vec!(
self.expr_str(span, msg),
self.expr_str(span,
token::intern_and_get_ident(loc.file.name)),
- self.expr_uint(span, loc.line),
- ])
+ self.expr_uint(span, loc.line)))
}
fn expr_unreachable(&self, span: Span) -> @ast::Expr {
let pat = ast::PatIdent(bm, path, None);
self.pat(span, pat)
}
- fn pat_enum(&self, span: Span, path: ast::Path, subpats: ~[@ast::Pat]) -> @ast::Pat {
+ fn pat_enum(&self, span: Span, path: ast::Path, subpats: Vec<@ast::Pat> ) -> @ast::Pat {
let pat = ast::PatEnum(path, Some(subpats));
self.pat(span, pat)
}
fn pat_struct(&self, span: Span,
- path: ast::Path, field_pats: ~[ast::FieldPat]) -> @ast::Pat {
+ path: ast::Path, field_pats: Vec<ast::FieldPat> ) -> @ast::Pat {
let pat = ast::PatStruct(path, field_pats, false);
self.pat(span, pat)
}
- fn arm(&self, _span: Span, pats: ~[@ast::Pat], expr: @ast::Expr) -> ast::Arm {
+ fn arm(&self, _span: Span, pats: Vec<@ast::Pat> , expr: @ast::Expr) -> ast::Arm {
ast::Arm {
pats: pats,
guard: None,
}
fn arm_unreachable(&self, span: Span) -> ast::Arm {
- self.arm(span, ~[self.pat_wild(span)], self.expr_unreachable(span))
+ self.arm(span, vec!(self.pat_wild(span)), self.expr_unreachable(span))
}
- fn expr_match(&self, span: Span, arg: @ast::Expr, arms: ~[ast::Arm]) -> @Expr {
+ fn expr_match(&self, span: Span, arg: @ast::Expr, arms: Vec<ast::Arm> ) -> @Expr {
self.expr(span, ast::ExprMatch(arg, arms))
}
fn_decl: P<ast::FnDecl>, blk: P<ast::Block>) -> @ast::Expr {
self.expr(span, ast::ExprFnBlock(fn_decl, blk))
}
- fn lambda(&self, span: Span, ids:
~[ast::Ident], blk: P<ast::Block>) -> @ast::Expr {
+ fn lambda(&self, span: Span, ids:
Vec<ast::Ident> , blk: P<ast::Block>) -> @ast::Expr {
let fn_decl = self.fn_decl(
ids.map(|id| self.arg(span, *id, self.ty_infer(span))),
self.ty_infer(span));
self.expr(span, ast::ExprFnBlock(fn_decl, blk))
}
- fn lambda0(&self, _span: Span, blk: P<ast::Block>) -> @ast::Expr {
- let blk_e = self.expr(blk.span, ast::ExprBlock(blk));
- quote_expr!(self, || $blk_e )
+ fn lambda0(&self, span: Span, blk: P<ast::Block>) -> @ast::Expr {
+ self.lambda(span, Vec::new(), blk)
}
- fn lambda1(&self, _span: Span, blk: P<ast::Block>, ident: ast::Ident) -> @ast::Expr {
- let blk_e = self.expr(blk.span, ast::ExprBlock(blk));
- quote_expr!(self, |$ident| $blk_e )
+ fn lambda1(&self, span: Span, blk: P<ast::Block>, ident: ast::Ident) -> @ast::Expr {
+ self.lambda(span, vec!(ident), blk)
}
- fn lambda_expr(&self, span: Span, ids: ~[ast::Ident], expr: @ast::Expr) -> @ast::Expr {
+ fn lambda_expr(&self, span: Span, ids: Vec<ast::Ident> , expr: @ast::Expr) -> @ast::Expr {
self.lambda(span, ids, self.block_expr(expr))
}
fn lambda_expr_0(&self, span: Span, expr: @ast::Expr) -> @ast::Expr {
self.lambda1(span, self.block_expr(expr), ident)
}
- fn lambda_stmts(&self, span: Span, ids: ~[ast::Ident], stmts: ~[@ast::Stmt]) -> @ast::Expr {
+ fn lambda_stmts(&self,
+ span: Span,
+ ids: Vec<ast::Ident>,
+ stmts: Vec<@ast::Stmt>)
+ -> @ast::Expr {
self.lambda(span, ids, self.block(span, stmts, None))
}
- fn lambda_stmts_0(&self, span: Span, stmts: ~[@ast::Stmt]) -> @ast::Expr {
+ fn lambda_stmts_0(&self, span: Span, stmts: Vec<@ast::Stmt> ) -> @ast::Expr {
self.lambda0(span, self.block(span, stmts, None))
}
- fn lambda_stmts_1(&self, span: Span, stmts: ~[@ast::Stmt], ident: ast::Ident) -> @ast::Expr {
+ fn lambda_stmts_1(&self, span: Span, stmts: Vec<@ast::Stmt> , ident: ast::Ident) -> @ast::Expr {
self.lambda1(span, self.block(span, stmts, None), ident)
}
}
// FIXME unused self
- fn fn_decl(&self, inputs:
~[ast::Arg], output: P<ast::Ty>) -> P<ast::FnDecl> {
+ fn fn_decl(&self, inputs:
Vec<ast::Arg> , output: P<ast::Ty>) -> P<ast::FnDecl> {
P(ast::FnDecl {
inputs: inputs,
output: output,
}
fn item(&self, span: Span,
- name: Ident, attrs: ~[ast::Attribute], node: ast::Item_) -> @ast::Item {
+ name: Ident, attrs: Vec<ast::Attribute> , node: ast::Item_) -> @ast::Item {
// FIXME: Would be nice if our generated code didn't violate
// Rust coding conventions
@ast::Item { ident: name,
fn item_fn_poly(&self,
span: Span,
name: Ident,
- inputs: ~[ast::Arg],
+ inputs: Vec<ast::Arg> ,
output: P<ast::Ty>,
generics: Generics,
body: P<ast::Block>) -> @ast::Item {
self.item(span,
name,
- ~[],
+ Vec::new(),
ast::ItemFn(self.fn_decl(inputs, output),
ast::ImpureFn,
AbiSet::Rust(),
fn item_fn(&self,
span: Span,
name: Ident,
- inputs: ~[ast::Arg],
+ inputs: Vec<ast::Arg> ,
output: P<ast::Ty>,
body: P<ast::Block>
) -> @ast::Item {
body)
}
- fn variant(&self, span: Span, name: Ident, tys: ~[P<ast::Ty>]) -> ast::Variant {
+ fn variant(&self, span: Span, name: Ident, tys: Vec<P<ast::Ty>> ) -> ast::Variant {
let args = tys.move_iter().map(|ty| {
ast::VariantArg { ty: ty, id: ast::DUMMY_NODE_ID }
}).collect();
respan(span,
ast::Variant_ {
name: name,
- attrs: ~[],
+ attrs: Vec::new(),
kind: ast::TupleVariantKind(args),
id: ast::DUMMY_NODE_ID,
disr_expr: None,
fn item_enum_poly(&self, span: Span, name: Ident,
enum_definition: ast::EnumDef,
generics: Generics) -> @ast::Item {
- self.item(span, name, ~[], ast::ItemEnum(enum_definition, generics))
+ self.item(span, name, Vec::new(), ast::ItemEnum(enum_definition, generics))
}
fn item_enum(&self, span: Span, name: Ident,
fn item_struct_poly(&self, span: Span, name: Ident,
struct_def: ast::StructDef, generics: Generics) -> @ast::Item {
- self.item(span, name, ~[], ast::ItemStruct(@struct_def, generics))
+ self.item(span, name, Vec::new(), ast::ItemStruct(@struct_def, generics))
}
fn item_mod(&self, span: Span, name: Ident,
- attrs: ~[ast::Attribute],
- vi: ~[ast::ViewItem],
- items: ~[@ast::Item]) -> @ast::Item {
+ attrs: Vec<ast::Attribute> ,
+ vi: Vec<ast::ViewItem> ,
+ items: Vec<@ast::Item> ) -> @ast::Item {
self.item(
span,
name,
fn item_ty_poly(&self, span: Span, name: Ident, ty: P<ast::Ty>,
generics: Generics) -> @ast::Item {
- self.item(span, name, ~[], ast::ItemTy(ty, generics))
+ self.item(span, name, Vec::new(), ast::ItemTy(ty, generics))
}
fn item_ty(&self, span: Span, name: Ident, ty: P<ast::Ty>) -> @ast::Item {
fn meta_list(&self,
sp: Span,
name: InternedString,
- mis: ~[@ast::MetaItem])
+ mis: Vec<@ast::MetaItem> )
-> @ast::MetaItem {
@respan(sp, ast::MetaList(name, mis))
}
}
fn view_use(&self, sp: Span,
- vis: ast::Visibility, vp: ~[@ast::ViewPath]) -> ast::ViewItem {
+ vis: ast::Visibility, vp: Vec<@ast::ViewPath> ) -> ast::ViewItem {
ast::ViewItem {
node: ast::ViewItemUse(vp),
- attrs: ~[],
+ attrs: Vec::new(),
vis: vis,
span: sp
}
fn view_use_simple_(&self, sp: Span, vis: ast::Visibility,
ident: ast::Ident, path: ast::Path) -> ast::ViewItem {
self.view_use(sp, vis,
- ~[@respan(sp,
+ vec!(@respan(sp,
ast::ViewPathSimple(ident,
path,
- ast::DUMMY_NODE_ID))])
+ ast::DUMMY_NODE_ID))))
}
fn view_use_list(&self, sp: Span, vis: ast::Visibility,
- path: ~[ast::Ident], imports: &[ast::Ident]) -> ast::ViewItem {
+ path: Vec<ast::Ident> , imports: &[ast::Ident]) -> ast::ViewItem {
let imports = imports.map(|id| {
respan(sp, ast::PathListIdent_ { name: *id, id: ast::DUMMY_NODE_ID })
});
self.view_use(sp, vis,
- ~[@respan(sp,
+ vec!(@respan(sp,
ast::ViewPathList(self.path(sp, path),
- imports,
- ast::DUMMY_NODE_ID))])
+ imports.iter()
+ .map(|x| *x)
+ .collect(),
+ ast::DUMMY_NODE_ID))))
}
fn view_use_glob(&self, sp: Span,
- vis: ast::Visibility, path: ~[ast::Ident]) -> ast::ViewItem {
+ vis: ast::Visibility, path: Vec<ast::Ident> ) -> ast::ViewItem {
self.view_use(sp, vis,
- ~[@respan(sp,
- ast::ViewPathGlob(self.path(sp, path), ast::DUMMY_NODE_ID))])
+ vec!(@respan(sp,
+ ast::ViewPathGlob(self.path(sp, path), ast::DUMMY_NODE_ID))))
}
}
use ext::build::AstBuilder;
use std::char;
+use std::vec_ng::Vec;
pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> base::MacResult {
// Gather all argument expressions
None => return MacResult::dummy_expr(sp),
Some(e) => e,
};
- let mut bytes = ~[];
+ let mut bytes = Vec::new();
for expr in exprs.iter() {
match expr.node {
use parse::token;
use parse;
+use std::vec_ng::Vec;
+
pub fn expand_cfg(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> base::MacResult {
let mut p = parse::new_parser_from_tts(cx.parse_sess(),
cx.cfg(),
- tts.to_owned());
+ tts.iter()
+ .map(|x| (*x).clone())
+ .collect());
- let mut cfgs = ~[];
+ let mut cfgs = Vec::new();
// parse `cfg!(meta_item, meta_item(x,y), meta_item="foo", ...)`
while p.token != token::EOF {
cfgs.push(p.parse_meta_item());
// test_cfg searches for meta items looking like `cfg(foo, ...)`
let in_cfg = &[cx.meta_list(sp, InternedString::new("cfg"), cfgs)];
- let matches_cfg = attr::test_cfg(cx.cfg(), in_cfg.iter().map(|&x| x));
+ let matches_cfg = attr::test_cfg(cx.cfg().as_slice(),
+ in_cfg.iter().map(|&x| x));
let e = cx.expr_bool(sp, matches_cfg);
MRExpr(e)
}
ast::Path {
span: sp,
global: false,
- segments: ~[
+ segments: vec!(
ast::PathSegment {
identifier: res,
lifetimes: opt_vec::Empty,
types: opt_vec::Empty,
}
- ]
+ )
}
),
span: sp,
use ext::build::AstBuilder;
use ext::deriving::generic::*;
+use std::vec_ng::Vec;
+
pub fn expand_deriving_clone(cx: &mut ExtCtxt,
span: Span,
mitem: @MetaItem,
push: |@Item|) {
let trait_def = TraitDef {
span: span,
- attributes: ~[],
- path: Path::new(~["std", "clone", "Clone"]),
- additional_bounds: ~[],
+ attributes: Vec::new(),
+ path: Path::new(vec!("std", "clone", "Clone")),
+ additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
- methods: ~[
+ methods: vec!(
MethodDef {
name: "clone",
generics: LifetimeBounds::empty(),
explicit_self: borrowed_explicit_self(),
- args: ~[],
+ args: Vec::new(),
ret_ty: Self,
inline: true,
const_nonmatching: false,
combine_substructure: |c, s, sub| cs_clone("Clone", c, s, sub)
}
- ]
+ )
};
trait_def.expand(cx, mitem, item, push)
push: |@Item|) {
let trait_def = TraitDef {
span: span,
- attributes: ~[],
- path: Path::new(~["std", "clone", "DeepClone"]),
- additional_bounds: ~[],
+ attributes: Vec::new(),
+ path: Path::new(vec!("std", "clone", "DeepClone")),
+ additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
- methods: ~[
+ methods: vec!(
MethodDef {
name: "deep_clone",
generics: LifetimeBounds::empty(),
explicit_self: borrowed_explicit_self(),
- args: ~[],
+ args: Vec::new(),
ret_ty: Self,
inline: true,
const_nonmatching: false,
// call deep_clone (not clone) here.
combine_substructure: |c, s, sub| cs_clone("DeepClone", c, s, sub)
}
- ]
+ )
};
trait_def.expand(cx, mitem, item, push)
let ctor_ident;
let all_fields;
let subcall = |field: &FieldInfo|
- cx.expr_method_call(field.span, field.self_, clone_ident, ~[]);
+ cx.expr_method_call(field.span, field.self_, clone_ident, Vec::new());
match *substr.fields {
Struct(ref af) => {
name))
}
- if all_fields.len() >= 1 && all_fields[0].name.is_none() {
+ if all_fields.len() >= 1 && all_fields.get(0).name.is_none() {
// enum-like
let subcalls = all_fields.map(subcall);
cx.expr_call_ident(trait_span, ctor_ident, subcalls)
use ext::build::AstBuilder;
use ext::deriving::generic::*;
+use std::vec_ng::Vec;
+
pub fn expand_deriving_eq(cx: &mut ExtCtxt,
span: Span,
mitem: @MetaItem,
name: $name,
generics: LifetimeBounds::empty(),
explicit_self: borrowed_explicit_self(),
- args: ~[borrowed_self()],
- ret_ty: Literal(Path::new(~["bool"])),
+ args: vec!(borrowed_self()),
+ ret_ty: Literal(Path::new(vec!("bool"))),
inline: true,
const_nonmatching: true,
combine_substructure: $f
let trait_def = TraitDef {
span: span,
- attributes: ~[],
- path: Path::new(~["std", "cmp", "Eq"]),
- additional_bounds: ~[],
+ attributes: Vec::new(),
+ path: Path::new(vec!("std", "cmp", "Eq")),
+ additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
- methods: ~[
+ methods: vec!(
md!("eq", cs_eq),
md!("ne", cs_ne)
- ]
+ )
};
trait_def.expand(cx, mitem, item, push)
}
use ext::build::AstBuilder;
use ext::deriving::generic::*;
+use std::vec_ng::Vec;
+
pub fn expand_deriving_ord(cx: &mut ExtCtxt,
span: Span,
mitem: @MetaItem,
name: $name,
generics: LifetimeBounds::empty(),
explicit_self: borrowed_explicit_self(),
- args: ~[borrowed_self()],
- ret_ty: Literal(Path::new(~["bool"])),
+ args: vec!(borrowed_self()),
+ ret_ty: Literal(Path::new(vec!("bool"))),
inline: true,
const_nonmatching: false,
combine_substructure: |cx, span, substr| cs_op($op, $equal, cx, span, substr)
let trait_def = TraitDef {
span: span,
- attributes: ~[],
- path: Path::new(~["std", "cmp", "Ord"]),
- additional_bounds: ~[],
+ attributes: Vec::new(),
+ path: Path::new(vec!("std", "cmp", "Ord")),
+ additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
- methods: ~[
+ methods: vec!(
md!("lt", true, false),
md!("le", true, true),
md!("gt", false, false),
md!("ge", false, true)
- ]
+ )
};
trait_def.expand(cx, mitem, item, push)
}
use ext::build::AstBuilder;
use ext::deriving::generic::*;
+use std::vec_ng::Vec;
+
pub fn expand_deriving_totaleq(cx: &mut ExtCtxt,
span: Span,
mitem: @MetaItem,
let trait_def = TraitDef {
span: span,
- attributes: ~[],
- path: Path::new(~["std", "cmp", "TotalEq"]),
- additional_bounds: ~[],
+ attributes: Vec::new(),
+ path: Path::new(vec!("std", "cmp", "TotalEq")),
+ additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
- methods: ~[
+ methods: vec!(
MethodDef {
name: "equals",
generics: LifetimeBounds::empty(),
explicit_self: borrowed_explicit_self(),
- args: ~[borrowed_self()],
- ret_ty: Literal(Path::new(~["bool"])),
+ args: vec!(borrowed_self()),
+ ret_ty: Literal(Path::new(vec!("bool"))),
inline: true,
const_nonmatching: true,
combine_substructure: cs_equals
}
- ]
+ )
};
trait_def.expand(cx, mitem, item, push)
}
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
use ext::deriving::generic::*;
+
use std::cmp::{Ordering, Equal, Less, Greater};
+use std::vec_ng::Vec;
pub fn expand_deriving_totalord(cx: &mut ExtCtxt,
span: Span,
push: |@Item|) {
let trait_def = TraitDef {
span: span,
- attributes: ~[],
- path: Path::new(~["std", "cmp", "TotalOrd"]),
- additional_bounds: ~[],
+ attributes: Vec::new(),
+ path: Path::new(vec!("std", "cmp", "TotalOrd")),
+ additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
- methods: ~[
+ methods: vec!(
MethodDef {
name: "cmp",
generics: LifetimeBounds::empty(),
explicit_self: borrowed_explicit_self(),
- args: ~[borrowed_self()],
- ret_ty: Literal(Path::new(~["std", "cmp", "Ordering"])),
+ args: vec!(borrowed_self()),
+ ret_ty: Literal(Path::new(vec!("std", "cmp", "Ordering"))),
inline: true,
const_nonmatching: false,
combine_substructure: cs_cmp
}
- ]
+ )
};
trait_def.expand(cx, mitem, item, push)
Greater => "Greater"
};
cx.path_global(span,
- ~[cx.ident_of("std"),
+ vec!(cx.ident_of("std"),
cx.ident_of("cmp"),
- cx.ident_of(cnst)])
+ cx.ident_of(cnst)))
}
pub fn cs_cmp(cx: &mut ExtCtxt, span: Span,
let if_ = cx.expr_if(span,
cond,
old, Some(cx.expr_ident(span, test_id)));
- cx.expr_block(cx.block(span, ~[assign], Some(if_)))
+ cx.expr_block(cx.block(span, vec!(assign), Some(if_)))
},
cx.expr_path(equals_path.clone()),
|cx, span, list, _| {
use parse::token::InternedString;
use parse::token;
+use std::vec_ng::Vec;
+
pub fn expand_deriving_decodable(cx: &mut ExtCtxt,
span: Span,
mitem: @MetaItem,
push: |@Item|) {
let trait_def = TraitDef {
span: span,
- attributes: ~[],
- path: Path::new_(~["serialize", "Decodable"], None,
- ~[~Literal(Path::new_local("__D"))], true),
- additional_bounds: ~[],
+ attributes: Vec::new(),
+ path: Path::new_(vec!("serialize", "Decodable"), None,
+ vec!(~Literal(Path::new_local("__D"))), true),
+ additional_bounds: Vec::new(),
generics: LifetimeBounds {
- lifetimes: ~[],
- bounds: ~[("__D", ~[Path::new(~["serialize", "Decoder"])])],
+ lifetimes: Vec::new(),
+ bounds: vec!(("__D", vec!(Path::new(vec!("serialize", "Decoder"))))),
},
- methods: ~[
+ methods: vec!(
MethodDef {
name: "decode",
generics: LifetimeBounds::empty(),
explicit_self: None,
- args: ~[Ptr(~Literal(Path::new_local("__D")),
- Borrowed(None, MutMutable))],
+ args: vec!(Ptr(~Literal(Path::new_local("__D")),
+ Borrowed(None, MutMutable))),
ret_ty: Self,
inline: false,
const_nonmatching: true,
combine_substructure: decodable_substructure,
- },
- ]
+ })
};
trait_def.expand(cx, mitem, item, push)
fn decodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
substr: &Substructure) -> @Expr {
let decoder = substr.nonself_args[0];
- let recurse = ~[cx.ident_of("serialize"),
+ let recurse = vec!(cx.ident_of("serialize"),
cx.ident_of("Decodable"),
- cx.ident_of("decode")];
+ cx.ident_of("decode"));
// throw an underscore in front to suppress unused variable warnings
let blkarg = cx.ident_of("_d");
let blkdecoder = cx.expr_ident(trait_span, blkarg);
- let calldecode = cx.expr_call_global(trait_span, recurse, ~[blkdecoder]);
+ let calldecode = cx.expr_call_global(trait_span, recurse, vec!(blkdecoder));
let lambdadecode = cx.lambda_expr_1(trait_span, calldecode, blkarg);
return match *substr.fields {
summary,
|cx, span, name, field| {
cx.expr_method_call(span, blkdecoder, read_struct_field,
- ~[cx.expr_str(span, name),
+ vec!(cx.expr_str(span, name),
cx.expr_uint(span, field),
- lambdadecode])
+ lambdadecode))
});
cx.expr_method_call(trait_span,
decoder,
cx.ident_of("read_struct"),
- ~[
+ vec!(
cx.expr_str(trait_span, token::get_ident(substr.type_ident)),
cx.expr_uint(trait_span, nfields),
cx.lambda_expr_1(trait_span, result, blkarg)
- ])
+ ))
}
StaticEnum(_, ref fields) => {
let variant = cx.ident_of("i");
- let mut arms = ~[];
- let mut variants = ~[];
+ let mut arms = Vec::new();
+ let mut variants = Vec::new();
let rvariant_arg = cx.ident_of("read_enum_variant_arg");
for (i, &(name, v_span, ref parts)) in fields.iter().enumerate() {
|cx, span, _, field| {
let idx = cx.expr_uint(span, field);
cx.expr_method_call(span, blkdecoder, rvariant_arg,
- ~[idx, lambdadecode])
+ vec!(idx, lambdadecode))
});
arms.push(cx.arm(v_span,
- ~[cx.pat_lit(v_span, cx.expr_uint(v_span, i))],
+ vec!(cx.pat_lit(v_span, cx.expr_uint(v_span, i))),
decoded));
}
arms.push(cx.arm_unreachable(trait_span));
let result = cx.expr_match(trait_span, cx.expr_ident(trait_span, variant), arms);
- let lambda = cx.lambda_expr(trait_span, ~[blkarg, variant], result);
+ let lambda = cx.lambda_expr(trait_span, vec!(blkarg, variant), result);
let variant_vec = cx.expr_vec(trait_span, variants);
let result = cx.expr_method_call(trait_span, blkdecoder,
cx.ident_of("read_enum_variant"),
- ~[variant_vec, lambda]);
+ vec!(variant_vec, lambda));
cx.expr_method_call(trait_span,
decoder,
cx.ident_of("read_enum"),
- ~[
+ vec!(
cx.expr_str(trait_span, token::get_ident(substr.type_ident)),
cx.lambda_expr_1(trait_span, result, blkarg)
- ])
+ ))
}
_ => cx.bug("expected StaticEnum or StaticStruct in deriving(Decodable)")
};
use ext::build::AstBuilder;
use ext::deriving::generic::*;
+use std::vec_ng::Vec;
+
pub fn expand_deriving_default(cx: &mut ExtCtxt,
span: Span,
mitem: @MetaItem,
push: |@Item|) {
let trait_def = TraitDef {
span: span,
- attributes: ~[],
- path: Path::new(~["std", "default", "Default"]),
- additional_bounds: ~[],
+ attributes: Vec::new(),
+ path: Path::new(vec!("std", "default", "Default")),
+ additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
- methods: ~[
+ methods: vec!(
MethodDef {
name: "default",
generics: LifetimeBounds::empty(),
explicit_self: None,
- args: ~[],
+ args: Vec::new(),
ret_ty: Self,
inline: true,
const_nonmatching: false,
combine_substructure: default_substructure
- },
- ]
+ })
};
trait_def.expand(cx, mitem, item, push)
}
fn default_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> @Expr {
- let default_ident = ~[
+ let default_ident = vec!(
cx.ident_of("std"),
cx.ident_of("default"),
cx.ident_of("Default"),
cx.ident_of("default")
- ];
- let default_call = |span| cx.expr_call_global(span, default_ident.clone(), ~[]);
+ );
+ let default_call = |span| cx.expr_call_global(span, default_ident.clone(), Vec::new());
return match *substr.fields {
StaticStruct(_, ref summary) => {
use ext::deriving::generic::*;
use parse::token;
+use std::vec_ng::Vec;
+
pub fn expand_deriving_encodable(cx: &mut ExtCtxt,
span: Span,
mitem: @MetaItem,
push: |@Item|) {
let trait_def = TraitDef {
span: span,
- attributes: ~[],
- path: Path::new_(~["serialize", "Encodable"], None,
- ~[~Literal(Path::new_local("__E"))], true),
- additional_bounds: ~[],
+ attributes: Vec::new(),
+ path: Path::new_(vec!("serialize", "Encodable"), None,
+ vec!(~Literal(Path::new_local("__E"))), true),
+ additional_bounds: Vec::new(),
generics: LifetimeBounds {
- lifetimes: ~[],
- bounds: ~[("__E", ~[Path::new(~["serialize", "Encoder"])])],
+ lifetimes: Vec::new(),
+ bounds: vec!(("__E", vec!(Path::new(vec!("serialize", "Encoder"))))),
},
- methods: ~[
+ methods: vec!(
MethodDef {
name: "encode",
generics: LifetimeBounds::empty(),
explicit_self: borrowed_explicit_self(),
- args: ~[Ptr(~Literal(Path::new_local("__E")),
- Borrowed(None, MutMutable))],
+ args: vec!(Ptr(~Literal(Path::new_local("__E")),
+ Borrowed(None, MutMutable))),
ret_ty: nil_ty(),
inline: false,
const_nonmatching: true,
combine_substructure: encodable_substructure,
- },
- ]
+ })
};
trait_def.expand(cx, mitem, item, push)
return match *substr.fields {
Struct(ref fields) => {
let emit_struct_field = cx.ident_of("emit_struct_field");
- let mut stmts = ~[];
+ let mut stmts = Vec::new();
for (i, &FieldInfo {
name,
self_,
token::intern_and_get_ident(format!("_field{}", i))
}
};
- let enc = cx.expr_method_call(span, self_, encode, ~[blkencoder]);
+ let enc = cx.expr_method_call(span, self_, encode, vec!(blkencoder));
let lambda = cx.lambda_expr_1(span, enc, blkarg);
let call = cx.expr_method_call(span, blkencoder,
emit_struct_field,
- ~[cx.expr_str(span, name),
+ vec!(cx.expr_str(span, name),
cx.expr_uint(span, i),
- lambda]);
+ lambda));
stmts.push(cx.stmt_expr(call));
}
cx.expr_method_call(trait_span,
encoder,
cx.ident_of("emit_struct"),
- ~[
+ vec!(
cx.expr_str(trait_span, token::get_ident(substr.type_ident)),
cx.expr_uint(trait_span, fields.len()),
blk
- ])
+ ))
}
EnumMatching(idx, variant, ref fields) => {
let me = cx.stmt_let(trait_span, false, blkarg, encoder);
let encoder = cx.expr_ident(trait_span, blkarg);
let emit_variant_arg = cx.ident_of("emit_enum_variant_arg");
- let mut stmts = ~[];
+ let mut stmts = Vec::new();
for (i, &FieldInfo { self_, span, .. }) in fields.iter().enumerate() {
- let enc = cx.expr_method_call(span, self_, encode, ~[blkencoder]);
+ let enc = cx.expr_method_call(span, self_, encode, vec!(blkencoder));
let lambda = cx.lambda_expr_1(span, enc, blkarg);
let call = cx.expr_method_call(span, blkencoder,
emit_variant_arg,
- ~[cx.expr_uint(span, i),
- lambda]);
+ vec!(cx.expr_uint(span, i),
+ lambda));
stmts.push(cx.stmt_expr(call));
}
let name = cx.expr_str(trait_span, token::get_ident(variant.node.name));
let call = cx.expr_method_call(trait_span, blkencoder,
cx.ident_of("emit_enum_variant"),
- ~[name,
+ vec!(name,
cx.expr_uint(trait_span, idx),
cx.expr_uint(trait_span, fields.len()),
- blk]);
+ blk));
let blk = cx.lambda_expr_1(trait_span, call, blkarg);
let ret = cx.expr_method_call(trait_span,
encoder,
cx.ident_of("emit_enum"),
- ~[
+ vec!(
cx.expr_str(trait_span, token::get_ident(substr.type_ident)),
blk
- ]);
- cx.expr_block(cx.block(trait_span, ~[me], Some(ret)))
+ ));
+ cx.expr_block(cx.block(trait_span, vec!(me), Some(ret)))
}
_ => cx.bug("expected Struct or EnumMatching in deriving(Encodable)")
use parse::token::InternedString;
use parse::token;
-use std::vec;
+use std::vec_ng::Vec;
+use std::vec_ng;
pub use self::ty::*;
mod ty;
/// The span for the current #[deriving(Foo)] header.
span: Span,
- attributes: ~[ast::Attribute],
+ attributes: Vec<ast::Attribute> ,
/// Path of the trait, including any type parameters
path: Path<'a>,
/// Additional bounds required of any type parameters of the type,
/// other than the current trait
- additional_bounds: ~[Ty<'a>],
+ additional_bounds: Vec<Ty<'a>> ,
/// Any extra lifetimes and/or bounds, e.g. `D: serialize::Decoder`
generics: LifetimeBounds<'a>,
- methods: ~[MethodDef<'a>]
-}
+ methods: Vec<MethodDef<'a>> }
pub struct MethodDef<'a> {
explicit_self: Option<Option<PtrTy<'a>>>,
/// Arguments other than the self argument
- args: ~[Ty<'a>],
+ args: Vec<Ty<'a>> ,
/// Return type
ret_ty: Ty<'a>,
self_: @Expr,
/// The expressions corresponding to references to this field in
/// the other Self arguments.
- other: ~[@Expr]
-}
+ other: Vec<@Expr> }
/// Fields for a static method
pub enum StaticFields {
/// Tuple structs/enum variants like this
- Unnamed(~[Span]),
+ Unnamed(Vec<Span> ),
/// Normal structs/struct variants.
- Named(~[(Ident, Span)])
+ Named(Vec<(Ident, Span)> )
}
/// A summary of the possible sets of fields. See above for details
/// and examples
pub enum SubstructureFields<'a> {
- Struct(~[FieldInfo]),
+ Struct(Vec<FieldInfo> ),
/**
Matching variants of the enum: variant index, ast::Variant,
fields: the field name is only non-`None` in the case of a struct
variant.
*/
- EnumMatching(uint, &'a ast::Variant, ~[FieldInfo]),
+ EnumMatching(uint, &'a ast::Variant, Vec<FieldInfo> ),
/**
non-matching variants of the enum, [(variant index, ast::Variant,
[field span, field ident, fields])] (i.e. all fields for self are in the
first tuple, for other1 are in the second tuple, etc.)
*/
- EnumNonMatching(&'a [(uint, P<ast::Variant>, ~[(Span, Option<Ident>, @Expr)])]),
+ EnumNonMatching(&'a [(uint, P<ast::Variant>, Vec<(Span, Option<Ident>, @Expr)> )]),
/// A static method where Self is a struct.
StaticStruct(&'a ast::StructDef, StaticFields),
/// A static method where Self is an enum.
- StaticEnum(&'a ast::EnumDef, ~[(Ident, Span, StaticFields)])
+ StaticEnum(&'a ast::EnumDef, Vec<(Ident, Span, StaticFields)> )
}
pub type EnumNonMatchFunc<'a> =
'a |&mut ExtCtxt,
Span,
- &[(uint, P<ast::Variant>, ~[(Span, Option<Ident>, @Expr)])],
+ &[(uint, P<ast::Variant>, Vec<(Span, Option<Ident>, @Expr)> )],
&[@Expr]|
-> @Expr;
cx: &mut ExtCtxt,
type_ident: Ident,
generics: &Generics,
- methods: ~[@ast::Method]) -> @ast::Item {
+ methods: Vec<@ast::Method> ) -> @ast::Item {
let trait_path = self.path.to_path(cx, self.span, type_ident, generics);
let mut trait_generics = self.generics.to_generics(cx, self.span,
// Create the type of `self`.
let self_type = cx.ty_path(
- cx.path_all(self.span, false, ~[ type_ident ], self_lifetimes,
+ cx.path_all(self.span, false, vec!( type_ident ), self_lifetimes,
opt_vec::take_vec(self_ty_params)), None);
let doc_attr = cx.attribute(
cx.item(
self.span,
ident,
- vec::append(~[doc_attr], self.attributes),
+ vec_ng::append(vec!(doc_attr), self.attributes.as_slice()),
ast::ItemImpl(trait_generics, opt_trait_ref,
self_type, methods.map(|x| *x)))
}
self,
struct_def,
type_ident,
- self_args, nonself_args)
+ self_args.as_slice(),
+ nonself_args.as_slice())
} else {
method_def.expand_struct_method_body(cx,
self,
struct_def,
type_ident,
- self_args, nonself_args)
+ self_args.as_slice(),
+ nonself_args.as_slice())
};
method_def.create_method(cx, self,
self,
enum_def,
type_ident,
- self_args, nonself_args)
+ self_args.as_slice(),
+ nonself_args.as_slice())
} else {
method_def.expand_enum_method_body(cx,
self,
enum_def,
type_ident,
- self_args, nonself_args)
+ self_args.as_slice(),
+ nonself_args.as_slice())
};
method_def.create_method(cx, self,
trait_: &TraitDef,
type_ident: Ident,
generics: &Generics)
- -> (ast::ExplicitSelf, ~[@Expr], ~[@Expr], ~[(Ident, P<ast::Ty>)]) {
+ -> (ast::ExplicitSelf, Vec<@Expr> , Vec<@Expr> , Vec<(Ident, P<ast::Ty>)> ) {
- let mut self_args = ~[];
- let mut nonself_args = ~[];
- let mut arg_tys = ~[];
+ let mut self_args = Vec::new();
+ let mut nonself_args = Vec::new();
+ let mut arg_tys = Vec::new();
let mut nonstatic = false;
let ast_explicit_self = match self.explicit_self {
type_ident: Ident,
generics: &Generics,
explicit_self: ast::ExplicitSelf,
- arg_types: ~[(Ident, P<ast::Ty>)],
+ arg_types: Vec<(Ident, P<ast::Ty>)> ,
body: @Expr) -> @ast::Method {
// create the generics that aren't for Self
let fn_generics = self.generics.to_generics(cx, trait_.span, type_ident, generics);
let body_block = cx.block_expr(body);
let attrs = if self.inline {
- ~[
+ vec!(
cx
.attribute(trait_.span,
cx
.meta_word(trait_.span,
InternedString::new(
"inline")))
- ]
+ )
} else {
- ~[]
+ Vec::new()
};
// Create the method.
nonself_args: &[@Expr])
-> @Expr {
- let mut raw_fields = ~[]; // ~[[fields of self],
+ let mut raw_fields = Vec::new(); // ~[[fields of self],
// [fields of next Self arg], [etc]]
- let mut patterns = ~[];
+ let mut patterns = Vec::new();
for i in range(0u, self_args.len()) {
let (pat, ident_expr) = trait_.create_struct_pattern(cx, type_ident, struct_def,
format!("__self_{}", i),
// transpose raw_fields
let fields = if raw_fields.len() > 0 {
- raw_fields[0].iter()
- .enumerate()
- .map(|(i, &(span, opt_id, field))| {
- let other_fields = raw_fields.tail().map(|l| {
- match &l[i] {
+ raw_fields.get(0)
+ .iter()
+ .enumerate()
+ .map(|(i, &(span, opt_id, field))| {
+ let other_fields = raw_fields.tail().iter().map(|l| {
+ match l.get(i) {
&(_, _, ex) => ex
}
- });
+ }).collect();
FieldInfo {
span: span,
name: opt_id,
// matter.
for (&arg_expr, &pat) in self_args.iter().zip(patterns.iter()) {
body = cx.expr_match(trait_.span, arg_expr,
- ~[ cx.arm(trait_.span, ~[pat], body) ])
+ vec!( cx.arm(trait_.span, vec!(pat), body) ))
}
body
}
self_args: &[@Expr],
nonself_args: &[@Expr])
-> @Expr {
- let mut matches = ~[];
+ let mut matches = Vec::new();
self.build_enum_match(cx, trait_, enum_def, type_ident,
self_args, nonself_args,
None, &mut matches, 0)
self_args: &[@Expr],
nonself_args: &[@Expr],
matching: Option<uint>,
- matches_so_far: &mut
~[(uint, P<ast::Variant>,
- ~[(Span, Option<Ident>, @Expr)])],
+ matches_so_far: &mut
Vec<(uint, P<ast::Variant>,
+ Vec<(Span, Option<Ident>, @Expr)> )> ,
match_count: uint) -> @Expr {
if match_count == self_args.len() {
// we've matched against all arguments, so make the final
Some(variant_index) => {
// `ref` inside let matches is buggy. Causes havoc wih rusc.
// let (variant_index, ref self_vec) = matches_so_far[0];
- let (variant, self_vec) = match matches_so_far[0] {
- (_, v, ref s) => (v, s)
+ let (variant, self_vec) = match matches_so_far.get(0) {
+ &(_, v, ref s) => (v, s)
};
- let mut enum_matching_fields = vec::from_elem(self_vec.len(), ~[]);
+ let mut enum_matching_fields = Vec::from_elem(self_vec.len(), Vec::new());
for triple in matches_so_far.tail().iter() {
match triple {
&(_, _, ref other_fields) => {
for (i, &(_, _, e)) in other_fields.iter().enumerate() {
- enum_matching_fields[i].push(e);
+ enum_matching_fields.get_mut(i).push(e);
}
}
}
substructure = EnumMatching(variant_index, variant, field_tuples);
}
None => {
- substructure = EnumNonMatching(*matches_so_far);
+ substructure = EnumNonMatching(matches_so_far.as_slice());
}
}
self.call_substructure_method(cx, trait_, type_ident,
format!("__arg_{}", match_count)
};
- let mut arms = ~[];
+ let mut arms = Vec::new();
// the code for nonmatching variants only matters when
// we've seen at least one other variant already
};
// matching-variant match
- let variant = enum_def.variants[index];
+ let variant = *enum_def.variants.get(index);
let (pattern, idents) = trait_.create_enum_variant_pattern(cx,
variant,
current_match_str,
matches_so_far,
match_count + 1);
matches_so_far.pop().unwrap();
- arms.push(cx.arm(trait_.span, ~[ pattern ], arm_expr));
+ arms.push(cx.arm(trait_.span, vec!( pattern ), arm_expr));
if enum_def.variants.len() > 1 {
let e = &EnumNonMatching(&[]);
e);
let wild_arm = cx.arm(
trait_.span,
- ~[ cx.pat_wild(trait_.span) ],
+ vec!( cx.pat_wild(trait_.span) ),
wild_expr);
arms.push(wild_arm);
}
match_count + 1);
matches_so_far.pop().unwrap();
- let arm = cx.arm(trait_.span, ~[ pattern ], arm_expr);
+ let arm = cx.arm(trait_.span, vec!( pattern ), arm_expr);
arms.push(arm);
}
}
fn summarise_struct(&self,
cx: &mut ExtCtxt,
struct_def: &StructDef) -> StaticFields {
- let mut named_idents = ~[];
- let mut just_spans = ~[];
+ let mut named_idents = Vec::new();
+ let mut just_spans = Vec::new();
for field in struct_def.fields.iter(){
let sp = self.set_expn_info(cx, field.span);
match field.node.kind {
fn create_subpatterns(&self,
cx: &mut ExtCtxt,
- field_paths: ~[ast::Path],
+ field_paths: Vec<ast::Path> ,
mutbl: ast::Mutability)
- -> ~[@ast::Pat] {
+ -> Vec<@ast::Pat> {
field_paths.map(|path| {
cx.pat(path.span,
ast::PatIdent(ast::BindByRef(mutbl), (*path).clone(), None))
struct_def: &StructDef,
prefix: &str,
mutbl: ast::Mutability)
- -> (@ast::Pat, ~[(Span, Option<Ident>, @Expr)]) {
+ -> (@ast::Pat, Vec<(Span, Option<Ident>, @Expr)> ) {
if struct_def.fields.is_empty() {
return (
cx.pat_ident_binding_mode(
self.span, struct_ident, ast::BindByValue(ast::MutImmutable)),
- ~[]);
+ Vec::new());
}
- let matching_path = cx.path(self.span, ~[ struct_ident ]);
+ let matching_path = cx.path(self.span, vec!( struct_ident ));
- let mut paths = ~[];
- let mut ident_expr = ~[];
+ let mut paths = Vec::new();
+ let mut ident_expr = Vec::new();
let mut struct_type = Unknown;
for (i, struct_field) in struct_def.fields.iter().enumerate() {
variant: &ast::Variant,
prefix: &str,
mutbl: ast::Mutability)
- -> (@ast::Pat, ~[(Span, Option<Ident>, @Expr)]) {
+ -> (@ast::Pat, Vec<(Span, Option<Ident>, @Expr)> ) {
let variant_ident = variant.node.name;
match variant.node.kind {
ast::TupleVariantKind(ref variant_args) => {
if variant_args.is_empty() {
return (cx.pat_ident_binding_mode(variant.span, variant_ident,
ast::BindByValue(ast::MutImmutable)),
- ~[]);
+ Vec::new());
}
let matching_path = cx.path_ident(variant.span, variant_ident);
- let mut paths = ~[];
- let mut ident_expr = ~[];
+ let mut paths = Vec::new();
+ let mut ident_expr = Vec::new();
for (i, va) in variant_args.iter().enumerate() {
let sp = self.set_expn_info(cx, va.ty.span);
let path = cx.path_ident(sp, cx.ident_of(format!("{}_{}", prefix, i)));
EnumMatching(_, _, ref all_fields) | Struct(ref all_fields) => {
if use_foldl {
all_fields.iter().fold(base, |old, field| {
- f(cx, field.span, old, field.self_, field.other)
+ f(cx,
+ field.span,
+ old,
+ field.self_,
+ field.other.as_slice())
})
} else {
all_fields.rev_iter().fold(base, |old, field| {
- f(cx, field.span, old, field.self_, field.other)
+ f(cx,
+ field.span,
+ old,
+ field.self_,
+ field.other.as_slice())
})
}
},
~~~
*/
#[inline]
-pub fn cs_same_method(f: |&mut ExtCtxt, Span, ~[@Expr]| -> @Expr,
+pub fn cs_same_method(f: |&mut ExtCtxt, Span, Vec<@Expr> | -> @Expr,
enum_nonmatch_f: EnumNonMatchFunc,
cx: &mut ExtCtxt,
trait_span: Span,
use ext::build::AstBuilder;
use ext::deriving::generic::*;
+use std::vec_ng::Vec;
+
pub fn expand_deriving_hash(cx: &mut ExtCtxt,
span: Span,
mitem: @MetaItem,
let hash_trait_def = TraitDef {
span: span,
- attributes: ~[],
- path: Path::new(~["std", "hash", "Hash"]),
- additional_bounds: ~[],
+ attributes: Vec::new(),
+ path: Path::new(vec!("std", "hash", "Hash")),
+ additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
- methods: ~[
+ methods: vec!(
MethodDef {
name: "hash",
generics: LifetimeBounds::empty(),
explicit_self: borrowed_explicit_self(),
- args: ~[Ptr(~Literal(Path::new(~["std", "hash", "sip", "SipState"])),
- Borrowed(None, MutMutable))],
+ args: vec!(Ptr(~Literal(Path::new(vec!("std", "hash", "sip", "SipState"))),
+ Borrowed(None, MutMutable))),
ret_ty: nil_ty(),
inline: true,
const_nonmatching: false,
combine_substructure: hash_substructure
}
- ]
+ )
};
hash_trait_def.expand(cx, mitem, item, push);
};
let hash_ident = substr.method_ident;
let call_hash = |span, thing_expr| {
- let expr = cx.expr_method_call(span, thing_expr, hash_ident, ~[state_expr]);
+ let expr = cx.expr_method_call(span, thing_expr, hash_ident, vec!(state_expr));
cx.stmt_expr(expr)
};
- let mut stmts = ~[];
+ let mut stmts = Vec::new();
let fields = match *substr.fields {
Struct(ref fs) => fs,
use ext::deriving::generic::*;
use parse::token::InternedString;
+use std::vec_ng::Vec;
+
pub fn expand_deriving_from_primitive(cx: &mut ExtCtxt,
span: Span,
mitem: @MetaItem,
push: |@Item|) {
let trait_def = TraitDef {
span: span,
- attributes: ~[],
- path: Path::new(~["std", "num", "FromPrimitive"]),
- additional_bounds: ~[],
+ attributes: Vec::new(),
+ path: Path::new(vec!("std", "num", "FromPrimitive")),
+ additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
- methods: ~[
+ methods: vec!(
MethodDef {
name: "from_i64",
generics: LifetimeBounds::empty(),
explicit_self: None,
- args: ~[
- Literal(Path::new(~["i64"])),
- ],
- ret_ty: Literal(Path::new_(~["std", "option", "Option"],
+ args: vec!(
+ Literal(Path::new(vec!("i64")))),
+ ret_ty: Literal(Path::new_(vec!("std", "option", "Option"),
None,
- ~[~Self],
+ vec!(~Self),
true)),
// liable to cause code-bloat
inline: true,
name: "from_u64",
generics: LifetimeBounds::empty(),
explicit_self: None,
- args: ~[
- Literal(Path::new(~["u64"])),
- ],
- ret_ty: Literal(Path::new_(~["std", "option", "Option"],
+ args: vec!(
+ Literal(Path::new(vec!("u64")))),
+ ret_ty: Literal(Path::new_(vec!("std", "option", "Option"),
None,
- ~[~Self],
+ vec!(~Self),
true)),
// liable to cause code-bloat
inline: true,
const_nonmatching: false,
combine_substructure: |c, s, sub| cs_from("u64", c, s, sub),
- },
- ]
+ })
};
trait_def.expand(cx, mitem, item, push)
return cx.expr_fail(trait_span, InternedString::new(""));
}
- let mut arms = ~[];
+ let mut arms = Vec::new();
for variant in enum_def.variants.iter() {
match variant.node.kind {
// arm for `_ if $guard => $body`
let arm = ast::Arm {
- pats: ~[cx.pat_wild(span)],
+ pats: vec!(cx.pat_wild(span)),
guard: Some(guard),
body: cx.block_expr(body),
};
// arm for `_ => None`
let arm = ast::Arm {
- pats: ~[cx.pat_wild(trait_span)],
+ pats: vec!(cx.pat_wild(trait_span)),
guard: None,
body: cx.block_expr(cx.expr_none(trait_span)),
};
use ext::deriving::generic::*;
use opt_vec;
+use std::vec_ng::Vec;
+
pub fn expand_deriving_rand(cx: &mut ExtCtxt,
span: Span,
mitem: @MetaItem,
push: |@Item|) {
let trait_def = TraitDef {
span: span,
- attributes: ~[],
- path: Path::new(~["std", "rand", "Rand"]),
- additional_bounds: ~[],
+ attributes: Vec::new(),
+ path: Path::new(vec!("std", "rand", "Rand")),
+ additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
- methods: ~[
+ methods: vec!(
MethodDef {
name: "rand",
generics: LifetimeBounds {
- lifetimes: ~[],
- bounds: ~[("R",
- ~[ Path::new(~["std", "rand", "Rng"]) ])]
+ lifetimes: Vec::new(),
+ bounds: vec!(("R",
+ vec!( Path::new(vec!("std", "rand", "Rng")) )))
},
explicit_self: None,
- args: ~[
+ args: vec!(
Ptr(~Literal(Path::new_local("R")),
Borrowed(None, ast::MutMutable))
- ],
+ ),
ret_ty: Self,
inline: false,
const_nonmatching: false,
combine_substructure: rand_substructure
}
- ]
+ )
};
trait_def.expand(cx, mitem, item, push)
}
fn rand_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> @Expr {
let rng = match substr.nonself_args {
- [rng] => ~[ rng ],
+ [rng] => vec!( rng ),
_ => cx.bug("Incorrect number of arguments to `rand` in `deriving(Rand)`")
};
- let rand_ident = ~[
+ let rand_ident = vec!(
cx.ident_of("std"),
cx.ident_of("rand"),
cx.ident_of("Rand"),
cx.ident_of("rand")
- ];
+ );
let rand_call = |cx: &mut ExtCtxt, span| {
cx.expr_call_global(span,
rand_ident.clone(),
- ~[ rng[0] ])
+ vec!( *rng.get(0) ))
};
return match *substr.fields {
true,
rand_ident.clone(),
opt_vec::Empty,
- ~[]);
+ Vec::new());
let rand_name = cx.expr_path(rand_name);
// ::std::rand::Rand::rand(rng)
let rv_call = cx.expr_call(trait_span,
rand_name,
- ~[ rng[0] ]);
+ vec!( *rng.get(0) ));
// need to specify the uint-ness of the random number
let uint_ty = cx.ty_ident(trait_span, cx.ident_of("uint"));
let pat = cx.pat_lit(v_span, i_expr);
let thing = rand_thing(cx, v_span, ident, summary, |cx, sp| rand_call(cx, sp));
- cx.arm(v_span, ~[ pat ], thing)
- }).collect::<~[ast::Arm]>();
+ cx.arm(v_span, vec!( pat ), thing)
+ }).collect::<Vec<ast::Arm> >();
// _ => {} at the end. Should never occur
arms.push(cx.arm_unreachable(trait_span));
let match_expr = cx.expr_match(trait_span, rand_variant, arms);
- let block = cx.block(trait_span, ~[ let_statement ], Some(match_expr));
+ let block = cx.block(trait_span, vec!( let_statement ), Some(match_expr));
cx.expr_block(block)
}
_ => cx.bug("Non-static method in `deriving(Rand)`")
use parse::token;
use collections::HashMap;
+use std::vec_ng::Vec;
pub fn expand_deriving_show(cx: &mut ExtCtxt,
span: Span,
item: @Item,
push: |@Item|) {
// &mut ::std::fmt::Formatter
- let fmtr = Ptr(~Literal(Path::new(~["std", "fmt", "Formatter"])),
+ let fmtr = Ptr(~Literal(Path::new(vec!("std", "fmt", "Formatter"))),
Borrowed(None, ast::MutMutable));
let trait_def = TraitDef {
span: span,
- attributes: ~[],
- path: Path::new(~["std", "fmt", "Show"]),
- additional_bounds: ~[],
+ attributes: Vec::new(),
+ path: Path::new(vec!("std", "fmt", "Show")),
+ additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
- methods: ~[
+ methods: vec!(
MethodDef {
name: "fmt",
generics: LifetimeBounds::empty(),
explicit_self: borrowed_explicit_self(),
- args: ~[fmtr],
- ret_ty: Literal(Path::new(~["std", "fmt", "Result"])),
+ args: vec!(fmtr),
+ ret_ty: Literal(Path::new(vec!("std", "fmt", "Result"))),
inline: false,
const_nonmatching: false,
combine_substructure: show_substructure
}
- ]
+ )
};
trait_def.expand(cx, mitem, item, push)
}
let mut format_string = token::get_ident(name).get().to_owned();
// the internal fields we're actually formatting
- let mut exprs = ~[];
+ let mut exprs = Vec::new();
// Getting harder... making the format string:
match *substr.fields {
EnumMatching(_, _, ref fields) if fields.len() == 0 => {}
Struct(ref fields) | EnumMatching(_, _, ref fields) => {
- if fields[0].name.is_none() {
+ if fields.get(0).name.is_none() {
// tuple struct/"normal" variant
format_string.push_str("(");
let formatter = substr.nonself_args[0];
let buf = cx.expr_field_access(span, formatter, cx.ident_of("buf"));
- let std_write = ~[cx.ident_of("std"), cx.ident_of("fmt"), cx.ident_of("write")];
+ let std_write = vec!(cx.ident_of("std"), cx.ident_of("fmt"), cx.ident_of("write"));
let args = cx.ident_of("__args");
- let write_call = cx.expr_call_global(span, std_write, ~[buf, cx.expr_ident(span, args)]);
- let format_closure = cx.lambda_expr(span, ~[args], write_call);
+ let write_call = cx.expr_call_global(span, std_write, vec!(buf, cx.expr_ident(span, args)));
+ let format_closure = cx.lambda_expr(span, vec!(args), write_call);
let s = token::intern_and_get_ident(format_string);
let format_string = cx.expr_str(span, s);
// phew, not our responsibility any more!
format::expand_preparsed_format_args(cx, span,
format_closure,
- format_string, exprs, ~[],
+ format_string, exprs, Vec::new(),
HashMap::new())
}
use opt_vec;
use opt_vec::OptVec;
+use std::vec_ng::Vec;
+
/// The types of pointers
pub enum PtrTy<'a> {
Send, // ~
/// A path, e.g. `::std::option::Option::<int>` (global). Has support
/// for type parameters and a lifetime.
pub struct Path<'a> {
- path: ~[&'a str],
+ path: Vec<&'a str> ,
lifetime: Option<&'a str>,
- params: ~[~Ty<'a>],
+ params: Vec<~Ty<'a>> ,
global: bool
}
impl<'a> Path<'a> {
- pub fn new<'r>(path: ~[&'r str]) -> Path<'r> {
- Path::new_(path, None, ~[], true)
+ pub fn new<'r>(path: Vec<&'r str> ) -> Path<'r> {
+ Path::new_(path, None, Vec::new(), true)
}
pub fn new_local<'r>(path: &'r str) -> Path<'r> {
- Path::new_(~[ path ], None, ~[], false)
+ Path::new_(vec!( path ), None, Vec::new(), false)
}
- pub fn new_<'r>(path: ~[&'r str],
+ pub fn new_<'r>(path: Vec<&'r str> ,
lifetime: Option<&'r str>,
- params: ~[~Ty<'r>],
+ params: Vec<~Ty<'r>> ,
global: bool)
-> Path<'r> {
Path {
// parameter, and things like `int`
Literal(Path<'a>),
// includes nil
- Tuple(~[Ty<'a>])
+ Tuple(Vec<Ty<'a>> )
}
pub fn borrowed_ptrty<'r>() -> PtrTy<'r> {
}
pub fn nil_ty() -> Ty<'static> {
- Tuple(~[])
+ Tuple(Vec::new())
}
fn mk_lifetime(cx: &ExtCtxt, span: Span, lt: &Option<&str>) -> Option<ast::Lifetime> {
});
let lifetimes = self_generics.lifetimes.clone();
- cx.path_all(span, false, ~[self_ty], lifetimes,
+ cx.path_all(span, false, vec!(self_ty), lifetimes,
opt_vec::take_vec(self_params))
}
Literal(ref p) => {
fn mk_ty_param(cx: &ExtCtxt, span: Span, name: &str, bounds: &[Path],
self_ident: Ident, self_generics: &Generics) -> ast::TyParam {
let bounds = opt_vec::from(
- bounds.map(|b| {
+ bounds.iter().map(|b| {
let path = b.to_path(cx, span, self_ident, self_generics);
cx.typarambound(path)
- }));
+ }).collect());
cx.typaram(cx.ident_of(name), bounds, None)
}
-fn mk_generics(lifetimes: ~[ast::Lifetime], ty_params: ~[ast::TyParam]) -> Generics {
+fn mk_generics(lifetimes: Vec<ast::Lifetime> , ty_params: Vec<ast::TyParam> ) -> Generics {
Generics {
lifetimes: opt_vec::from(lifetimes),
ty_params: opt_vec::from(ty_params)
/// Lifetimes and bounds on type parameters
pub struct LifetimeBounds<'a> {
- lifetimes: ~[&'a str],
- bounds: ~[(&'a str, ~[Path<'a>])]
+ lifetimes: Vec<&'a str>,
+ bounds: Vec<(&'a str, Vec<Path<'a>>)>,
}
impl<'a> LifetimeBounds<'a> {
pub fn empty() -> LifetimeBounds<'static> {
LifetimeBounds {
- lifetimes: ~[], bounds: ~[]
+ lifetimes: Vec::new(), bounds: Vec::new()
}
}
pub fn to_generics(&self,
let ty_params = self.bounds.map(|t| {
match t {
&(ref name, ref bounds) => {
- mk_ty_param(cx, span, *name, *bounds, self_ty, self_generics)
+ mk_ty_param(cx,
+ span,
+ *name,
+ bounds.as_slice(),
+ self_ty,
+ self_generics)
}
}
});
use ext::build::AstBuilder;
use ext::deriving::generic::*;
+use std::vec_ng::Vec;
+
pub fn expand_deriving_zero(cx: &mut ExtCtxt,
span: Span,
mitem: @MetaItem,
push: |@Item|) {
let trait_def = TraitDef {
span: span,
- attributes: ~[],
- path: Path::new(~["std", "num", "Zero"]),
- additional_bounds: ~[],
+ attributes: Vec::new(),
+ path: Path::new(vec!("std", "num", "Zero")),
+ additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
- methods: ~[
+ methods: vec!(
MethodDef {
name: "zero",
generics: LifetimeBounds::empty(),
explicit_self: None,
- args: ~[],
+ args: Vec::new(),
ret_ty: Self,
inline: true,
const_nonmatching: false,
name: "is_zero",
generics: LifetimeBounds::empty(),
explicit_self: borrowed_explicit_self(),
- args: ~[],
- ret_ty: Literal(Path::new(~["bool"])),
+ args: Vec::new(),
+ ret_ty: Literal(Path::new(vec!("bool"))),
inline: true,
const_nonmatching: false,
combine_substructure: |cx, span, substr| {
cx, span, substr)
}
}
- ]
+ )
};
trait_def.expand(cx, mitem, item, push)
}
fn zero_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> @Expr {
- let zero_ident = ~[
+ let zero_ident = vec!(
cx.ident_of("std"),
cx.ident_of("num"),
cx.ident_of("Zero"),
cx.ident_of("zero")
- ];
- let zero_call = |span| cx.expr_call_global(span, zero_ident.clone(), ~[]);
+ );
+ let zero_call = |span| cx.expr_call_global(span, zero_ident.clone(), Vec::new());
return match *substr.fields {
StaticStruct(_, ref summary) => {
use ext::base::*;
use ext::base;
use ext::build::AstBuilder;
+use opt_vec;
use parse::token;
use std::os;
};
let e = match os::getenv(var) {
- None => quote_expr!(cx, ::std::option::None::<&'static str>),
- Some(s) => quote_expr!(cx, ::std::option::Some($s))
+ None => {
+ cx.expr_path(cx.path_all(sp,
+ true,
+ vec!(cx.ident_of("std"),
+ cx.ident_of("option"),
+ cx.ident_of("None")),
+ opt_vec::Empty,
+ vec!(cx.ty_rptr(sp,
+ cx.ty_ident(sp,
+ cx.ident_of("str")),
+ Some(cx.lifetime(sp,
+ cx.ident_of(
+ "static").name)),
+ ast::MutImmutable))))
+ }
+ Some(s) => {
+ cx.expr_call_global(sp,
+ vec!(cx.ident_of("std"),
+ cx.ident_of("option"),
+ cx.ident_of("Some")),
+ vec!(cx.expr_str(sp,
+ token::intern_and_get_ident(
+ s))))
+ }
};
MRExpr(e)
}
Some(exprs) => exprs
};
- let var = match expr_to_str(cx, exprs[0], "expected string literal") {
+ let var = match expr_to_str(cx,
+ *exprs.get(0),
+ "expected string literal") {
None => return MacResult::dummy_expr(sp),
Some((v, _style)) => v
};
var))
}
2 => {
- match expr_to_str(cx, exprs[1], "expected string literal") {
+ match expr_to_str(cx, *exprs.get(1), "expected string literal") {
None => return MacResult::dummy_expr(sp),
Some((s, _style)) => s
}
use std::cast;
use std::unstable::dynamic_lib::DynamicLibrary;
use std::os;
+use std::vec_ng::Vec;
pub fn expand_expr(e: @ast::Expr, fld: &mut MacroExpander) -> @ast::Expr {
match e.node {
// let compilation continue
return MacResult::raw_dummy_expr(e.span);
}
- let extname = pth.segments[0].identifier;
+ let extname = pth.segments.get(0).identifier;
let extnamestr = token::get_ident(extname);
// leaving explicit deref here to highlight unbox op:
let marked_after = match fld.extsbox.find(&extname.name) {
});
let fm = fresh_mark();
// mark before:
- let marked_before = mark_tts(*tts,fm);
+ let marked_before = mark_tts(tts.as_slice(), fm);
// The span that we pass to the expanders we want to
// be the root of the call stack. That's the most
let expanded = match expandfun.expand(fld.cx,
mac_span.call_site,
- marked_before) {
+ marked_before.as_slice()) {
MRExpr(e) => e,
MRAny(any_macro) => any_macro.make_expr(),
_ => {
let none_arm = {
let break_expr = fld.cx.expr(span, ast::ExprBreak(opt_ident));
let none_pat = fld.cx.pat_ident(span, none_ident);
- fld.cx.arm(span, ~[none_pat], break_expr)
+ fld.cx.arm(span, vec!(none_pat), break_expr)
};
// `Some(<src_pat>) => <src_loop_block>`
let some_arm =
fld.cx.arm(span,
- ~[fld.cx.pat_enum(span, some_path, ~[src_pat])],
+ vec!(fld.cx.pat_enum(span, some_path, vec!(src_pat))),
fld.cx.expr_block(src_loop_block));
// `match i.next() { ... }`
let match_expr = {
let next_call_expr =
- fld.cx.expr_method_call(span, fld.cx.expr_path(local_path), next_ident, ~[]);
+ fld.cx.expr_method_call(span,
+ fld.cx.expr_path(local_path),
+ next_ident,
+ Vec::new());
- fld.cx.expr_match(span, next_call_expr, ~[none_arm, some_arm])
+ fld.cx.expr_match(span, next_call_expr, vec!(none_arm, some_arm))
};
// ['ident:] loop { ... }
// `match &mut <src_expr> { i => loop { ... } }`
let discrim = fld.cx.expr_mut_addr_of(span, src_expr);
let i_pattern = fld.cx.pat_ident(span, local_ident);
- let arm = fld.cx.arm(span, ~[i_pattern], loop_expr);
- fld.cx.expr_match(span, discrim, ~[arm])
+ let arm = fld.cx.arm(span, vec!(i_pattern), loop_expr);
+ fld.cx.expr_match(span, discrim, vec!(arm))
}
ast::ExprLoop(loop_block, opt_ident) => {
let new_label = fresh_name(&label);
let rename = (label, new_label);
fld.extsbox.info().pending_renames.push(rename);
- let mut pending_renames = ~[rename];
+ let mut pending_renames = vec!(rename);
let mut rename_fld = renames_to_fold(&mut pending_renames);
(Some(rename_fld.fold_ident(label)),
rename_fld.fold_block(loop_block))
ast::ItemMac(..) => expand_item_mac(it, fld),
ast::ItemMod(_) | ast::ItemForeignMod(_) => {
fld.cx.mod_push(it.ident);
- let macro_escape = contains_macro_escape(it.attrs);
+ let macro_escape = contains_macro_escape(it.attrs.as_slice());
let result = with_exts_frame!(fld.extsbox,
macro_escape,
noop_fold_item(it, fld));
_ => fld.cx.span_bug(it.span, "invalid item macro invocation")
};
- let extname = pth.segments[0].identifier;
+ let extname = pth.segments.get(0).identifier;
let extnamestr = token::get_ident(extname);
let fm = fresh_mark();
let expanded = match fld.extsbox.find(&extname.name) {
}
});
// mark before expansion:
- let marked_before = mark_tts(tts,fm);
- expander.expand(fld.cx, it.span, marked_before)
+ let marked_before = mark_tts(tts.as_slice(), fm);
+ expander.expand(fld.cx, it.span, marked_before.as_slice())
}
Some(&IdentTT(ref expander, span)) => {
if it.ident.name == parse::token::special_idents::invalid.name {
}
});
// mark before expansion:
- let marked_tts = mark_tts(tts,fm);
+ let marked_tts = mark_tts(tts.as_slice(), fm);
expander.expand(fld.cx, it.span, it.ident, marked_tts)
}
_ => {
// yikes... no idea how to apply the mark to this. I'm afraid
// we're going to have to wait-and-see on this one.
fld.extsbox.insert(intern(name), ext);
- if attr::contains_name(it.attrs, "macro_export") {
+ if attr::contains_name(it.attrs.as_slice(), "macro_export") {
SmallVector::one(it)
} else {
SmallVector::zero()
fld.cx.span_err(pth.span, "expected macro name without module separators");
return SmallVector::zero();
}
- let extname = pth.segments[0].identifier;
+ let extname = pth.segments.get(0).identifier;
let extnamestr = token::get_ident(extname);
let marked_after = match fld.extsbox.find(&extname.name) {
None => {
});
let fm = fresh_mark();
// mark before expansion:
- let marked_tts = mark_tts(tts,fm);
+ let marked_tts = mark_tts(tts.as_slice(), fm);
// See the comment in expand_expr for why we want the original span,
// not the current mac.span.
let expanded = match expandfun.expand(fld.cx,
mac_span.call_site,
- marked_tts) {
+ marked_tts.as_slice()) {
MRExpr(e) => {
@codemap::Spanned {
node: StmtExpr(e, ast::DUMMY_NODE_ID),
// oh dear heaven... this is going to include the enum
// names, as well... but that should be okay, as long as
// the new names are gensyms for the old ones.
- let mut name_finder = new_name_finder(~[]);
+ let mut name_finder = new_name_finder(Vec::new());
name_finder.visit_pat(expanded_pat,());
// generate fresh names, push them to a new pending list
- let mut new_pending_renames = ~[];
+ let mut new_pending_renames = Vec::new();
for ident in name_finder.ident_accumulator.iter() {
let new_name = fresh_name(ident);
new_pending_renames.push((*ident,new_name));
// array (passed in to the traversal)
#[deriving(Clone)]
struct NewNameFinderContext {
- ident_accumulator: ~[ast::Ident],
+ ident_accumulator: Vec<ast::Ident> ,
}
impl Visitor<()> for NewNameFinderContext {
span: _,
segments: ref segments
} if segments.len() == 1 => {
- self.ident_accumulator.push(segments[0].identifier)
+ self.ident_accumulator.push(segments.get(0)
+ .identifier)
}
// I believe these must be enums...
_ => ()
// return a visitor that extracts the pat_ident paths
// from a given thingy and puts them in a mutable
// array (passed in to the traversal)
-pub fn new_name_finder(idents: ~[ast::Ident]) -> NewNameFinderContext {
+pub fn new_name_finder(idents: Vec<ast::Ident> ) -> NewNameFinderContext {
NewNameFinderContext {
ident_accumulator: idents,
}
let macro = match m.node {
MacInvocTT(ref path, ref tts, ctxt) => {
MacInvocTT(self.fold_path(path),
- fold_tts(*tts, self),
+ fold_tts(tts.as_slice(), self),
new_mark(self.mark, ctxt))
}
};
}
// apply a given mark to the given token trees. Used prior to expansion of a macro.
-fn mark_tts(tts: &[TokenTree], m: Mrk) -> ~[TokenTree] {
+fn mark_tts(tts: &[TokenTree], m: Mrk) -> Vec<TokenTree> {
fold_tts(tts, &mut new_mark_folder(m))
}
use visit;
use visit::Visitor;
+ use std::vec_ng::Vec;
+
// a visitor that extracts the paths
// from a given thingy and puts them in a mutable
// array (passed in to the traversal)
#[deriving(Clone)]
struct NewPathExprFinderContext {
- path_accumulator: ~[ast::Path],
+ path_accumulator: Vec<ast::Path> ,
}
impl Visitor<()> for NewPathExprFinderContext {
// return a visitor that extracts the paths
// from a given pattern and puts them in a mutable
// array (passed in to the traversal)
- pub fn new_path_finder(paths: ~[ast::Path]) -> NewPathExprFinderContext {
+ pub fn new_path_finder(paths: Vec<ast::Path> ) -> NewPathExprFinderContext {
NewPathExprFinderContext {
path_accumulator: paths
}
fail!("lolwut")
}
- fn get_exported_macros(&mut self, _: ast::CrateNum) -> ~[~str] {
+ fn get_exported_macros(&mut self, _: ast::CrateNum) -> Vec<~str> {
fail!("lolwut")
}
let crate_ast = parse::parse_crate_from_source_str(
~"<test>",
src,
- ~[],sess);
+ Vec::new(),sess);
// should fail:
let mut loader = ErrLoader;
expand_crate(sess,&mut loader,crate_ast);
let crate_ast = parse::parse_crate_from_source_str(
~"<test>",
src,
- ~[],sess);
+ Vec::new(),sess);
// should fail:
let mut loader = ErrLoader;
expand_crate(sess,&mut loader,crate_ast);
let crate_ast = parse::parse_crate_from_source_str(
~"<test>",
src,
- ~[], sess);
+ Vec::new(), sess);
// should fail:
let mut loader = ErrLoader;
expand_crate(sess, &mut loader, crate_ast);
let attr1 = make_dummy_attr ("foo");
let attr2 = make_dummy_attr ("bar");
let escape_attr = make_dummy_attr ("macro_escape");
- let attrs1 = ~[attr1, escape_attr, attr2];
- assert_eq!(contains_macro_escape (attrs1),true);
- let attrs2 = ~[attr1,attr2];
- assert_eq!(contains_macro_escape (attrs2),false);
+ let attrs1 = vec!(attr1, escape_attr, attr2);
+ assert_eq!(contains_macro_escape(attrs1.as_slice()),true);
+ let attrs2 = vec!(attr1,attr2);
+ assert_eq!(contains_macro_escape(attrs2.as_slice()),false);
}
// make a MetaWord outer attribute with the given name
// in principle, you might want to control this boolean on a per-varref basis,
// but that would make things even harder to understand, and might not be
// necessary for thorough testing.
- type RenamingTest = (&'static str, ~[~[uint]], bool);
+ type RenamingTest = (&'static str, Vec<Vec<uint>>, bool);
#[test]
fn automatic_renaming () {
- let tests: ~[RenamingTest] =
- ~[// b & c should get new names throughout, in the expr too:
+ let tests: Vec<RenamingTest> =
+ vec!(// b & c should get new names throughout, in the expr too:
("fn a() -> int { let b = 13; let c = b; b+c }",
- ~[~[0,1],~[2]], false),
+ vec!(vec!(0,1),vec!(2)), false),
// both x's should be renamed (how is this causing a bug?)
("fn main () {let x: int = 13;x;}",
- ~[~[0]], false),
+ vec!(vec!(0)), false),
// the use of b after the + should be renamed, the other one not:
("macro_rules! f (($x:ident) => (b + $x)) fn a() -> int { let b = 13; f!(b)}",
- ~[~[1]], false),
+ vec!(vec!(1)), false),
// the b before the plus should not be renamed (requires marks)
("macro_rules! f (($x:ident) => ({let b=9; ($x + b)})) fn a() -> int { f!(b)}",
- ~[~[1]], false),
+ vec!(vec!(1)), false),
// the marks going in and out of letty should cancel, allowing that $x to
// capture the one following the semicolon.
// this was an awesome test case, and caught a *lot* of bugs.
("macro_rules! letty(($x:ident) => (let $x = 15;))
macro_rules! user(($x:ident) => ({letty!($x); $x}))
fn main() -> int {user!(z)}",
- ~[~[0]], false),
- // no longer a fixme #8062: this test exposes a *potential* bug; our system does
- // not behave exactly like MTWT, but a conversation with Matthew Flatt
- // suggests that this can only occur in the presence of local-expand, which
- // we have no plans to support.
- // ("fn main() {let hrcoo = 19; macro_rules! getx(()=>(hrcoo)); getx!();}",
- // ~[~[0]], true)
- // FIXME #6994: the next string exposes the bug referred to in issue 6994, so I'm
- // commenting it out.
- // the z flows into and out of two macros (g & f) along one path, and one
- // (just g) along the other, so the result of the whole thing should
- // be "let z_123 = 3; z_123"
- //"macro_rules! g (($x:ident) =>
- // ({macro_rules! f(($y:ident)=>({let $y=3;$x}));f!($x)}))
- // fn a(){g!(z)}"
- // create a really evil test case where a $x appears inside a binding of $x
- // but *shouldnt* bind because it was inserted by a different macro....
- // can't write this test case until we have macro-generating macros.
- ];
+ vec!(vec!(0)), false));
for (idx,s) in tests.iter().enumerate() {
run_renaming_test(s,idx);
}
};
let cr = expand_crate_str(teststr.to_owned());
// find the bindings:
- let mut name_finder = new_name_finder(~[]);
+ let mut name_finder = new_name_finder(Vec::new());
visit::walk_crate(&mut name_finder,&cr,());
let bindings = name_finder.ident_accumulator;
// find the varrefs:
- let mut path_finder = new_path_finder(~[]);
+ let mut path_finder = new_path_finder(Vec::new());
visit::walk_crate(&mut path_finder,&cr,());
let varrefs = path_finder.path_accumulator;
// must be one check clause for each binding:
assert_eq!(bindings.len(),bound_connections.len());
for (binding_idx,shouldmatch) in bound_connections.iter().enumerate() {
- let binding_name = mtwt_resolve(bindings[binding_idx]);
- let binding_marks = mtwt_marksof(bindings[binding_idx].ctxt,invalid_name);
+ let binding_name = mtwt_resolve(*bindings.get(binding_idx));
+ let binding_marks = mtwt_marksof(bindings.get(binding_idx).ctxt,invalid_name);
// shouldmatch can't name varrefs that don't exist:
assert!((shouldmatch.len() == 0) ||
(varrefs.len() > *shouldmatch.iter().max().unwrap()));
// it should be a path of length 1, and it should
// be free-identifier=? or bound-identifier=? to the given binding
assert_eq!(varref.segments.len(),1);
- let varref_name = mtwt_resolve(varref.segments[0].identifier);
- let varref_marks = mtwt_marksof(varref.segments[0].identifier.ctxt,
+ let varref_name = mtwt_resolve(varref.segments
+ .get(0)
+ .identifier);
+ let varref_marks = mtwt_marksof(varref.segments
+ .get(0)
+ .identifier
+ .ctxt,
invalid_name);
if !(varref_name==binding_name) {
println!("uh oh, should match but doesn't:");
println!("varref: {:?}",varref);
- println!("binding: {:?}", bindings[binding_idx]);
+ println!("binding: {:?}", *bindings.get(binding_idx));
ast_util::display_sctable(get_sctable());
}
assert_eq!(varref_name,binding_name);
}
} else {
let fail = (varref.segments.len() == 1)
- && (mtwt_resolve(varref.segments[0].identifier) == binding_name);
+ && (mtwt_resolve(varref.segments.get(0).identifier) ==
+ binding_name);
// temp debugging:
if fail {
println!("failure on test {}",test_idx);
println!("uh oh, matches but shouldn't:");
println!("varref: {:?}",varref);
// good lord, you can't make a path with 0 segments, can you?
- let string = token::get_ident(varref.segments[0].identifier);
+ let string = token::get_ident(varref.segments
+ .get(0)
+ .identifier);
println!("varref's first segment's uint: {}, and string: \"{}\"",
- varref.segments[0].identifier.name,
+ varref.segments.get(0).identifier.name,
string.get());
- println!("binding: {:?}", bindings[binding_idx]);
+ println!("binding: {:?}", *bindings.get(binding_idx));
ast_util::display_sctable(get_sctable());
}
assert!(!fail);
";
let cr = expand_crate_str(crate_str);
// find the xx binding
- let mut name_finder = new_name_finder(~[]);
+ let mut name_finder = new_name_finder(Vec::new());
visit::walk_crate(&mut name_finder, &cr, ());
let bindings = name_finder.ident_accumulator;
- let cxbinds: ~[&ast::Ident] =
+ let cxbinds: Vec<&ast::Ident> =
bindings.iter().filter(|b| {
let ident = token::get_ident(**b);
let string = ident.get();
"xx" == string
}).collect();
- let cxbinds: &[&ast::Ident] = cxbinds;
+ let cxbinds: &[&ast::Ident] = cxbinds.as_slice();
let cxbind = match cxbinds {
[b] => b,
_ => fail!("expected just one binding for ext_cx")
};
let resolved_binding = mtwt_resolve(*cxbind);
// find all the xx varrefs:
- let mut path_finder = new_path_finder(~[]);
+ let mut path_finder = new_path_finder(Vec::new());
visit::walk_crate(&mut path_finder, &cr, ());
let varrefs = path_finder.path_accumulator;
// the xx binding should bind all of the xx varrefs:
for (idx,v) in varrefs.iter().filter(|p| {
p.segments.len() == 1
- && "xx" == token::get_ident(p.segments[0].identifier).get()
+ && "xx" == token::get_ident(p.segments.get(0).identifier).get()
}).enumerate() {
- if mtwt_resolve(v.segments[0].identifier) != resolved_binding {
+ if mtwt_resolve(v.segments.get(0).identifier) !=
+ resolved_binding {
println!("uh oh, xx binding didn't match xx varref:");
println!("this is xx varref \\# {:?}",idx);
println!("binding: {:?}",cxbind);
println!("resolves to: {:?}",resolved_binding);
- println!("varref: {:?}",v.segments[0].identifier);
+ println!("varref: {:?}",v.segments.get(0).identifier);
println!("resolves to: {:?}",
- mtwt_resolve(v.segments[0].identifier));
+ mtwt_resolve(v.segments.get(0).identifier));
let table = get_sctable();
println!("SC table:");
}
}
}
- assert_eq!(mtwt_resolve(v.segments[0].identifier),resolved_binding);
+ assert_eq!(mtwt_resolve(v.segments.get(0).identifier),
+ resolved_binding);
};
}
#[test]
fn pat_idents(){
let pat = string_to_pat(~"(a,Foo{x:c @ (b,9),y:Bar(4,d)})");
- let mut pat_idents = new_name_finder(~[]);
+ let mut pat_idents = new_name_finder(Vec::new());
pat_idents.visit_pat(pat, ());
assert_eq!(pat_idents.ident_accumulator,
- strs_to_idents(~["a","c","b","d"]));
+ strs_to_idents(vec!("a","c","b","d")));
}
}
use std::fmt::parse;
use collections::{HashMap, HashSet};
use std::vec;
+use std::vec_ng::Vec;
#[deriving(Eq)]
enum ArgumentType {
// Parsed argument expressions and the types that we've found so far for
// them.
- args: ~[@ast::Expr],
- arg_types: ~[Option<ArgumentType>],
+ args: Vec<@ast::Expr>,
+ arg_types: Vec<Option<ArgumentType>>,
// Parsed named expressions and the types that we've found for them so far.
// Note that we keep a side-array of the ordering of the named arguments
// found to be sure that we can translate them in the same order that they
// were declared in.
names: HashMap<~str, @ast::Expr>,
name_types: HashMap<~str, ArgumentType>,
- name_ordering: ~[~str],
+ name_ordering: Vec<~str>,
// Collection of the compiled `rt::Piece` structures
- pieces: ~[@ast::Expr],
+ pieces: Vec<@ast::Expr> ,
name_positions: HashMap<~str, uint>,
- method_statics: ~[@ast::Item],
+ method_statics: Vec<@ast::Item> ,
// Updated as arguments are consumed or methods are entered
nest_level: uint,
/// Some((fmtstr, unnamed arguments, ordering of named arguments,
/// named arguments))
fn parse_args(ecx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
- -> (@ast::Expr, Option<(@ast::Expr, ~[@ast::Expr], ~[~str],
- HashMap<~str, @ast::Expr>)>)
-{
- let mut args = ~[];
+ -> (@ast::Expr, Option<(@ast::Expr, Vec<@ast::Expr>, Vec<~str>,
+ HashMap<~str, @ast::Expr>)>) {
+ let mut args = Vec::new();
let mut names = HashMap::<~str, @ast::Expr>::new();
- let mut order = ~[];
+ let mut order = Vec::new();
let mut p = rsparse::new_parser_from_tts(ecx.parse_sess(),
ecx.cfg(),
- tts.to_owned());
+ tts.iter()
+ .map(|x| (*x).clone())
+ .collect());
// Parse the leading function expression (maybe a block, maybe a path)
let extra = p.parse_expr();
if !p.eat(&token::COMMA) {
return;
}
{
- let arg_type = match self.arg_types[arg] {
- None => None,
- Some(ref x) => Some(x)
+ let arg_type = match self.arg_types.get(arg) {
+ &None => None,
+ &Some(ref x) => Some(x)
};
- self.verify_same(self.args[arg].span, &ty, arg_type);
+ self.verify_same(self.args.get(arg).span, &ty, arg_type);
}
- if self.arg_types[arg].is_none() {
- self.arg_types[arg] = Some(ty);
+ if self.arg_types.get(arg).is_none() {
+ *self.arg_types.get_mut(arg) = Some(ty);
}
}
/// These attributes are applied to all statics that this syntax extension
/// will generate.
- fn static_attrs(&self) -> ~[ast::Attribute] {
+ fn static_attrs(&self) -> Vec<ast::Attribute> {
// Flag statics as `address_insignificant` so LLVM can merge duplicate
// globals as much as possible (which we're generating a whole lot of).
let unnamed = self.ecx
InternedString::new("dead_code"));
let allow_dead_code = self.ecx.meta_list(self.fmtsp,
InternedString::new("allow"),
- ~[dead_code]);
+ vec!(dead_code));
let allow_dead_code = self.ecx.attribute(self.fmtsp, allow_dead_code);
- return ~[unnamed, allow_dead_code];
+ return vec!(unnamed, allow_dead_code);
}
- fn parsepath(&self, s: &str) -> ~[ast::Ident] {
- ~[self.ecx.ident_of("std"), self.ecx.ident_of("fmt"),
- self.ecx.ident_of("parse"), self.ecx.ident_of(s)]
+ fn parsepath(&self, s: &str) -> Vec<ast::Ident> {
+ vec!(self.ecx.ident_of("std"), self.ecx.ident_of("fmt"),
+ self.ecx.ident_of("parse"), self.ecx.ident_of(s))
}
- fn rtpath(&self, s: &str) -> ~[ast::Ident] {
- ~[self.ecx.ident_of("std"), self.ecx.ident_of("fmt"),
- self.ecx.ident_of("rt"), self.ecx.ident_of(s)]
+ fn rtpath(&self, s: &str) -> Vec<ast::Ident> {
+ vec!(self.ecx.ident_of("std"), self.ecx.ident_of("fmt"),
+ self.ecx.ident_of("rt"), self.ecx.ident_of(s))
}
- fn ctpath(&self, s: &str) -> ~[ast::Ident] {
- ~[self.ecx.ident_of("std"), self.ecx.ident_of("fmt"),
- self.ecx.ident_of("parse"), self.ecx.ident_of(s)]
+ fn ctpath(&self, s: &str) -> Vec<ast::Ident> {
+ vec!(self.ecx.ident_of("std"), self.ecx.ident_of("fmt"),
+ self.ecx.ident_of("parse"), self.ecx.ident_of(s))
}
fn none(&self) -> @ast::Expr {
- let none = self.ecx.path_global(self.fmtsp, ~[
+ let none = self.ecx.path_global(self.fmtsp, vec!(
self.ecx.ident_of("std"),
self.ecx.ident_of("option"),
- self.ecx.ident_of("None")]);
+ self.ecx.ident_of("None")));
self.ecx.expr_path(none)
}
fn some(&self, e: @ast::Expr) -> @ast::Expr {
- let p = self.ecx.path_global(self.fmtsp, ~[
+ let p = self.ecx.path_global(self.fmtsp, vec!(
self.ecx.ident_of("std"),
self.ecx.ident_of("option"),
- self.ecx.ident_of("Some")]);
+ self.ecx.ident_of("Some")));
let p = self.ecx.expr_path(p);
- self.ecx.expr_call(self.fmtsp, p, ~[e])
+ self.ecx.expr_call(self.fmtsp, p, vec!(e))
}
fn trans_count(&self, c: parse::Count) -> @ast::Expr {
match c {
parse::CountIs(i) => {
self.ecx.expr_call_global(sp, self.rtpath("CountIs"),
- ~[self.ecx.expr_uint(sp, i)])
+ vec!(self.ecx.expr_uint(sp, i)))
}
parse::CountIsParam(i) => {
self.ecx.expr_call_global(sp, self.rtpath("CountIsParam"),
- ~[self.ecx.expr_uint(sp, i)])
+ vec!(self.ecx.expr_uint(sp, i)))
}
parse::CountImplied => {
let path = self.ecx.path_global(sp, self.rtpath("CountImplied"));
};
let i = i + self.args.len();
self.ecx.expr_call_global(sp, self.rtpath("CountIsParam"),
- ~[self.ecx.expr_uint(sp, i)])
+ vec!(self.ecx.expr_uint(sp, i)))
}
}
}
}).collect();
let s = token::intern_and_get_ident(arm.selector);
let selector = self.ecx.expr_str(sp, s);
- self.ecx.expr_struct(sp, p, ~[
+ self.ecx.expr_struct(sp, p, vec!(
self.ecx.field_imm(sp,
self.ecx.ident_of("selector"),
selector),
self.ecx.field_imm(sp, self.ecx.ident_of("result"),
- self.ecx.expr_vec_slice(sp, result)),
- ])
+ self.ecx.expr_vec_slice(sp, result))))
}).collect();
let default = default.iter().map(|p| {
self.trans_piece(p)
}).collect();
- self.ecx.expr_call_global(sp, self.rtpath("Select"), ~[
+ self.ecx.expr_call_global(sp, self.rtpath("Select"), vec!(
self.ecx.expr_vec_slice(sp, arms),
- self.ecx.expr_vec_slice(sp, default),
- ])
+ self.ecx.expr_vec_slice(sp, default)))
}
parse::Plural(offset, ref arms, ref default) => {
let offset = match offset {
}
};
let selector = self.ecx.expr_call_global(sp,
- lr, ~[selarg]);
- self.ecx.expr_struct(sp, p, ~[
+ lr, vec!(selarg));
+ self.ecx.expr_struct(sp, p, vec!(
self.ecx.field_imm(sp,
self.ecx.ident_of("selector"),
selector),
self.ecx.field_imm(sp, self.ecx.ident_of("result"),
- self.ecx.expr_vec_slice(sp, result)),
- ])
+ self.ecx.expr_vec_slice(sp, result))))
}).collect();
let default = default.iter().map(|p| {
self.trans_piece(p)
}).collect();
- self.ecx.expr_call_global(sp, self.rtpath("Plural"), ~[
+ self.ecx.expr_call_global(sp, self.rtpath("Plural"), vec!(
offset,
self.ecx.expr_vec_slice(sp, arms),
- self.ecx.expr_vec_slice(sp, default),
- ])
+ self.ecx.expr_vec_slice(sp, default)))
}
};
let life = self.ecx.lifetime(sp, self.ecx.ident_of("static").name);
true,
self.rtpath("Method"),
opt_vec::with(life),
- ~[]
+ Vec::new()
), None);
let st = ast::ItemStatic(ty, ast::MutImmutable, method);
let static_name = self.ecx.ident_of(format!("__STATIC_METHOD_{}",
let s = token::intern_and_get_ident(s);
self.ecx.expr_call_global(sp,
self.rtpath("String"),
- ~[
+ vec!(
self.ecx.expr_str(sp, s)
- ])
+ ))
}
parse::CurrentArgument => {
let nil = self.ecx.expr_lit(sp, ast::LitNil);
- self.ecx.expr_call_global(sp, self.rtpath("CurrentArgument"), ~[nil])
+ self.ecx.expr_call_global(sp, self.rtpath("CurrentArgument"), vec!(nil))
}
parse::Argument(ref arg) => {
// Translate the position
}
parse::ArgumentIs(i) => {
self.ecx.expr_call_global(sp, self.rtpath("ArgumentIs"),
- ~[self.ecx.expr_uint(sp, i)])
+ vec!(self.ecx.expr_uint(sp, i)))
}
// Named arguments are converted to positional arguments at
// the end of the list of arguments
};
let i = i + self.args.len();
self.ecx.expr_call_global(sp, self.rtpath("ArgumentIs"),
- ~[self.ecx.expr_uint(sp, i)])
+ vec!(self.ecx.expr_uint(sp, i)))
}
};
let prec = self.trans_count(arg.format.precision);
let width = self.trans_count(arg.format.width);
let path = self.ecx.path_global(sp, self.rtpath("FormatSpec"));
- let fmt = self.ecx.expr_struct(sp, path, ~[
+ let fmt = self.ecx.expr_struct(sp, path, vec!(
self.ecx.field_imm(sp, self.ecx.ident_of("fill"), fill),
self.ecx.field_imm(sp, self.ecx.ident_of("align"), align),
self.ecx.field_imm(sp, self.ecx.ident_of("flags"), flags),
self.ecx.field_imm(sp, self.ecx.ident_of("precision"), prec),
- self.ecx.field_imm(sp, self.ecx.ident_of("width"), width),
- ]);
+ self.ecx.field_imm(sp, self.ecx.ident_of("width"), width)));
// Translate the method (if any)
let method = match arg.method {
}
};
let path = self.ecx.path_global(sp, self.rtpath("Argument"));
- let s = self.ecx.expr_struct(sp, path, ~[
+ let s = self.ecx.expr_struct(sp, path, vec!(
self.ecx.field_imm(sp, self.ecx.ident_of("position"), pos),
self.ecx.field_imm(sp, self.ecx.ident_of("format"), fmt),
- self.ecx.field_imm(sp, self.ecx.ident_of("method"), method),
- ]);
- self.ecx.expr_call_global(sp, self.rtpath("Argument"), ~[s])
+ self.ecx.field_imm(sp, self.ecx.ident_of("method"), method)));
+ self.ecx.expr_call_global(sp, self.rtpath("Argument"), vec!(s))
}
}
}
/// Actually builds the expression which the iformat! block will be expanded
/// to
fn to_expr(&self, extra: @ast::Expr) -> @ast::Expr {
- let mut lets = ~[];
- let mut locals = ~[];
+ let mut lets = Vec::new();
+ let mut locals = Vec::new();
let mut names = vec::from_fn(self.name_positions.len(), |_| None);
- let mut pats = ~[];
- let mut heads = ~[];
+ let mut pats = Vec::new();
+ let mut heads = Vec::new();
// First, declare all of our methods that are statics
for &method in self.method_statics.iter() {
let fmt = self.ecx.expr_vec(self.fmtsp, self.pieces.clone());
let piece_ty = self.ecx.ty_path(self.ecx.path_all(
self.fmtsp,
- true, ~[
+ true, vec!(
self.ecx.ident_of("std"),
self.ecx.ident_of("fmt"),
self.ecx.ident_of("rt"),
- self.ecx.ident_of("Piece"),
- ],
+ self.ecx.ident_of("Piece")),
opt_vec::with(
self.ecx.lifetime(self.fmtsp, self.ecx.ident_of("static").name)),
- ~[]
+ Vec::new()
), None);
let ty = ast::TyFixedLengthVec(
piece_ty,
// of each variable because we don't want to move out of the arguments
// passed to this function.
for (i, &e) in self.args.iter().enumerate() {
- if self.arg_types[i].is_none() { continue } // error already generated
+ if self.arg_types.get(i).is_none() {
+ continue // error already generated
+ }
let name = self.ecx.ident_of(format!("__arg{}", i));
pats.push(self.ecx.pat_ident(e.span, name));
// Now create the fmt::Arguments struct with all our locals we created.
let fmt = self.ecx.expr_ident(self.fmtsp, static_name);
let args_slice = self.ecx.expr_ident(self.fmtsp, slicename);
- let result = self.ecx.expr_call_global(self.fmtsp, ~[
+ let result = self.ecx.expr_call_global(self.fmtsp, vec!(
self.ecx.ident_of("std"),
self.ecx.ident_of("fmt"),
self.ecx.ident_of("Arguments"),
- self.ecx.ident_of("new"),
- ], ~[fmt, args_slice]);
+ self.ecx.ident_of("new")), vec!(fmt, args_slice));
// We did all the work of making sure that the arguments
// structure is safe, so we can safely have an unsafe block.
let result = self.ecx.expr_block(P(ast::Block {
- view_items: ~[],
- stmts: ~[],
+ view_items: Vec::new(),
+ stmts: Vec::new(),
expr: Some(result),
id: ast::DUMMY_NODE_ID,
rules: ast::UnsafeBlock(ast::CompilerGenerated),
let resname = self.ecx.ident_of("__args");
lets.push(self.ecx.stmt_let(self.fmtsp, false, resname, result));
let res = self.ecx.expr_ident(self.fmtsp, resname);
- let result = self.ecx.expr_call(extra.span, extra, ~[
- self.ecx.expr_addr_of(extra.span, res)]);
+ let result = self.ecx.expr_call(extra.span, extra, vec!(
+ self.ecx.expr_addr_of(extra.span, res)));
let body = self.ecx.expr_block(self.ecx.block(self.fmtsp, lets,
Some(result)));
// But the nested match expression is proved to perform not as well
// as series of let's; the first approach does.
let pat = self.ecx.pat(self.fmtsp, ast::PatTup(pats));
- let arm = self.ecx.arm(self.fmtsp, ~[pat], body);
+ let arm = self.ecx.arm(self.fmtsp, vec!(pat), body);
let head = self.ecx.expr(self.fmtsp, ast::ExprTup(heads));
- self.ecx.expr_match(self.fmtsp, head, ~[arm])
+ self.ecx.expr_match(self.fmtsp, head, vec!(arm))
}
fn format_arg(&self, sp: Span, argno: Position, arg: @ast::Expr)
-> @ast::Expr {
let ty = match argno {
- Exact(ref i) => self.arg_types[*i].get_ref(),
+ Exact(ref i) => self.arg_types.get(*i).get_ref(),
Named(ref s) => self.name_types.get(s)
};
}
}
String => {
- return self.ecx.expr_call_global(sp, ~[
+ return self.ecx.expr_call_global(sp, vec!(
self.ecx.ident_of("std"),
self.ecx.ident_of("fmt"),
- self.ecx.ident_of("argumentstr"),
- ], ~[arg])
+ self.ecx.ident_of("argumentstr")), vec!(arg))
}
Unsigned => {
- return self.ecx.expr_call_global(sp, ~[
+ return self.ecx.expr_call_global(sp, vec!(
self.ecx.ident_of("std"),
self.ecx.ident_of("fmt"),
- self.ecx.ident_of("argumentuint"),
- ], ~[arg])
+ self.ecx.ident_of("argumentuint")), vec!(arg))
}
};
- let format_fn = self.ecx.path_global(sp, ~[
+ let format_fn = self.ecx.path_global(sp, vec!(
self.ecx.ident_of("std"),
self.ecx.ident_of("fmt"),
- self.ecx.ident_of(fmt_fn),
- ]);
- self.ecx.expr_call_global(sp, ~[
+ self.ecx.ident_of(fmt_fn)));
+ self.ecx.expr_call_global(sp, vec!(
self.ecx.ident_of("std"),
self.ecx.ident_of("fmt"),
- self.ecx.ident_of("argument"),
- ], ~[self.ecx.expr_path(format_fn), arg])
+ self.ecx.ident_of("argument")), vec!(self.ecx.expr_path(format_fn), arg))
}
}
/// expression.
pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt, sp: Span,
extra: @ast::Expr,
- efmt: @ast::Expr, args: ~[@ast::Expr],
- name_ordering: ~[~str],
+ efmt: @ast::Expr, args: Vec<@ast::Expr>,
+ name_ordering: Vec<~str>,
names: HashMap<~str, @ast::Expr>) -> @ast::Expr {
- let arg_types = vec::from_fn(args.len(), |_| None);
+ let arg_types = Vec::from_fn(args.len(), |_| None);
let mut cx = Context {
ecx: ecx,
args: args,
name_ordering: name_ordering,
nest_level: 0,
next_arg: 0,
- pieces: ~[],
- method_statics: ~[],
+ pieces: Vec::new(),
+ method_statics: Vec::new(),
fmtsp: sp,
};
cx.fmtsp = efmt.span;
// Make sure that all arguments were used and all arguments have types.
for (i, ty) in cx.arg_types.iter().enumerate() {
if ty.is_none() {
- cx.ecx.span_err(cx.args[i].span, "argument never used");
+ cx.ecx.span_err(cx.args.get(i).span, "argument never used");
}
}
for (name, e) in cx.names.iter() {
-> base::MacResult {
cx.print_backtrace();
- println!("{}", print::pprust::tt_to_str(&ast::TTDelim(@tt.to_owned())));
+ println!("{}", print::pprust::tt_to_str(&ast::TTDelim(
+ @tt.iter().map(|x| (*x).clone()).collect())));
//trivial expression
MRExpr(@ast::Expr {
use parse::token;
use parse;
+use std::vec_ng::Vec;
+
/**
*
* Quasiquoting works via token trees.
use parse;
use print::pprust;
+ use std::vec_ng::Vec;
+
pub use ast::*;
pub use parse::token::*;
pub use parse::new_parser_from_tts;
pub use codemap::{BytePos, Span, dummy_spanned};
pub trait ToTokens {
- fn to_tokens(&self, _cx: &ExtCtxt) -> ~[TokenTree];
+ fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> ;
}
- impl ToTokens for ~[TokenTree] {
- fn to_tokens(&self, _cx: &ExtCtxt) -> ~[TokenTree] {
+ impl ToTokens for Vec<TokenTree> {
+ fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
(*self).clone()
}
}
macro_rules! impl_to_tokens(
($t:ty) => (
impl ToTokens for $t {
- fn to_tokens(&self, cx: &ExtCtxt) -> ~[TokenTree] {
+ fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
cx.parse_tts(self.to_source())
}
}
macro_rules! impl_to_tokens_self(
($t:ty) => (
impl<'a> ToTokens for $t {
- fn to_tokens(&self, cx: &ExtCtxt) -> ~[TokenTree] {
+ fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
cx.parse_tts(self.to_source())
}
}
fn parse_item(&self, s: ~str) -> @ast::Item;
fn parse_expr(&self, s: ~str) -> @ast::Expr;
fn parse_stmt(&self, s: ~str) -> @ast::Stmt;
- fn parse_tts(&self, s: ~str) -> ~[ast::TokenTree];
+ fn parse_tts(&self, s: ~str) -> Vec<ast::TokenTree> ;
}
impl<'a> ExtParseUtils for ExtCtxt<'a> {
parse::parse_stmt_from_source_str("<quote expansion>".to_str(),
s,
self.cfg(),
- ~[],
+ Vec::new(),
self.parse_sess())
}
self.parse_sess())
}
- fn parse_tts(&self, s: ~str) -> ~[ast::TokenTree] {
+ fn parse_tts(&self, s: ~str) -> Vec<ast::TokenTree> {
parse::parse_tts_from_source_str("<quote expansion>".to_str(),
s,
self.cfg(),
pub fn expand_quote_expr(cx: &mut ExtCtxt,
sp: Span,
tts: &[ast::TokenTree]) -> base::MacResult {
- let expanded = expand_parse_call(cx, sp, "parse_expr", ~[], tts);
+ let expanded = expand_parse_call(cx, sp, "parse_expr", Vec::new(), tts);
base::MRExpr(expanded)
}
pub fn expand_quote_item(cx: &mut ExtCtxt,
sp: Span,
tts: &[ast::TokenTree]) -> base::MacResult {
- let e_attrs = cx.expr_vec_uniq(sp, ~[]);
+ let e_attrs = cx.expr_vec_ng(sp);
let expanded = expand_parse_call(cx, sp, "parse_item",
- ~[e_attrs], tts);
+ vec!(e_attrs), tts);
base::MRExpr(expanded)
}
tts: &[ast::TokenTree]) -> base::MacResult {
let e_refutable = cx.expr_lit(sp, ast::LitBool(true));
let expanded = expand_parse_call(cx, sp, "parse_pat",
- ~[e_refutable], tts);
+ vec!(e_refutable), tts);
base::MRExpr(expanded)
}
tts: &[ast::TokenTree]) -> base::MacResult {
let e_param_colons = cx.expr_lit(sp, ast::LitBool(false));
let expanded = expand_parse_call(cx, sp, "parse_ty",
- ~[e_param_colons], tts);
+ vec!(e_param_colons), tts);
base::MRExpr(expanded)
}
pub fn expand_quote_stmt(cx: &mut ExtCtxt,
sp: Span,
tts: &[ast::TokenTree]) -> base::MacResult {
- let e_attrs = cx.expr_vec_uniq(sp, ~[]);
+ let e_attrs = cx.expr_vec_ng(sp);
let expanded = expand_parse_call(cx, sp, "parse_stmt",
- ~[e_attrs], tts);
+ vec!(e_attrs), tts);
base::MRExpr(expanded)
}
-fn ids_ext(strs: ~[~str]) -> ~[ast::Ident] {
+fn ids_ext(strs: Vec<~str> ) -> Vec<ast::Ident> {
strs.map(|str| str_to_ident(*str))
}
cx.expr_method_call(sp,
cx.expr_ident(sp, id_ext("ext_cx")),
id_ext("ident_of"),
- ~[e_str])
+ vec!(e_str))
}
fn mk_binop(cx: &ExtCtxt, sp: Span, bop: token::BinOp) -> @ast::Expr {
BINOP(binop) => {
return cx.expr_call_ident(sp,
id_ext("BINOP"),
- ~[mk_binop(cx, sp, binop)]);
+ vec!(mk_binop(cx, sp, binop)));
}
BINOPEQ(binop) => {
return cx.expr_call_ident(sp,
id_ext("BINOPEQ"),
- ~[mk_binop(cx, sp, binop)]);
+ vec!(mk_binop(cx, sp, binop)));
}
LIT_CHAR(i) => {
let e_char = cx.expr_lit(sp, ast::LitChar(i));
- return cx.expr_call_ident(sp, id_ext("LIT_CHAR"), ~[e_char]);
+ return cx.expr_call_ident(sp, id_ext("LIT_CHAR"), vec!(e_char));
}
LIT_INT(i, ity) => {
return cx.expr_call_ident(sp,
id_ext("LIT_INT"),
- ~[e_i64, e_ity]);
+ vec!(e_i64, e_ity));
}
LIT_UINT(u, uty) => {
return cx.expr_call_ident(sp,
id_ext("LIT_UINT"),
- ~[e_u64, e_uty]);
+ vec!(e_u64, e_uty));
}
LIT_INT_UNSUFFIXED(i) => {
return cx.expr_call_ident(sp,
id_ext("LIT_INT_UNSUFFIXED"),
- ~[e_i64]);
+ vec!(e_i64));
}
LIT_FLOAT(fident, fty) => {
return cx.expr_call_ident(sp,
id_ext("LIT_FLOAT"),
- ~[e_fident, e_fty]);
+ vec!(e_fident, e_fty));
}
LIT_STR(ident) => {
return cx.expr_call_ident(sp,
id_ext("LIT_STR"),
- ~[mk_ident(cx, sp, ident)]);
+ vec!(mk_ident(cx, sp, ident)));
}
LIT_STR_RAW(ident, n) => {
return cx.expr_call_ident(sp,
id_ext("LIT_STR_RAW"),
- ~[mk_ident(cx, sp, ident),
- cx.expr_uint(sp, n)]);
+ vec!(mk_ident(cx, sp, ident),
+ cx.expr_uint(sp, n)));
}
IDENT(ident, b) => {
return cx.expr_call_ident(sp,
id_ext("IDENT"),
- ~[mk_ident(cx, sp, ident),
- cx.expr_bool(sp, b)]);
+ vec!(mk_ident(cx, sp, ident),
+ cx.expr_bool(sp, b)));
}
LIFETIME(ident) => {
return cx.expr_call_ident(sp,
id_ext("LIFETIME"),
- ~[mk_ident(cx, sp, ident)]);
+ vec!(mk_ident(cx, sp, ident)));
}
DOC_COMMENT(ident) => {
return cx.expr_call_ident(sp,
id_ext("DOC_COMMENT"),
- ~[mk_ident(cx, sp, ident)]);
+ vec!(mk_ident(cx, sp, ident)));
}
INTERPOLATED(_) => fail!("quote! with interpolated token"),
}
-fn mk_tt(cx: &ExtCtxt, sp: Span, tt: &ast::TokenTree) -> ~[@ast::Stmt] {
+fn mk_tt(cx: &ExtCtxt, sp: Span, tt: &ast::TokenTree) -> Vec<@ast::Stmt> {
match *tt {
let e_sp = cx.expr_ident(sp, id_ext("_sp"));
let e_tok = cx.expr_call_ident(sp,
id_ext("TTTok"),
- ~[e_sp, mk_token(cx, sp, tok)]);
+ vec!(e_sp, mk_token(cx, sp, tok)));
let e_push =
cx.expr_method_call(sp,
cx.expr_ident(sp, id_ext("tt")),
id_ext("push"),
- ~[e_tok]);
- ~[cx.stmt_expr(e_push)]
+ vec!(e_tok));
+ vec!(cx.stmt_expr(e_push))
}
- ast::TTDelim(ref tts) => mk_tts(cx, sp, **tts),
+ ast::TTDelim(ref tts) => mk_tts(cx, sp, tts.as_slice()),
ast::TTSeq(..) => fail!("TTSeq in quote!"),
ast::TTNonterminal(sp, ident) => {
cx.expr_method_call(sp,
cx.expr_ident(sp, ident),
id_ext("to_tokens"),
- ~[cx.expr_ident(sp, id_ext("ext_cx"))]);
+ vec!(cx.expr_ident(sp, id_ext("ext_cx"))));
let e_push =
cx.expr_method_call(sp,
cx.expr_ident(sp, id_ext("tt")),
id_ext("push_all_move"),
- ~[e_to_toks]);
+ vec!(e_to_toks));
- ~[cx.stmt_expr(e_push)]
+ vec!(cx.stmt_expr(e_push))
}
}
}
fn mk_tts(cx: &ExtCtxt, sp: Span, tts: &[ast::TokenTree])
- -> ~[@ast::Stmt] {
- let mut ss = ~[];
+ -> Vec<@ast::Stmt> {
+ let mut ss = Vec::new();
for tt in tts.iter() {
ss.push_all_move(mk_tt(cx, sp, tt));
}
let mut p = parse::new_parser_from_tts(cx.parse_sess(),
cx.cfg(),
- tts.to_owned());
+ tts.iter()
+ .map(|x| (*x).clone())
+ .collect());
p.quote_depth += 1u;
let cx_expr = p.parse_expr();
let e_sp = cx.expr_method_call(sp,
cx.expr_ident(sp, id_ext("ext_cx")),
id_ext("call_site"),
- ~[]);
+ Vec::new());
let stmt_let_sp = cx.stmt_let(sp, false,
id_ext("_sp"),
e_sp);
- let stmt_let_tt = cx.stmt_let(sp, true,
- id_ext("tt"),
- cx.expr_vec_uniq(sp, ~[]));
+ let stmt_let_tt = cx.stmt_let(sp, true, id_ext("tt"), cx.expr_vec_ng(sp));
+ let mut vector = vec!(stmt_let_sp, stmt_let_tt);
+ vector.push_all_move(mk_tts(cx, sp, tts.as_slice()));
let block = cx.expr_block(
cx.block_all(sp,
- ~[],
- ~[stmt_let_sp, stmt_let_tt] + mk_tts(cx, sp, tts),
+ Vec::new(),
+ vector,
Some(cx.expr_ident(sp, id_ext("tt")))));
(cx_expr, block)
sp: Span,
cx_expr: @ast::Expr,
expr: @ast::Expr) -> @ast::Expr {
- let uses = ~[ cx.view_use_glob(sp, ast::Inherited,
- ids_ext(~[~"syntax",
+ let uses = vec!( cx.view_use_glob(sp, ast::Inherited,
+ ids_ext(vec!(~"syntax",
~"ext",
~"quote",
- ~"rt"])) ];
+ ~"rt"))) );
let stmt_let_ext_cx = cx.stmt_let(sp, false, id_ext("ext_cx"), cx_expr);
- cx.expr_block(cx.block_all(sp, uses, ~[stmt_let_ext_cx], Some(expr)))
+ cx.expr_block(cx.block_all(sp, uses, vec!(stmt_let_ext_cx), Some(expr)))
}
fn expand_parse_call(cx: &ExtCtxt,
sp: Span,
parse_method: &str,
- arg_exprs: ~[@ast::Expr],
+ arg_exprs: Vec<@ast::Expr> ,
tts: &[ast::TokenTree]) -> @ast::Expr {
let (cx_expr, tts_expr) = expand_tts(cx, sp, tts);
let cfg_call = || cx.expr_method_call(
sp, cx.expr_ident(sp, id_ext("ext_cx")),
- id_ext("cfg"), ~[]);
+ id_ext("cfg"), Vec::new());
let parse_sess_call = || cx.expr_method_call(
sp, cx.expr_ident(sp, id_ext("ext_cx")),
- id_ext("parse_sess"), ~[]);
+ id_ext("parse_sess"), Vec::new());
let new_parser_call =
cx.expr_call(sp,
cx.expr_ident(sp, id_ext("new_parser_from_tts")),
- ~[parse_sess_call(), cfg_call(), tts_expr]);
+ vec!(parse_sess_call(), cfg_call(), tts_expr));
let expr = cx.expr_method_call(sp, new_parser_call, id_ext(parse_method),
arg_exprs);
use visit;
use visit::Visitor;
+use std::vec_ng::Vec;
+
struct MacroRegistrarContext {
- registrars: ~[(ast::NodeId, Span)],
+ registrars: Vec<(ast::NodeId, Span)> ,
}
impl Visitor<()> for MacroRegistrarContext {
fn visit_item(&mut self, item: &ast::Item, _: ()) {
match item.node {
ast::ItemFn(..) => {
- if attr::contains_name(item.attrs, "macro_registrar") {
+ if attr::contains_name(item.attrs.as_slice(),
+ "macro_registrar") {
self.registrars.push((item.id, item.span));
}
}
pub fn find_macro_registrar(diagnostic: @diagnostic::SpanHandler,
krate: &ast::Crate) -> Option<ast::DefId> {
- let mut ctx = MacroRegistrarContext { registrars: ~[] };
+ let mut ctx = MacroRegistrarContext { registrars: Vec::new() };
visit::walk_crate(&mut ctx, krate, ());
match ctx.registrars.len() {
return MacResult::dummy_expr(sp);
}
Ok(bytes) => {
+ let bytes = bytes.iter().map(|x| *x).collect();
base::MRExpr(cx.expr_lit(sp, ast::LitBinary(Rc::new(bytes))))
}
}
let cfg = cx.cfg();
let tt_rdr = new_tt_reader(cx.parse_sess().span_diagnostic,
None,
- tt.to_owned());
+ tt.iter().map(|x| (*x).clone()).collect());
let mut rust_parser = Parser(sess, cfg.clone(), tt_rdr.dup());
if rust_parser.is_keyword(keywords::True) {
use parse::token;
use collections::HashMap;
-use std::vec;
+use std::vec_ng::Vec;
/* This is an Earley-like parser, without support for in-grammar nonterminals,
only by calling out to the main rust parser for named nonterminals (which it
#[deriving(Clone)]
pub struct MatcherPos {
- elts: ~[ast::Matcher], // maybe should be <'>? Need to understand regions.
+ elts: Vec<ast::Matcher> , // maybe should be <'>? Need to understand regions.
sep: Option<Token>,
idx: uint,
up: Option<~MatcherPos>,
- matches: ~[~[@NamedMatch]],
+ matches: Vec<Vec<@NamedMatch>>,
match_lo: uint, match_hi: uint,
sp_lo: BytePos,
}
ms.iter().fold(0, |ct, m| {
ct + match m.node {
MatchTok(_) => 0u,
- MatchSeq(ref more_ms, _, _, _, _) => count_names((*more_ms)),
+ MatchSeq(ref more_ms, _, _, _, _) => {
+ count_names(more_ms.as_slice())
+ }
MatchNonterminal(_, _, _) => 1u
}})
}
-pub fn initial_matcher_pos(ms: ~[Matcher], sep: Option<Token>, lo: BytePos)
+pub fn initial_matcher_pos(ms: Vec<Matcher> , sep: Option<Token>, lo: BytePos)
-> ~MatcherPos {
let mut match_idx_hi = 0u;
for elt in ms.iter() {
}
}
}
- let matches = vec::from_fn(count_names(ms), |_i| ~[]);
+ let matches = Vec::from_fn(count_names(ms.as_slice()), |_i| Vec::new());
~MatcherPos {
elts: ms,
sep: sep,
// ast::Matcher it was derived from.
pub enum NamedMatch {
- MatchedSeq(~[@NamedMatch], codemap::Span),
+ MatchedSeq(Vec<@NamedMatch> , codemap::Span),
MatchedNonterminal(Nonterminal)
}
pub fn parse_or_else<R: Reader>(sess: @ParseSess,
cfg: ast::CrateConfig,
rdr: R,
- ms: ~[Matcher])
+ ms: Vec<Matcher> )
-> HashMap<Ident, @NamedMatch> {
- match parse(sess, cfg, rdr, ms) {
+ match parse(sess, cfg, rdr, ms.as_slice()) {
Success(m) => m,
Failure(sp, str) => sess.span_diagnostic.span_fatal(sp, str),
Error(sp, str) => sess.span_diagnostic.span_fatal(sp, str)
rdr: R,
ms: &[Matcher])
-> ParseResult {
- let mut cur_eis = ~[];
- cur_eis.push(initial_matcher_pos(ms.to_owned(), None, rdr.peek().sp.lo));
+ let mut cur_eis = Vec::new();
+ cur_eis.push(initial_matcher_pos(ms.iter()
+ .map(|x| (*x).clone())
+ .collect(),
+ None,
+ rdr.peek().sp.lo));
loop {
- let mut bb_eis = ~[]; // black-box parsed by parser.rs
- let mut next_eis = ~[]; // or proceed normally
- let mut eof_eis = ~[];
+ let mut bb_eis = Vec::new(); // black-box parsed by parser.rs
+ let mut next_eis = Vec::new(); // or proceed normally
+ let mut eof_eis = Vec::new();
let TokenAndSpan {tok: tok, sp: sp} = rdr.peek();
// Only touch the binders we have actually bound
for idx in range(ei.match_lo, ei.match_hi) {
- let sub = ei.matches[idx].clone();
- new_pos.matches[idx]
+ let sub = (*ei.matches.get(idx)).clone();
+ new_pos.matches
+ .get_mut(idx)
.push(@MatchedSeq(sub, mk_sp(ei.sp_lo,
sp.hi)));
}
eof_eis.push(ei);
}
} else {
- match ei.elts[idx].node.clone() {
+ match ei.elts.get(idx).node.clone() {
/* need to descend into sequence */
MatchSeq(ref matchers, ref sep, zero_ok,
match_idx_lo, match_idx_hi) => {
new_ei.idx += 1u;
//we specifically matched zero repeats.
for idx in range(match_idx_lo, match_idx_hi) {
- new_ei.matches[idx].push(@MatchedSeq(~[], sp));
+ new_ei.matches
+ .get_mut(idx)
+ .push(@MatchedSeq(Vec::new(), sp));
}
cur_eis.push(new_ei);
}
- let matches = vec::from_elem(ei.matches.len(), ~[]);
+ let matches = Vec::from_elem(ei.matches.len(), Vec::new());
let ei_t = ei;
cur_eis.push(~MatcherPos {
elts: (*matchers).clone(),
/* error messages here could be improved with links to orig. rules */
if token_name_eq(&tok, &EOF) {
if eof_eis.len() == 1u {
- let mut v = ~[];
- for dv in eof_eis[0u].matches.mut_iter() {
+ let mut v = Vec::new();
+ for dv in eof_eis.get_mut(0).matches.mut_iter() {
v.push(dv.pop().unwrap());
}
- return Success(nameize(sess, ms, v));
+ return Success(nameize(sess, ms, v.as_slice()));
} else if eof_eis.len() > 1u {
return Error(sp, ~"ambiguity: multiple successful parses");
} else {
if (bb_eis.len() > 0u && next_eis.len() > 0u)
|| bb_eis.len() > 1u {
let nts = bb_eis.map(|ei| {
- match ei.elts[ei.idx].node {
+ match ei.elts.get(ei.idx).node {
MatchNonterminal(bind, name, _) => {
format!("{} ('{}')",
token::get_ident(name),
let mut rust_parser = Parser(sess, cfg.clone(), rdr.dup());
let mut ei = bb_eis.pop().unwrap();
- match ei.elts[ei.idx].node {
+ match ei.elts.get(ei.idx).node {
MatchNonterminal(_, name, idx) => {
let name_string = token::get_ident(name);
- ei.matches[idx].push(@MatchedNonterminal(
+ ei.matches.get_mut(idx).push(@MatchedNonterminal(
parse_nt(&mut rust_parser, name_string.get())));
ei.idx += 1u;
}
pub fn parse_nt(p: &mut Parser, name: &str) -> Nonterminal {
match name {
- "item" => match p.parse_item(~[]) {
+ "item" => match p.parse_item(Vec::new()) {
Some(i) => token::NtItem(i),
None => p.fatal("expected an item keyword")
},
"block" => token::NtBlock(p.parse_block()),
- "stmt" => token::NtStmt(p.parse_stmt(~[])),
+ "stmt" => token::NtStmt(p.parse_stmt(Vec::new())),
"pat" => token::NtPat(p.parse_pat()),
"expr" => token::NtExpr(p.parse_expr()),
"ty" => token::NtTy(p.parse_ty(false /* no need to disambiguate*/)),
use parse::token::{FAT_ARROW, SEMI, NtMatchers, NtTT, EOF};
use parse::token;
use print;
-use std::cell::RefCell;
use util::small_vector::SmallVector;
+use std::cell::RefCell;
+use std::vec_ng::Vec;
+
struct ParserAnyMacro {
parser: RefCell<Parser>,
}
struct MacroRulesMacroExpander {
name: Ident,
- lhses: @~[@NamedMatch],
- rhses: @~[@NamedMatch],
+ lhses: @Vec<@NamedMatch> ,
+ rhses: @Vec<@NamedMatch> ,
}
impl MacroExpander for MacroRulesMacroExpander {
sp: Span,
arg: &[ast::TokenTree])
-> MacResult {
- generic_extension(cx, sp, self.name, arg, *self.lhses, *self.rhses)
+ generic_extension(cx,
+ sp,
+ self.name,
+ arg,
+ self.lhses.as_slice(),
+ self.rhses.as_slice())
}
}
if cx.trace_macros() {
println!("{}! \\{ {} \\}",
token::get_ident(name),
- print::pprust::tt_to_str(&TTDelim(@arg.to_owned())));
+ print::pprust::tt_to_str(&TTDelim(@arg.iter()
+ .map(|x| (*x).clone())
+ .collect())));
}
// Which arm's failure should we report? (the one furthest along)
match **lhs {
MatchedNonterminal(NtMatchers(ref mtcs)) => {
// `None` is because we're not interpolating
- let arg_rdr = new_tt_reader(s_d, None, arg.to_owned());
- match parse(cx.parse_sess(), cx.cfg(), arg_rdr, *mtcs) {
+ let arg_rdr = new_tt_reader(s_d,
+ None,
+ arg.iter()
+ .map(|x| (*x).clone())
+ .collect());
+ match parse(cx.parse_sess(), cx.cfg(), arg_rdr, mtcs.as_slice()) {
Success(named_matches) => {
let rhs = match *rhses[i] {
// okay, what's your transcriber?
match *tt {
// cut off delimiters; don't parse 'em
TTDelim(ref tts) => {
- (*tts).slice(1u,(*tts).len()-1u).to_owned()
+ (*tts).slice(1u,(*tts).len()-1u)
+ .iter()
+ .map(|x| (*x).clone())
+ .collect()
}
_ => cx.span_fatal(
sp, "macro rhs must be delimited")
pub fn add_new_extension(cx: &mut ExtCtxt,
sp: Span,
name: Ident,
- arg: ~[ast::TokenTree])
+ arg: Vec<ast::TokenTree> )
-> base::MacResult {
// these spans won't matter, anyways
fn ms(m: Matcher_) -> Matcher {
// The grammar for macro_rules! is:
// $( $lhs:mtcs => $rhs:tt );+
// ...quasiquoting this would be nice.
- let argument_gram = ~[
- ms(MatchSeq(~[
+ let argument_gram = vec!(
+ ms(MatchSeq(vec!(
ms(MatchNonterminal(lhs_nm, special_idents::matchers, 0u)),
ms(MatchTok(FAT_ARROW)),
- ms(MatchNonterminal(rhs_nm, special_idents::tt, 1u)),
- ], Some(SEMI), false, 0u, 2u)),
+ ms(MatchNonterminal(rhs_nm, special_idents::tt, 1u))), Some(SEMI), false, 0u, 2u)),
//to phase into semicolon-termination instead of
//semicolon-separation
- ms(MatchSeq(~[ms(MatchTok(SEMI))], None, true, 2u, 2u))];
+ ms(MatchSeq(vec!(ms(MatchTok(SEMI))), None, true, 2u, 2u)));
// Parse the macro_rules! invocation (`none` is for no interpolations):
use parse::lexer::TokenAndSpan;
use std::cell::{Cell, RefCell};
+use std::vec_ng::Vec;
use collections::HashMap;
///an unzipping of `TokenTree`s
struct TtFrame {
- forest: @~[ast::TokenTree],
+ forest: @Vec<ast::TokenTree> ,
idx: Cell<uint>,
dotdotdoted: bool,
sep: Option<Token>,
priv stack: RefCell<@TtFrame>,
/* for MBE-style macro transcription */
priv interpolations: RefCell<HashMap<Ident, @NamedMatch>>,
- priv repeat_idx: RefCell<~[uint]>,
- priv repeat_len: RefCell<~[uint]>,
+ priv repeat_idx: RefCell<Vec<uint> >,
+ priv repeat_len: RefCell<Vec<uint> >,
/* cached: */
cur_tok: RefCell<Token>,
cur_span: RefCell<Span>,
* should) be none. */
pub fn new_tt_reader(sp_diag: @SpanHandler,
interp: Option<HashMap<Ident, @NamedMatch>>,
- src: ~[ast::TokenTree])
+ src: Vec<ast::TokenTree> )
-> TtReader {
let r = TtReader {
sp_diag: sp_diag,
None => RefCell::new(HashMap::new()),
Some(x) => RefCell::new(x),
},
- repeat_idx: RefCell::new(~[]),
- repeat_len: RefCell::new(~[]),
+ repeat_idx: RefCell::new(Vec::new()),
+ repeat_len: RefCell::new(Vec::new()),
/* dummy values, never read: */
cur_tok: RefCell::new(EOF),
cur_span: RefCell::new(DUMMY_SP),
// end of the line; duplicate henceforth
ad
}
- MatchedSeq(ref ads, _) => ads[*idx]
+ MatchedSeq(ref ads, _) => *ads.get(*idx)
}
}
let repeat_idx = r.repeat_idx.borrow();
r.stack.get().idx.set(0u);
{
let mut repeat_idx = r.repeat_idx.borrow_mut();
- repeat_idx.get()[repeat_idx.get().len() - 1u] += 1u;
+ let last_repeat_idx = repeat_idx.get().len() - 1u;
+ *repeat_idx.get().get_mut(last_repeat_idx) += 1u;
}
match r.stack.get().sep.clone() {
Some(tk) => {
loop { /* because it's easiest, this handles `TTDelim` not starting
with a `TTTok`, even though it won't happen */
// FIXME(pcwalton): Bad copy.
- match r.stack.get().forest[r.stack.get().idx.get()].clone() {
+ match (*r.stack.get().forest.get(r.stack.get().idx.get())).clone() {
TTDelim(tts) => {
r.stack.set(@TtFrame {
forest: tts,
use opt_vec::OptVec;
use util::small_vector::SmallVector;
+use std::vec_ng::Vec;
+
// We may eventually want to be able to fold over type parameters, too.
pub trait Folder {
fn fold_crate(&mut self, c: Crate) -> Crate {
noop_fold_crate(c, self)
}
- fn fold_meta_items(&mut self, meta_items: &[@MetaItem]) -> ~[@MetaItem] {
- meta_items.map(|x| fold_meta_item_(*x, self))
+ fn fold_meta_items(&mut self, meta_items: &[@MetaItem]) -> Vec<@MetaItem> {
+ meta_items.iter().map(|x| fold_meta_item_(*x, self)).collect()
}
- fn fold_view_paths(&mut self, view_paths: &[@ViewPath]) -> ~[@ViewPath] {
- view_paths.map(|view_path| {
+ fn fold_view_paths(&mut self, view_paths: &[@ViewPath]) -> Vec<@ViewPath> {
+ view_paths.iter().map(|view_path| {
let inner_view_path = match view_path.node {
ViewPathSimple(ref ident, ref path, node_id) => {
ViewPathSimple(ident.clone(),
node: inner_view_path,
span: self.new_span(view_path.span),
}
- })
+ }).collect()
}
fn fold_view_item(&mut self, vi: &ViewItem) -> ViewItem {
node: match macro.node {
MacInvocTT(ref p, ref tts, ctxt) => {
MacInvocTT(self.fold_path(p),
- fold_tts(*tts, self),
+ fold_tts(tts.as_slice(), self),
ctxt)
}
},
}
}
- fn map_exprs(&self, f: |@Expr| -> @Expr, es: &[@Expr]) -> ~[@Expr] {
- es.map(|x| f(*x))
+ fn map_exprs(&self, f: |@Expr| -> @Expr, es: &[@Expr]) -> Vec<@Expr> {
+ es.iter().map(|x| f(*x)).collect()
}
fn new_id(&mut self, i: NodeId) -> NodeId {
// since many token::IDENT are not necessary part of let bindings and most
// token::LIFETIME are certainly not loop labels. But we can't tell in their
// token form. So this is less ideal and hacky but it works.
-pub fn fold_tts<T: Folder>(tts: &[TokenTree], fld: &mut T) -> ~[TokenTree] {
- tts.map(|tt| {
+pub fn fold_tts<T: Folder>(tts: &[TokenTree], fld: &mut T) -> Vec<TokenTree> {
+ tts.iter().map(|tt| {
match *tt {
TTTok(span, ref tok) =>
TTTok(span,maybe_fold_ident(tok,fld)),
- TTDelim(tts) => TTDelim(@fold_tts(*tts, fld)),
+ TTDelim(tts) => TTDelim(@fold_tts(tts.as_slice(), fld)),
TTSeq(span, pattern, ref sep, is_optional) =>
TTSeq(span,
- @fold_tts(*pattern, fld),
+ @fold_tts(pattern.as_slice(), fld),
sep.as_ref().map(|tok|maybe_fold_ident(tok,fld)),
is_optional),
TTNonterminal(sp,ref ident) =>
TTNonterminal(sp,fld.fold_ident(*ident))
}
- })
+ }).collect()
}
// apply ident folder if it's an ident, otherwise leave it alone
folder.new_id(node_id))
}
ViewItemUse(ref view_paths) => {
- ViewItemUse(folder.fold_view_paths(*view_paths))
+ ViewItemUse(folder.fold_view_paths(view_paths.as_slice()))
}
};
ViewItem {
// this version doesn't care about getting comments or docstrings in.
fn fake_print_crate(s: &mut pprust::State,
krate: &ast::Crate) -> io::IoResult<()> {
- pprust::print_mod(s, &krate.module, krate.attrs)
+ pprust::print_mod(s, &krate.module, krate.attrs.as_slice())
}
// change every identifier to "zz"
* other useful things like `push()` and `len()`.
*/
-use std::vec;
use std::default::Default;
+use std::vec;
+use std::vec_ng::Vec;
#[deriving(Clone, Encodable, Decodable, Hash)]
pub enum OptVec<T> {
Empty,
- Vec(~[T])
+ Vec(Vec<T> )
}
pub fn with<T>(t: T) -> OptVec<T> {
- Vec(~[t])
+ Vec(vec!(t))
}
-pub fn from<T>(t: ~[T]) -> OptVec<T> {
+pub fn from<T>(t: Vec<T> ) -> OptVec<T> {
if t.len() == 0 {
Empty
} else {
return;
}
Empty => {
- *self = Vec(~[t]);
+ *self = Vec(vec!(t));
}
}
}
pub fn get<'a>(&'a self, i: uint) -> &'a T {
match *self {
Empty => fail!("invalid index {}", i),
- Vec(ref v) => &v[i]
+ Vec(ref v) => v.get(i)
}
}
}
#[inline]
- pub fn map_to_vec<B>(&self, op: |&T| -> B) -> ~[B] {
+ pub fn map_to_vec<B>(&self, op: |&T| -> B) -> Vec<B> {
self.iter().map(op).collect()
}
- pub fn mapi_to_vec<B>(&self, op: |uint, &T| -> B) -> ~[B] {
+ pub fn mapi_to_vec<B>(&self, op: |uint, &T| -> B) -> Vec<B> {
let mut index = 0;
self.map_to_vec(|a| {
let i = index;
}
}
-pub fn take_vec<T>(v: OptVec<T>) -> ~[T] {
+pub fn take_vec<T>(v: OptVec<T>) -> Vec<T> {
match v {
- Empty => ~[],
+ Empty => Vec::new(),
Vec(v) => v
}
}
impl<T:Clone> OptVec<T> {
pub fn prepend(&self, t: T) -> OptVec<T> {
- let mut v0 = ~[t];
+ let mut v0 = vec!(t);
match *self {
Empty => {}
- Vec(ref v1) => { v0.push_all(*v1); }
+ Vec(ref v1) => { v0.push_all(v1.as_slice()); }
}
return Vec(v0);
}
use parse::parser::Parser;
use parse::token::INTERPOLATED;
+use std::vec_ng::Vec;
+
// a parser that can parse attributes.
pub trait ParserAttr {
- fn parse_outer_attributes(&mut self) -> ~[ast::Attribute];
+ fn parse_outer_attributes(&mut self) -> Vec<ast::Attribute> ;
fn parse_attribute(&mut self, permit_inner: bool) -> ast::Attribute;
fn parse_inner_attrs_and_next(&mut self)
- -> (~[ast::Attribute], ~[ast::Attribute]);
+ -> (Vec<ast::Attribute> , Vec<ast::Attribute> );
fn parse_meta_item(&mut self) -> @ast::MetaItem;
- fn parse_meta_seq(&mut self) -> ~[@ast::MetaItem];
- fn parse_optional_meta(&mut self) -> ~[@ast::MetaItem];
+ fn parse_meta_seq(&mut self) -> Vec<@ast::MetaItem> ;
+ fn parse_optional_meta(&mut self) -> Vec<@ast::MetaItem> ;
}
impl ParserAttr for Parser {
// Parse attributes that appear before an item
- fn parse_outer_attributes(&mut self) -> ~[ast::Attribute] {
- let mut attrs: ~[ast::Attribute] = ~[];
+ fn parse_outer_attributes(&mut self) -> Vec<ast::Attribute> {
+ let mut attrs: Vec<ast::Attribute> = Vec::new();
loop {
debug!("parse_outer_attributes: self.token={:?}",
self.token);
// you can make the 'next' field an Option, but the result is going to be
// more useful as a vector.
fn parse_inner_attrs_and_next(&mut self)
- -> (~[ast::Attribute], ~[ast::Attribute]) {
- let mut inner_attrs: ~[ast::Attribute] = ~[];
- let mut next_outer_attrs: ~[ast::Attribute] = ~[];
+ -> (Vec<ast::Attribute> , Vec<ast::Attribute> ) {
+ let mut inner_attrs: Vec<ast::Attribute> = Vec::new();
+ let mut next_outer_attrs: Vec<ast::Attribute> = Vec::new();
loop {
let attr = match self.token {
token::INTERPOLATED(token::NtAttr(..)) => {
}
// matches meta_seq = ( COMMASEP(meta_item) )
- fn parse_meta_seq(&mut self) -> ~[@ast::MetaItem] {
+ fn parse_meta_seq(&mut self) -> Vec<@ast::MetaItem> {
self.parse_seq(&token::LPAREN,
&token::RPAREN,
seq_sep_trailing_disallowed(token::COMMA),
|p| p.parse_meta_item()).node
}
- fn parse_optional_meta(&mut self) -> ~[@ast::MetaItem] {
+ fn parse_optional_meta(&mut self) -> Vec<@ast::MetaItem> {
match self.token {
token::LPAREN => self.parse_meta_seq(),
- _ => ~[]
+ _ => Vec::new()
}
}
}
use std::io;
use std::str;
use std::uint;
+use std::vec_ng::Vec;
#[deriving(Clone, Eq)]
pub enum CommentStyle {
#[deriving(Clone)]
pub struct Comment {
style: CommentStyle,
- lines: ~[~str],
+ lines: Vec<~str> ,
pos: BytePos
}
pub fn strip_doc_comment_decoration(comment: &str) -> ~str {
/// remove whitespace-only lines from the start/end of lines
- fn vertical_trim(lines: ~[~str]) -> ~[~str] {
+ fn vertical_trim(lines: Vec<~str> ) -> Vec<~str> {
let mut i = 0u;
let mut j = lines.len();
// first line of all-stars should be omitted
- if lines.len() > 0 && lines[0].chars().all(|c| c == '*') {
+ if lines.len() > 0 && lines.get(0).chars().all(|c| c == '*') {
i += 1;
}
- while i < j && lines[i].trim().is_empty() {
+ while i < j && lines.get(i).trim().is_empty() {
i += 1;
}
// like the first, a last line of all stars should be omitted
- if j > i && lines[j - 1].chars().skip(1).all(|c| c == '*') {
+ if j > i && lines.get(j - 1).chars().skip(1).all(|c| c == '*') {
j -= 1;
}
- while j > i && lines[j - 1].trim().is_empty() {
+ while j > i && lines.get(j - 1).trim().is_empty() {
j -= 1;
}
- return lines.slice(i, j).to_owned();
+ return lines.slice(i, j).iter().map(|x| (*x).clone()).collect();
}
/// remove a "[ \t]*\*" block from each line, if possible
- fn horizontal_trim(lines: ~[~str]) -> ~[~str] {
+ fn horizontal_trim(lines: Vec<~str> ) -> Vec<~str> {
let mut i = uint::MAX;
let mut can_trim = true;
let mut first = true;
let lines = comment.slice(3u, comment.len() - 2u)
.lines_any()
.map(|s| s.to_owned())
- .collect::<~[~str]>();
+ .collect::<Vec<~str> >();
let lines = vertical_trim(lines);
let lines = horizontal_trim(lines);
}
}
-fn push_blank_line_comment(rdr: &StringReader, comments: &mut ~[Comment]) {
+fn push_blank_line_comment(rdr: &StringReader, comments: &mut Vec<Comment> ) {
debug!(">>> blank-line comment");
- let v: ~[~str] = ~[];
+ let v: Vec<~str> = Vec::new();
comments.push(Comment {
style: BlankLine,
lines: v,
}
fn consume_whitespace_counting_blank_lines(rdr: &StringReader,
- comments: &mut ~[Comment]) {
+ comments: &mut Vec<Comment> ) {
while is_whitespace(rdr.curr.get()) && !is_eof(rdr) {
if rdr.col.get() == CharPos(0u) && rdr.curr_is('\n') {
push_blank_line_comment(rdr, &mut *comments);
fn read_shebang_comment(rdr: &StringReader, code_to_the_left: bool,
- comments: &mut ~[Comment]) {
+ comments: &mut Vec<Comment> ) {
debug!(">>> shebang comment");
let p = rdr.last_pos.get();
debug!("<<< shebang comment");
comments.push(Comment {
style: if code_to_the_left { Trailing } else { Isolated },
- lines: ~[read_one_line_comment(rdr)],
+ lines: vec!(read_one_line_comment(rdr)),
pos: p
});
}
fn read_line_comments(rdr: &StringReader, code_to_the_left: bool,
- comments: &mut ~[Comment]) {
+ comments: &mut Vec<Comment> ) {
debug!(">>> line comments");
let p = rdr.last_pos.get();
- let mut lines: ~[~str] = ~[];
+ let mut lines: Vec<~str> = Vec::new();
while rdr.curr_is('/') && nextch_is(rdr, '/') {
let line = read_one_line_comment(rdr);
debug!("{}", line);
return Some(cursor);
}
-fn trim_whitespace_prefix_and_push_line(lines: &mut ~[~str],
+fn trim_whitespace_prefix_and_push_line(lines: &mut Vec<~str> ,
s: ~str, col: CharPos) {
let len = s.len();
let s1 = match all_whitespace(s, col) {
fn read_block_comment(rdr: &StringReader,
code_to_the_left: bool,
- comments: &mut ~[Comment]) {
+ comments: &mut Vec<Comment> ) {
debug!(">>> block comment");
let p = rdr.last_pos.get();
- let mut lines: ~[~str] = ~[];
+ let mut lines: Vec<~str> = Vec::new();
let col: CharPos = rdr.col.get();
bump(rdr);
bump(rdr);
fn consume_comment(rdr: &StringReader,
code_to_the_left: bool,
- comments: &mut ~[Comment]) {
+ comments: &mut Vec<Comment> ) {
debug!(">>> consume comment");
if rdr.curr_is('/') && nextch_is(rdr, '/') {
read_line_comments(rdr, code_to_the_left, comments);
@diagnostic::SpanHandler,
path: ~str,
srdr: &mut io::Reader)
- -> (~[Comment], ~[Literal]) {
+ -> (Vec<Comment> , Vec<Literal> ) {
let src = srdr.read_to_end().unwrap();
let src = str::from_utf8_owned(src).unwrap();
let cm = CodeMap::new();
let filemap = cm.new_filemap(path, src);
let rdr = lexer::new_low_level_string_reader(span_diagnostic, filemap);
- let mut comments: ~[Comment] = ~[];
- let mut literals: ~[Literal] = ~[];
+ let mut comments: Vec<Comment> = Vec::new();
+ let mut literals: Vec<Literal> = Vec::new();
let mut first_read: bool = true;
while !is_eof(&rdr) {
loop {
use parse::token;
use parse::token::{str_to_ident};
use std::io::util;
+ use std::vec_ng::Vec;
// represents a testing reader (incl. both reader and interner)
struct Env {
// check that the given reader produces the desired stream
// of tokens (stop checking after exhausting the expected vec)
- fn check_tokenization (env: Env, expected: ~[token::Token]) {
+ fn check_tokenization (env: Env, expected: Vec<token::Token> ) {
for expected_tok in expected.iter() {
let TokenAndSpan {tok:actual_tok, sp: _} =
env.string_reader.next_token();
#[test] fn doublecolonparsing () {
let env = setup (~"a b");
check_tokenization (env,
- ~[mk_ident("a",false),
- mk_ident("b",false)]);
+ vec!(mk_ident("a",false),
+ mk_ident("b",false)));
}
#[test] fn dcparsing_2 () {
let env = setup (~"a::b");
check_tokenization (env,
- ~[mk_ident("a",true),
+ vec!(mk_ident("a",true),
token::MOD_SEP,
- mk_ident("b",false)]);
+ mk_ident("b",false)));
}
#[test] fn dcparsing_3 () {
let env = setup (~"a ::b");
check_tokenization (env,
- ~[mk_ident("a",false),
+ vec!(mk_ident("a",false),
token::MOD_SEP,
- mk_ident("b",false)]);
+ mk_ident("b",false)));
}
#[test] fn dcparsing_4 () {
let env = setup (~"a:: b");
check_tokenization (env,
- ~[mk_ident("a",true),
+ vec!(mk_ident("a",true),
token::MOD_SEP,
- mk_ident("b",false)]);
+ mk_ident("b",false)));
}
#[test] fn character_a() {
use std::cell::RefCell;
use std::io::File;
use std::str;
+use std::vec_ng::Vec;
pub mod lexer;
pub mod parser;
cm: @codemap::CodeMap, // better be the same as the one in the reader!
span_diagnostic: @SpanHandler, // better be the same as the one in the reader!
/// Used to determine and report recursive mod inclusions
- included_mod_stack: RefCell<~[Path]>,
+ included_mod_stack: RefCell<Vec<Path> >,
}
pub fn new_parse_sess() -> @ParseSess {
@ParseSess {
cm: cm,
span_diagnostic: mk_span_handler(default_handler(), cm),
- included_mod_stack: RefCell::new(~[]),
+ included_mod_stack: RefCell::new(Vec::new()),
}
}
@ParseSess {
cm: cm,
span_diagnostic: sh,
- included_mod_stack: RefCell::new(~[]),
+ included_mod_stack: RefCell::new(Vec::new()),
}
}
input: &Path,
cfg: ast::CrateConfig,
sess: @ParseSess
-) -> ~[ast::Attribute] {
+) -> Vec<ast::Attribute> {
let mut parser = new_parser_from_file(sess, cfg, input);
let (inner, _) = parser.parse_inner_attrs_and_next();
return inner;
source: ~str,
cfg: ast::CrateConfig,
sess: @ParseSess)
- -> ~[ast::Attribute] {
+ -> Vec<ast::Attribute> {
let mut p = new_parser_from_source_str(sess,
cfg,
name,
pub fn parse_stmt_from_source_str(name: ~str,
source: ~str,
cfg: ast::CrateConfig,
- attrs: ~[ast::Attribute],
+ attrs: Vec<ast::Attribute> ,
sess: @ParseSess)
-> @ast::Stmt {
let mut p = new_parser_from_source_str(
source: ~str,
cfg: ast::CrateConfig,
sess: @ParseSess)
- -> ~[ast::TokenTree] {
+ -> Vec<ast::TokenTree> {
let mut p = new_parser_from_source_str(
sess,
cfg,
// compiler expands into it
pub fn new_parser_from_tts(sess: @ParseSess,
cfg: ast::CrateConfig,
- tts: ~[ast::TokenTree]) -> Parser {
+ tts: Vec<ast::TokenTree> ) -> Parser {
tts_to_parser(sess,tts,cfg)
}
// given a filemap, produce a sequence of token-trees
pub fn filemap_to_tts(sess: @ParseSess, filemap: @FileMap)
- -> ~[ast::TokenTree] {
+ -> Vec<ast::TokenTree> {
// it appears to me that the cfg doesn't matter here... indeed,
// parsing tt's probably shouldn't require a parser at all.
- let cfg = ~[];
+ let cfg = Vec::new();
let srdr = lexer::new_string_reader(sess.span_diagnostic, filemap);
let mut p1 = Parser(sess, cfg, ~srdr);
p1.parse_all_token_trees()
// given tts and cfg, produce a parser
pub fn tts_to_parser(sess: @ParseSess,
- tts: ~[ast::TokenTree],
+ tts: Vec<ast::TokenTree> ,
cfg: ast::CrateConfig) -> Parser {
let trdr = lexer::new_tt_reader(sess.span_diagnostic, None, tts);
Parser(sess, cfg, ~trdr)
use std::io;
use std::io::MemWriter;
use std::str;
+ use std::vec_ng::Vec;
use codemap::{Span, BytePos, Spanned};
use opt_vec;
use ast;
node: ast::ExprPath(ast::Path {
span: sp(0, 1),
global: false,
- segments: ~[
+ segments: vec!(
ast::PathSegment {
identifier: str_to_ident("a"),
lifetimes: opt_vec::Empty,
types: opt_vec::Empty,
}
- ],
+ ),
}),
span: sp(0, 1)
})
node: ast::ExprPath(ast::Path {
span: sp(0, 6),
global: true,
- segments: ~[
+ segments: vec!(
ast::PathSegment {
identifier: str_to_ident("a"),
lifetimes: opt_vec::Empty,
lifetimes: opt_vec::Empty,
types: opt_vec::Empty,
}
- ]
+ )
}),
span: sp(0, 6)
})
// check the token-tree-ization of macros
#[test] fn string_to_tts_macro () {
let tts = string_to_tts(~"macro_rules! zip (($a)=>($a))");
- let tts: &[ast::TokenTree] = tts;
+ let tts: &[ast::TokenTree] = tts.as_slice();
match tts {
[ast::TTTok(_,_),
ast::TTTok(_,token::NOT),
ast::TTTok(_,_),
ast::TTDelim(delim_elts)] => {
- let delim_elts: &[ast::TokenTree] = *delim_elts;
+ let delim_elts: &[ast::TokenTree] = delim_elts.as_slice();
match delim_elts {
[ast::TTTok(_,token::LPAREN),
ast::TTDelim(first_set),
ast::TTTok(_,token::FAT_ARROW),
ast::TTDelim(second_set),
ast::TTTok(_,token::RPAREN)] => {
- let first_set: &[ast::TokenTree] = *first_set;
+ let first_set: &[ast::TokenTree] =
+ first_set.as_slice();
match first_set {
[ast::TTTok(_,token::LPAREN),
ast::TTTok(_,token::DOLLAR),
ast::TTTok(_,_),
ast::TTTok(_,token::RPAREN)] => {
let second_set: &[ast::TokenTree] =
- *second_set;
+ second_set.as_slice();
match second_set {
[ast::TTTok(_,token::LPAREN),
ast::TTTok(_,token::DOLLAR),
node:ast::ExprPath(ast::Path{
span: sp(7, 8),
global: false,
- segments: ~[
+ segments: vec!(
ast::PathSegment {
identifier: str_to_ident("d"),
lifetimes: opt_vec::Empty,
types: opt_vec::Empty,
}
- ],
+ ),
}),
span:sp(7,8)
})),
node: ast::ExprPath(ast::Path {
span:sp(0,1),
global:false,
- segments: ~[
+ segments: vec!(
ast::PathSegment {
identifier: str_to_ident("b"),
lifetimes: opt_vec::Empty,
types: opt_vec::Empty,
}
- ],
+ ),
}),
span: sp(0,1)},
ast::DUMMY_NODE_ID),
ast::Path {
span:sp(0,1),
global:false,
- segments: ~[
+ segments: vec!(
ast::PathSegment {
identifier: str_to_ident("b"),
lifetimes: opt_vec::Empty,
types: opt_vec::Empty,
}
- ],
+ ),
},
None /* no idea */),
span: sp(0,1)});
assert!(string_to_item(~"fn a (b : int) { b; }") ==
Some(
@ast::Item{ident:str_to_ident("a"),
- attrs:~[],
+ attrs:Vec::new(),
id: ast::DUMMY_NODE_ID,
node: ast::ItemFn(ast::P(ast::FnDecl {
- inputs: ~[ast::Arg{
+ inputs: vec!(ast::Arg{
ty: ast::P(ast::Ty{id: ast::DUMMY_NODE_ID,
node: ast::TyPath(ast::Path{
span:sp(10,13),
global:false,
- segments: ~[
+ segments: vec!(
ast::PathSegment {
identifier:
str_to_ident("int"),
lifetimes: opt_vec::Empty,
types: opt_vec::Empty,
}
- ],
+ ),
}, None, ast::DUMMY_NODE_ID),
span:sp(10,13)
}),
ast::Path {
span:sp(6,7),
global:false,
- segments: ~[
+ segments: vec!(
ast::PathSegment {
identifier:
str_to_ident("b"),
lifetimes: opt_vec::Empty,
types: opt_vec::Empty,
}
- ],
+ ),
},
None // no idea
),
span: sp(6,7)
},
id: ast::DUMMY_NODE_ID
- }],
+ }),
output: ast::P(ast::Ty{id: ast::DUMMY_NODE_ID,
node: ast::TyNil,
span:sp(15,15)}), // not sure
ty_params: opt_vec::Empty,
},
ast::P(ast::Block {
- view_items: ~[],
- stmts: ~[@Spanned{
+ view_items: Vec::new(),
+ stmts: vec!(@Spanned{
node: ast::StmtSemi(@ast::Expr{
id: ast::DUMMY_NODE_ID,
node: ast::ExprPath(
ast::Path{
span:sp(17,18),
global:false,
- segments: ~[
+ segments: vec!(
ast::PathSegment {
identifier:
str_to_ident(
types:
opt_vec::Empty
}
- ],
+ ),
}),
span: sp(17,18)},
ast::DUMMY_NODE_ID),
- span: sp(17,18)}],
+ span: sp(17,18)}),
expr: None,
id: ast::DUMMY_NODE_ID,
rules: ast::DefaultBlock, // no idea
use collections::HashSet;
use std::kinds::marker;
use std::mem::replace;
-use std::vec;
+use std::vec_ng::Vec;
+use std::vec_ng;
#[allow(non_camel_case_types)]
#[deriving(Eq)]
RESTRICT_NO_BAR_OR_DOUBLEBAR_OP,
}
-type ItemInfo = (Ident, Item_, Option<~[Attribute]>);
+type ItemInfo = (Ident, Item_, Option<Vec<Attribute> >);
/// How to parse a path. There are four different kinds of paths, all of which
/// are parsed somewhat differently.
enum ItemOrViewItem {
// Indicates a failure to parse any kind of item. The attributes are
// returned.
- IoviNone(~[Attribute]),
+ IoviNone(Vec<Attribute> ),
IoviItem(@Item),
IoviForeignItem(@ForeignItem),
IoviViewItem(ViewItem)
};
match __found__ {
Some(INTERPOLATED(token::$constructor(x))) => {
- return (~[], x)
+ return (Vec::new(), x)
}
_ => {}
}
)
-fn maybe_append(lhs: ~[Attribute], rhs: Option<~[Attribute]>)
- -> ~[Attribute] {
+fn maybe_append(lhs: Vec<Attribute> , rhs: Option<Vec<Attribute> >)
+ -> Vec<Attribute> {
match rhs {
None => lhs,
- Some(ref attrs) => vec::append(lhs, (*attrs))
+ Some(ref attrs) => vec_ng::append(lhs, attrs.as_slice())
}
}
struct ParsedItemsAndViewItems {
- attrs_remaining: ~[Attribute],
- view_items: ~[ViewItem],
- items: ~[@Item],
- foreign_items: ~[@ForeignItem]
-}
+ attrs_remaining: Vec<Attribute> ,
+ view_items: Vec<ViewItem> ,
+ items: Vec<@Item> ,
+ foreign_items: Vec<@ForeignItem> }
/* ident is handled by common.rs */
restriction: UNRESTRICTED,
quote_depth: 0,
obsolete_set: HashSet::new(),
- mod_path_stack: ~[],
- open_braces: ~[],
+ mod_path_stack: Vec::new(),
+ open_braces: Vec::new(),
nopod: marker::NoPod
}
}
/// extra detail when the same error is seen twice
obsolete_set: HashSet<ObsoleteSyntax>,
/// Used to determine the path to externally loaded source files
- mod_path_stack: ~[InternedString],
+ mod_path_stack: Vec<InternedString> ,
/// Stack of spans of open delimiters. Used for error message.
- open_braces: ~[Span],
+ open_braces: Vec<Span> ,
/* do not copy the parser; its state is tied to outside state */
priv nopod: marker::NoPod
}
} else if inedible.contains(&self.token) {
// leave it in the input
} else {
- let expected = vec::append(edible.to_owned(), inedible);
- let expect = tokens_to_str(expected);
+ let expected = vec_ng::append(edible.iter()
+ .map(|x| (*x).clone())
+ .collect(),
+ inedible);
+ let expect = tokens_to_str(expected.as_slice());
let actual = self.this_token_to_str();
self.fatal(
if expected.len() != 1 {
match e.node {
ExprPath(..) => {
// might be unit-struct construction; check for recoverableinput error.
- let expected = vec::append(edible.to_owned(), inedible);
- self.check_for_erroneous_unit_struct_expecting(expected);
+ let expected = vec_ng::append(edible.iter()
+ .map(|x| (*x).clone())
+ .collect(),
+ inedible);
+ self.check_for_erroneous_unit_struct_expecting(
+ expected.as_slice());
}
_ => {}
}
debug!("commit_stmt {:?}", s);
let _s = s; // unused, but future checks might want to inspect `s`.
if self.last_token.as_ref().map_or(false, |t| is_ident_or_path(*t)) {
- let expected = vec::append(edible.to_owned(), inedible);
- self.check_for_erroneous_unit_struct_expecting(expected);
+ let expected = vec_ng::append(edible.iter()
+ .map(|x| (*x).clone())
+ .collect(),
+ inedible.as_slice());
+ self.check_for_erroneous_unit_struct_expecting(
+ expected.as_slice());
}
self.expect_one_of(edible, inedible)
}
&mut self,
sep: &token::Token,
f: |&mut Parser| -> T)
- -> ~[T] {
+ -> Vec<T> {
let mut first = true;
- let mut vector = ~[];
+ let mut vector = Vec::new();
while self.token != token::BINOP(token::OR) &&
self.token != token::OROR {
if first {
ket: &token::Token,
sep: SeqSep,
f: |&mut Parser| -> T)
- -> ~[T] {
+ -> Vec<T> {
let val = self.parse_seq_to_before_end(ket, sep, f);
self.bump();
val
ket: &token::Token,
sep: SeqSep,
f: |&mut Parser| -> T)
- -> ~[T] {
+ -> Vec<T> {
let mut first: bool = true;
- let mut v: ~[T] = ~[];
+ let mut v: Vec<T> = Vec::new();
while self.token != *ket {
match sep.sep {
Some(ref t) => {
ket: &token::Token,
sep: SeqSep,
f: |&mut Parser| -> T)
- -> ~[T] {
+ -> Vec<T> {
self.expect(bra);
let result = self.parse_seq_to_before_end(ket, sep, f);
self.bump();
ket: &token::Token,
sep: SeqSep,
f: |&mut Parser| -> T)
- -> Spanned<~[T]> {
+ -> Spanned<Vec<T> > {
let lo = self.span.lo;
self.expect(bra);
let result = self.parse_seq_to_before_end(ket, sep, f);
};
let inputs = if self.eat(&token::OROR) {
- ~[]
+ Vec::new()
} else {
self.expect_or();
let inputs = self.parse_seq_to_before_or(
}
// parse the methods in a trait declaration
- pub fn parse_trait_methods(&mut self) -> ~[TraitMethod] {
+ pub fn parse_trait_methods(&mut self) -> Vec<TraitMethod> {
self.parse_unspanned_seq(
&token::LBRACE,
&token::RBRACE,
debug!("parse_trait_methods(): parsing provided method");
let (inner_attrs, body) =
p.parse_inner_attrs_and_block();
- let attrs = vec::append(attrs, inner_attrs);
+ let attrs = vec_ng::append(attrs, inner_attrs.as_slice());
Provided(@ast::Method {
ident: ident,
attrs: attrs,
// (t) is a parenthesized ty
// (t,) is the type of a tuple with only one field,
// of type t
- let mut ts = ~[self.parse_ty(false)];
+ let mut ts = vec!(self.parse_ty(false));
let mut one_tuple = false;
while self.token == token::COMMA {
self.bump();
if ts.len() == 1 && !one_tuple {
self.expect(&token::RPAREN);
- return ts[0]
+ return *ts.get(0)
}
let t = TyTup(ts);
// Parse any number of segments and bound sets. A segment is an
// identifier followed by an optional lifetime and a set of types.
// A bound set is a set of type parameter bounds.
- let mut segments = ~[];
+ let mut segments = Vec::new();
loop {
// First, parse an identifier.
let identifier = self.parse_ident();
let span = mk_sp(lo, self.last_span.hi);
// Assemble the path segments.
- let mut path_segments = ~[];
+ let mut path_segments = Vec::new();
let mut bounds = None;
let last_segment_index = segments.len() - 1;
for (i, segment_and_bounds) in segments.move_iter().enumerate() {
ExprBinary(binop, lhs, rhs)
}
- pub fn mk_call(&mut self, f: @Expr, args: ~[@Expr]) -> ast::Expr_ {
+ pub fn mk_call(&mut self, f: @Expr, args: Vec<@Expr> ) -> ast::Expr_ {
ExprCall(f, args)
}
- fn mk_method_call(&mut self, ident: Ident, tps: ~[P<Ty>], args: ~[@Expr]) -> ast::Expr_ {
+ fn mk_method_call(&mut self, ident: Ident, tps: Vec<P<Ty>> , args: Vec<@Expr> ) -> ast::Expr_ {
ExprMethodCall(ident, tps, args)
}
ExprIndex(expr, idx)
}
- pub fn mk_field(&mut self, expr: @Expr, ident: Ident, tys: ~[P<Ty>]) -> ast::Expr_ {
+ pub fn mk_field(&mut self, expr: @Expr, ident: Ident, tys: Vec<P<Ty>> ) -> ast::Expr_ {
ExprField(expr, ident, tys)
}
let lit = @spanned(lo, hi, LitNil);
return self.mk_expr(lo, hi, ExprLit(lit));
}
- let mut es = ~[self.parse_expr()];
+ let mut es = vec!(self.parse_expr());
self.commit_expr(*es.last().unwrap(), &[], &[token::COMMA, token::RPAREN]);
while self.token == token::COMMA {
self.bump();
self.commit_expr_expecting(*es.last().unwrap(), token::RPAREN);
return if es.len() == 1 && !trailing_comma {
- self.mk_expr(lo, hi, ExprParen(es[0]))
+ self.mk_expr(lo, hi, ExprParen(*es.get(0)))
}
else {
self.mk_expr(lo, hi, ExprTup(es))
let decl = self.parse_proc_decl();
let body = self.parse_expr();
let fakeblock = P(ast::Block {
- view_items: ~[],
- stmts: ~[],
+ view_items: Vec::new(),
+ stmts: Vec::new(),
expr: Some(body),
id: ast::DUMMY_NODE_ID,
rules: DefaultBlock,
if self.token == token::RBRACKET {
// Empty vector.
self.bump();
- ex = ExprVec(~[], mutbl);
+ ex = ExprVec(Vec::new(), mutbl);
} else {
// Nonempty vector.
let first_expr = self.parse_expr();
seq_sep_trailing_allowed(token::COMMA),
|p| p.parse_expr()
);
- ex = ExprVec(~[first_expr] + remaining_exprs, mutbl);
+ let mut exprs = vec!(first_expr);
+ exprs.push_all_move(remaining_exprs);
+ ex = ExprVec(exprs, mutbl);
} else {
// Vector with one element.
self.expect(&token::RBRACKET);
- ex = ExprVec(~[first_expr], mutbl);
+ ex = ExprVec(vec!(first_expr), mutbl);
}
}
hi = self.last_span.hi;
if self.looking_at_struct_literal() {
// It's a struct literal.
self.bump();
- let mut fields = ~[];
+ let mut fields = Vec::new();
let mut base = None;
while self.token != token::RBRACE {
self.expect(&token::LT);
self.parse_generic_values_after_lt()
} else {
- (opt_vec::Empty, ~[])
+ (opt_vec::Empty, Vec::new())
};
// expr.f() method call
// Parse the open delimiter.
self.open_braces.push(self.span);
- let mut result = ~[parse_any_tt_tok(self)];
+ let mut result = vec!(parse_any_tt_tok(self));
let trees =
self.parse_seq_to_before_end(&close_delim,
// parse a stream of tokens into a list of TokenTree's,
// up to EOF.
- pub fn parse_all_token_trees(&mut self) -> ~[TokenTree] {
- let mut tts = ~[];
+ pub fn parse_all_token_trees(&mut self) -> Vec<TokenTree> {
+ let mut tts = Vec::new();
while self.token != token::EOF {
tts.push(self.parse_token_tree());
}
tts
}
- pub fn parse_matchers(&mut self) -> ~[Matcher] {
+ pub fn parse_matchers(&mut self) -> Vec<Matcher> {
// unification of Matcher's and TokenTree's would vastly improve
// the interpolation of Matcher's
maybe_whole!(self, NtMatchers);
pub fn parse_matcher_subseq_upto(&mut self,
name_idx: @Cell<uint>,
ket: &token::Token)
- -> ~[Matcher] {
- let mut ret_val = ~[];
+ -> Vec<Matcher> {
+ let mut ret_val = Vec::new();
let mut lparens = 0u;
while self.token != *ket || lparens > 0u {
_ => {
// No argument list - `do foo {`
P(FnDecl {
- inputs: ~[],
+ inputs: Vec::new(),
output: P(Ty {
id: ast::DUMMY_NODE_ID,
node: TyInfer,
let decl = parse_decl(self);
let body = parse_body(self);
let fakeblock = P(ast::Block {
- view_items: ~[],
- stmts: ~[],
+ view_items: Vec::new(),
+ stmts: Vec::new(),
expr: Some(body),
id: ast::DUMMY_NODE_ID,
rules: DefaultBlock,
let lo = self.last_span.lo;
let discriminant = self.parse_expr();
self.commit_expr_expecting(discriminant, token::LBRACE);
- let mut arms: ~[Arm] = ~[];
+ let mut arms: Vec<Arm> = Vec::new();
while self.token != token::RBRACE {
let pats = self.parse_pats();
let mut guard = None;
}
let blk = P(ast::Block {
- view_items: ~[],
- stmts: ~[],
+ view_items: Vec::new(),
+ stmts: Vec::new(),
expr: Some(expr),
id: ast::DUMMY_NODE_ID,
rules: DefaultBlock,
}
// parse patterns, separated by '|' s
- fn parse_pats(&mut self) -> ~[@Pat] {
- let mut pats = ~[];
+ fn parse_pats(&mut self) -> Vec<@Pat> {
+ let mut pats = Vec::new();
loop {
pats.push(self.parse_pat());
if self.token == token::BINOP(token::OR) { self.bump(); }
fn parse_pat_vec_elements(
&mut self,
- ) -> (~[@Pat], Option<@Pat>, ~[@Pat]) {
- let mut before = ~[];
+ ) -> (Vec<@Pat> , Option<@Pat>, Vec<@Pat> ) {
+ let mut before = Vec::new();
let mut slice = None;
- let mut after = ~[];
+ let mut after = Vec::new();
let mut first = true;
let mut before_slice = true;
}
// parse the fields of a struct-like pattern
- fn parse_pat_fields(&mut self) -> (~[ast::FieldPat], bool) {
- let mut fields = ~[];
+ fn parse_pat_fields(&mut self) -> (Vec<ast::FieldPat> , bool) {
+ let mut fields = Vec::new();
let mut etc = false;
let mut first = true;
while self.token != token::RBRACE {
let expr = self.mk_expr(lo, hi, ExprLit(lit));
pat = PatLit(expr);
} else {
- let mut fields = ~[self.parse_pat()];
+ let mut fields = vec!(self.parse_pat());
if self.look_ahead(1, |t| *t != token::RPAREN) {
while self.token == token::COMMA {
self.bump();
pat = PatStruct(enum_path, fields, etc);
}
_ => {
- let mut args: ~[@Pat] = ~[];
+ let mut args: Vec<@Pat> = Vec::new();
match self.token {
token::LPAREN => {
let is_star = self.look_ahead(1, |t| {
// parse a structure field
fn parse_name_and_ty(&mut self, pr: Visibility,
- attrs: ~[Attribute]) -> StructField {
+ attrs: Vec<Attribute> ) -> StructField {
let lo = self.span.lo;
if !is_plain_ident(&self.token) {
self.fatal("expected ident");
// parse a statement. may include decl.
// precondition: any attributes are parsed already
- pub fn parse_stmt(&mut self, item_attrs: ~[Attribute]) -> @Stmt {
+ pub fn parse_stmt(&mut self, item_attrs: Vec<Attribute> ) -> @Stmt {
maybe_whole!(self, NtStmt);
fn check_expected_item(p: &mut Parser, found_attrs: bool) {
self.mk_item(
lo, hi, id /*id is good here*/,
ItemMac(spanned(lo, hi, MacInvocTT(pth, tts, EMPTY_CTXT))),
- Inherited, ~[/*no attrs*/]))),
+ Inherited, Vec::new(/*no attrs*/)))),
ast::DUMMY_NODE_ID));
}
}
self.expect(&token::LBRACE);
- return self.parse_block_tail_(lo, DefaultBlock, ~[]);
+ return self.parse_block_tail_(lo, DefaultBlock, Vec::new());
}
// parse a block. Inner attrs are allowed.
fn parse_inner_attrs_and_block(&mut self)
- -> (~[Attribute], P<Block>) {
+ -> (Vec<Attribute> , P<Block>) {
maybe_whole!(pair_empty self, NtBlock);
// necessary, and this should take a qualifier.
// some blocks start with "#{"...
fn parse_block_tail(&mut self, lo: BytePos, s: BlockCheckMode) -> P<Block> {
- self.parse_block_tail_(lo, s, ~[])
+ self.parse_block_tail_(lo, s, Vec::new())
}
// parse the rest of a block expression or function body
fn parse_block_tail_(&mut self, lo: BytePos, s: BlockCheckMode,
- first_item_attrs: ~[Attribute]) -> P<Block> {
- let mut stmts = ~[];
+ first_item_attrs: Vec<Attribute> ) -> P<Block> {
+ let mut stmts = Vec::new();
let mut expr = None;
// wouldn't it be more uniform to parse view items only, here?
while self.token != token::RBRACE {
// parsing items even when they're not allowed lets us give
// better error messages and recover more gracefully.
- attributes_box.push_all(self.parse_outer_attributes());
+ attributes_box.push_all(self.parse_outer_attributes().as_slice());
match self.token {
token::SEMI => {
if !attributes_box.is_empty() {
self.span_err(self.last_span, "expected item after attributes");
- attributes_box = ~[];
+ attributes_box = Vec::new();
}
self.bump(); // empty
}
}
_ => {
let stmt = self.parse_stmt(attributes_box);
- attributes_box = ~[];
+ attributes_box = Vec::new();
match stmt.node {
StmtExpr(e, stmt_id) => {
// expression without semicolon
}
}
- fn parse_generic_values_after_lt(&mut self) -> (OptVec<ast::Lifetime>, ~[P<Ty>]) {
+ fn parse_generic_values_after_lt(&mut self) -> (OptVec<ast::Lifetime>, Vec<P<Ty>> ) {
let lifetimes = self.parse_lifetimes();
let result = self.parse_seq_to_gt(
Some(token::COMMA),
}
fn parse_fn_args(&mut self, named_args: bool, allow_variadic: bool)
- -> (~[Arg], bool) {
+ -> (Vec<Arg> , bool) {
let sp = self.span;
- let mut args: ~[Option<Arg>] =
+ let mut args: Vec<Option<Arg>> =
self.parse_unspanned_seq(
&token::LPAREN,
&token::RPAREN,
fn_inputs
}
token::RPAREN => {
- ~[Arg::new_self(explicit_self_sp, mutbl_self)]
+ vec!(Arg::new_self(explicit_self_sp, mutbl_self))
}
_ => {
let token_str = self.this_token_to_str();
fn parse_fn_block_decl(&mut self) -> P<FnDecl> {
let inputs_captures = {
if self.eat(&token::OROR) {
- ~[]
+ Vec::new()
} else {
self.parse_unspanned_seq(
&token::BINOP(token::OR),
fn mk_item(&mut self, lo: BytePos, hi: BytePos, ident: Ident,
node: Item_, vis: Visibility,
- attrs: ~[Attribute]) -> @Item {
+ attrs: Vec<Attribute> ) -> @Item {
@Item {
ident: ident,
attrs: attrs,
}
// parse a method in a trait impl, starting with `attrs` attributes.
- fn parse_method(&mut self, already_parsed_attrs: Option<~[Attribute]>) -> @Method {
+ fn parse_method(&mut self, already_parsed_attrs: Option<Vec<Attribute> >) -> @Method {
let next_attrs = self.parse_outer_attributes();
let attrs = match already_parsed_attrs {
Some(mut a) => { a.push_all_move(next_attrs); a }
let (inner_attrs, body) = self.parse_inner_attrs_and_block();
let hi = body.span.hi;
- let attrs = vec::append(attrs, inner_attrs);
+ let attrs = vec_ng::append(attrs, inner_attrs.as_slice());
@ast::Method {
ident: ident,
attrs: attrs,
self.bump();
traits = self.parse_trait_ref_list(&token::LBRACE);
} else {
- traits = ~[];
+ traits = Vec::new();
}
let meths = self.parse_trait_methods();
None
};
- let mut meths = ~[];
+ let mut meths = Vec::new();
self.expect(&token::LBRACE);
let (inner_attrs, next) = self.parse_inner_attrs_and_next();
let mut method_attrs = Some(next);
}
// parse B + C<~str,int> + D
- fn parse_trait_ref_list(&mut self, ket: &token::Token) -> ~[TraitRef] {
+ fn parse_trait_ref_list(&mut self, ket: &token::Token) -> Vec<TraitRef> {
self.parse_seq_to_before_end(
ket,
seq_sep_trailing_disallowed(token::BINOP(token::PLUS)),
let class_name = self.parse_ident();
let generics = self.parse_generics();
- let mut fields: ~[StructField];
+ let mut fields: Vec<StructField> ;
let is_tuple_like;
if self.eat(&token::LBRACE) {
// It's a record-like struct.
is_tuple_like = false;
- fields = ~[];
+ fields = Vec::new();
while self.token != token::RBRACE {
fields.push(self.parse_struct_decl_field());
}
} else if self.eat(&token::SEMI) {
// It's a unit-like struct.
is_tuple_like = true;
- fields = ~[];
+ fields = Vec::new();
} else {
let token_str = self.this_token_to_str();
self.fatal(format!("expected `\\{`, `(`, or `;` after struct \
// parse a structure field declaration
pub fn parse_single_struct_field(&mut self,
vis: Visibility,
- attrs: ~[Attribute])
+ attrs: Vec<Attribute> )
-> StructField {
let a_var = self.parse_name_and_ty(vis, attrs);
match self.token {
// attributes (of length 0 or 1), parse all of the items in a module
fn parse_mod_items(&mut self,
term: token::Token,
- first_item_attrs: ~[Attribute])
+ first_item_attrs: Vec<Attribute> )
-> Mod {
// parse all of the items up to closing or an attribute.
// view items are legal here.
items: starting_items,
..
} = self.parse_items_and_view_items(first_item_attrs, true, true);
- let mut items: ~[@Item] = starting_items;
+ let mut items: Vec<@Item> = starting_items;
let attrs_remaining_len = attrs_remaining.len();
// don't think this other loop is even necessary....
while self.token != term {
let mut attrs = self.parse_outer_attributes();
if first {
- attrs = attrs_remaining + attrs;
+ attrs = vec_ng::append(attrs_remaining.clone(),
+ attrs.as_slice());
first = false;
}
debug!("parse_mod_items: parse_item_or_view_item(attrs={:?})",
id: ast::Ident,
outer_attrs: &[ast::Attribute],
id_sp: Span)
- -> (ast::Item_, ~[ast::Attribute]) {
+ -> (ast::Item_, Vec<ast::Attribute> ) {
let mut prefix = Path::new(self.sess.cm.span_to_filename(self.span));
prefix.pop();
- let mod_path = Path::new(".").join_many(self.mod_path_stack);
+ let mod_path = Path::new(".").join_many(self.mod_path_stack.as_slice());
let dir_path = prefix.join(&mod_path);
let file_path = match ::attr::first_attr_value_str_by_name(
outer_attrs, "path") {
};
self.eval_src_mod_from_path(file_path,
- outer_attrs.to_owned(),
+ outer_attrs.iter().map(|x| *x).collect(),
id_sp)
}
fn eval_src_mod_from_path(&mut self,
path: Path,
- outer_attrs: ~[ast::Attribute],
- id_sp: Span) -> (ast::Item_, ~[ast::Attribute]) {
+ outer_attrs: Vec<ast::Attribute> ,
+ id_sp: Span) -> (ast::Item_, Vec<ast::Attribute> ) {
{
let mut included_mod_stack = self.sess
.included_mod_stack
&path,
id_sp);
let (inner, next) = p0.parse_inner_attrs_and_next();
- let mod_attrs = vec::append(outer_attrs, inner);
+ let mod_attrs = vec_ng::append(outer_attrs, inner.as_slice());
let first_item_outer_attrs = next;
let m0 = p0.parse_mod_items(token::EOF, first_item_outer_attrs);
{
// parse a function declaration from a foreign module
fn parse_item_foreign_fn(&mut self, vis: ast::Visibility,
- attrs: ~[Attribute]) -> @ForeignItem {
+ attrs: Vec<Attribute> ) -> @ForeignItem {
let lo = self.span.lo;
// Parse obsolete purity.
// parse a static item from a foreign module
fn parse_item_foreign_static(&mut self, vis: ast::Visibility,
- attrs: ~[Attribute]) -> @ForeignItem {
+ attrs: Vec<Attribute> ) -> @ForeignItem {
let lo = self.span.lo;
self.expect_keyword(keywords::Static);
// parse_foreign_items.
fn parse_foreign_mod_items(&mut self,
abis: AbiSet,
- first_item_attrs: ~[Attribute])
+ first_item_attrs: Vec<Attribute> )
-> ForeignMod {
let ParsedItemsAndViewItems {
attrs_remaining: attrs_remaining,
fn parse_item_extern_crate(&mut self,
lo: BytePos,
visibility: Visibility,
- attrs: ~[Attribute])
+ attrs: Vec<Attribute> )
-> ItemOrViewItem {
let (maybe_path, ident) = match self.token {
lo: BytePos,
opt_abis: Option<AbiSet>,
visibility: Visibility,
- attrs: ~[Attribute])
+ attrs: Vec<Attribute> )
-> ItemOrViewItem {
self.expect(&token::LBRACE);
// parse a structure-like enum variant definition
// this should probably be renamed or refactored...
fn parse_struct_def(&mut self) -> @StructDef {
- let mut fields: ~[StructField] = ~[];
+ let mut fields: Vec<StructField> = Vec::new();
while self.token != token::RBRACE {
fields.push(self.parse_struct_decl_field());
}
// parse the part of an "enum" decl following the '{'
fn parse_enum_def(&mut self, _generics: &ast::Generics) -> EnumDef {
- let mut variants = ~[];
+ let mut variants = Vec::new();
let mut all_nullary = true;
let mut have_disr = false;
while self.token != token::RBRACE {
let ident;
let kind;
- let mut args = ~[];
+ let mut args = Vec::new();
let mut disr_expr = None;
ident = self.parse_ident();
if self.eat(&token::LBRACE) {
disr_expr = Some(self.parse_expr());
kind = TupleVariantKind(args);
} else {
- kind = TupleVariantKind(~[]);
+ kind = TupleVariantKind(Vec::new());
}
let vr = ast::Variant_ {
// NB: this function no longer parses the items inside an
// extern crate.
fn parse_item_or_view_item(&mut self,
- attrs: ~[Attribute],
+ attrs: Vec<Attribute> ,
macros_allowed: bool)
-> ItemOrViewItem {
match self.token {
INTERPOLATED(token::NtItem(item)) => {
self.bump();
- let new_attrs = vec::append(attrs, item.attrs);
+ let new_attrs = vec_ng::append(attrs, item.attrs.as_slice());
return IoviItem(@Item {
attrs: new_attrs,
..(*item).clone()
}
if self.eat_keyword(keywords::Mod) {
// MODULE ITEM
- let (ident, item_, extra_attrs) = self.parse_item_mod(attrs);
+ let (ident, item_, extra_attrs) =
+ self.parse_item_mod(attrs.as_slice());
let item = self.mk_item(lo,
self.last_span.hi,
ident,
// parse a foreign item; on failure, return IoviNone.
fn parse_foreign_item(&mut self,
- attrs: ~[Attribute],
+ attrs: Vec<Attribute> ,
macros_allowed: bool)
-> ItemOrViewItem {
maybe_whole!(iovi self, NtItem);
// this is the fall-through for parsing items.
fn parse_macro_use_or_failure(
&mut self,
- attrs: ~[Attribute],
+ attrs: Vec<Attribute> ,
macros_allowed: bool,
lo: BytePos,
visibility: Visibility
return IoviNone(attrs);
}
- pub fn parse_item(&mut self, attrs: ~[Attribute]) -> Option<@Item> {
+ pub fn parse_item(&mut self, attrs: Vec<Attribute> ) -> Option<@Item> {
match self.parse_item_or_view_item(attrs, true) {
IoviNone(_) => None,
IoviViewItem(_) =>
let path = ast::Path {
span: mk_sp(lo, self.span.hi),
global: false,
- segments: ~[]
+ segments: Vec::new()
};
return @spanned(lo, self.span.hi,
ViewPathList(path, idents, ast::DUMMY_NODE_ID));
}
let first_ident = self.parse_ident();
- let mut path = ~[first_ident];
+ let mut path = vec!(first_ident);
match self.token {
token::EQ => {
// x = foo::bar
self.bump();
let path_lo = self.span.lo;
- path = ~[self.parse_ident()];
+ path = vec!(self.parse_ident());
while self.token == token::MOD_SEP {
self.bump();
let id = self.parse_ident();
}
_ => ()
}
- let last = path[path.len() - 1u];
+ let last = *path.get(path.len() - 1u);
let path = ast::Path {
span: mk_sp(lo, self.span.hi),
global: false,
}
// matches view_paths = view_path | view_path , view_paths
- fn parse_view_paths(&mut self) -> ~[@ViewPath] {
- let mut vp = ~[self.parse_view_path()];
+ fn parse_view_paths(&mut self) -> Vec<@ViewPath> {
+ let mut vp = vec!(self.parse_view_path());
while self.token == token::COMMA {
self.bump();
self.obsolete(self.last_span, ObsoleteMultipleImport);
// - mod_items uses extern_mod_allowed = true
// - block_tail_ uses extern_mod_allowed = false
fn parse_items_and_view_items(&mut self,
- first_item_attrs: ~[Attribute],
+ first_item_attrs: Vec<Attribute> ,
mut extern_mod_allowed: bool,
macros_allowed: bool)
-> ParsedItemsAndViewItems {
- let mut attrs = vec::append(first_item_attrs,
- self.parse_outer_attributes());
+ let mut attrs = vec_ng::append(first_item_attrs,
+ self.parse_outer_attributes()
+ .as_slice());
// First, parse view items.
- let mut view_items : ~[ast::ViewItem] = ~[];
- let mut items = ~[];
+ let mut view_items : Vec<ast::ViewItem> = Vec::new();
+ let mut items = Vec::new();
// I think this code would probably read better as a single
// loop with a mutable three-state-variable (for extern crates,
attrs_remaining: attrs,
view_items: view_items,
items: items,
- foreign_items: ~[]
+ foreign_items: Vec::new()
}
}
IoviViewItem(view_item) => {
attrs_remaining: attrs,
view_items: view_items,
items: items,
- foreign_items: ~[]
+ foreign_items: Vec::new()
}
}
// Parses a sequence of foreign items. Stops when it finds program
// text that can't be parsed as an item
- fn parse_foreign_items(&mut self, first_item_attrs: ~[Attribute],
+ fn parse_foreign_items(&mut self, first_item_attrs: Vec<Attribute> ,
macros_allowed: bool)
-> ParsedItemsAndViewItems {
- let mut attrs = vec::append(first_item_attrs,
- self.parse_outer_attributes());
- let mut foreign_items = ~[];
+ let mut attrs = vec_ng::append(first_item_attrs,
+ self.parse_outer_attributes()
+ .as_slice());
+ let mut foreign_items = Vec::new();
loop {
match self.parse_foreign_item(attrs, macros_allowed) {
IoviNone(returned_attrs) => {
ParsedItemsAndViewItems {
attrs_remaining: attrs,
- view_items: ~[],
- items: ~[],
+ view_items: Vec::new(),
+ items: Vec::new(),
foreign_items: foreign_items
}
}
use std::fmt;
use std::local_data;
use std::path::BytesContainer;
+use std::vec_ng::Vec;
#[allow(non_camel_case_types)]
#[deriving(Clone, Encodable, Decodable, Eq, Hash, Show)]
NtAttr(@ast::Attribute), // #[foo]
NtPath(~ast::Path),
NtTT( @ast::TokenTree), // needs @ed to break a circularity
- NtMatchers(~[ast::Matcher])
+ NtMatchers(Vec<ast::Matcher> )
}
impl fmt::Show for Nonterminal {
// The indices here must correspond to the numbers in
// special_idents, in Keyword to_ident(), and in static
// constants below.
- let init_vec = ~[
- $( $si_str, )*
- $( $sk_str, )*
- $( $rk_str, )*
- ];
-
- interner::StrInterner::prefill(init_vec)
+ let mut init_vec = Vec::new();
+ $(init_vec.push($si_str);)*
+ $(init_vec.push($sk_str);)*
+ $(init_vec.push($rk_str);)*
+ interner::StrInterner::prefill(init_vec.as_slice())
}
}}
*/
use std::io;
-use std::vec;
+use std::vec_ng::Vec;
#[deriving(Clone, Eq)]
pub enum Breaks {
}
}
-pub fn buf_str(toks: ~[Token], szs: ~[int], left: uint, right: uint,
+pub fn buf_str(toks: Vec<Token> , szs: Vec<int> , left: uint, right: uint,
lim: uint) -> ~str {
let n = toks.len();
assert_eq!(n, szs.len());
if i != left {
s.push_str(", ");
}
- s.push_str(format!("{}={}", szs[i], tok_str(toks[i].clone())));
+ s.push_str(format!("{}={}", szs.get(i), tok_str(toks.get(i).clone())));
i += 1u;
i %= n;
}
// fall behind.
let n: uint = 3 * linewidth;
debug!("mk_printer {}", linewidth);
- let token: ~[Token] = vec::from_elem(n, Eof);
- let size: ~[int] = vec::from_elem(n, 0);
- let scan_stack: ~[uint] = vec::from_elem(n, 0u);
+ let token: Vec<Token> = Vec::from_elem(n, Eof);
+ let size: Vec<int> = Vec::from_elem(n, 0);
+ let scan_stack: Vec<uint> = Vec::from_elem(n, 0u);
Printer {
out: out,
buf_len: n,
scan_stack_empty: true,
top: 0,
bottom: 0,
- print_stack: ~[],
+ print_stack: Vec::new(),
pending_indentation: 0
}
}
space: int, // number of spaces left on line
left: uint, // index of left side of input stream
right: uint, // index of right side of input stream
- token: ~[Token], // ring-buffr stream goes through
- size: ~[int], // ring-buffer of calculated sizes
+ token: Vec<Token> , // ring-buffr stream goes through
+ size: Vec<int> , // ring-buffer of calculated sizes
left_total: int, // running size of stream "...left"
right_total: int, // running size of stream "...right"
// pseudo-stack, really a ring too. Holds the
// Begin (if there is any) on top of it. Stuff is flushed off the
// bottom as it becomes irrelevant due to the primary ring-buffer
// advancing.
- scan_stack: ~[uint],
+ scan_stack: Vec<uint> ,
scan_stack_empty: bool, // top==bottom disambiguator
top: uint, // index of top of scan_stack
bottom: uint, // index of bottom of scan_stack
// stack of blocks-in-progress being flushed by print
- print_stack: ~[PrintStackElem],
+ print_stack: Vec<PrintStackElem> ,
// buffered indentation to avoid writing trailing whitespace
pending_indentation: int,
}
impl Printer {
pub fn last_token(&mut self) -> Token {
- self.token[self.right].clone()
+ (*self.token.get(self.right)).clone()
}
// be very careful with this!
pub fn replace_last_token(&mut self, t: Token) {
- self.token[self.right] = t;
+ *self.token.get_mut(self.right) = t;
}
pub fn pretty_print(&mut self, t: Token) -> io::IoResult<()> {
debug!("pp ~[{},{}]", self.left, self.right);
Eof => {
if !self.scan_stack_empty {
self.check_stack(0);
- let left = self.token[self.left].clone();
- try!(self.advance_left(left, self.size[self.left]));
+ let left = (*self.token.get(self.left)).clone();
+ let left_size = *self.size.get(self.left);
+ try!(self.advance_left(left, left_size));
}
self.indent(0);
Ok(())
} else { self.advance_right(); }
debug!("pp Begin({})/buffer ~[{},{}]",
b.offset, self.left, self.right);
- self.token[self.right] = t;
- self.size[self.right] = -self.right_total;
+ *self.token.get_mut(self.right) = t;
+ *self.size.get_mut(self.right) = -self.right_total;
self.scan_push(self.right);
Ok(())
}
} else {
debug!("pp End/buffer ~[{},{}]", self.left, self.right);
self.advance_right();
- self.token[self.right] = t;
- self.size[self.right] = -1;
+ *self.token.get_mut(self.right) = t;
+ *self.size.get_mut(self.right) = -1;
self.scan_push(self.right);
Ok(())
}
b.offset, self.left, self.right);
self.check_stack(0);
self.scan_push(self.right);
- self.token[self.right] = t;
- self.size[self.right] = -self.right_total;
+ *self.token.get_mut(self.right) = t;
+ *self.size.get_mut(self.right) = -self.right_total;
self.right_total += b.blank_space;
Ok(())
}
debug!("pp String('{}')/buffer ~[{},{}]",
*s, self.left, self.right);
self.advance_right();
- self.token[self.right] = t.clone();
- self.size[self.right] = len;
+ *self.token.get_mut(self.right) = t.clone();
+ *self.size.get_mut(self.right) = len;
self.right_total += len;
self.check_stream()
}
debug!("scan window is {}, longer than space on line ({})",
self.right_total - self.left_total, self.space);
if !self.scan_stack_empty {
- if self.left == self.scan_stack[self.bottom] {
+ if self.left == *self.scan_stack.get(self.bottom) {
debug!("setting {} to infinity and popping", self.left);
- self.size[self.scan_pop_bottom()] = SIZE_INFINITY;
+ let scanned = self.scan_pop_bottom();
+ *self.size.get_mut(scanned) = SIZE_INFINITY;
}
}
- let left = self.token[self.left].clone();
- try!(self.advance_left(left, self.size[self.left]));
+ let left = (*self.token.get(self.left)).clone();
+ let left_size = *self.size.get(self.left);
+ try!(self.advance_left(left, left_size));
if self.left != self.right {
try!(self.check_stream());
}
self.top %= self.buf_len;
assert!((self.top != self.bottom));
}
- self.scan_stack[self.top] = x;
+ *self.scan_stack.get_mut(self.top) = x;
}
pub fn scan_pop(&mut self) -> uint {
assert!((!self.scan_stack_empty));
- let x = self.scan_stack[self.top];
+ let x = *self.scan_stack.get(self.top);
if self.top == self.bottom {
self.scan_stack_empty = true;
- } else { self.top += self.buf_len - 1u; self.top %= self.buf_len; }
+ } else {
+ self.top += self.buf_len - 1u; self.top %= self.buf_len;
+ }
return x;
}
pub fn scan_top(&mut self) -> uint {
assert!((!self.scan_stack_empty));
- return self.scan_stack[self.top];
+ return *self.scan_stack.get(self.top);
}
pub fn scan_pop_bottom(&mut self) -> uint {
assert!((!self.scan_stack_empty));
- let x = self.scan_stack[self.bottom];
+ let x = *self.scan_stack.get(self.bottom);
if self.top == self.bottom {
self.scan_stack_empty = true;
- } else { self.bottom += 1u; self.bottom %= self.buf_len; }
+ } else {
+ self.bottom += 1u; self.bottom %= self.buf_len;
+ }
return x;
}
pub fn advance_right(&mut self) {
if self.left != self.right {
self.left += 1u;
self.left %= self.buf_len;
- let left = self.token[self.left].clone();
- try!(self.advance_left(left, self.size[self.left]));
+ let left = (*self.token.get(self.left)).clone();
+ let left_size = *self.size.get(self.left);
+ try!(self.advance_left(left, left_size));
}
ret
} else {
pub fn check_stack(&mut self, k: int) {
if !self.scan_stack_empty {
let x = self.scan_top();
- match self.token[x] {
- Begin(_) => {
+ match self.token.get(x) {
+ &Begin(_) => {
if k > 0 {
- self.size[self.scan_pop()] = self.size[x] +
+ let popped = self.scan_pop();
+ *self.size.get_mut(popped) = *self.size.get(x) +
self.right_total;
self.check_stack(k - 1);
}
}
- End => {
+ &End => {
// paper says + not =, but that makes no sense.
- self.size[self.scan_pop()] = 1;
+ let popped = self.scan_pop();
+ *self.size.get_mut(popped) = 1;
self.check_stack(k + 1);
}
_ => {
- self.size[self.scan_pop()] = self.size[x] + self.right_total;
- if k > 0 { self.check_stack(k); }
+ let popped = self.scan_pop();
+ *self.size.get_mut(popped) = *self.size.get(x) +
+ self.right_total;
+ if k > 0 {
+ self.check_stack(k);
+ }
}
}
}
let print_stack = &mut self.print_stack;
let n = print_stack.len();
if n != 0u {
- print_stack[n - 1u]
+ *print_stack.get(n - 1u)
} else {
PrintStackElem {
offset: 0,
use std::str;
use std::io;
use std::io::MemWriter;
+use std::vec_ng::Vec;
// The &mut State is stored here to prevent recursive type.
pub enum AnnNode<'a, 'b> {
s: pp::Printer,
cm: Option<@CodeMap>,
intr: @token::IdentInterner,
- comments: Option<~[comments::Comment]>,
- literals: Option<~[comments::Literal]>,
+ comments: Option<Vec<comments::Comment> >,
+ literals: Option<Vec<comments::Literal> >,
cur_cmnt_and_lit: CurrentCommentAndLiteral,
- boxes: RefCell<~[pp::Breaks]>,
+ boxes: RefCell<Vec<pp::Breaks> >,
ann: &'a PpAnn
}
cur_cmnt: 0,
cur_lit: 0
},
- boxes: RefCell::new(~[]),
+ boxes: RefCell::new(Vec::new()),
ann: ann
}
}
cur_cmnt: 0,
cur_lit: 0
},
- boxes: RefCell::new(~[]),
+ boxes: RefCell::new(Vec::new()),
ann: ann
};
print_crate_(&mut s, krate)
}
pub fn print_crate_(s: &mut State, krate: &ast::Crate) -> io::IoResult<()> {
- try!(print_mod(s, &krate.module, krate.attrs));
+ try!(print_mod(s, &krate.module, krate.attrs.as_slice()));
try!(print_remaining_comments(s));
try!(eof(&mut s.s));
Ok(())
let boxes = s.boxes.borrow();
let len = boxes.get().len();
if len == 0u { return false; }
- return boxes.get()[len - 1u] == pp::Consistent;
+ return *boxes.get().get(len - 1u) == pp::Consistent;
}
pub fn hardbreak_if_not_bol(s: &mut State) -> io::IoResult<()> {
}
ast::TyTup(ref elts) => {
try!(popen(s));
- try!(commasep(s, Inconsistent, *elts, print_type_ref));
+ try!(commasep(s, Inconsistent, elts.as_slice(), print_type_ref));
if elts.len() == 1 {
try!(word(&mut s.s, ","));
}
item: &ast::ForeignItem) -> io::IoResult<()> {
try!(hardbreak_if_not_bol(s));
try!(maybe_print_comment(s, item.span.lo));
- try!(print_outer_attributes(s, item.attrs));
+ try!(print_outer_attributes(s, item.attrs.as_slice()));
match item.node {
ast::ForeignItemFn(decl, ref generics) => {
try!(print_fn(s, decl, None, AbiSet::Rust(), item.ident, generics,
pub fn print_item(s: &mut State, item: &ast::Item) -> io::IoResult<()> {
try!(hardbreak_if_not_bol(s));
try!(maybe_print_comment(s, item.span.lo));
- try!(print_outer_attributes(s, item.attrs));
+ try!(print_outer_attributes(s, item.attrs.as_slice()));
{
let ann_node = NodeItem(s, item);
try!(s.ann.pre(ann_node));
item.vis
));
try!(word(&mut s.s, " "));
- try!(print_block_with_attrs(s, body, item.attrs));
+ try!(print_block_with_attrs(s, body, item.attrs.as_slice()));
}
ast::ItemMod(ref _mod) => {
try!(head(s, visibility_qualified(item.vis, "mod")));
try!(print_ident(s, item.ident));
try!(nbsp(s));
try!(bopen(s));
- try!(print_mod(s, _mod, item.attrs));
+ try!(print_mod(s, _mod, item.attrs.as_slice()));
try!(bclose(s, item.span));
}
ast::ItemForeignMod(ref nmod) => {
try!(head(s, "extern"));
try!(word_nbsp(s, nmod.abis.to_str()));
try!(bopen(s));
- try!(print_foreign_mod(s, nmod, item.attrs));
+ try!(print_foreign_mod(s, nmod, item.attrs.as_slice()));
try!(bclose(s, item.span));
}
ast::ItemTy(ty, ref params) => {
try!(space(&mut s.s));
try!(bopen(s));
- try!(print_inner_attributes(s, item.attrs));
+ try!(print_inner_attributes(s, item.attrs.as_slice()));
for meth in methods.iter() {
try!(print_method(s, *meth));
}
try!(print_ident(s, ident));
try!(print_generics(s, generics));
try!(space(&mut s.s));
- try!(print_variants(s, enum_definition.variants, span));
+ try!(print_variants(s, enum_definition.variants.as_slice(), span));
Ok(())
}
for &v in variants.iter() {
try!(space_if_not_bol(s));
try!(maybe_print_comment(s, v.span.lo));
- try!(print_outer_attributes(s, v.node.attrs));
+ try!(print_outer_attributes(s, v.node.attrs.as_slice()));
try!(ibox(s, indent_unit));
try!(print_variant(s, v));
try!(word(&mut s.s, ","));
if ast_util::struct_def_is_tuple_like(struct_def) {
if !struct_def.fields.is_empty() {
try!(popen(s));
- try!(commasep(s, Inconsistent, struct_def.fields, |s, field| {
+ try!(commasep(s,
+ Inconsistent,
+ struct_def.fields.as_slice(),
+ |s, field| {
match field.node.kind {
ast::NamedField(..) => fail!("unexpected named field"),
ast::UnnamedField => {
ast::NamedField(ident, visibility) => {
try!(hardbreak_if_not_bol(s));
try!(maybe_print_comment(s, field.span.lo));
- try!(print_outer_attributes(s, field.node.attrs));
+ try!(print_outer_attributes(s,
+ field.node.attrs.as_slice()));
try!(print_visibility(s, visibility));
try!(print_ident(s, ident));
try!(word_nbsp(s, ":"));
arg: &ast::VariantArg) -> io::IoResult<()> {
print_type(s, arg.ty)
}
- try!(commasep(s, Consistent, *args, print_variant_arg));
+ try!(commasep(s,
+ Consistent,
+ args.as_slice(),
+ print_variant_arg));
try!(pclose(s));
}
}
pub fn print_ty_method(s: &mut State, m: &ast::TypeMethod) -> io::IoResult<()> {
try!(hardbreak_if_not_bol(s));
try!(maybe_print_comment(s, m.span.lo));
- try!(print_outer_attributes(s, m.attrs));
+ try!(print_outer_attributes(s, m.attrs.as_slice()));
try!(print_ty_fn(s,
None,
None,
pub fn print_method(s: &mut State, meth: &ast::Method) -> io::IoResult<()> {
try!(hardbreak_if_not_bol(s));
try!(maybe_print_comment(s, meth.span.lo));
- try!(print_outer_attributes(s, meth.attrs));
+ try!(print_outer_attributes(s, meth.attrs.as_slice()));
try!(print_fn(s, meth.decl, Some(meth.purity), AbiSet::Rust(),
meth.ident, &meth.generics, Some(meth.explicit_self.node),
meth.vis));
try!(word(&mut s.s, " "));
- print_block_with_attrs(s, meth.body, meth.attrs)
+ print_block_with_attrs(s, meth.body, meth.attrs.as_slice())
}
pub fn print_outer_attributes(s: &mut State,
try!(word(&mut s.s, "mut"));
if exprs.len() > 0u { try!(nbsp(s)); }
}
- try!(commasep_exprs(s, Inconsistent, *exprs));
+ try!(commasep_exprs(s, Inconsistent, exprs.as_slice()));
try!(word(&mut s.s, "]"));
try!(end(s));
}
ast::ExprStruct(ref path, ref fields, wth) => {
try!(print_path(s, path, true));
try!(word(&mut s.s, "{"));
- try!(commasep_cmnt(s, Consistent, (*fields), print_field, get_span));
+ try!(commasep_cmnt(s,
+ Consistent,
+ fields.as_slice(),
+ print_field,
+ get_span));
match wth {
Some(expr) => {
try!(ibox(s, indent_unit));
}
ast::ExprTup(ref exprs) => {
try!(popen(s));
- try!(commasep_exprs(s, Inconsistent, *exprs));
+ try!(commasep_exprs(s, Inconsistent, exprs.as_slice()));
if exprs.len() == 1 {
try!(word(&mut s.s, ","));
}
}
ast::ExprCall(func, ref args) => {
try!(print_expr(s, func));
- try!(print_call_post(s, *args));
+ try!(print_call_post(s, args.as_slice()));
}
ast::ExprMethodCall(ident, ref tys, ref args) => {
let base_args = args.slice_from(1);
- try!(print_expr(s, args[0]));
+ try!(print_expr(s, *args.get(0)));
try!(word(&mut s.s, "."));
try!(print_ident(s, ident));
if tys.len() > 0u {
try!(word(&mut s.s, "::<"));
- try!(commasep(s, Inconsistent, *tys, print_type_ref));
+ try!(commasep(s, Inconsistent, tys.as_slice(), print_type_ref));
try!(word(&mut s.s, ">"));
}
try!(print_call_post(s, base_args));
try!(print_ident(s, id));
if tys.len() > 0u {
try!(word(&mut s.s, "::<"));
- try!(commasep(s, Inconsistent, *tys, print_type_ref));
+ try!(commasep(s, Inconsistent, tys.as_slice(), print_type_ref));
try!(word(&mut s.s, ">"));
}
}
}
try!(commasep(s,
Inconsistent,
- segment.types.map_to_vec(|&t| t),
+ segment.types.map_to_vec(|&t| t).as_slice(),
print_type_ref));
}
Some(ref args) => {
if !args.is_empty() {
try!(popen(s));
- try!(commasep(s, Inconsistent, *args,
+ try!(commasep(s, Inconsistent, args.as_slice(),
|s, &p| print_pat(s, p)));
try!(pclose(s));
} else { }
Ok(())
}
fn get_span(f: &ast::FieldPat) -> codemap::Span { return f.pat.span; }
- try!(commasep_cmnt(s, Consistent, *fields,
+ try!(commasep_cmnt(s, Consistent, fields.as_slice(),
|s, f| print_field(s,f),
get_span));
if etc {
}
ast::PatTup(ref elts) => {
try!(popen(s));
- try!(commasep(s, Inconsistent, *elts, |s, &p| print_pat(s, p)));
+ try!(commasep(s,
+ Inconsistent,
+ elts.as_slice(),
+ |s, &p| print_pat(s, p)));
if elts.len() == 1 {
try!(word(&mut s.s, ","));
}
}
ast::PatVec(ref before, slice, ref after) => {
try!(word(&mut s.s, "["));
- try!(commasep(s, Inconsistent, *before, |s, &p| print_pat(s, p)));
+ try!(commasep(s,
+ Inconsistent,
+ before.as_slice(),
+ |s, &p| print_pat(s, p)));
for &p in slice.iter() {
if !before.is_empty() { try!(word_space(s, ",")); }
match *p {
try!(print_pat(s, p));
if !after.is_empty() { try!(word_space(s, ",")); }
}
- try!(commasep(s, Inconsistent, *after, |s, &p| print_pat(s, p)));
+ try!(commasep(s,
+ Inconsistent,
+ after.as_slice(),
+ |s, &p| print_pat(s, p)));
try!(word(&mut s.s, "]"));
}
}
for &explicit_self in opt_explicit_self.iter() {
let m = match explicit_self {
ast::SelfStatic => ast::MutImmutable,
- _ => match decl.inputs[0].pat.node {
+ _ => match decl.inputs.get(0).pat.node {
ast::PatIdent(ast::BindByValue(m), _, _) => m,
_ => ast::MutImmutable
}
}
}
- let mut ints = ~[];
+ let mut ints = Vec::new();
for i in range(0u, total) {
ints.push(i);
}
- try!(commasep(s, Inconsistent, ints,
+ try!(commasep(s, Inconsistent, ints.as_slice(),
|s, &i| print_item(s, generics, i)));
try!(word(&mut s.s, ">"));
}
try!(print_path(s, path, false));
try!(word(&mut s.s, "::{"));
}
- try!(commasep(s, Inconsistent, (*idents), |s, w| {
+ try!(commasep(s, Inconsistent, idents.as_slice(), |s, w| {
print_ident(s, w.node.name)
}));
word(&mut s.s, "}")
pub fn print_view_item(s: &mut State, item: &ast::ViewItem) -> io::IoResult<()> {
try!(hardbreak_if_not_bol(s));
try!(maybe_print_comment(s, item.span.lo));
- try!(print_outer_attributes(s, item.attrs));
+ try!(print_outer_attributes(s, item.attrs.as_slice()));
try!(print_visibility(s, item.vis));
match item.node {
ast::ViewItemExternMod(id, ref optional_path, _) => {
ast::ViewItemUse(ref vps) => {
try!(head(s, "use"));
- try!(print_view_paths(s, *vps));
+ try!(print_view_paths(s, vps.as_slice()));
}
}
try!(word(&mut s.s, ";"));
match input.pat.node {
ast::PatIdent(_, ref path, _) if
path.segments.len() == 1 &&
- path.segments[0].identifier.name ==
+ path.segments.get(0).identifier.name ==
parse::token::special_idents::invalid.name => {
// Do nothing.
}
ast::LitBinary(ref arr) => {
try!(ibox(s, indent_unit));
try!(word(&mut s.s, "["));
- try!(commasep_cmnt(s, Inconsistent, *arr.borrow(),
+ try!(commasep_cmnt(s, Inconsistent, arr.borrow().as_slice(),
|s, u| word(&mut s.s, format!("{}", *u)),
|_| lit.span));
try!(word(&mut s.s, "]"));
match s.literals {
Some(ref lits) => {
while s.cur_cmnt_and_lit.cur_lit < lits.len() {
- let ltrl = (*lits)[s.cur_cmnt_and_lit.cur_lit].clone();
+ let ltrl = (*(*lits).get(s.cur_cmnt_and_lit.cur_lit)).clone();
if ltrl.pos > pos { return None; }
s.cur_cmnt_and_lit.cur_lit += 1u;
if ltrl.pos == pos { return Some(ltrl); }
comments::Mixed => {
assert_eq!(cmnt.lines.len(), 1u);
try!(zerobreak(&mut s.s));
- try!(word(&mut s.s, cmnt.lines[0]));
+ try!(word(&mut s.s, *cmnt.lines.get(0)));
try!(zerobreak(&mut s.s));
}
comments::Isolated => {
comments::Trailing => {
try!(word(&mut s.s, " "));
if cmnt.lines.len() == 1u {
- try!(word(&mut s.s, cmnt.lines[0]));
+ try!(word(&mut s.s, *cmnt.lines.get(0)));
try!(hardbreak(&mut s.s));
} else {
try!(ibox(s, 0u));
match s.comments {
Some(ref cmnts) => {
if s.cur_cmnt_and_lit.cur_cmnt < cmnts.len() {
- Some(cmnts[s.cur_cmnt_and_lit.cur_cmnt].clone())
+ Some((*cmnts.get(s.cur_cmnt_and_lit.cur_cmnt)).clone())
} else {
None
}
use codemap;
use parse::token;
+ use std::vec_ng::Vec;
+
#[test]
fn test_fun_to_str() {
let abba_ident = token::str_to_ident("abba");
let decl = ast::FnDecl {
- inputs: ~[],
+ inputs: Vec::new(),
output: ast::P(ast::Ty {id: 0,
node: ast::TyNil,
span: codemap::DUMMY_SP}),
let var = codemap::respan(codemap::DUMMY_SP, ast::Variant_ {
name: ident,
- attrs: ~[],
+ attrs: Vec::new(),
// making this up as I go.... ?
- kind: ast::TupleVariantKind(~[]),
+ kind: ast::TupleVariantKind(Vec::new()),
id: 0,
disr_expr: None,
vis: ast::Public,
use std::fmt;
use std::hash::Hash;
use std::rc::Rc;
+use std::vec_ng::Vec;
pub struct Interner<T> {
priv map: RefCell<HashMap<T, Name>>,
- priv vect: RefCell<~[T]>,
+ priv vect: RefCell<Vec<T> >,
}
// when traits can extend traits, we should extend index<Name,T> to get []
pub fn new() -> Interner<T> {
Interner {
map: RefCell::new(HashMap::new()),
- vect: RefCell::new(~[]),
+ vect: RefCell::new(Vec::new()),
}
}
pub fn get(&self, idx: Name) -> T {
let vect = self.vect.borrow();
- vect.get()[idx].clone()
+ (*vect.get().get(idx as uint)).clone()
}
pub fn len(&self) -> uint {
// &str rather than RcStr, resulting in less allocation.
pub struct StrInterner {
priv map: RefCell<HashMap<RcStr, Name>>,
- priv vect: RefCell<~[RcStr]>,
+ priv vect: RefCell<Vec<RcStr> >,
}
// when traits can extend traits, we should extend index<Name,T> to get []
pub fn new() -> StrInterner {
StrInterner {
map: RefCell::new(HashMap::new()),
- vect: RefCell::new(~[]),
+ vect: RefCell::new(Vec::new()),
}
}
let new_idx = self.len() as Name;
// leave out of map to avoid colliding
let mut vect = self.vect.borrow_mut();
- let existing = vect.get()[idx].clone();
+ let existing = (*vect.get().get(idx as uint)).clone();
vect.get().push(existing);
new_idx
}
pub fn get(&self, idx: Name) -> RcStr {
let vect = self.vect.borrow();
- vect.get()[idx].clone()
+ (*vect.get().get(idx as uint)).clone()
}
/// Returns this string with lifetime tied to the interner. Since
/// strings may never be removed from the interner, this is safe.
pub fn get_ref<'a>(&'a self, idx: Name) -> &'a str {
let vect = self.vect.borrow();
- let s: &str = vect.get()[idx].as_slice();
+ let s: &str = vect.get().get(idx as uint).as_slice();
unsafe {
cast::transmute(s)
}
use parse::parser::Parser;
use parse::token;
+use std::vec_ng::Vec;
+
// map a string to tts, using a made-up filename: return both the TokenTree's
// and the ParseSess
-pub fn string_to_tts_and_sess (source_str : ~str) -> (~[ast::TokenTree], @ParseSess) {
+pub fn string_to_tts_and_sess (source_str : ~str) -> (Vec<ast::TokenTree> , @ParseSess) {
let ps = new_parse_sess();
(filemap_to_tts(ps,string_to_filemap(ps,source_str,~"bogofile")),ps)
}
// map a string to tts, using a made-up filename:
-pub fn string_to_tts(source_str : ~str) -> ~[ast::TokenTree] {
+pub fn string_to_tts(source_str : ~str) -> Vec<ast::TokenTree> {
let (tts,_) = string_to_tts_and_sess(source_str);
tts
}
pub fn string_to_parser_and_sess(source_str: ~str) -> (Parser,@ParseSess) {
let ps = new_parse_sess();
- (new_parser_from_source_str(ps,~[],~"bogofile",source_str),ps)
+ (new_parser_from_source_str(ps,Vec::new(),~"bogofile",source_str),ps)
}
// map string to parser (via tts)
// parse a string, return an item
pub fn string_to_item (source_str : ~str) -> Option<@ast::Item> {
with_error_checking_parse(source_str, |p| {
- p.parse_item(~[])
+ p.parse_item(Vec::new())
})
}
// parse a string, return a stmt
pub fn string_to_stmt(source_str : ~str) -> @ast::Stmt {
with_error_checking_parse(source_str, |p| {
- p.parse_stmt(~[])
+ p.parse_stmt(Vec::new())
})
}
}
// convert a vector of strings to a vector of ast::Ident's
-pub fn strs_to_idents(ids: ~[&str]) -> ~[ast::Ident] {
+pub fn strs_to_idents(ids: Vec<&str> ) -> Vec<ast::Ident> {
ids.map(|u| token::str_to_ident(*u))
}
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+
use std::mem;
-use std::vec;
+use std::vec_ng::Vec;
+use std::vec_ng;
/// A vector type optimized for cases where the size is almost always 0 or 1
pub enum SmallVector<T> {
priv Zero,
priv One(T),
- priv Many(~[T]),
+ priv Many(Vec<T> ),
}
impl<T> Container for SmallVector<T> {
One(v)
}
- pub fn many(vs: ~[T]) -> SmallVector<T> {
+ pub fn many(vs: Vec<T> ) -> SmallVector<T> {
Many(vs)
}
One(..) => {
let one = mem::replace(self, Zero);
match one {
- One(v1) => mem::replace(self, Many(~[v1, v])),
+ One(v1) => mem::replace(self, Many(vec!(v1, v))),
_ => unreachable!()
};
}
pub fn get<'a>(&'a self, idx: uint) -> &'a T {
match *self {
One(ref v) if idx == 0 => v,
- Many(ref vs) => &vs[idx],
+ Many(ref vs) => vs.get(idx),
_ => fail!("out of bounds access")
}
}
pub enum MoveItems<T> {
priv ZeroIterator,
priv OneIterator(T),
- priv ManyIterator(vec::MoveItems<T>),
+ priv ManyIterator(vec_ng::MoveItems<T>),
}
impl<T> Iterator<T> for MoveItems<T> {
mod test {
use super::*;
+ use std::vec_ng::Vec;
+
#[test]
fn test_len() {
let v: SmallVector<int> = SmallVector::zero();
assert_eq!(0, v.len());
assert_eq!(1, SmallVector::one(1).len());
- assert_eq!(5, SmallVector::many(~[1, 2, 3, 4, 5]).len());
+ assert_eq!(5, SmallVector::many(vec!(1, 2, 3, 4, 5)).len());
}
#[test]
#[test]
fn test_from_iterator() {
- let v: SmallVector<int> = (~[1, 2, 3]).move_iter().collect();
+ let v: SmallVector<int> = (vec!(1, 2, 3)).move_iter().collect();
assert_eq!(3, v.len());
assert_eq!(&1, v.get(0));
assert_eq!(&2, v.get(1));
#[test]
fn test_move_iter() {
let v = SmallVector::zero();
- let v: ~[int] = v.move_iter().collect();
- assert_eq!(~[], v);
+ let v: Vec<int> = v.move_iter().collect();
+ assert_eq!(Vec::new(), v);
let v = SmallVector::one(1);
- assert_eq!(~[1], v.move_iter().collect());
+ assert_eq!(vec!(1), v.move_iter().collect());
- let v = SmallVector::many(~[1, 2, 3]);
- assert_eq!(~[1, 2, 3], v.move_iter().collect());
+ let v = SmallVector::many(vec!(1, 2, 3));
+ assert_eq!(vec!(1, 2, 3), v.move_iter().collect());
}
#[test]
#[test]
#[should_fail]
fn test_expect_one_many() {
- SmallVector::many(~[1, 2]).expect_one("");
+ SmallVector::many(vec!(1, 2)).expect_one("");
}
#[test]
fn test_expect_one_one() {
assert_eq!(1, SmallVector::one(1).expect_one(""));
- assert_eq!(1, SmallVector::many(~[1]).expect_one(""));
+ assert_eq!(1, SmallVector::many(vec!(1)).expect_one(""));
}
}
visitor.visit_expr(subexpression, env.clone())
}
ExprVec(ref subexpressions, _) => {
- walk_exprs(visitor, *subexpressions, env.clone())
+ walk_exprs(visitor, subexpressions.as_slice(), env.clone())
}
ExprRepeat(element, count, _) => {
visitor.visit_expr(element, env.clone());
visitor.visit_expr(callee_expression, env.clone())
}
ExprMethodCall(_, ref types, ref arguments) => {
- walk_exprs(visitor, *arguments, env.clone());
+ walk_exprs(visitor, arguments.as_slice(), env.clone());
for &typ in types.iter() {
visitor.visit_ty(typ, env.clone())
}
projects / rust.git / commitdiff