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

Remove legacy object creation mode, and convert remaining uses of it

Browse Source
This commit is contained in:
Niko Matsakis 2013-02-26 21:42:00 -05:00
parent 5680ec0270
commit 4ecb672d7f
54 changed files with 292 additions and 351 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/libcore/io.rs
View File

@ -504,7 +504,7 @@ pub fn FILE_reader(f: *libc::FILE, cleanup: bool) -> @Reader {
pub fn stdin() -> @Reader {
unsafe {
rustrt::rust_get_stdin() as @Reader
@rustrt::rust_get_stdin() as @Reader
}
}
@ -642,11 +642,11 @@ impl Writer for *libc::FILE {
}
}
pub fn FILE_writer(f: *libc::FILE, cleanup: bool) -> Writer {
pub fn FILE_writer(f: *libc::FILE, cleanup: bool) -> @Writer {
if cleanup {
Wrapper { base: f, cleanup: FILERes(f) } as Writer
@Wrapper { base: f, cleanup: FILERes(f) } as @Writer
} else {
f as Writer
@f as @Writer
}
}
@ -702,11 +702,11 @@ pub fn FdRes(fd: fd_t) -> FdRes {
}
}
pub fn fd_writer(fd: fd_t, cleanup: bool) -> Writer {
pub fn fd_writer(fd: fd_t, cleanup: bool) -> @Writer {
if cleanup {
Wrapper { base: fd, cleanup: FdRes(fd) } as Writer
@Wrapper { base: fd, cleanup: FdRes(fd) } as @Writer
} else {
fd as Writer
@fd as @Writer
}
}

12
src/libcore/rand.rs
View File

@ -412,8 +412,8 @@ pub fn Rng() -> Rng {
* all other generators constructed with the same seed. The seed may be any
* length.
*/
pub fn seeded_rng(seed: &[u8]) -> Rng {
seeded_randres(seed) as Rng
pub fn seeded_rng(seed: &[u8]) -> @Rng {
@seeded_randres(seed) as @Rng
}
fn seeded_randres(seed: &[u8]) -> @RandRes {
@ -449,8 +449,8 @@ pub pure fn xorshift() -> Rng {
seeded_xorshift(123456789u32, 362436069u32, 521288629u32, 88675123u32)
}
pub pure fn seeded_xorshift(x: u32, y: u32, z: u32, w: u32) -> Rng {
XorShiftState { x: x, y: y, z: z, w: w } as Rng
pub pure fn seeded_xorshift(x: u32, y: u32, z: u32, w: u32) -> @Rng {
@XorShiftState { x: x, y: y, z: z, w: w } as @Rng
}
@ -472,10 +472,10 @@ pub fn task_rng() -> Rng {
unsafe {
let rng = seeded_randres(seed());
task::local_data::local_data_set(tls_rng_state, rng);
rng as Rng
@rng as @Rng
}
}
Some(rng) => rng as Rng
Some(rng) => @rng as @Rng
}
}

4
src/libcore/repr.rs
View File

@ -201,7 +201,7 @@ pub impl ReprVisitor {
unsafe {
let mut u = ReprVisitor(ptr, self.writer);
let v = reflect::MovePtrAdaptor(u);
visit_tydesc(inner, (v) as @TyVisitor);
visit_tydesc(inner, @v as @TyVisitor);
true
}
}
@ -570,7 +570,7 @@ pub fn write_repr<T>(writer: @Writer, object: &T) {
let tydesc = intrinsic::get_tydesc::<T>();
let mut u = ReprVisitor(ptr, writer);
let v = reflect::MovePtrAdaptor(u);
visit_tydesc(tydesc, (v) as @TyVisitor)
visit_tydesc(tydesc, @v as @TyVisitor)
}
}

2
src/libcore/run.rs
View File

@ -288,7 +288,7 @@ pub fn start_program(prog: &str, args: &[~str]) -> Program {
finished: false,
};
ProgRes(repr) as Program
@ProgRes(repr) as @Program
}
fn read_all(rd: io::Reader) -> ~str {

2
src/libcore/task/local_data_priv.rs
View File

@ -155,7 +155,7 @@ pub unsafe fn local_set<T:Durable>(
// does not have a reference associated with it, so it may become invalid
// when the box is destroyed.
let data_ptr = cast::reinterpret_cast(&data);
let data_box = data as LocalData;
let data_box = @data as @LocalData;
// Construct new entry to store in the map.
let new_entry = Some((keyval, data_ptr, data_box));
// Find a place to put it.

5
src/librustc/metadata/common.rs
View File

@ -132,9 +132,8 @@ pub enum astencode_tag { // Reserves 0x50 -- 0x6f
tag_table_method_map = 0x60,
tag_table_vtable_map = 0x61,
tag_table_adjustments = 0x62,
tag_table_legacy_boxed_trait = 0x63,
tag_table_moves_map = 0x64,
tag_table_capture_map = 0x65
tag_table_moves_map = 0x63,
tag_table_capture_map = 0x64
}
pub const tag_item_trait_method_sort: uint = 0x70;

4
src/librustc/metadata/filesearch.rs
View File

@ -71,11 +71,11 @@ pub fn mk_filesearch(maybe_sysroot: Option<Path>,
let sysroot = get_sysroot(maybe_sysroot);
debug!("using sysroot = %s", sysroot.to_str());
FileSearchImpl {
@FileSearchImpl {
sysroot: sysroot,
addl_lib_search_paths: addl_lib_search_paths,
target_triple: str::from_slice(target_triple)
} as FileSearch
} as @FileSearch
}
pub fn search<T:Copy>(filesearch: FileSearch, pick: pick<T>) -> Option<T> {

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

@ -966,12 +966,6 @@ fn encode_side_tables_for_id(ecx: @e::EncodeContext,
}
}
do option::iter(&tcx.legacy_boxed_traits.find(&id)) |_x| {
do ebml_w.tag(c::tag_table_legacy_boxed_trait) {
ebml_w.id(id);
}
}
for maps.moves_map.find(&id).each |_| {
do ebml_w.tag(c::tag_table_moves_map) {
ebml_w.id(id);
@ -1121,8 +1115,6 @@ fn decode_side_tables(xcx: @ExtendedDecodeContext,
if tag == (c::tag_table_mutbl as uint) {
dcx.maps.mutbl_map.insert(id, ());
} else if tag == (c::tag_table_legacy_boxed_trait as uint) {
dcx.tcx.legacy_boxed_traits.insert(id, ());
} else if tag == (c::tag_table_moves_map as uint) {
dcx.maps.moves_map.insert(id, ());
} else {
@ -1230,7 +1222,7 @@ impl fake_ext_ctxt for fake_session {
#[cfg(test)]
fn mk_ctxt() -> fake_ext_ctxt {
parse::new_parse_sess(None) as fake_ext_ctxt
@parse::new_parse_sess(None) as fake_ext_ctxt
}
#[cfg(test)]

4
src/librustc/middle/trans/cabi.rs
View File

@ -209,8 +209,8 @@ impl ABIInfo for LLVM_ABIInfo {
}
}
pub fn llvm_abi_info() -> ABIInfo {
return LLVM_ABIInfo as ABIInfo;
pub fn llvm_abi_info() -> @ABIInfo {
return @LLVM_ABIInfo as @ABIInfo;
}

4
src/librustc/middle/trans/cabi_arm.rs
View File

@ -159,6 +159,6 @@ impl ABIInfo for ARM_ABIInfo {
}
}
pub fn abi_info() -> ABIInfo {
return ARM_ABIInfo as ABIInfo;
pub fn abi_info() -> @ABIInfo {
return @ARM_ABIInfo as @ABIInfo;
}

2
src/librustc/middle/trans/cabi_x86_64.rs
View File

@ -408,5 +408,5 @@ impl ABIInfo for X86_64_ABIInfo {
}
pub fn x86_64_abi_info() -> ABIInfo {
return X86_64_ABIInfo as ABIInfo;
return @X86_64_ABIInfo as @ABIInfo;
}

25
src/librustc/middle/trans/meth.rs
View File

@ -870,26 +870,11 @@ pub fn trans_trait_cast(bcx: block,
match vstore {
ty::vstore_slice(*) | ty::vstore_box => {
let mut llboxdest = GEPi(bcx, lldest, [0u, 1u]);
if bcx.tcx().legacy_boxed_traits.contains_key(&id) {
// Allocate an @ box and store the value into it
let MallocResult {bcx: new_bcx, box: llbox, body: body} =
malloc_boxed(bcx, v_ty);
bcx = new_bcx;
add_clean_free(bcx, llbox, heap_managed);
bcx = expr::trans_into(bcx, val, SaveIn(body));
revoke_clean(bcx, llbox);
// Store the @ box into the pair
Store(bcx, llbox, PointerCast(bcx,
llboxdest,
T_ptr(val_ty(llbox))));
} else {
// Just store the pointer into the pair.
llboxdest = PointerCast(bcx,
llboxdest,
T_ptr(type_of(bcx.ccx(), v_ty)));
bcx = expr::trans_into(bcx, val, SaveIn(llboxdest));
}
// Just store the pointer into the pair.
llboxdest = PointerCast(bcx,
llboxdest,
T_ptr(type_of(bcx.ccx(), v_ty)));
bcx = expr::trans_into(bcx, val, SaveIn(llboxdest));
}
ty::vstore_uniq => {
// Translate the uniquely-owned value into the second element of

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

@ -269,7 +269,6 @@ struct ctxt_ {
adjustments: HashMap<ast::node_id, @AutoAdjustment>,
normalized_cache: HashMap<t, t>,
lang_items: middle::lang_items::LanguageItems,
legacy_boxed_traits: HashMap<node_id, ()>,
// A mapping from an implementation ID to the method info and trait
// method ID of the provided (a.k.a. default) methods in the traits that
// that implementation implements.
@ -831,7 +830,6 @@ pub fn mk_ctxt(s: session::Session,
adjustments: HashMap(),
normalized_cache: new_ty_hash(),
lang_items: lang_items,
legacy_boxed_traits: HashMap(),
provided_methods: HashMap(),
provided_method_sources: HashMap(),
supertraits: HashMap(),

224
src/librustc/middle/typeck/check/vtable.rs
View File

@ -97,8 +97,8 @@ pub fn lookup_vtables(vcx: &VtableContext,
let mut result = ~[], i = 0u;
for substs.tps.each |ty| {
for ty::iter_bound_traits_and_supertraits(
tcx, bounds[i]) |trait_ty| {
tcx, bounds[i]) |trait_ty|
{
debug!("about to subst: %?, %?",
ppaux::ty_to_str(tcx, trait_ty),
ty::substs_to_str(tcx, substs));
@ -585,138 +585,102 @@ pub fn early_resolve_expr(ex: @ast::expr,
}
}
ast::expr_cast(src, _) => {
let target_ty = fcx.expr_ty(ex);
match ty::get(target_ty).sty {
ty::ty_trait(_, _, vstore) => {
// Look up vtables for the type we're casting to, passing in the
// source and target type.
//
// XXX: This is invariant and shouldn't be. --pcw
let target_ty = fcx.expr_ty(ex);
match ty::get(target_ty).sty {
ty::ty_trait(_, _, vstore) => {
// Look up vtables for the type we're casting to,
// passing in the source and target type. The source
// must be a pointer type suitable to the object sigil,
// e.g.: `@x as @Trait`, `&x as &Trait` or `~x as ~Trait`
let ty = structurally_resolved_type(fcx, ex.span,
fcx.expr_ty(src));
match (&ty::get(ty).sty, vstore) {
(&ty::ty_box(mt), ty::vstore_box) |
(&ty::ty_uniq(mt), ty::vstore_uniq) |
(&ty::ty_rptr(_, mt), ty::vstore_slice(*)) => {
let location_info =
&location_info_for_expr(ex);
let vcx = VtableContext {
ccx: fcx.ccx,
infcx: fcx.infcx()
};
let vtable_opt =
lookup_vtable(&vcx,
location_info,
mt.ty,
target_ty,
true,
is_early);
match vtable_opt {
Some(vtable) => {
// Map this expression to that
// vtable (that is: "ex has vtable
// <vtable>")
if !is_early {
let vtable_map =
cx.vtable_map;
vtable_map.insert(ex.id,
@~[vtable]);
}
}
None => {
fcx.tcx().sess.span_err(
ex.span,
fmt!("failed to find an implementation \
of trait %s for %s",
fcx.infcx().ty_to_str(target_ty),
fcx.infcx().ty_to_str(mt.ty)));
}
}
let ty = fcx.expr_ty(src);
let vcx = VtableContext { ccx: fcx.ccx, infcx: fcx.infcx() };
let vtable_opt =
lookup_vtable(&vcx,
&location_info_for_expr(ex),
ty,
target_ty,
true,
is_early);
match vtable_opt {
None => {
// Try the new-style boxed trait; "@int as @Trait".
// Or the new-style region trait; "&int as &Trait".
// Or the new-style uniquely-owned trait; "~int as
// ~Trait".
let mut err = false;
let ty = structurally_resolved_type(fcx, ex.span, ty);
match ty::get(ty).sty {
ty::ty_box(mt) | ty::ty_rptr(_, mt) |
ty::ty_uniq(mt) => {
// Ensure that the trait vstore and the pointer
// type match.
match (&ty::get(ty).sty, vstore) {
(&ty::ty_box(_), ty::vstore_box) |
(&ty::ty_uniq(_), ty::vstore_uniq) |
(&ty::ty_rptr(*), ty::vstore_slice(*)) => {
let location_info =
&location_info_for_expr(ex);
let vtable_opt =
lookup_vtable(&vcx,
location_info,
mt.ty,
target_ty,
true,
is_early);
match vtable_opt {
Some(vtable) => {
// Map this expression to that
// vtable (that is: "ex has vtable
// <vtable>")
if !is_early {
let vtable_map =
cx.vtable_map;
vtable_map.insert(ex.id,
@~[vtable]);
}
}
None => err = true
}
// Now, if this is &trait, we need to link the
// regions.
match (&ty::get(ty).sty, vstore) {
(&ty::ty_rptr(ra, _),
ty::vstore_slice(rb)) => {
infer::mk_subr(fcx.infcx(),
false,
ex.span,
rb,
ra);
}
_ => {}
}
}
// Now, if this is &trait, we need to link
// the regions.
match (&ty::get(ty).sty, vstore) {
(&ty::ty_rptr(ra, _),
ty::vstore_slice(rb)) => {
infer::mk_subr(fcx.infcx(),
false,
ex.span,
rb,
ra);
}
_ => {}
}
}
(&ty::ty_box(_), _) => {
fcx.ccx.tcx.sess.span_err(ex.span,
~"must cast \
a boxed \
pointer to \
a boxed
trait");
err = true;
}
(&ty::ty_rptr(*), _) => {
fcx.ccx.tcx.sess.span_err(ex.span,
~"must cast \
a borrowed \
pointer to \
a borrowed \
trait");
}
(&ty::ty_uniq(*), _) => {
fcx.ccx.tcx.sess.span_err(ex.span,
~"must cast \
a unique \
pointer to \
a uniquely-\
owned trait");
}
_ => {
fcx.ccx.tcx.sess.impossible_case(
ex.span,
~"impossible combination of type and \
trait vstore");
}
}
}
_ => err = true
}
(_, ty::vstore_box(*)) => {
fcx.ccx.tcx.sess.span_err(
ex.span,
fmt!("can only cast an @-pointer \
to an @-object, not a %s",
ty::ty_sort_str(fcx.tcx(), ty)));
}
if err {
fcx.tcx().sess.span_fatal(
ex.span,
fmt!("failed to find an implementation of trait \
%s for %s",
fcx.infcx().ty_to_str(target_ty),
fcx.infcx().ty_to_str(ty)));
}
}
Some(vtable) => {
/*
Map this expression to that vtable (that is: "ex has
vtable <vtable>")
*/
if !is_early {
let vtable_map = cx.vtable_map;
vtable_map.insert(ex.id, @~[vtable]);
}
fcx.tcx().legacy_boxed_traits.insert(ex.id, ());
}
}
(_, ty::vstore_uniq(*)) => {
fcx.ccx.tcx.sess.span_err(
ex.span,
fmt!("can only cast an ~-pointer \
to a ~-object, not a %s",
ty::ty_sort_str(fcx.tcx(), ty)));
}
(_, ty::vstore_slice(*)) => {
fcx.ccx.tcx.sess.span_err(
ex.span,
fmt!("can only cast an &-pointer \
to an &-object, not a %s",
ty::ty_sort_str(fcx.tcx(), ty)));
}
(_, ty::vstore_fixed(*)) => {
fcx.tcx().sess.span_bug(
ex.span,
fmt!("trait with fixed vstore"));
}
}
}
_ => { /* not a cast to a trait; ignore */ }
}
_ => ()
}
}
_ => ()
}

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

@ -70,11 +70,11 @@ pub fn bound_self_region(rp: Option<ty::region_variance>)
}
}
pub struct anon_rscope { anon: ty::Region, base: region_scope }
pub struct anon_rscope { anon: ty::Region, base: @region_scope }
pub fn in_anon_rscope<RS:region_scope + Copy + Durable>(self: RS,
r: ty::Region)
-> @anon_rscope {
@anon_rscope {anon: r, base: self as region_scope}
@anon_rscope {anon: r, base: @self as @region_scope}
}
impl region_scope for @anon_rscope {
@ -97,7 +97,7 @@ pub struct binding_rscope {
pub fn in_binding_rscope<RS:region_scope + Copy + Durable>(self: RS)
-> @mut binding_rscope {
let base = self as region_scope;
let base = @self as @region_scope;
@mut binding_rscope { base: base, anon_bindings: 0 }
}

4
src/libstd/sha1.rs
View File

@ -63,7 +63,7 @@ const k3: u32 = 0xCA62C1D6u32;
/// Construct a `sha` object
pub fn sha1() -> Sha1 {
pub fn sha1() -> @Sha1 {
struct Sha1State
{ h: ~[u32],
len_low: u32,
@ -269,7 +269,7 @@ pub fn sha1() -> Sha1 {
computed: false,
work_buf: @mut vec::from_elem(work_buf_len, 0u32)
};
let mut sh = (st) as Sha1;
let mut sh = @st as @Sha1;
sh.reset();
return sh;
}

8
src/libsyntax/ext/auto_encode.rs
View File

@ -1296,7 +1296,7 @@ mod test {
}
fn to_call_log (val: Encodable<TestEncoder>) -> ~[call] {
fn to_call_log<E:Encodable<TestEncoder>>(val: E) -> ~[call] {
let mut te = TestEncoder {call_log: @mut ~[]};
val.encode(&te);
copy *te.call_log
@ -1309,8 +1309,7 @@ mod test {
}
#[test] fn encode_enum_test () {
check_equal (to_call_log(Book(34,44)
as Encodable::<TestEncoder>),
check_equal (to_call_log(Book(34,44)),
~[CallToEmitEnum (~"Written"),
CallToEmitEnumVariant (~"Book",0,2),
CallToEmitEnumVariantArg (0),
@ -1325,8 +1324,7 @@ mod test {
pub struct HasPos { pos : BPos }
#[test] fn encode_newtype_test () {
check_equal (to_call_log (HasPos {pos:BPos(48)}
as Encodable::<TestEncoder>),
check_equal (to_call_log (HasPos {pos:BPos(48)}),
~[CallToEmitStruct(~"HasPos",1),
CallToEmitField(~"pos",0),
CallToEmitUint(48)]);

221
src/libsyntax/fold.rs
View File

@ -19,29 +19,29 @@ use core::option;
use core::vec;
pub trait ast_fold {
fn fold_crate(crate) -> crate;
fn fold_view_item(&&v: @view_item) -> @view_item;
fn fold_foreign_item(&&v: @foreign_item) -> @foreign_item;
fn fold_item(&&v: @item) -> Option<@item>;
fn fold_struct_field(&&v: @struct_field) -> @struct_field;
fn fold_item_underscore(item_) -> item_;
fn fold_method(&&v: @method) -> @method;
fn fold_block(blk) -> blk;
fn fold_stmt(&&v: @stmt) -> @stmt;
fn fold_arm(arm) -> arm;
fn fold_pat(&&v: @pat) -> @pat;
fn fold_decl(&&v: @decl) -> @decl;
fn fold_expr(&&v: @expr) -> @expr;
fn fold_ty(&&v: @Ty) -> @Ty;
fn fold_mod(_mod) -> _mod;
fn fold_foreign_mod(foreign_mod) -> foreign_mod;
fn fold_variant(variant) -> variant;
fn fold_ident(&&v: ident) -> ident;
fn fold_path(&&v: @path) -> @path;
fn fold_local(&&v: @local) -> @local;
fn map_exprs(fn@(&&v: @expr) -> @expr, ~[@expr]) -> ~[@expr];
fn new_id(node_id) -> node_id;
fn new_span(span) -> span;
fn fold_crate(@self, crate) -> crate;
fn fold_view_item(@self, &&v: @view_item) -> @view_item;
fn fold_foreign_item(@self, &&v: @foreign_item) -> @foreign_item;
fn fold_item(@self, &&v: @item) -> Option<@item>;
fn fold_struct_field(@self, &&v: @struct_field) -> @struct_field;
fn fold_item_underscore(@self, item_) -> item_;
fn fold_method(@self, &&v: @method) -> @method;
fn fold_block(@self, blk) -> blk;
fn fold_stmt(@self, &&v: @stmt) -> @stmt;
fn fold_arm(@self, arm) -> arm;
fn fold_pat(@self, &&v: @pat) -> @pat;
fn fold_decl(@self, &&v: @decl) -> @decl;
fn fold_expr(@self, &&v: @expr) -> @expr;
fn fold_ty(@self, &&v: @Ty) -> @Ty;
fn fold_mod(@self, _mod) -> _mod;
fn fold_foreign_mod(@self, foreign_mod) -> foreign_mod;
fn fold_variant(@self, variant) -> variant;
fn fold_ident(@self, &&v: ident) -> ident;
fn fold_path(@self, &&v: @path) -> @path;
fn fold_local(@self, &&v: @local) -> @local;
fn map_exprs(@self, fn@(&&v: @expr) -> @expr, ~[@expr]) -> ~[@expr];
fn new_id(@self, node_id) -> node_id;
fn new_span(@self, span) -> span;
}
// We may eventually want to be able to fold over type parameters, too
@ -78,7 +78,7 @@ pub type ast_fold_fns = @AstFoldFns;
/* some little folds that probably aren't useful to have in ast_fold itself*/
//used in noop_fold_item and noop_fold_crate and noop_fold_crate_directive
fn fold_meta_item_(&&mi: @meta_item, fld: ast_fold) -> @meta_item {
fn fold_meta_item_(&&mi: @meta_item, fld: @ast_fold) -> @meta_item {
@spanned {
node:
match mi.node {
@ -95,7 +95,7 @@ fn fold_meta_item_(&&mi: @meta_item, fld: ast_fold) -> @meta_item {
span: fld.new_span(mi.span) }
}
//used in noop_fold_item and noop_fold_crate
fn fold_attribute_(at: attribute, fld: ast_fold) -> attribute {
fn fold_attribute_(at: attribute, fld: @ast_fold) -> attribute {
spanned {
node: ast::attribute_ {
style: at.node.style,
@ -106,7 +106,7 @@ fn fold_attribute_(at: attribute, fld: ast_fold) -> attribute {
}
}
//used in noop_fold_foreign_item and noop_fold_fn_decl
fn fold_arg_(a: arg, fld: ast_fold) -> arg {
fn fold_arg_(a: arg, fld: @ast_fold) -> arg {
ast::arg {
mode: a.mode,
is_mutbl: a.is_mutbl,
@ -116,14 +116,14 @@ fn fold_arg_(a: arg, fld: ast_fold) -> arg {
}
}
//used in noop_fold_expr, and possibly elsewhere in the future
fn fold_mac_(m: mac, fld: ast_fold) -> mac {
fn fold_mac_(m: mac, fld: @ast_fold) -> mac {
spanned { node: match m.node {
mac_invoc_tt(*) => m.node,
},
span: fld.new_span(m.span) }
}
pub fn fold_fn_decl(decl: ast::fn_decl, fld: ast_fold) -> ast::fn_decl {
pub fn fold_fn_decl(decl: ast::fn_decl, fld: @ast_fold) -> ast::fn_decl {
ast::fn_decl {
inputs: decl.inputs.map(|x| fold_arg_(*x, fld)),
output: fld.fold_ty(decl.output),
@ -131,41 +131,44 @@ pub fn fold_fn_decl(decl: ast::fn_decl, fld: ast_fold) -> ast::fn_decl {
}
}
fn fold_ty_param_bound(tpb: TyParamBound, fld: ast_fold) -> TyParamBound {
fn fold_ty_param_bound(tpb: TyParamBound,
fld: @ast_fold) -> TyParamBound {
match tpb {
TraitTyParamBound(ty) => TraitTyParamBound(fld.fold_ty(ty)),
RegionTyParamBound => RegionTyParamBound
}
}
pub fn fold_ty_param(tp: TyParam, fld: ast_fold) -> TyParam {
pub fn fold_ty_param(tp: TyParam,
fld: @ast_fold) -> TyParam {
TyParam {ident: tp.ident,
id: fld.new_id(tp.id),
bounds: @tp.bounds.map(|x| fold_ty_param_bound(*x, fld))}
}
pub fn fold_ty_params(tps: &OptVec<TyParam>,
fld: ast_fold) -> OptVec<TyParam> {
fld: @ast_fold) -> OptVec<TyParam> {
tps.map(|tp| fold_ty_param(*tp, fld))
}
pub fn fold_lifetime(l: &Lifetime, fld: ast_fold) -> Lifetime {
pub fn fold_lifetime(l: &Lifetime,
fld: @ast_fold) -> Lifetime {
Lifetime {id: fld.new_id(l.id),
span: fld.new_span(l.span),
ident: l.ident}
}
pub fn fold_lifetimes(lts: &OptVec<Lifetime>,
fld: ast_fold) -> OptVec<Lifetime> {
fld: @ast_fold) -> OptVec<Lifetime> {
lts.map(|l| fold_lifetime(l, fld))
}
pub fn fold_generics(generics: &Generics, fld: ast_fold) -> Generics {
pub fn fold_generics(generics: &Generics, fld: @ast_fold) -> Generics {
Generics {ty_params: fold_ty_params(&generics.ty_params, fld),
lifetimes: fold_lifetimes(&generics.lifetimes, fld)}
}
pub fn noop_fold_crate(c: crate_, fld: ast_fold) -> crate_ {
pub fn noop_fold_crate(c: crate_, fld: @ast_fold) -> crate_ {
let fold_meta_item = |x| fold_meta_item_(x, fld);
let fold_attribute = |x| fold_attribute_(x, fld);
@ -176,12 +179,12 @@ pub fn noop_fold_crate(c: crate_, fld: ast_fold) -> crate_ {
}
}
fn noop_fold_view_item(vi: view_item_, _fld: ast_fold) -> view_item_ {
fn noop_fold_view_item(vi: view_item_, _fld: @ast_fold) -> view_item_ {
return /* FIXME (#2543) */ copy vi;
}
fn noop_fold_foreign_item(&&ni: @foreign_item, fld: ast_fold)
fn noop_fold_foreign_item(&&ni: @foreign_item, fld: @ast_fold)
-> @foreign_item {
let fold_arg = |x| fold_arg_(x, fld);
let fold_attribute = |x| fold_attribute_(x, fld);
@ -211,7 +214,7 @@ fn noop_fold_foreign_item(&&ni: @foreign_item, fld: ast_fold)
}
}
pub fn noop_fold_item(&&i: @item, fld: ast_fold) -> Option<@item> {
pub fn noop_fold_item(&&i: @item, fld: @ast_fold) -> Option<@item> {
let fold_attribute = |x| fold_attribute_(x, fld);
Some(@ast::item { ident: fld.fold_ident(i.ident),
@ -222,7 +225,7 @@ pub fn noop_fold_item(&&i: @item, fld: ast_fold) -> Option<@item> {
span: fld.new_span(i.span) })
}
fn noop_fold_struct_field(&&sf: @struct_field, fld: ast_fold)
fn noop_fold_struct_field(&&sf: @struct_field, fld: @ast_fold)
-> @struct_field {
@spanned { node: ast::struct_field_ { kind: copy sf.node.kind,
id: sf.node.id,
@ -230,7 +233,7 @@ fn noop_fold_struct_field(&&sf: @struct_field, fld: ast_fold)
span: sf.span }
}
pub fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
pub fn noop_fold_item_underscore(i: item_, fld: @ast_fold) -> item_ {
match i {
item_const(t, e) => item_const(fld.fold_ty(t), fld.fold_expr(e)),
item_fn(ref decl, purity, ref typms, ref body) => {
@ -281,7 +284,7 @@ pub fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
}
}
fn fold_struct_def(struct_def: @ast::struct_def, fld: ast_fold)
fn fold_struct_def(struct_def: @ast::struct_def, fld: @ast_fold)
-> @ast::struct_def {
let dtor = do option::map(&struct_def.dtor) |dtor| {
let dtor_body = fld.fold_block(dtor.node.body);
@ -298,21 +301,21 @@ fn fold_struct_def(struct_def: @ast::struct_def, fld: ast_fold)
}
}
fn fold_trait_ref(&&p: @trait_ref, fld: ast_fold) -> @trait_ref {
fn fold_trait_ref(&&p: @trait_ref, fld: @ast_fold) -> @trait_ref {
@ast::trait_ref {
path: fld.fold_path(p.path),
ref_id: fld.new_id(p.ref_id),
}
}
fn fold_struct_field(&&f: @struct_field, fld: ast_fold) -> @struct_field {
fn fold_struct_field(&&f: @struct_field, fld: @ast_fold) -> @struct_field {
@spanned { node: ast::struct_field_ { kind: copy f.node.kind,
id: fld.new_id(f.node.id),
ty: fld.fold_ty(f.node.ty) },
span: fld.new_span(f.span) }
}
fn noop_fold_method(&&m: @method, fld: ast_fold) -> @method {
fn noop_fold_method(&&m: @method, fld: @ast_fold) -> @method {
@ast::method {
ident: fld.fold_ident(m.ident),
attrs: /* FIXME (#2543) */ copy m.attrs,
@ -329,7 +332,7 @@ fn noop_fold_method(&&m: @method, fld: ast_fold) -> @method {
}
pub fn noop_fold_block(b: blk_, fld: ast_fold) -> blk_ {
pub fn noop_fold_block(b: blk_, fld: @ast_fold) -> blk_ {
ast::blk_ {
view_items: b.view_items.map(|x| fld.fold_view_item(*x)),
stmts: b.stmts.map(|x| fld.fold_stmt(*x)),
@ -339,7 +342,7 @@ pub fn noop_fold_block(b: blk_, fld: ast_fold) -> blk_ {
}
}
fn noop_fold_stmt(s: stmt_, fld: ast_fold) -> stmt_ {
fn noop_fold_stmt(s: stmt_, fld: @ast_fold) -> stmt_ {
let fold_mac = |x| fold_mac_(x, fld);
return match s {
stmt_decl(d, nid) => stmt_decl(fld.fold_decl(d), fld.new_id(nid)),
@ -349,7 +352,7 @@ fn noop_fold_stmt(s: stmt_, fld: ast_fold) -> stmt_ {
};
}
fn noop_fold_arm(a: arm, fld: ast_fold) -> arm {
fn noop_fold_arm(a: arm, fld: @ast_fold) -> arm {
arm {
pats: vec::map(a.pats, |x| fld.fold_pat(*x)),
guard: option::map(&a.guard, |x| fld.fold_expr(*x)),
@ -357,7 +360,7 @@ fn noop_fold_arm(a: arm, fld: ast_fold) -> arm {
}
}
pub fn noop_fold_pat(p: pat_, fld: ast_fold) -> pat_ {
pub fn noop_fold_pat(p: pat_, fld: @ast_fold) -> pat_ {
return match p {
pat_wild => pat_wild,
pat_ident(binding_mode, pth, sub) => {
@ -403,7 +406,7 @@ pub fn noop_fold_pat(p: pat_, fld: ast_fold) -> pat_ {
};
}
fn noop_fold_decl(d: decl_, fld: ast_fold) -> decl_ {
fn noop_fold_decl(d: decl_, fld: @ast_fold) -> decl_ {
match d {
decl_local(ls) => decl_local(vec::map(ls, |x| fld.fold_local(*x))),
decl_item(it) => match fld.fold_item(it) {
@ -416,13 +419,13 @@ fn noop_fold_decl(d: decl_, fld: ast_fold) -> decl_ {
pub fn wrap<T>(f: fn@(T, ast_fold) -> T)
-> fn@(T, span, ast_fold) -> (T, span)
{
return fn@(x: T, s: span, fld: ast_fold) -> (T, span) {
return fn@(x: T, s: span, fld: @ast_fold) -> (T, span) {
(f(x, fld), s)
}
}
pub fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
fn fold_field_(field: field, fld: ast_fold) -> field {
pub fn noop_fold_expr(e: expr_, fld: @ast_fold) -> expr_ {
fn fold_field_(field: field, fld: @ast_fold) -> field {
spanned {
node: ast::field_ {
mutbl: field.node.mutbl,
@ -533,12 +536,12 @@ pub fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
}
}
pub fn noop_fold_ty(t: ty_, fld: ast_fold) -> ty_ {
pub fn noop_fold_ty(t: ty_, fld: @ast_fold) -> ty_ {
let fold_mac = |x| fold_mac_(x, fld);
fn fold_mt(mt: mt, fld: ast_fold) -> mt {
fn fold_mt(mt: mt, fld: @ast_fold) -> mt {
mt { ty: fld.fold_ty(mt.ty), mutbl: mt.mutbl }
}
fn fold_field(f: ty_field, fld: ast_fold) -> ty_field {
fn fold_field(f: ty_field, fld: @ast_fold) -> ty_field {
spanned {
node: ast::ty_field_ {
ident: fld.fold_ident(f.node.ident),
@ -579,14 +582,14 @@ pub fn noop_fold_ty(t: ty_, fld: ast_fold) -> ty_ {
}
// ...nor do modules
pub fn noop_fold_mod(m: _mod, fld: ast_fold) -> _mod {
pub fn noop_fold_mod(m: _mod, fld: @ast_fold) -> _mod {
ast::_mod {
view_items: vec::map(m.view_items, |x| fld.fold_view_item(*x)),
items: vec::filter_mapped(m.items, |x| fld.fold_item(*x)),
}
}
fn noop_fold_foreign_mod(nm: foreign_mod, fld: ast_fold) -> foreign_mod {
fn noop_fold_foreign_mod(nm: foreign_mod, fld: @ast_fold) -> foreign_mod {
ast::foreign_mod {
sort: nm.sort,
abi: nm.abi,
@ -595,8 +598,8 @@ fn noop_fold_foreign_mod(nm: foreign_mod, fld: ast_fold) -> foreign_mod {
}
}
fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
fn fold_variant_arg_(va: variant_arg, fld: ast_fold) -> variant_arg {
fn noop_fold_variant(v: variant_, fld: @ast_fold) -> variant_ {
fn fold_variant_arg_(va: variant_arg, fld: @ast_fold) -> variant_arg {
ast::variant_arg { ty: fld.fold_ty(va.ty), id: fld.new_id(va.id) }
}
let fold_variant_arg = |x| fold_variant_arg_(x, fld);
@ -654,11 +657,11 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
}
}
fn noop_fold_ident(&&i: ident, _fld: ast_fold) -> ident {
fn noop_fold_ident(&&i: ident, _fld: @ast_fold) -> ident {
return /* FIXME (#2543) */ copy i;
}
fn noop_fold_path(&&p: path, fld: ast_fold) -> path {
fn noop_fold_path(&&p: path, fld: @ast_fold) -> path {
ast::path { span: fld.new_span(p.span),
global: p.global,
idents: p.idents.map(|x| fld.fold_ident(*x)),
@ -666,7 +669,7 @@ fn noop_fold_path(&&p: path, fld: ast_fold) -> path {
types: p.types.map(|x| fld.fold_ty(*x)) }
}
fn noop_fold_local(l: local_, fld: ast_fold) -> local_ {
fn noop_fold_local(l: local_, fld: @ast_fold) -> local_ {
local_ {
is_mutbl: l.is_mutbl,
ty: fld.fold_ty(l.ty),
@ -712,72 +715,72 @@ pub fn default_ast_fold() -> ast_fold_fns {
new_span: noop_span};
}
impl ast_fold for ast_fold_fns {
impl ast_fold for AstFoldFns {
/* naturally, a macro to write these would be nice */
fn fold_crate(c: crate) -> crate {
let (n, s) = (self.fold_crate)(c.node, c.span, self as ast_fold);
fn fold_crate(@self, c: crate) -> crate {
let (n, s) = (self.fold_crate)(c.node, c.span, self as @ast_fold);
spanned { node: n, span: (self.new_span)(s) }
}
fn fold_view_item(&&x: @view_item) ->
fn fold_view_item(@self, &&x: @view_item) ->
@view_item {
@ast::view_item {
node: (self.fold_view_item)(x.node, self as ast_fold),
node: (self.fold_view_item)(x.node, self as @ast_fold),
attrs: vec::map(x.attrs, |a|
fold_attribute_(*a, self as ast_fold)),
fold_attribute_(*a, self as @ast_fold)),
vis: x.vis,
span: (self.new_span)(x.span),
}
}
fn fold_foreign_item(&&x: @foreign_item)
fn fold_foreign_item(@self, &&x: @foreign_item)
-> @foreign_item {
return (self.fold_foreign_item)(x, self as ast_fold);
return (self.fold_foreign_item)(x, self as @ast_fold);
}
fn fold_item(&&i: @item) -> Option<@item> {
return (self.fold_item)(i, self as ast_fold);
fn fold_item(@self, &&i: @item) -> Option<@item> {
return (self.fold_item)(i, self as @ast_fold);
}
fn fold_struct_field(&&sf: @struct_field) -> @struct_field {
fn fold_struct_field(@self, &&sf: @struct_field) -> @struct_field {
@spanned {
node: ast::struct_field_ {
kind: copy sf.node.kind,
id: sf.node.id,
ty: (self as ast_fold).fold_ty(sf.node.ty),
ty: (self as @ast_fold).fold_ty(sf.node.ty),
},
span: (self.new_span)(sf.span),
}
}
fn fold_item_underscore(i: item_) ->
fn fold_item_underscore(@self, i: item_) ->
item_ {
return (self.fold_item_underscore)(i, self as ast_fold);
return (self.fold_item_underscore)(i, self as @ast_fold);
}
fn fold_method(&&x: @method)
fn fold_method(@self, &&x: @method)
-> @method {
return (self.fold_method)(x, self as ast_fold);
return (self.fold_method)(x, self as @ast_fold);
}
fn fold_block(x: blk) -> blk {
let (n, s) = (self.fold_block)(x.node, x.span, self as ast_fold);
fn fold_block(@self, x: blk) -> blk {
let (n, s) = (self.fold_block)(x.node, x.span, self as @ast_fold);
spanned { node: n, span: (self.new_span)(s) }
}
fn fold_stmt(&&x: @stmt) -> @stmt {
let (n, s) = (self.fold_stmt)(x.node, x.span, self as ast_fold);
fn fold_stmt(@self, &&x: @stmt) -> @stmt {
let (n, s) = (self.fold_stmt)(x.node, x.span, self as @ast_fold);
@spanned { node: n, span: (self.new_span)(s) }
}
fn fold_arm(x: arm) -> arm {
return (self.fold_arm)(x, self as ast_fold);
fn fold_arm(@self, x: arm) -> arm {
return (self.fold_arm)(x, self as @ast_fold);
}
fn fold_pat(&&x: @pat) -> @pat {
let (n, s) = (self.fold_pat)(x.node, x.span, self as ast_fold);
fn fold_pat(@self, &&x: @pat) -> @pat {
let (n, s) = (self.fold_pat)(x.node, x.span, self as @ast_fold);
@pat {
id: (self.new_id)(x.id),
node: n,
span: (self.new_span)(s),
}
}
fn fold_decl(&&x: @decl) -> @decl {
let (n, s) = (self.fold_decl)(x.node, x.span, self as ast_fold);
fn fold_decl(@self, &&x: @decl) -> @decl {
let (n, s) = (self.fold_decl)(x.node, x.span, self as @ast_fold);
@spanned { node: n, span: (self.new_span)(s) }
}
fn fold_expr(&&x: @expr) -> @expr {
let (n, s) = (self.fold_expr)(x.node, x.span, self as ast_fold);
fn fold_expr(@self, &&x: @expr) -> @expr {
let (n, s) = (self.fold_expr)(x.node, x.span, self as @ast_fold);
@expr {
id: (self.new_id)(x.id),
callee_id: (self.new_id)(x.callee_id),
@ -785,43 +788,45 @@ impl ast_fold for ast_fold_fns {
span: (self.new_span)(s),
}
}
fn fold_ty(&&x: @Ty) -> @Ty {
let (n, s) = (self.fold_ty)(x.node, x.span, self as ast_fold);
fn fold_ty(@self, &&x: @Ty) -> @Ty {
let (n, s) = (self.fold_ty)(x.node, x.span, self as @ast_fold);
@Ty {
id: (self.new_id)(x.id),
node: n,
span: (self.new_span)(s),
}
}
fn fold_mod(x: _mod) -> _mod {
return (self.fold_mod)(x, self as ast_fold);
fn fold_mod(@self, x: _mod) -> _mod {
return (self.fold_mod)(x, self as @ast_fold);
}
fn fold_foreign_mod(x: foreign_mod) ->
fn fold_foreign_mod(@self, x: foreign_mod) ->
foreign_mod {
return (self.fold_foreign_mod)(x, self as ast_fold);
return (self.fold_foreign_mod)(x, self as @ast_fold);
}
fn fold_variant(x: variant) ->
fn fold_variant(@self, x: variant) ->
variant {
let (n, s) = (self.fold_variant)(x.node, x.span, self as ast_fold);
let (n, s) = (self.fold_variant)(x.node, x.span, self as @ast_fold);
spanned { node: n, span: (self.new_span)(s) }
}
fn fold_ident(&&x: ident) -> ident {
return (self.fold_ident)(x, self as ast_fold);
fn fold_ident(@self, &&x: ident) -> ident {
return (self.fold_ident)(x, self as @ast_fold);
}
fn fold_path(&&x: @path) -> @path {
@(self.fold_path)(*x, self as ast_fold)
fn fold_path(@self, &&x: @path) -> @path {
@(self.fold_path)(*x, self as @ast_fold)
}
fn fold_local(&&x: @local) -> @local {
let (n, s) = (self.fold_local)(x.node, x.span, self as ast_fold);
fn fold_local(@self, &&x: @local) -> @local {
let (n, s) = (self.fold_local)(x.node, x.span, self as @ast_fold);
@spanned { node: n, span: (self.new_span)(s) }
}
fn map_exprs(f: fn@(&&v: @expr) -> @expr, e: ~[@expr]) -> ~[@expr] {
fn map_exprs(@self,
f: fn@(&&v: @expr) -> @expr,
e: ~[@expr]) -> ~[@expr] {
(self.map_exprs)(f, e)
}
fn new_id(node_id: ast::node_id) -> node_id {
fn new_id(@self, node_id: ast::node_id) -> node_id {
(self.new_id)(node_id)
}
fn new_span(span: span) -> span {
fn new_span(@self, span: span) -> span {
(self.new_span)(span)
}
}
@ -833,7 +838,7 @@ pub impl ast_fold {
}
pub fn make_fold(afp: ast_fold_fns) -> ast_fold {
afp as ast_fold
afp as @ast_fold
}
//

2
src/libsyntax/parse/mod.rs
View File

@ -251,7 +251,7 @@ mod test {
@~"fn foo (x : int) { x; }",
~[],
new_parse_sess(None));
check_equal(to_json_str(tts as Encodable::<std::json::Encoder>),
check_equal(to_json_str(@tts as Encodable::<std::json::Encoder>),
~"[[\"tt_tok\",[,[\"IDENT\",[\"fn\",false]]]],\
[\"tt_tok\",[,[\"IDENT\",[\"foo\",false]]]],\
[\"tt_delim\",[[[\"tt_tok\",[,[\"LPAREN\",[]]]],\

2
src/test/auxiliary/issue-2380.rs
View File

@ -16,5 +16,5 @@ pub trait i<T> { }
pub fn f<T>() -> i<T> {
impl<T> i<T> for () { }
() as i::<T>
@() as @i<T>
}

2
src/test/bench/shootout-mandelbrot.rs
View File

@ -112,7 +112,7 @@ fn writer(path: ~str, pport: comm::Port<Line>, size: uint)
{
let cout: io::Writer = match path {
~"" => {
Devnull as io::Writer
@Devnull as @io::Writer
}
~"-" => {
io::stdout()

2
src/test/compile-fail/class-cast-to-trait.rs
View File

@ -58,6 +58,6 @@ fn cat(in_x : uint, in_y : int, in_name: ~str) -> cat {
}
fn main() {
let nyan : noisy = cat(0, 2, ~"nyan") as noisy;
let nyan : noisy = @cat(0, 2, ~"nyan") as @noisy;
nyan.eat(); //~ ERROR type `@noisy` does not implement any method in scope named `eat`
}

2
src/test/compile-fail/kindck-owned-trait-contains.rs
View File

@ -16,7 +16,7 @@ impl<A:Copy> repeat<A> for @A {
fn repeater<A:Copy>(v: @A) -> repeat<A> {
// Note: owned kind is not necessary as A appears in the trait type
v as repeat::<A> // No
@v as repeat::<A> // No
}
fn main() {

6
src/test/compile-fail/kindck-owned-trait-scoped.rs
View File

@ -26,7 +26,7 @@ fn to_foo<T:Copy>(t: T) {
// the fn body itself.
let v = &3;
struct F<T> { f: T }
let x = F {f:t} as foo;
let x = @F {f:t} as foo;
assert x.foo(v) == 3;
}
@ -34,14 +34,14 @@ fn to_foo_2<T:Copy>(t: T) -> foo {
// Not OK---T may contain borrowed ptrs and it is going to escape
// as part of the returned foo value
struct F<T> { f: T }
F {f:t} as foo //~ ERROR value may contain borrowed pointers; use `&static` bound
@F {f:t} as foo //~ ERROR value may contain borrowed pointers; use `&static` bound
}
fn to_foo_3<T:Copy + &static>(t: T) -> foo {
// OK---T may escape as part of the returned foo value, but it is
// owned and hence does not contain borrowed ptrs
struct F<T> { f: T }
F {f:t} as foo
@F {f:t} as foo
}
fn main() {

4
src/test/compile-fail/kindck-owned-trait.rs
View File

@ -11,11 +11,11 @@
trait foo { fn foo(); }
fn to_foo<T:Copy + foo>(t: T) -> foo {
t as foo //~ ERROR value may contain borrowed pointers; use `&static` bound
@t as @foo //~ ERROR value may contain borrowed pointers; use `&static` bound
}
fn to_foo2<T:Copy + foo + &static>(t: T) -> foo {
t as foo
@t as @foo
}
fn main() {}

4
src/test/compile-fail/map-types.rs
View File

@ -14,8 +14,8 @@ use core::hashmap::linear::LinearMap;
// Test that trait types printed in error msgs include the type arguments.
fn main() {
let x: Map<~str, ~str> = LinearMap::new::<~str, ~str>() as
let x: @Map<~str, ~str> = @LinearMap::new::<~str, ~str>() as
Map::<~str, ~str>;
let y: Map<uint, ~str> = x;
let y: @Map<uint, ~str> = @x;
//~^ ERROR mismatched types: expected `@core::container::Map/&<uint,~str>`
}

2
src/test/compile-fail/regions-trait-1.rs
View File

@ -34,5 +34,5 @@ fn get_v(gc: get_ctxt) -> uint {
fn main() {
let ctxt = ctxt { v: 22u };
let hc = has_ctxt { c: &ctxt };
assert get_v(hc as get_ctxt) == 22u;
assert get_v(@hc as get_ctxt) == 22u;
}

2
src/test/compile-fail/regions-trait-2.rs
View File

@ -23,7 +23,7 @@ impl get_ctxt for has_ctxt {
fn make_gc() -> get_ctxt {
let ctxt = ctxt { v: 22u };
let hc = has_ctxt { c: &ctxt }; //~ ERROR illegal borrow
return hc as get_ctxt;
return @hc as get_ctxt;
}
fn main() {

2
src/test/compile-fail/regions-trait-3.rs
View File

@ -17,7 +17,7 @@ fn make_gc1(gc: get_ctxt/&a) -> get_ctxt/&b {
}
fn make_gc2(gc: get_ctxt/&a) -> get_ctxt/&b {
return gc as get_ctxt; //~ ERROR cannot infer an appropriate lifetime
return @gc as get_ctxt; //~ ERROR cannot infer an appropriate lifetime
}
fn main() {

4
src/test/compile-fail/selftype-astparam.rs
View File

@ -19,7 +19,7 @@ impl add for int {
fn do_add<A:add>(x: A, y: A) -> A { x.plus(y) }
fn main() {
let x = 3 as add;
let y = 4 as add;
let x = @3 as @add;
let y = @4 as @add;
do_add(x, y); //~ ERROR a boxed trait with self types may not be passed as a bounded type
}

2
src/test/compile-fail/tps-invariant-trait.rs
View File

@ -34,7 +34,7 @@ fn set_box_impl<T>(b: box_impl<@const T>, v: @const T) {
fn main() {
let b = box_impl::<@int>(box::<@int> {f: @3});
set_box_trait(b as box_trait::<@int>, @mut 5);
set_box_trait(@b as box_trait::<@int>, @mut 5);
//~^ ERROR values differ in mutability
set_box_impl(b, @mut 5);
//~^ ERROR values differ in mutability

2
src/test/compile-fail/trait-cast.rs
View File

@ -11,7 +11,7 @@
trait foo<T> { }
fn bar(x: foo<uint>) -> foo<int> {
return (x as foo::<int>);
return (@x as foo::<int>);
//~^ ERROR mismatched types: expected `@foo<int>` but found `@foo<uint>`
//~^^ ERROR mismatched types: expected `@foo<int>` but found `@foo<uint>`
// This is unfortunate -- new handling of parens means the error message

2
src/test/compile-fail/trait-test-2.rs
View File

@ -15,5 +15,5 @@ impl bar for uint { fn dup() -> uint { self } fn blah<X>() {} }
fn main() {
10i.dup::<int>(); //~ ERROR does not take type parameters
10i.blah::<int, int>(); //~ ERROR incorrect number of type parameters
(10 as bar).dup(); //~ ERROR contains a self-type
(@10 as bar).dup(); //~ ERROR contains a self-type
}

2
src/test/run-fail/unwind-box-trait.rs
View File

@ -23,7 +23,7 @@ impl i for ~int {
}
fn main() {
let x = ~0 as i;
let x = @~0 as @i;
failfn();
log(error, x);
}

2
src/test/run-pass/autoderef-method-on-trait-monomorphized.rs
View File

@ -21,6 +21,6 @@ fn is_equal<D:double>(x: @D, exp: uint) {
}
pub fn main() {
let x = @(3u as double);
let x = @(@3u as @double);
is_equal(x, 6);
}

2
src/test/run-pass/autoderef-method-on-trait.rs
View File

@ -17,6 +17,6 @@ impl double for uint {
}
pub fn main() {
let x = @(3u as double);
let x = @(@3u as @double);
assert x.double() == 6u;
}

2
src/test/run-pass/boxed-trait-with-vstore.rs
View File

@ -19,7 +19,7 @@ impl Foo for int {
}
pub fn main() {
let x = 3 as @Foo;
let x = @3 as @Foo;
x.foo();
}

2
src/test/run-pass/class-cast-to-trait-cross-crate-2.rs
View File

@ -21,7 +21,7 @@ fn print_out<T:ToStr>(thing: T, expected: ~str) {
}
pub fn main() {
let nyan : ToStr = cat(0u, 2, ~"nyan") as ToStr;
let nyan : @ToStr = @cat(0u, 2, ~"nyan") as @ToStr;
print_out(nyan, ~"nyan");
}

4
src/test/run-pass/class-cast-to-trait-multiple-types.rs
View File

@ -86,8 +86,8 @@ fn annoy_neighbors<T:noisy>(critter: T) {
pub fn main() {
let nyan : cat = cat(0u, 2, ~"nyan");
let whitefang : dog = dog();
annoy_neighbors((copy nyan) as noisy);
annoy_neighbors((copy whitefang) as noisy);
annoy_neighbors(@(copy nyan) as @noisy);
annoy_neighbors(@(copy whitefang) as @noisy);
assert(nyan.meow_count() == 10u);
assert(*whitefang.volume == 1);
}

2
src/test/run-pass/class-cast-to-trait.rs
View File

@ -56,6 +56,6 @@ fn cat(in_x : uint, in_y : int, in_name: ~str) -> cat {
pub fn main() {
let mut nyan: noisy = cat(0u, 2, ~"nyan") as noisy;
let mut nyan: @noisy = @cat(0u, 2, ~"nyan") as @noisy;
nyan.speak();
}

2
src/test/run-pass/class-separate-impl.rs
View File

@ -63,6 +63,6 @@ fn print_out<T:ToStr>(thing: T, expected: ~str) {
}
pub fn main() {
let mut nyan : ToStr = cat(0u, 2, ~"nyan") as ToStr;
let mut nyan : @ToStr = @cat(0u, 2, ~"nyan") as @ToStr;
print_out(nyan, ~"nyan");
}

2
src/test/run-pass/explicit-self-objects-ext-1.rs
View File

@ -34,6 +34,6 @@ impl Reader for S {
pub fn main() {
let x = S { x: 1, y: 2 };
let x = x as @Reader;
let x = @x as @Reader;
x.read_bytes(0);
}

2
src/test/run-pass/explicit-self-objects-ext-2.rs
View File

@ -34,6 +34,6 @@ impl Reader for S {
pub fn main() {
let x = S { x: 1, y: 2 };
let x = x as @Reader;
let x = @x as @Reader;
x.read_bytes(0);
}

2
src/test/run-pass/explicit-self-objects-ext-3.rs
View File

@ -34,6 +34,6 @@ impl Reader for S {
pub fn main() {
let x = S { x: 1, y: 2 };
let x = x as @Reader;
let x = @x as @Reader;
x.read_bytes(0);
}

2
src/test/run-pass/explicit-self-objects-ext-4.rs
View File

@ -34,6 +34,6 @@ impl Reader for S {
pub fn main() {
let x = S { x: 1, y: 2 };
let x = x as @Reader;
let x = @x as @Reader;
x.read_bytes(0);
}

2
src/test/run-pass/issue-2288.rs
View File

@ -33,6 +33,6 @@ fn f<A:Copy>(x: clam<A>, a: A) {
pub fn main() {
let c = foo(42);
let d: clam<int> = c as clam::<int>;
let d: clam<int> = @c as clam::<int>;
f(d, c.x);
}

2
src/test/run-pass/issue-2734.rs
View File

@ -12,7 +12,7 @@ trait hax { }
impl<A> hax for A { }
fn perform_hax<T:&static>(x: @T) -> hax {
x as hax
@x as @hax
}
fn deadcode() {

6
src/test/run-pass/issue-2735.rs
View File

@ -8,11 +8,11 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
trait hax { }
impl<A> hax for A { }
trait hax { }
impl<A> hax for A { }
fn perform_hax<T:&static>(x: @T) -> hax {
x as hax
@x as @hax
}
fn deadcode() {

2
src/test/run-pass/issue-2904.rs
View File

@ -60,7 +60,7 @@ fn square_from_char(c: char) -> square {
}
fn read_board_grid<rdr: &static + io::Reader>(+in: rdr) -> ~[~[square]] {
let in = (in) as io::Reader;
let in = @in as @io::Reader;
let mut grid = ~[];
for in.each_line |line| {
let mut row = ~[];

2
src/test/run-pass/issue-2935.rs
View File

@ -25,7 +25,7 @@ pub fn main() {
// let y = @({a: 4i});
// let z = @({a: 4i} as it);
// let z = @({a: true} as it);
let z = @(true as it);
let z = @(@true as it);
// x.f();
// y.f();
// (*z).f();

2
src/test/run-pass/issue-3305.rs
View File

@ -21,6 +21,6 @@ fn is_equal<D:double>(x: @D, exp: uint) {
}
pub fn main() {
let x = @(3u as double);
let x = @(@3u as @double);
is_equal(x, 6);
}

2
src/test/run-pass/kindck-owned-trait-contains-1.rs
View File

@ -16,7 +16,7 @@ impl<A:Copy> repeat<A> for @A {
fn repeater<A:Copy>(v: @A) -> repeat<A> {
// Note: owned kind is not necessary as A appears in the trait type
v as repeat::<A> // No
@v as repeat::<A> // No
}
pub fn main() {

4
src/test/run-pass/reflect-visit-data.rs
View File

@ -489,7 +489,7 @@ pub impl my_visitor {
unsafe {
let u = my_visitor(*self);
let v = ptr_visit_adaptor::<my_visitor>(Inner {inner: u});
visit_tydesc(inner, v as TyVisitor);
visit_tydesc(inner, @v as @TyVisitor);
true
}
}
@ -644,7 +644,7 @@ pub fn main() {
let td = get_tydesc_for(r);
unsafe { error!("tydesc sz: %u, align: %u",
(*td).size, (*td).align); }
let v = v as TyVisitor;
let v = @v as @TyVisitor;
visit_tydesc(td, v);
for (copy u.vals).each |s| {

2
src/test/run-pass/regions-trait.rs
View File

@ -30,5 +30,5 @@ pub fn main() {
let ctxt = Ctxt { v: 22 };
let hc = HasCtxt { c: &ctxt };
assert get_v(hc as get_ctxt) == 22;
assert get_v(@hc as @get_ctxt) == 22;
}