diff options
| author | bors <bors@rust-lang.org> | 2013-04-20 01:00:49 -0700 |
|---|---|---|
| committer | bors <bors@rust-lang.org> | 2013-04-20 01:00:49 -0700 |
| commit | 4ff701b7db609cabe59832d47779832a16627b5f (patch) | |
| tree | 49317e2439d493b798412dad2c92b60e366f229f /src/libsyntax | |
| parent | 028dc589d1cfb7e44b36b978ea1dcc304d70cee0 (diff) | |
| parent | cd982ad3f74673c55af6034a4f757e60be9b381c (diff) | |
| download | rust-4ff701b7db609cabe59832d47779832a16627b5f.tar.gz rust-4ff701b7db609cabe59832d47779832a16627b5f.zip | |
auto merge of #5965 : alexcrichton/rust/issue-4364, r=pcwalton
This closes #4364. I came into rust after modes had begun to be phased out, so I'm not exactly sure what they all did. My strategy was basically to turn on the compilation warnings and then when everything compiles and passes all the tests it's all good. In most cases, I just dropped the mode, but in others I converted things to use `&` pointers when otherwise a move would happen. This depends on #5963. When running the tests, everything passed except for a few compile-fail tests. These tests leaked memory, causing the task to abort differently. By suppressing the ICE from #5963, no leaks happen and the tests all pass. I would have looked into where the leaks were coming from, but I wasn't sure where or how to debug them (I found `RUSTRT_TRACK_ALLOCATIONS`, but it wasn't all that useful).
Diffstat (limited to 'src/libsyntax')
30 files changed, 363 insertions, 364 deletions
diff --git a/src/libsyntax/abi.rs b/src/libsyntax/abi.rs index a848f97d2e0..b6580b4c5a1 100644 --- a/src/libsyntax/abi.rs +++ b/src/libsyntax/abi.rs @@ -255,13 +255,13 @@ pub impl AbiSet { } impl to_bytes::IterBytes for Abi { - fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { self.index().iter_bytes(lsb0, f) } } impl to_bytes::IterBytes for AbiSet { - fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { self.bits.iter_bytes(lsb0, f) } } diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 6f4693adb9f..b0b3e45abe5 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -97,7 +97,7 @@ impl<D:Decoder> Decodable<D> for ident { } impl to_bytes::IterBytes for ident { - fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { self.repr.iter_bytes(lsb0, f) } } @@ -284,7 +284,7 @@ pub enum binding_mode { } impl to_bytes::IterBytes for binding_mode { - fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { match *self { bind_by_copy => 0u8.iter_bytes(lsb0, f), @@ -330,7 +330,7 @@ pub enum pat_ { pub enum mutability { m_mutbl, m_imm, m_const, } impl to_bytes::IterBytes for mutability { - fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { (*self as u8).iter_bytes(lsb0, f) } } @@ -345,7 +345,7 @@ pub enum Sigil { } impl to_bytes::IterBytes for Sigil { - fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { (*self as uint).iter_bytes(lsb0, f) } } @@ -428,7 +428,7 @@ pub enum inferable<T> { } impl<T:to_bytes::IterBytes> to_bytes::IterBytes for inferable<T> { - fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { match *self { expl(ref t) => to_bytes::iter_bytes_2(&0u8, t, lsb0, f), @@ -446,7 +446,7 @@ impl<T:to_bytes::IterBytes> to_bytes::IterBytes for inferable<T> { pub enum rmode { by_ref, by_copy } impl to_bytes::IterBytes for rmode { - fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { (*self as u8).iter_bytes(lsb0, f) } } @@ -781,7 +781,7 @@ impl ToStr for int_ty { } impl to_bytes::IterBytes for int_ty { - fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { (*self as u8).iter_bytes(lsb0, f) } } @@ -798,7 +798,7 @@ impl ToStr for uint_ty { } impl to_bytes::IterBytes for uint_ty { - fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { (*self as u8).iter_bytes(lsb0, f) } } @@ -815,7 +815,7 @@ impl ToStr for float_ty { } impl to_bytes::IterBytes for float_ty { - fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { (*self as u8).iter_bytes(lsb0, f) } } @@ -860,7 +860,7 @@ impl ToStr for Onceness { } impl to_bytes::IterBytes for Onceness { - fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { (*self as uint).iter_bytes(lsb0, f); } } @@ -911,7 +911,7 @@ pub enum ty_ { } impl to_bytes::IterBytes for Ty { - fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { to_bytes::iter_bytes_2(&self.span.lo, &self.span.hi, lsb0, f); } } @@ -979,7 +979,7 @@ impl ToStr for purity { } impl to_bytes::IterBytes for purity { - fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { (*self as u8).iter_bytes(lsb0, f) } } @@ -994,7 +994,7 @@ pub enum ret_style { } impl to_bytes::IterBytes for ret_style { - fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { (*self as u8).iter_bytes(lsb0, f) } } @@ -1268,7 +1268,7 @@ pub enum item_ { pub enum struct_mutability { struct_mutable, struct_immutable } impl to_bytes::IterBytes for struct_mutability { - fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { (*self as u8).iter_bytes(lsb0, f) } } diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs index 147d8227b81..05e67196b4c 100644 --- a/src/libsyntax/ast_map.rs +++ b/src/libsyntax/ast_map.rs @@ -115,7 +115,7 @@ pub struct Ctx { pub type vt = visit::vt<@mut Ctx>; -pub fn extend(cx: @mut Ctx, +elt: ident) -> @path { +pub fn extend(cx: @mut Ctx, elt: ident) -> @path { @(vec::append(copy cx.path, ~[path_name(elt)])) } @@ -132,7 +132,7 @@ pub fn mk_ast_map_visitor() -> vt { }); } -pub fn map_crate(diag: @span_handler, c: crate) -> map { +pub fn map_crate(diag: @span_handler, c: @crate) -> map { let cx = @mut Ctx { map: @mut HashMap::new(), path: ~[], @@ -148,8 +148,8 @@ pub fn map_crate(diag: @span_handler, c: crate) -> map { // the item itself. pub fn map_decoded_item(diag: @span_handler, map: map, - +path: path, - ii: inlined_item) { + path: path, + ii: &inlined_item) { // I believe it is ok for the local IDs of inlined items from other crates // to overlap with the local ids from this crate, so just generate the ids // starting from 0. (In particular, I think these ids are only used in @@ -167,7 +167,7 @@ pub fn map_decoded_item(diag: @span_handler, // methods get added to the AST map when their impl is visited. Since we // don't decode and instantiate the impl, but just the method, we have to // add it to the table now: - match ii { + match *ii { ii_item(*) | ii_dtor(*) => { /* fallthrough */ } ii_foreign(i) => { cx.map.insert(i.id, node_foreign_item(i, @@ -190,7 +190,7 @@ pub fn map_fn( body: &blk, sp: codemap::span, id: node_id, - &&cx: @mut Ctx, + cx: @mut Ctx, v: visit::vt<@mut Ctx> ) { for decl.inputs.each |a| { @@ -222,7 +222,7 @@ pub fn map_fn( visit::visit_fn(fk, decl, body, sp, id, cx, v); } -pub fn map_block(b: &blk, &&cx: @mut Ctx, v: visit::vt<@mut Ctx>) { +pub fn map_block(b: &blk, cx: @mut Ctx, v: visit::vt<@mut Ctx>) { cx.map.insert(b.node.id, node_block(/* FIXME (#2543) */ copy *b)); visit::visit_block(b, cx, v); } @@ -239,24 +239,24 @@ pub fn number_pat(cx: @mut Ctx, pat: @pat) { }; } -pub fn map_local(loc: @local, &&cx: @mut Ctx, v: visit::vt<@mut Ctx>) { +pub fn map_local(loc: @local, cx: @mut Ctx, v: visit::vt<@mut Ctx>) { number_pat(cx, loc.node.pat); visit::visit_local(loc, cx, v); } -pub fn map_arm(arm: &arm, &&cx: @mut Ctx, v: visit::vt<@mut Ctx>) { +pub fn map_arm(arm: &arm, cx: @mut Ctx, v: visit::vt<@mut Ctx>) { number_pat(cx, arm.pats[0]); visit::visit_arm(arm, cx, v); } pub fn map_method(impl_did: def_id, impl_path: @path, - m: @method, &&cx: @mut Ctx) { + m: @method, cx: @mut Ctx) { cx.map.insert(m.id, node_method(m, impl_did, impl_path)); cx.map.insert(m.self_id, node_local(cx.local_id)); cx.local_id += 1u; } -pub fn map_item(i: @item, &&cx: @mut Ctx, v: visit::vt<@mut Ctx>) { +pub fn map_item(i: @item, cx: @mut Ctx, v: visit::vt<@mut Ctx>) { let item_path = @/* FIXME (#2543) */ copy cx.path; cx.map.insert(i.id, node_item(i, item_path)); match i.node { @@ -355,13 +355,13 @@ pub fn map_struct_def( } } -pub fn map_expr(ex: @expr, &&cx: @mut Ctx, v: visit::vt<@mut Ctx>) { +pub fn map_expr(ex: @expr, cx: @mut Ctx, v: visit::vt<@mut Ctx>) { cx.map.insert(ex.id, node_expr(ex)); visit::visit_expr(ex, cx, v); } -pub fn map_stmt(stmt: @stmt, &&cx: @mut Ctx, v: visit::vt<@mut Ctx>) { - cx.map.insert(stmt_id(*stmt), node_stmt(stmt)); +pub fn map_stmt(stmt: @stmt, cx: @mut Ctx, v: visit::vt<@mut Ctx>) { + cx.map.insert(stmt_id(stmt), node_stmt(stmt)); visit::visit_stmt(stmt, cx, v); } @@ -408,7 +408,7 @@ pub fn node_id_to_str(map: map, id: node_id, itr: @ident_interner) -> ~str { } Some(&node_stmt(stmt)) => { fmt!("stmt %s (id=%?)", - pprust::stmt_to_str(*stmt, itr), id) + pprust::stmt_to_str(stmt, itr), id) } Some(&node_arg(_, _)) => { // add more info here fmt!("arg (id=%?)", id) @@ -430,7 +430,7 @@ pub fn node_id_to_str(map: map, id: node_id, itr: @ident_interner) -> ~str { pub fn node_item_query<Result>(items: map, id: node_id, query: &fn(@item) -> Result, - +error_msg: ~str) -> Result { + error_msg: ~str) -> Result { match items.find(&id) { Some(&node_item(it, _)) => query(it), _ => fail!(error_msg) diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index 59a640bb571..910c9857d2d 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -39,7 +39,7 @@ pub fn local_def(id: node_id) -> def_id { pub fn is_local(did: ast::def_id) -> bool { did.crate == local_crate } -pub fn stmt_id(s: stmt) -> node_id { +pub fn stmt_id(s: &stmt) -> node_id { match s.node { stmt_decl(_, id) => id, stmt_expr(_, id) => id, @@ -200,7 +200,7 @@ pub fn is_call_expr(e: @expr) -> bool { // This makes def_id hashable impl to_bytes::IterBytes for def_id { #[inline(always)] - fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { to_bytes::iter_bytes_2(&self.crate, &self.node, lsb0, f); } } @@ -211,7 +211,7 @@ pub fn block_from_expr(e: @expr) -> blk { } pub fn default_block( - +stmts1: ~[@stmt], + stmts1: ~[@stmt], expr1: Option<@expr>, id1: node_id ) -> blk_ { @@ -224,7 +224,7 @@ pub fn default_block( } } -pub fn ident_to_path(s: span, +i: ident) -> @Path { +pub fn ident_to_path(s: span, i: ident) -> @Path { @ast::Path { span: s, global: false, idents: ~[i], @@ -232,7 +232,7 @@ pub fn ident_to_path(s: span, +i: ident) -> @Path { types: ~[] } } -pub fn ident_to_pat(id: node_id, s: span, +i: ident) -> @pat { +pub fn ident_to_pat(id: node_id, s: span, i: ident) -> @pat { @ast::pat { id: id, node: pat_ident(bind_by_copy, ident_to_path(s, i), None), span: s } @@ -300,7 +300,7 @@ pub fn struct_field_visibility(field: ast::struct_field) -> visibility { pub trait inlined_item_utils { fn ident(&self) -> ident; fn id(&self) -> ast::node_id; - fn accept<E>(&self, e: E, v: visit::vt<E>); + fn accept<E: Copy>(&self, e: E, v: visit::vt<E>); } impl inlined_item_utils for inlined_item { @@ -322,7 +322,7 @@ impl inlined_item_utils for inlined_item { } } - fn accept<E>(&self, e: E, v: visit::vt<E>) { + fn accept<E: Copy>(&self, e: E, v: visit::vt<E>) { match *self { ii_item(i) => (v.visit_item)(i, e, v), ii_foreign(i) => (v.visit_foreign_item)(i, e, v), @@ -435,7 +435,7 @@ pub fn id_visitor(vfn: @fn(node_id)) -> visit::vt<()> { visit_local: |l| vfn(l.node.id), visit_block: |b| vfn(b.node.id), - visit_stmt: |s| vfn(ast_util::stmt_id(*s)), + visit_stmt: |s| vfn(ast_util::stmt_id(s)), visit_arm: |_| {}, visit_pat: |p| vfn(p.id), visit_decl: |_| {}, @@ -491,7 +491,7 @@ pub fn id_visitor(vfn: @fn(node_id)) -> visit::vt<()> { }) } -pub fn visit_ids_for_inlined_item(item: inlined_item, vfn: @fn(node_id)) { +pub fn visit_ids_for_inlined_item(item: &inlined_item, vfn: @fn(node_id)) { item.accept((), id_visitor(vfn)); } @@ -505,7 +505,7 @@ pub fn compute_id_range(visit_ids_fn: &fn(@fn(node_id))) -> id_range { id_range { min: *min, max: *max } } -pub fn compute_id_range_for_inlined_item(item: inlined_item) -> id_range { +pub fn compute_id_range_for_inlined_item(item: &inlined_item) -> id_range { compute_id_range(|f| visit_ids_for_inlined_item(item, f)) } @@ -609,7 +609,7 @@ pub fn mk_rename (id:ident, to:Name, tail:SyntaxContext, table: &mut SCTable) pub fn mk_sctable() -> SCTable { ~[EmptyCtxt] } /// Add a value to the end of a vec, return its index -fn idx_push<T>(vec: &mut ~[T], +val: T) -> uint { +fn idx_push<T>(vec: &mut ~[T], val: T) -> uint { vec.push(val); vec.len() - 1 } diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs index 5063a0381e7..98cfdd33ef6 100644 --- a/src/libsyntax/attr.rs +++ b/src/libsyntax/attr.rs @@ -31,12 +31,12 @@ pub fn mk_name_value_item_str(name: @~str, value: @~str) mk_name_value_item(name, value_lit) } -pub fn mk_name_value_item(name: @~str, +value: ast::lit) +pub fn mk_name_value_item(name: @~str, value: ast::lit) -> @ast::meta_item { @dummy_spanned(ast::meta_name_value(name, value)) } -pub fn mk_list_item(name: @~str, +items: ~[@ast::meta_item]) -> +pub fn mk_list_item(name: @~str, items: ~[@ast::meta_item]) -> @ast::meta_item { @dummy_spanned(ast::meta_list(name, items)) } @@ -51,8 +51,8 @@ pub fn mk_attr(item: @ast::meta_item) -> ast::attribute { is_sugared_doc: false }) } -pub fn mk_sugared_doc_attr(+text: ~str, - +lo: BytePos, +hi: BytePos) -> ast::attribute { +pub fn mk_sugared_doc_attr(text: ~str, + lo: BytePos, hi: BytePos) -> ast::attribute { let style = doc_comment_style(text); let lit = spanned(lo, hi, ast::lit_str(@text)); let attr = ast::attribute_ { diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index 0ed371d9c9a..bd8aa7011b7 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -71,7 +71,7 @@ impl Sub<BytePos, BytePos> for BytePos { } impl to_bytes::IterBytes for BytePos { - fn iter_bytes(&self, +lsb0: bool, &&f: to_bytes::Cb) { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { (**self).iter_bytes(lsb0, f) } } @@ -89,7 +89,7 @@ impl cmp::Ord for CharPos { } impl to_bytes::IterBytes for CharPos { - fn iter_bytes(&self, +lsb0: bool, &&f: to_bytes::Cb) { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { (**self).iter_bytes(lsb0, f) } } @@ -141,20 +141,20 @@ impl<D:Decoder> Decodable<D> for span { } } -pub fn spanned<T>(+lo: BytePos, +hi: BytePos, +t: T) -> spanned<T> { +pub fn spanned<T>(lo: BytePos, hi: BytePos, t: T) -> spanned<T> { respan(mk_sp(lo, hi), t) } -pub fn respan<T>(sp: span, +t: T) -> spanned<T> { +pub fn respan<T>(sp: span, t: T) -> spanned<T> { spanned {node: t, span: sp} } -pub fn dummy_spanned<T>(+t: T) -> spanned<T> { +pub fn dummy_spanned<T>(t: T) -> spanned<T> { respan(dummy_sp(), t) } /* assuming that we're not in macro expansion */ -pub fn mk_sp(+lo: BytePos, +hi: BytePos) -> span { +pub fn mk_sp(lo: BytePos, hi: BytePos) -> span { span {lo: lo, hi: hi, expn_info: None} } @@ -247,7 +247,7 @@ pub impl FileMap { // UNCHECKED INVARIANT: these offsets must be added in the right // order and must be in the right places; there is shared knowledge // about what ends a line between this file and parse.rs - fn next_line(&self, +pos: BytePos) { + fn next_line(&self, pos: BytePos) { // the new charpos must be > the last one (or it's the first one). let lines = &mut *self.lines; assert!((lines.len() == 0) || (lines[lines.len() - 1] < pos)); @@ -287,14 +287,14 @@ pub impl CodeMap { } /// Add a new FileMap to the CodeMap and return it - fn new_filemap(&self, +filename: FileName, src: @~str) -> @FileMap { + fn new_filemap(&self, filename: FileName, src: @~str) -> @FileMap { return self.new_filemap_w_substr(filename, FssNone, src); } fn new_filemap_w_substr( &self, - +filename: FileName, - +substr: FileSubstr, + filename: FileName, + substr: FileSubstr, src: @~str ) -> @FileMap { let files = &mut *self.files; @@ -325,11 +325,11 @@ pub impl CodeMap { } /// Lookup source information about a BytePos - pub fn lookup_char_pos(&self, +pos: BytePos) -> Loc { + pub fn lookup_char_pos(&self, pos: BytePos) -> Loc { return self.lookup_pos(pos); } - pub fn lookup_char_pos_adj(&self, +pos: BytePos) -> LocWithOpt + pub fn lookup_char_pos_adj(&self, pos: BytePos) -> LocWithOpt { let loc = self.lookup_char_pos(pos); match (loc.file.substr) { @@ -405,7 +405,7 @@ pub impl CodeMap { priv impl CodeMap { - fn lookup_filemap_idx(&self, +pos: BytePos) -> uint { + fn lookup_filemap_idx(&self, pos: BytePos) -> uint { let files = &*self.files; let len = files.len(); let mut a = 0u; @@ -440,7 +440,7 @@ priv impl CodeMap { return FileMapAndLine {fm: f, line: a}; } - fn lookup_pos(&self, +pos: BytePos) -> Loc { + fn lookup_pos(&self, pos: BytePos) -> Loc { let FileMapAndLine {fm: f, line: a} = self.lookup_line(pos); let line = a + 1u; // Line numbers start at 1 let chpos = self.bytepos_to_local_charpos(pos); @@ -466,7 +466,7 @@ priv impl CodeMap { lo.line, lo.col.to_uint(), hi.line, hi.col.to_uint()) } - fn lookup_byte_offset(&self, +bpos: BytePos) + fn lookup_byte_offset(&self, bpos: BytePos) -> FileMapAndBytePos { let idx = self.lookup_filemap_idx(bpos); let fm = self.files[idx]; @@ -476,7 +476,7 @@ priv impl CodeMap { // Converts an absolute BytePos to a CharPos relative to the file it is // located in - fn bytepos_to_local_charpos(&self, +bpos: BytePos) -> CharPos { + fn bytepos_to_local_charpos(&self, bpos: BytePos) -> CharPos { debug!("codemap: converting %? to char pos", bpos); let idx = self.lookup_filemap_idx(bpos); let map = self.files[idx]; diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs index e53a8f361b5..67c09c00733 100644 --- a/src/libsyntax/ext/auto_encode.rs +++ b/src/libsyntax/ext/auto_encode.rs @@ -239,7 +239,7 @@ priv impl @ext_ctxt { } } - fn expr(&self, span: span, +node: ast::expr_) -> @ast::expr { + fn expr(&self, span: span, node: ast::expr_) -> @ast::expr { @ast::expr { id: self.next_id(), callee_id: self.next_id(), @@ -248,7 +248,7 @@ priv impl @ext_ctxt { } } - fn path(&self, span: span, +strs: ~[ast::ident]) -> @ast::Path { + fn path(&self, span: span, strs: ~[ast::ident]) -> @ast::Path { @ast::Path { span: span, global: false, @@ -258,7 +258,7 @@ priv impl @ext_ctxt { } } - fn path_global(&self, span: span, +strs: ~[ast::ident]) -> @ast::Path { + fn path_global(&self, span: span, strs: ~[ast::ident]) -> @ast::Path { @ast::Path { span: span, global: true, @@ -271,8 +271,8 @@ priv impl @ext_ctxt { fn path_tps( &self, span: span, - +strs: ~[ast::ident], - +tps: ~[@ast::Ty] + strs: ~[ast::ident], + tps: ~[@ast::Ty] ) -> @ast::Path { @ast::Path { span: span, @@ -286,8 +286,8 @@ priv impl @ext_ctxt { fn path_tps_global( &self, span: span, - +strs: ~[ast::ident], - +tps: ~[@ast::Ty] + strs: ~[ast::ident], + tps: ~[@ast::Ty] ) -> @ast::Path { @ast::Path { span: span, @@ -301,8 +301,8 @@ priv impl @ext_ctxt { fn ty_path( &self, span: span, - +strs: ~[ast::ident], - +tps: ~[@ast::Ty] + strs: ~[ast::ident], + tps: ~[@ast::Ty] ) -> @ast::Ty { @ast::Ty { id: self.next_id(), @@ -349,13 +349,13 @@ priv impl @ext_ctxt { span: span})) } - fn lambda(&self, +blk: ast::blk) -> @ast::expr { + fn lambda(&self, blk: ast::blk) -> @ast::expr { let ext_cx = *self; let blk_e = self.expr(copy blk.span, ast::expr_block(copy blk)); quote_expr!( || $blk_e ) } - fn blk(&self, span: span, +stmts: ~[@ast::stmt]) -> ast::blk { + fn blk(&self, span: span, stmts: ~[@ast::stmt]) -> ast::blk { codemap::spanned { node: ast::blk_ { view_items: ~[], @@ -381,19 +381,19 @@ priv impl @ext_ctxt { } } - fn expr_path(&self, span: span, +strs: ~[ast::ident]) -> @ast::expr { + fn expr_path(&self, span: span, strs: ~[ast::ident]) -> @ast::expr { self.expr(span, ast::expr_path(self.path(span, strs))) } fn expr_path_global( &self, span: span, - +strs: ~[ast::ident] + strs: ~[ast::ident] ) -> @ast::expr { self.expr(span, ast::expr_path(self.path_global(span, strs))) } - fn expr_var(&self, span: span, +var: ~str) -> @ast::expr { + fn expr_var(&self, span: span, var: ~str) -> @ast::expr { self.expr_path(span, ~[self.ident_of(var)]) } @@ -410,7 +410,7 @@ priv impl @ext_ctxt { &self, span: span, expr: @ast::expr, - +args: ~[@ast::expr] + args: ~[@ast::expr] ) -> @ast::expr { self.expr(span, ast::expr_call(expr, args, ast::NoSugar)) } @@ -420,7 +420,7 @@ priv impl @ext_ctxt { span: span, expr: @ast::expr, ident: ast::ident, - +args: ~[@ast::expr] + args: ~[@ast::expr] ) -> @ast::expr { self.expr(span, ast::expr_method_call(expr, ident, ~[], args, ast::NoSugar)) } @@ -429,7 +429,7 @@ priv impl @ext_ctxt { self.lambda(self.expr_blk(expr)) } - fn lambda_stmts(&self, span: span, +stmts: ~[@ast::stmt]) -> @ast::expr { + fn lambda_stmts(&self, span: span, stmts: ~[@ast::stmt]) -> @ast::expr { self.lambda(self.blk(span, stmts)) } } @@ -597,7 +597,7 @@ fn mk_deser_impl( fn mk_ser_method( cx: @ext_ctxt, span: span, - +ser_body: ast::blk + ser_body: ast::blk ) -> @ast::method { let ty_s = @ast::Ty { id: cx.next_id(), @@ -660,7 +660,7 @@ fn mk_deser_method( cx: @ext_ctxt, span: span, ty: @ast::Ty, - +deser_body: ast::blk + deser_body: ast::blk ) -> @ast::method { let ty_d = @ast::Ty { id: cx.next_id(), @@ -864,7 +864,7 @@ fn mk_enum_ser_impl( cx: @ext_ctxt, span: span, ident: ast::ident, - +enum_def: ast::enum_def, + enum_def: ast::enum_def, generics: &ast::Generics ) -> @ast::item { let body = mk_enum_ser_body( @@ -881,7 +881,7 @@ fn mk_enum_deser_impl( cx: @ext_ctxt, span: span, ident: ast::ident, - +enum_def: ast::enum_def, + enum_def: ast::enum_def, generics: &ast::Generics ) -> @ast::item { let body = mk_enum_deser_body( @@ -974,7 +974,7 @@ fn mk_enum_ser_body( cx: @ext_ctxt, span: span, name: ast::ident, - +variants: ~[ast::variant] + variants: ~[ast::variant] ) -> @ast::expr { let arms = do variants.mapi |v_idx, variant| { match variant.node.kind { @@ -1219,37 +1219,37 @@ mod test { impl Encoder for TestEncoder { fn emit_nil(&self) { self.add_to_log(CallToEmitNil) } - fn emit_uint(&self, +v: uint) {self.add_to_log(CallToEmitUint(v)); } - fn emit_u64(&self, +_v: u64) { self.add_unknown_to_log(); } - fn emit_u32(&self, +_v: u32) { self.add_unknown_to_log(); } - fn emit_u16(&self, +_v: u16) { self.add_unknown_to_log(); } - fn emit_u8(&self, +_v: u8) { self.add_unknown_to_log(); } + fn emit_uint(&self, v: uint) {self.add_to_log(CallToEmitUint(v)); } + fn emit_u64(&self, _v: u64) { self.add_unknown_to_log(); } + fn emit_u32(&self, _v: u32) { self.add_unknown_to_log(); } + fn emit_u16(&self, _v: u16) { self.add_unknown_to_log(); } + fn emit_u8(&self, _v: u8) { self.add_unknown_to_log(); } - fn emit_int(&self, +_v: int) { self.add_unknown_to_log(); } - fn emit_i64(&self, +_v: i64) { self.add_unknown_to_log(); } - fn emit_i32(&self, +_v: i32) { self.add_unknown_to_log(); } - fn emit_i16(&self, +_v: i16) { self.add_unknown_to_log(); } - fn emit_i8(&self, +_v: i8) { self.add_unknown_to_log(); } + fn emit_int(&self, _v: int) { self.add_unknown_to_log(); } + fn emit_i64(&self, _v: i64) { self.add_unknown_to_log(); } + fn emit_i32(&self, _v: i32) { self.add_unknown_to_log(); } + fn emit_i16(&self, _v: i16) { self.add_unknown_to_log(); } + fn emit_i8(&self, _v: i8) { self.add_unknown_to_log(); } - fn emit_bool(&self, +_v: bool) { self.add_unknown_to_log(); } + fn emit_bool(&self, _v: bool) { self.add_unknown_to_log(); } - fn emit_f64(&self, +_v: f64) { self.add_unknown_to_log(); } - fn emit_f32(&self, +_v: f32) { self.add_unknown_to_log(); } - fn emit_float(&self, +_v: float) { self.add_unknown_to_log(); } + fn emit_f64(&self, _v: f64) { self.add_unknown_to_log(); } + fn emit_f32(&self, _v: f32) { self.add_unknown_to_log(); } + fn emit_float(&self, _v: float) { self.add_unknown_to_log(); } - fn emit_char(&self, +_v: char) { self.add_unknown_to_log(); } - fn emit_str(&self, +_v: &str) { self.add_unknown_to_log(); } + fn emit_char(&self, _v: char) { self.add_unknown_to_log(); } + fn emit_str(&self, _v: &str) { self.add_unknown_to_log(); } fn emit_enum(&self, name: &str, f: &fn()) { self.add_to_log(CallToEmitEnum(name.to_str())); f(); } - fn emit_enum_variant(&self, name: &str, +id: uint, - +cnt: uint, f: &fn()) { + fn emit_enum_variant(&self, name: &str, id: uint, + cnt: uint, f: &fn()) { self.add_to_log(CallToEmitEnumVariant (name.to_str(),id,cnt)); f(); } - fn emit_enum_variant_arg(&self, +idx: uint, f: &fn()) { + fn emit_enum_variant_arg(&self, idx: uint, f: &fn()) { self.add_to_log(CallToEmitEnumVariantArg (idx)); f(); } @@ -1261,10 +1261,10 @@ mod test { self.emit_enum_variant_arg(idx, f) } - fn emit_struct(&self, name: &str, +len: uint, f: &fn()) { + fn emit_struct(&self, name: &str, len: uint, f: &fn()) { self.add_to_log(CallToEmitStruct (name.to_str(),len)); f(); } - fn emit_struct_field(&self, name: &str, +idx: uint, f: &fn()) { + fn emit_struct_field(&self, name: &str, idx: uint, f: &fn()) { self.add_to_log(CallToEmitField (name.to_str(),idx)); f(); } @@ -1294,10 +1294,10 @@ mod test { f(); } - fn emit_seq(&self, +_len: uint, f: &fn()) { + fn emit_seq(&self, _len: uint, f: &fn()) { self.add_unknown_to_log(); f(); } - fn emit_seq_elt(&self, +_idx: uint, f: &fn()) { + fn emit_seq_elt(&self, _idx: uint, f: &fn()) { self.add_unknown_to_log(); f(); } diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 886af694920..4eb48d12bfe 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -238,7 +238,7 @@ pub trait ext_ctxt { fn ident_of(@mut self, st: ~str) -> ast::ident; } -pub fn mk_ctxt(parse_sess: @mut parse::ParseSess, +cfg: ast::crate_cfg) +pub fn mk_ctxt(parse_sess: @mut parse::ParseSess, cfg: ast::crate_cfg) -> @ext_ctxt { struct CtxtRepr { parse_sess: @mut parse::ParseSess, @@ -439,7 +439,7 @@ pub enum MapChain<K,V> { impl <K: Eq + Hash + IterBytes ,V: Copy> MapChain<K,V>{ // Constructor. I don't think we need a zero-arg one. - fn new(+init: ~HashMap<K,@V>) -> @mut MapChain<K,V> { + fn new(init: ~HashMap<K,@V>) -> @mut MapChain<K,V> { @mut BaseMapChain(init) } @@ -509,7 +509,7 @@ impl <K: Eq + Hash + IterBytes ,V: Copy> MapChain<K,V>{ } // insert the binding into the top-level map - fn insert (&mut self, +key: K, +ext: @V) -> bool { + fn insert (&mut self, key: K, ext: @V) -> bool { // can't abstract over get_map because of flow sensitivity... match *self { BaseMapChain (~ref mut map) => map.insert(key, ext), diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index b375adef926..ff78ddb803c 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -27,7 +27,7 @@ pub struct Field { pub fn mk_expr(cx: @ext_ctxt, sp: codemap::span, - +expr: ast::expr_) + expr: ast::expr_) -> @ast::expr { @ast::expr { id: cx.next_id(), @@ -63,12 +63,12 @@ pub fn mk_unary(cx: @ext_ctxt, sp: span, op: ast::unop, e: @ast::expr) cx.next_id(); // see ast_util::op_expr_callee_id mk_expr(cx, sp, ast::expr_unary(op, e)) } -pub fn mk_raw_path(sp: span, +idents: ~[ast::ident]) -> @ast::Path { +pub fn mk_raw_path(sp: span, idents: ~[ast::ident]) -> @ast::Path { mk_raw_path_(sp, idents, ~[]) } pub fn mk_raw_path_(sp: span, - +idents: ~[ast::ident], - +types: ~[@ast::Ty]) + idents: ~[ast::ident], + types: ~[@ast::Ty]) -> @ast::Path { @ast::Path { span: sp, global: false, @@ -76,23 +76,23 @@ pub fn mk_raw_path_(sp: span, rp: None, types: types } } -pub fn mk_raw_path_global(sp: span, +idents: ~[ast::ident]) -> @ast::Path { +pub fn mk_raw_path_global(sp: span, idents: ~[ast::ident]) -> @ast::Path { mk_raw_path_global_(sp, idents, ~[]) } pub fn mk_raw_path_global_(sp: span, - +idents: ~[ast::ident], - +types: ~[@ast::Ty]) -> @ast::Path { + idents: ~[ast::ident], + types: ~[@ast::Ty]) -> @ast::Path { @ast::Path { span: sp, global: true, idents: idents, rp: None, types: types } } -pub fn mk_path(cx: @ext_ctxt, sp: span, +idents: ~[ast::ident]) +pub fn mk_path(cx: @ext_ctxt, sp: span, idents: ~[ast::ident]) -> @ast::expr { mk_expr(cx, sp, ast::expr_path(mk_raw_path(sp, idents))) } -pub fn mk_path_global(cx: @ext_ctxt, sp: span, +idents: ~[ast::ident]) +pub fn mk_path_global(cx: @ext_ctxt, sp: span, idents: ~[ast::ident]) -> @ast::expr { mk_expr(cx, sp, ast::expr_path(mk_raw_path_global(sp, idents))) } @@ -100,7 +100,7 @@ pub fn mk_access_(cx: @ext_ctxt, sp: span, p: @ast::expr, m: ast::ident) -> @ast::expr { mk_expr(cx, sp, ast::expr_field(p, m, ~[])) } -pub fn mk_access(cx: @ext_ctxt, sp: span, +p: ~[ast::ident], m: ast::ident) +pub fn mk_access(cx: @ext_ctxt, sp: span, p: ~[ast::ident], m: ast::ident) -> @ast::expr { let pathexpr = mk_path(cx, sp, p); return mk_access_(cx, sp, pathexpr, m); @@ -115,25 +115,25 @@ pub fn mk_method_call(cx: @ext_ctxt, sp: span, rcvr_expr: @ast::expr, method_ident: ast::ident, - +args: ~[@ast::expr]) -> @ast::expr { + args: ~[@ast::expr]) -> @ast::expr { mk_expr(cx, sp, ast::expr_method_call(rcvr_expr, method_ident, ~[], args, ast::NoSugar)) } pub fn mk_call_(cx: @ext_ctxt, sp: span, fn_expr: @ast::expr, - +args: ~[@ast::expr]) -> @ast::expr { + args: ~[@ast::expr]) -> @ast::expr { mk_expr(cx, sp, ast::expr_call(fn_expr, args, ast::NoSugar)) } -pub fn mk_call(cx: @ext_ctxt, sp: span, +fn_path: ~[ast::ident], - +args: ~[@ast::expr]) -> @ast::expr { +pub fn mk_call(cx: @ext_ctxt, sp: span, fn_path: ~[ast::ident], + args: ~[@ast::expr]) -> @ast::expr { let pathexpr = mk_path(cx, sp, fn_path); return mk_call_(cx, sp, pathexpr, args); } -pub fn mk_call_global(cx: @ext_ctxt, sp: span, +fn_path: ~[ast::ident], - +args: ~[@ast::expr]) -> @ast::expr { +pub fn mk_call_global(cx: @ext_ctxt, sp: span, fn_path: ~[ast::ident], + args: ~[@ast::expr]) -> @ast::expr { let pathexpr = mk_path_global(cx, sp, fn_path); return mk_call_(cx, sp, pathexpr, args); } // e = expr, t = type -pub fn mk_base_vec_e(cx: @ext_ctxt, sp: span, +exprs: ~[@ast::expr]) +pub fn mk_base_vec_e(cx: @ext_ctxt, sp: span, exprs: ~[@ast::expr]) -> @ast::expr { let vecexpr = ast::expr_vec(exprs, ast::m_imm); mk_expr(cx, sp, vecexpr) @@ -143,20 +143,20 @@ pub fn mk_vstore_e(cx: @ext_ctxt, sp: span, expr: @ast::expr, @ast::expr { mk_expr(cx, sp, ast::expr_vstore(expr, vst)) } -pub fn mk_uniq_vec_e(cx: @ext_ctxt, sp: span, +exprs: ~[@ast::expr]) +pub fn mk_uniq_vec_e(cx: @ext_ctxt, sp: span, exprs: ~[@ast::expr]) -> @ast::expr { mk_vstore_e(cx, sp, mk_base_vec_e(cx, sp, exprs), ast::expr_vstore_uniq) } -pub fn mk_slice_vec_e(cx: @ext_ctxt, sp: span, +exprs: ~[@ast::expr]) +pub fn mk_slice_vec_e(cx: @ext_ctxt, sp: span, exprs: ~[@ast::expr]) -> @ast::expr { mk_vstore_e(cx, sp, mk_base_vec_e(cx, sp, exprs), ast::expr_vstore_slice) } -pub fn mk_base_str(cx: @ext_ctxt, sp: span, +s: ~str) -> @ast::expr { +pub fn mk_base_str(cx: @ext_ctxt, sp: span, s: ~str) -> @ast::expr { let lit = ast::lit_str(@s); return mk_lit(cx, sp, lit); } -pub fn mk_uniq_str(cx: @ext_ctxt, sp: span, +s: ~str) -> @ast::expr { +pub fn mk_uniq_str(cx: @ext_ctxt, sp: span, s: ~str) -> @ast::expr { mk_vstore_e(cx, sp, mk_base_str(cx, sp, s), ast::expr_vstore_uniq) } pub fn mk_field(sp: span, f: &Field) -> ast::field { @@ -170,8 +170,8 @@ pub fn mk_fields(sp: span, fields: ~[Field]) -> ~[ast::field] { } pub fn mk_struct_e(cx: @ext_ctxt, sp: span, - +ctor_path: ~[ast::ident], - +fields: ~[Field]) + ctor_path: ~[ast::ident], + fields: ~[Field]) -> @ast::expr { mk_expr(cx, sp, ast::expr_struct(mk_raw_path(sp, ctor_path), @@ -180,8 +180,8 @@ pub fn mk_struct_e(cx: @ext_ctxt, } pub fn mk_global_struct_e(cx: @ext_ctxt, sp: span, - +ctor_path: ~[ast::ident], - +fields: ~[Field]) + ctor_path: ~[ast::ident], + fields: ~[Field]) -> @ast::expr { mk_expr(cx, sp, ast::expr_struct(mk_raw_path_global(sp, ctor_path), @@ -190,7 +190,7 @@ pub fn mk_global_struct_e(cx: @ext_ctxt, } pub fn mk_glob_use(cx: @ext_ctxt, sp: span, - +path: ~[ast::ident]) -> @ast::view_item { + path: ~[ast::ident]) -> @ast::view_item { let glob = @codemap::spanned { node: ast::view_path_glob(mk_raw_path(sp, path), cx.next_id()), span: sp, @@ -226,8 +226,8 @@ pub fn mk_local(cx: @ext_ctxt, sp: span, mutbl: bool, @codemap::spanned { node: ast::stmt_decl(@decl, cx.next_id()), span: sp } } pub fn mk_block(cx: @ext_ctxt, span: span, - +view_items: ~[@ast::view_item], - +stmts: ~[@ast::stmt], + view_items: ~[@ast::view_item], + stmts: ~[@ast::stmt], expr: Option<@ast::expr>) -> @ast::expr { let blk = codemap::spanned { node: ast::blk_ { @@ -243,7 +243,7 @@ pub fn mk_block(cx: @ext_ctxt, span: span, } pub fn mk_block_(cx: @ext_ctxt, span: span, - +stmts: ~[@ast::stmt]) + stmts: ~[@ast::stmt]) -> ast::blk { codemap::spanned { node: ast::blk_ { @@ -307,7 +307,7 @@ pub fn mk_copy(cx: @ext_ctxt, sp: span, e: @ast::expr) -> @ast::expr { pub fn mk_managed(cx: @ext_ctxt, sp: span, e: @ast::expr) -> @ast::expr { mk_expr(cx, sp, ast::expr_unary(ast::box(ast::m_imm), e)) } -pub fn mk_pat(cx: @ext_ctxt, span: span, +pat: ast::pat_) -> @ast::pat { +pub fn mk_pat(cx: @ext_ctxt, span: span, pat: ast::pat_) -> @ast::pat { @ast::pat { id: cx.next_id(), node: pat, span: span } } pub fn mk_pat_wild(cx: @ext_ctxt, span: span) -> @ast::pat { @@ -335,7 +335,7 @@ pub fn mk_pat_ident_with_binding_mode(cx: @ext_ctxt, pub fn mk_pat_enum(cx: @ext_ctxt, span: span, path: @ast::Path, - +subpats: ~[@ast::pat]) + subpats: ~[@ast::pat]) -> @ast::pat { let pat = ast::pat_enum(path, Some(subpats)); mk_pat(cx, span, pat) @@ -343,7 +343,7 @@ pub fn mk_pat_enum(cx: @ext_ctxt, pub fn mk_pat_struct(cx: @ext_ctxt, span: span, path: @ast::Path, - +field_pats: ~[ast::field_pat]) + field_pats: ~[ast::field_pat]) -> @ast::pat { let pat = ast::pat_struct(path, field_pats, false); mk_pat(cx, span, pat) @@ -360,7 +360,7 @@ pub fn mk_stmt(cx: @ext_ctxt, span: span, expr: @ast::expr) -> @ast::stmt { } pub fn mk_ty_path(cx: @ext_ctxt, span: span, - +idents: ~[ ast::ident ]) + idents: ~[ ast::ident ]) -> @ast::Ty { let ty = build::mk_raw_path(span, idents); let ty = ast::ty_path(ty, cx.next_id()); @@ -369,7 +369,7 @@ pub fn mk_ty_path(cx: @ext_ctxt, } pub fn mk_ty_path_global(cx: @ext_ctxt, span: span, - +idents: ~[ ast::ident ]) + idents: ~[ ast::ident ]) -> @ast::Ty { let ty = build::mk_raw_path_global(span, idents); let ty = ast::ty_path(ty, cx.next_id()); @@ -399,7 +399,7 @@ pub fn mk_ty_infer(cx: @ext_ctxt, span: span) -> @ast::Ty { } pub fn mk_trait_ref_global(cx: @ext_ctxt, span: span, - +idents: ~[ ast::ident ]) + idents: ~[ ast::ident ]) -> @ast::trait_ref { mk_trait_ref_(cx, build::mk_raw_path_global(span, idents)) @@ -430,12 +430,12 @@ pub fn mk_arg(cx: @ext_ctxt, id: cx.next_id() } } -pub fn mk_fn_decl(+inputs: ~[ast::arg], output: @ast::Ty) -> ast::fn_decl { +pub fn mk_fn_decl(inputs: ~[ast::arg], output: @ast::Ty) -> ast::fn_decl { ast::fn_decl { inputs: inputs, output: output, cf: ast::return_val } } pub fn mk_trait_ty_param_bound_global(cx: @ext_ctxt, span: span, - +idents: ~[ast::ident]) + idents: ~[ast::ident]) -> ast::TyParamBound { ast::TraitTyParamBound(mk_trait_ref_global(cx, span, idents)) } diff --git a/src/libsyntax/ext/deriving/encodable.rs b/src/libsyntax/ext/deriving/encodable.rs index 9776f484818..6fd27c5f3d7 100644 --- a/src/libsyntax/ext/deriving/encodable.rs +++ b/src/libsyntax/ext/deriving/encodable.rs @@ -91,7 +91,7 @@ fn create_derived_encodable_impl( fn create_encode_method( cx: @ext_ctxt, span: span, - +statements: ~[@stmt] + statements: ~[@stmt] ) -> @method { // Create the `e` parameter. let e_arg_type = build::mk_ty_rptr( diff --git a/src/libsyntax/ext/deriving/iter_bytes.rs b/src/libsyntax/ext/deriving/iter_bytes.rs index 75215b90eb0..85592d142ab 100644 --- a/src/libsyntax/ext/deriving/iter_bytes.rs +++ b/src/libsyntax/ext/deriving/iter_bytes.rs @@ -64,7 +64,7 @@ fn create_derived_iter_bytes_impl(cx: @ext_ctxt, // signature of the `iter_bytes` method. fn create_iter_bytes_method(cx: @ext_ctxt, span: span, - +statements: ~[@stmt]) + statements: ~[@stmt]) -> @method { // Create the `lsb0` parameter. let bool_ident = cx.ident_of(~"bool"); diff --git a/src/libsyntax/ext/deriving/mod.rs b/src/libsyntax/ext/deriving/mod.rs index 78faf5556b2..577cf4c01cf 100644 --- a/src/libsyntax/ext/deriving/mod.rs +++ b/src/libsyntax/ext/deriving/mod.rs @@ -142,7 +142,7 @@ pub fn expand_deriving(cx: @ext_ctxt, result } -fn create_impl_item(cx: @ext_ctxt, span: span, +item: item_) -> @item { +fn create_impl_item(cx: @ext_ctxt, span: span, item: item_) -> @item { let doc_attr = respan(span, ast::lit_str(@~"Automatically derived.")); let doc_attr = respan(span, ast::meta_name_value(@~"doc", doc_attr)); diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 430402a8982..61032429c93 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -237,8 +237,8 @@ macro_rules! without_macro_scoping( // Support for item-position macro invocations, exactly the same // logic as for expression-position macro invocations. -pub fn expand_item_mac(+extsbox: @mut SyntaxEnv, - cx: @ext_ctxt, &&it: @ast::item, +pub fn expand_item_mac(extsbox: @mut SyntaxEnv, + cx: @ext_ctxt, it: @ast::item, fld: @ast_fold) -> Option<@ast::item> { let (pth, tts) = match it.node { diff --git a/src/libsyntax/ext/pipes/ast_builder.rs b/src/libsyntax/ext/pipes/ast_builder.rs index 5eea58b89b1..e0f6c90f5b3 100644 --- a/src/libsyntax/ext/pipes/ast_builder.rs +++ b/src/libsyntax/ext/pipes/ast_builder.rs @@ -34,7 +34,7 @@ mod syntax { pub use parse; } -pub fn path(+ids: ~[ident], span: span) -> @ast::Path { +pub fn path(ids: ~[ident], span: span) -> @ast::Path { @ast::Path { span: span, global: false, idents: ids, @@ -42,7 +42,7 @@ pub fn path(+ids: ~[ident], span: span) -> @ast::Path { types: ~[] } } -pub fn path_global(+ids: ~[ident], span: span) -> @ast::Path { +pub fn path_global(ids: ~[ident], span: span) -> @ast::Path { @ast::Path { span: span, global: true, idents: ids, @@ -52,7 +52,7 @@ pub fn path_global(+ids: ~[ident], span: span) -> @ast::Path { pub trait append_types { fn add_ty(&self, ty: @ast::Ty) -> @ast::Path; - fn add_tys(&self, +tys: ~[@ast::Ty]) -> @ast::Path; + fn add_tys(&self, tys: ~[@ast::Ty]) -> @ast::Path; } impl append_types for @ast::Path { @@ -63,7 +63,7 @@ impl append_types for @ast::Path { } } - fn add_tys(&self, +tys: ~[@ast::Ty]) -> @ast::Path { + fn add_tys(&self, tys: ~[@ast::Ty]) -> @ast::Path { @ast::Path { types: vec::append(copy self.types, tys), .. copy **self @@ -76,63 +76,63 @@ pub trait ext_ctxt_ast_builder { -> ast::TyParam; fn arg(&self, name: ident, ty: @ast::Ty) -> ast::arg; fn expr_block(&self, e: @ast::expr) -> ast::blk; - fn fn_decl(&self, +inputs: ~[ast::arg], output: @ast::Ty) -> ast::fn_decl; - fn item(&self, name: ident, span: span, +node: ast::item_) -> @ast::item; + fn fn_decl(&self, inputs: ~[ast::arg], output: @ast::Ty) -> ast::fn_decl; + fn item(&self, name: ident, span: span, node: ast::item_) -> @ast::item; fn item_fn_poly(&self, ame: ident, - +inputs: ~[ast::arg], + inputs: ~[ast::arg], output: @ast::Ty, - +generics: Generics, - +body: ast::blk) -> @ast::item; + generics: Generics, + body: ast::blk) -> @ast::item; fn item_fn(&self, name: ident, - +inputs: ~[ast::arg], + inputs: ~[ast::arg], output: @ast::Ty, - +body: ast::blk) -> @ast::item; + body: ast::blk) -> @ast::item; fn item_enum_poly(&self, name: ident, span: span, - +enum_definition: ast::enum_def, - +generics: Generics) -> @ast::item; + enum_definition: ast::enum_def, + generics: Generics) -> @ast::item; fn item_enum(&self, name: ident, span: span, - +enum_definition: ast::enum_def) -> @ast::item; + enum_definition: ast::enum_def) -> @ast::item; fn item_struct_poly(&self, name: ident, span: span, - +struct_def: ast::struct_def, - +generics: Generics) -> @ast::item; + struct_def: ast::struct_def, + generics: Generics) -> @ast::item; fn item_struct(&self, name: ident, span: span, - +struct_def: ast::struct_def) -> @ast::item; + struct_def: ast::struct_def) -> @ast::item; fn struct_expr(&self, path: @ast::Path, - +fields: ~[ast::field]) -> @ast::expr; + fields: ~[ast::field]) -> @ast::expr; fn variant(&self, name: ident, span: span, - +tys: ~[@ast::Ty]) -> ast::variant; + tys: ~[@ast::Ty]) -> ast::variant; fn item_mod(&self, name: ident, span: span, - +items: ~[@ast::item]) -> @ast::item; + items: ~[@ast::item]) -> @ast::item; fn ty_path_ast_builder(&self, path: @ast::Path) -> @ast::Ty; fn item_ty_poly(&self, name: ident, span: span, ty: @ast::Ty, - +generics: Generics) -> @ast::item; + generics: Generics) -> @ast::item; fn item_ty(&self, name: ident, span: span, ty: @ast::Ty) -> @ast::item; fn ty_vars(&self, ty_params: &OptVec<ast::TyParam>) -> ~[@ast::Ty]; fn ty_vars_global(&self, ty_params: &OptVec<ast::TyParam>) -> ~[@ast::Ty]; fn ty_field_imm(&self, name: ident, ty: @ast::Ty) -> ast::ty_field; fn field_imm(&self, name: ident, e: @ast::expr) -> ast::field; - fn block(&self, +stmts: ~[@ast::stmt], e: @ast::expr) -> ast::blk; + fn block(&self, stmts: ~[@ast::stmt], e: @ast::expr) -> ast::blk; fn stmt_let(&self, ident: ident, e: @ast::expr) -> @ast::stmt; fn stmt_expr(&self, e: @ast::expr) -> @ast::stmt; - fn block_expr(&self, +b: ast::blk) -> @ast::expr; + fn block_expr(&self, b: ast::blk) -> @ast::expr; fn ty_option(&self, ty: @ast::Ty) -> @ast::Ty; fn ty_infer(&self) -> @ast::Ty; fn ty_nil_ast_builder(&self) -> @ast::Ty; @@ -148,7 +148,7 @@ impl ext_ctxt_ast_builder for @ext_ctxt { ], dummy_sp()).add_ty(ty)) } - fn block_expr(&self, +b: ast::blk) -> @ast::expr { + fn block_expr(&self, b: ast::blk) -> @ast::expr { @expr { id: self.next_id(), callee_id: self.next_id(), @@ -215,7 +215,7 @@ impl ext_ctxt_ast_builder for @ext_ctxt { } } - fn block(&self, +stmts: ~[@ast::stmt], e: @ast::expr) -> ast::blk { + fn block(&self, stmts: ~[@ast::stmt], e: @ast::expr) -> ast::blk { let blk = ast::blk_ { view_items: ~[], stmts: stmts, @@ -231,7 +231,7 @@ impl ext_ctxt_ast_builder for @ext_ctxt { self.block(~[], e) } - fn fn_decl(&self, +inputs: ~[ast::arg], + fn fn_decl(&self, inputs: ~[ast::arg], output: @ast::Ty) -> ast::fn_decl { ast::fn_decl { inputs: inputs, @@ -241,7 +241,7 @@ impl ext_ctxt_ast_builder for @ext_ctxt { } fn item(&self, name: ident, span: span, - +node: ast::item_) -> @ast::item { + node: ast::item_) -> @ast::item { // XXX: Would be nice if our generated code didn't violate // Rust coding conventions @@ -265,10 +265,10 @@ impl ext_ctxt_ast_builder for @ext_ctxt { } fn item_fn_poly(&self, name: ident, - +inputs: ~[ast::arg], + inputs: ~[ast::arg], output: @ast::Ty, - +generics: Generics, - +body: ast::blk) -> @ast::item { + generics: Generics, + body: ast::blk) -> @ast::item { self.item(name, dummy_sp(), ast::item_fn(self.fn_decl(inputs, output), @@ -280,9 +280,9 @@ impl ext_ctxt_ast_builder for @ext_ctxt { fn item_fn(&self, name: ident, - +inputs: ~[ast::arg], + inputs: ~[ast::arg], output: @ast::Ty, - +body: ast::blk + body: ast::blk ) -> @ast::item { self.item_fn_poly( name, @@ -294,13 +294,13 @@ impl ext_ctxt_ast_builder for @ext_ctxt { } fn item_enum_poly(&self, name: ident, span: span, - +enum_definition: ast::enum_def, - +generics: Generics) -> @ast::item { + enum_definition: ast::enum_def, + generics: Generics) -> @ast::item { self.item(name, span, ast::item_enum(enum_definition, generics)) } fn item_enum(&self, name: ident, span: span, - +enum_definition: ast::enum_def) -> @ast::item { + enum_definition: ast::enum_def) -> @ast::item { self.item_enum_poly(name, span, enum_definition, ast_util::empty_generics()) } @@ -308,7 +308,7 @@ impl ext_ctxt_ast_builder for @ext_ctxt { fn item_struct( &self, name: ident, span: span, - +struct_def: ast::struct_def + struct_def: ast::struct_def ) -> @ast::item { self.item_struct_poly( name, @@ -322,14 +322,14 @@ impl ext_ctxt_ast_builder for @ext_ctxt { &self, name: ident, span: span, - +struct_def: ast::struct_def, - +generics: Generics + struct_def: ast::struct_def, + generics: Generics ) -> @ast::item { self.item(name, span, ast::item_struct(@struct_def, generics)) } fn struct_expr(&self, path: @ast::Path, - +fields: ~[ast::field]) -> @ast::expr { + fields: ~[ast::field]) -> @ast::expr { @ast::expr { id: self.next_id(), callee_id: self.next_id(), @@ -339,7 +339,7 @@ impl ext_ctxt_ast_builder for @ext_ctxt { } fn variant(&self, name: ident, span: span, - +tys: ~[@ast::Ty]) -> ast::variant { + tys: ~[@ast::Ty]) -> ast::variant { let args = do tys.map |ty| { ast::variant_arg { ty: *ty, id: self.next_id() } }; @@ -358,7 +358,7 @@ impl ext_ctxt_ast_builder for @ext_ctxt { } fn item_mod(&self, name: ident, span: span, - +items: ~[@ast::item]) -> @ast::item { + items: ~[@ast::item]) -> @ast::item { // XXX: Total hack: import `core::kinds::Owned` to work around a // parser bug whereby `fn f<T:::kinds::Owned>` doesn't parse. @@ -425,7 +425,7 @@ impl ext_ctxt_ast_builder for @ext_ctxt { } fn item_ty_poly(&self, name: ident, span: span, ty: @ast::Ty, - +generics: Generics) -> @ast::item { + generics: Generics) -> @ast::item { self.item(name, span, ast::item_ty(ty, generics)) } diff --git a/src/libsyntax/ext/pipes/parse_proto.rs b/src/libsyntax/ext/pipes/parse_proto.rs index 0725f288949..7339ebdaa98 100644 --- a/src/libsyntax/ext/pipes/parse_proto.rs +++ b/src/libsyntax/ext/pipes/parse_proto.rs @@ -19,13 +19,13 @@ use parse::token; use core::prelude::*; pub trait proto_parser { - fn parse_proto(&self, +id: ~str) -> protocol; + fn parse_proto(&self, id: ~str) -> protocol; fn parse_state(&self, proto: protocol); fn parse_message(&self, state: state); } impl proto_parser for parser::Parser { - fn parse_proto(&self, +id: ~str) -> protocol { + fn parse_proto(&self, id: ~str) -> protocol { let proto = protocol(id, *self.span); self.parse_seq_to_before_end( diff --git a/src/libsyntax/ext/pipes/proto.rs b/src/libsyntax/ext/pipes/proto.rs index 4a8ceedc8e3..6495750f93b 100644 --- a/src/libsyntax/ext/pipes/proto.rs +++ b/src/libsyntax/ext/pipes/proto.rs @@ -81,8 +81,8 @@ pub struct state_ { } pub impl state_ { - fn add_message(@self, +name: ~str, span: span, - +data: ~[@ast::Ty], +next: Option<next_state>) { + fn add_message(@self, name: ~str, span: span, + data: ~[@ast::Ty], next: Option<next_state>) { self.messages.push(message(name, span, data, self, next)); } @@ -119,11 +119,11 @@ pub impl state_ { pub type protocol = @mut protocol_; -pub fn protocol(+name: ~str, +span: span) -> protocol { +pub fn protocol(name: ~str, span: span) -> protocol { @mut protocol_(name, span) } -pub fn protocol_(+name: ~str, span: span) -> protocol_ { +pub fn protocol_(name: ~str, span: span) -> protocol_ { protocol_ { name: name, span: span, @@ -177,10 +177,10 @@ pub impl protocol_ { pub impl protocol_ { fn add_state_poly(@mut self, - +name: ~str, + name: ~str, ident: ast::ident, dir: direction, - +generics: ast::Generics) + generics: ast::Generics) -> state { let messages = @mut ~[]; let states = &*self.states; diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs index a6f078d07b4..f355d327d4f 100644 --- a/src/libsyntax/ext/quote.rs +++ b/src/libsyntax/ext/quote.rs @@ -419,7 +419,7 @@ fn ids_ext(cx: @ext_ctxt, strs: ~[~str]) -> ~[ast::ident] { strs.map(|str| cx.parse_sess().interner.intern(@copy *str)) } -fn id_ext(cx: @ext_ctxt, +str: ~str) -> ast::ident { +fn id_ext(cx: @ext_ctxt, str: ~str) -> ast::ident { cx.parse_sess().interner.intern(@str) } @@ -734,8 +734,8 @@ fn expand_tts(cx: @ext_ctxt, fn expand_parse_call(cx: @ext_ctxt, sp: span, - +parse_method: ~str, - +arg_exprs: ~[@ast::expr], + parse_method: ~str, + arg_exprs: ~[@ast::expr], tts: &[ast::token_tree]) -> @ast::expr { let tts_expr = expand_tts(cx, sp, tts); diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index afb7e04a532..9df7a8e7e1d 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -98,9 +98,9 @@ pub enum matcher_pos_up { /* to break a circularity */ matcher_pos_up(Option<~MatcherPos>) } -pub fn is_some(&&mpu: matcher_pos_up) -> bool { - match &mpu { - &matcher_pos_up(None) => false, +pub fn is_some(mpu: &matcher_pos_up) -> bool { + match *mpu { + matcher_pos_up(None) => false, _ => true } } @@ -115,9 +115,9 @@ pub struct MatcherPos { sp_lo: BytePos, } -pub fn copy_up(&& mpu: matcher_pos_up) -> ~MatcherPos { - match &mpu { - &matcher_pos_up(Some(ref mp)) => copy (*mp), +pub fn copy_up(mpu: &matcher_pos_up) -> ~MatcherPos { + match *mpu { + matcher_pos_up(Some(ref mp)) => copy (*mp), _ => fail!() } } @@ -132,7 +132,7 @@ pub fn count_names(ms: &[matcher]) -> uint { } #[allow(non_implicitly_copyable_typarams)] -pub fn initial_matcher_pos(+ms: ~[matcher], +sep: Option<Token>, lo: BytePos) +pub fn initial_matcher_pos(ms: ~[matcher], sep: Option<Token>, lo: BytePos) -> ~MatcherPos { let mut match_idx_hi = 0u; for ms.each |elt| { @@ -220,7 +220,7 @@ pub enum parse_result { pub fn parse_or_else( sess: @mut ParseSess, - +cfg: ast::crate_cfg, + cfg: ast::crate_cfg, rdr: @reader, ms: ~[matcher] ) -> HashMap<ident, @named_match> { @@ -257,7 +257,7 @@ pub fn parse( /* at end of sequence */ if idx >= len { // can't move out of `match`es, so: - if is_some(ei.up) { + if is_some(&ei.up) { // hack: a matcher sequence is repeating iff it has a // parent (the top level is just a container) @@ -267,7 +267,7 @@ pub fn parse( if idx == len { // pop from the matcher position - let mut new_pos = copy_up(ei.up); + let mut new_pos = copy_up(&ei.up); // update matches (the MBE "parse tree") by appending // each tree as a subtree. @@ -394,7 +394,7 @@ pub fn parse( match ei.elts[ei.idx].node { match_nonterminal(_, name, idx) => { ei.matches[idx].push(@matched_nonterminal( - parse_nt(rust_parser, *sess.interner.get(name)))); + parse_nt(&rust_parser, *sess.interner.get(name)))); ei.idx += 1u; } _ => fail!() @@ -411,7 +411,7 @@ pub fn parse( } } -pub fn parse_nt(p: Parser, name: ~str) -> nonterminal { +pub fn parse_nt(p: &Parser, name: ~str) -> nonterminal { match name { ~"item" => match p.parse_item(~[]) { Some(i) => token::nt_item(i), diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs index f39f3a01328..482e7b80339 100644 --- a/src/libsyntax/ext/tt/transcribe.rs +++ b/src/libsyntax/ext/tt/transcribe.rs @@ -53,7 +53,7 @@ pub struct TtReader { pub fn new_tt_reader(sp_diag: @span_handler, itr: @ident_interner, interp: Option<HashMap<ident,@named_match>>, - +src: ~[ast::token_tree]) + src: ~[ast::token_tree]) -> @mut TtReader { let r = @mut TtReader { sp_diag: sp_diag, @@ -109,7 +109,7 @@ pub fn dup_tt_reader(r: @mut TtReader) -> @mut TtReader { fn lookup_cur_matched_by_matched(r: &mut TtReader, start: @named_match) -> @named_match { - fn red(+ad: @named_match, idx: &uint) -> @named_match { + fn red(ad: @named_match, idx: &uint) -> @named_match { match *ad { matched_nonterminal(_) => { // end of the line; duplicate henceforth diff --git a/src/libsyntax/opt_vec.rs b/src/libsyntax/opt_vec.rs index 1604c40f917..c7ca9eba512 100644 --- a/src/libsyntax/opt_vec.rs +++ b/src/libsyntax/opt_vec.rs @@ -27,11 +27,11 @@ pub enum OptVec<T> { Vec(~[T]) } -pub fn with<T>(+t: T) -> OptVec<T> { +pub fn with<T>(t: T) -> OptVec<T> { Vec(~[t]) } -pub fn from<T>(+t: ~[T]) -> OptVec<T> { +pub fn from<T>(t: ~[T]) -> OptVec<T> { if t.len() == 0 { Empty } else { @@ -40,7 +40,7 @@ pub fn from<T>(+t: ~[T]) -> OptVec<T> { } impl<T> OptVec<T> { - fn push(&mut self, +t: T) { + fn push(&mut self, t: T) { match *self { Vec(ref mut v) => { v.push(t); @@ -91,7 +91,7 @@ impl<T> OptVec<T> { } } -pub fn take_vec<T>(+v: OptVec<T>) -> ~[T] { +pub fn take_vec<T>(v: OptVec<T>) -> ~[T] { match v { Empty => ~[], Vec(v) => v @@ -99,7 +99,7 @@ pub fn take_vec<T>(+v: OptVec<T>) -> ~[T] { } impl<T:Copy> OptVec<T> { - fn prepend(&self, +t: T) -> OptVec<T> { + fn prepend(&self, t: T) -> OptVec<T> { let mut v0 = ~[t]; match *self { Empty => {} @@ -157,7 +157,7 @@ impl<A> BaseIter<A> for OptVec<A> { impl<A> iter::ExtendedIter<A> for OptVec<A> { #[inline(always)] - fn eachi(&self, blk: &fn(+v: uint, v: &A) -> bool) { + fn eachi(&self, blk: &fn(v: uint, v: &A) -> bool) { iter::eachi(self, blk) } #[inline(always)] @@ -169,7 +169,7 @@ impl<A> iter::ExtendedIter<A> for OptVec<A> { iter::any(self, blk) } #[inline(always)] - fn foldl<B>(&self, +b0: B, blk: &fn(&B, &A) -> B) -> B { + fn foldl<B>(&self, b0: B, blk: &fn(&B, &A) -> B) -> B { iter::foldl(self, b0, blk) } #[inline(always)] diff --git a/src/libsyntax/parse/classify.rs b/src/libsyntax/parse/classify.rs index 4125a0bc3b4..840fb891bff 100644 --- a/src/libsyntax/parse/classify.rs +++ b/src/libsyntax/parse/classify.rs @@ -40,7 +40,7 @@ pub fn expr_is_simple_block(e: @ast::expr) -> bool { } } -pub fn stmt_ends_with_semi(stmt: ast::stmt) -> bool { +pub fn stmt_ends_with_semi(stmt: &ast::stmt) -> bool { return match stmt.node { ast::stmt_decl(d, _) => { match d.node { diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs index f90ff21cdf0..2f6bfd4cfc5 100644 --- a/src/libsyntax/parse/comments.rs +++ b/src/libsyntax/parse/comments.rs @@ -319,7 +319,7 @@ pub struct lit { pub fn gather_comments_and_literals(span_diagnostic: @diagnostic::span_handler, - +path: ~str, + path: ~str, srdr: @io::Reader) -> (~[cmnt], ~[lit]) { let src = @str::from_bytes(srdr.read_whole_stream()); diff --git a/src/libsyntax/parse/common.rs b/src/libsyntax/parse/common.rs index f353d94894a..2d4a6d47eaa 100644 --- a/src/libsyntax/parse/common.rs +++ b/src/libsyntax/parse/common.rs @@ -28,13 +28,13 @@ pub struct SeqSep { trailing_sep_allowed: bool } -pub fn seq_sep_trailing_disallowed(+t: token::Token) -> SeqSep { +pub fn seq_sep_trailing_disallowed(t: token::Token) -> SeqSep { SeqSep { sep: Some(t), trailing_sep_allowed: false, } } -pub fn seq_sep_trailing_allowed(+t: token::Token) -> SeqSep { +pub fn seq_sep_trailing_allowed(t: token::Token) -> SeqSep { SeqSep { sep: Some(t), trailing_sep_allowed: true, diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index 9348b72981d..4d8fdcfe617 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -126,7 +126,7 @@ pub fn parse_crate_from_source_str( pub fn parse_expr_from_source_str( name: ~str, source: @~str, - +cfg: ast::crate_cfg, + cfg: ast::crate_cfg, sess: @mut ParseSess ) -> @ast::expr { let p = new_parser_from_source_str( @@ -142,8 +142,8 @@ pub fn parse_expr_from_source_str( pub fn parse_item_from_source_str( name: ~str, source: @~str, - +cfg: ast::crate_cfg, - +attrs: ~[ast::attribute], + cfg: ast::crate_cfg, + attrs: ~[ast::attribute], sess: @mut ParseSess ) -> Option<@ast::item> { let p = new_parser_from_source_str( @@ -159,7 +159,7 @@ pub fn parse_item_from_source_str( pub fn parse_meta_from_source_str( name: ~str, source: @~str, - +cfg: ast::crate_cfg, + cfg: ast::crate_cfg, sess: @mut ParseSess ) -> @ast::meta_item { let p = new_parser_from_source_str( @@ -175,8 +175,8 @@ pub fn parse_meta_from_source_str( pub fn parse_stmt_from_source_str( name: ~str, source: @~str, - +cfg: ast::crate_cfg, - +attrs: ~[ast::attribute], + cfg: ast::crate_cfg, + attrs: ~[ast::attribute], sess: @mut ParseSess ) -> @ast::stmt { let p = new_parser_from_source_str( @@ -192,7 +192,7 @@ pub fn parse_stmt_from_source_str( pub fn parse_tts_from_source_str( name: ~str, source: @~str, - +cfg: ast::crate_cfg, + cfg: ast::crate_cfg, sess: @mut ParseSess ) -> ~[ast::token_tree] { let p = new_parser_from_source_str( @@ -207,20 +207,20 @@ pub fn parse_tts_from_source_str( } pub fn parse_from_source_str<T>( - f: &fn (Parser) -> T, + f: &fn(&Parser) -> T, name: ~str, ss: codemap::FileSubstr, source: @~str, - +cfg: ast::crate_cfg, + cfg: ast::crate_cfg, sess: @mut ParseSess ) -> T { let p = new_parser_from_source_str( sess, cfg, - /*bad*/ copy name, - /*bad*/ copy ss, + name, + ss, source ); - let r = f(p); + let r = f(&p); if !p.reader.is_eof() { p.reader.fatal(~"expected end-of-string"); } @@ -236,9 +236,9 @@ pub fn next_node_id(sess: @mut ParseSess) -> node_id { } pub fn new_parser_from_source_str(sess: @mut ParseSess, - +cfg: ast::crate_cfg, - +name: ~str, - +ss: codemap::FileSubstr, + cfg: ast::crate_cfg, + name: ~str, + ss: codemap::FileSubstr, source: @~str) -> Parser { let filemap = sess.cm.new_filemap_w_substr(name, ss, source); @@ -254,7 +254,7 @@ pub fn new_parser_from_source_str(sess: @mut ParseSess, /// that draws from that string pub fn new_parser_result_from_file( sess: @mut ParseSess, - +cfg: ast::crate_cfg, + cfg: ast::crate_cfg, path: &Path ) -> Result<Parser, ~str> { match io::read_whole_file_str(path) { @@ -274,7 +274,7 @@ pub fn new_parser_result_from_file( /// if the file doesn't exist pub fn new_parser_from_file( sess: @mut ParseSess, - +cfg: ast::crate_cfg, + cfg: ast::crate_cfg, path: &Path ) -> Parser { match new_parser_result_from_file(sess, cfg, path) { @@ -289,7 +289,7 @@ pub fn new_parser_from_file( /// error messages correctly when the file does not exist. pub fn new_sub_parser_from_file( sess: @mut ParseSess, - +cfg: ast::crate_cfg, + cfg: ast::crate_cfg, path: &Path, sp: span ) -> Parser { @@ -303,8 +303,8 @@ pub fn new_sub_parser_from_file( pub fn new_parser_from_tts( sess: @mut ParseSess, - +cfg: ast::crate_cfg, - +tts: ~[ast::token_tree] + cfg: ast::crate_cfg, + tts: ~[ast::token_tree] ) -> Parser { let trdr = lexer::new_tt_reader( copy sess.span_diagnostic, @@ -316,7 +316,7 @@ pub fn new_parser_from_tts( } // abort if necessary -pub fn maybe_aborted<T>(+result : T, p: Parser) -> T { +pub fn maybe_aborted<T>(result : T, p: Parser) -> T { p.abort_if_errors(); result } diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs index 75a3d9ab2b1..423fc6dca6d 100644 --- a/src/libsyntax/parse/obsolete.rs +++ b/src/libsyntax/parse/obsolete.rs @@ -66,7 +66,7 @@ pub enum ObsoleteSyntax { impl to_bytes::IterBytes for ObsoleteSyntax { #[inline(always)] - fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { (*self as uint).iter_bytes(lsb0, f); } } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index c1f781f8570..e892f212b05 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -201,7 +201,7 @@ macro_rules! maybe_whole ( ) -fn maybe_append(+lhs: ~[attribute], rhs: Option<~[attribute]>) +fn maybe_append(lhs: ~[attribute], rhs: Option<~[attribute]>) -> ~[attribute] { match rhs { None => lhs, @@ -220,8 +220,8 @@ struct ParsedItemsAndViewItems { /* ident is handled by common.rs */ pub fn Parser(sess: @mut ParseSess, - +cfg: ast::crate_cfg, - +rdr: @reader) + cfg: ast::crate_cfg, + rdr: @reader) -> Parser { let tok0 = copy rdr.next_token(); let interner = rdr.interner(); @@ -299,7 +299,7 @@ pub impl Parser { *self.tokens_consumed += 1u; } // EFFECT: replace the current token and span with the given one - fn replace_token(&self, +next: token::Token, +lo: BytePos, +hi: BytePos) { + fn replace_token(&self, next: token::Token, lo: BytePos, hi: BytePos) { *self.token = next; *self.span = mk_sp(lo, hi); } @@ -713,7 +713,7 @@ pub impl Parser { fn parse_box_or_uniq_pointee( &self, sigil: ast::Sigil, - ctor: &fn(+v: mt) -> ty_) -> ty_ + ctor: &fn(v: mt) -> ty_) -> ty_ { // @'foo fn() or @foo/fn() or @fn() are parsed directly as fn types: match *self.token { @@ -1112,7 +1112,7 @@ pub impl Parser { spanned(lo, e.span.hi, ast::field_ { mutbl: m, ident: i, expr: e }) } - fn mk_expr(&self, +lo: BytePos, +hi: BytePos, +node: expr_) -> @expr { + fn mk_expr(&self, lo: BytePos, hi: BytePos, node: expr_) -> @expr { @expr { id: self.get_id(), callee_id: self.get_id(), @@ -1121,7 +1121,7 @@ pub impl Parser { } } - fn mk_mac_expr(&self, +lo: BytePos, +hi: BytePos, +m: mac_) -> @expr { + fn mk_mac_expr(&self, lo: BytePos, hi: BytePos, m: mac_) -> @expr { @expr { id: self.get_id(), callee_id: self.get_id(), @@ -1897,7 +1897,7 @@ pub impl Parser { fn parse_sugary_call_expr(&self, keyword: ~str, sugar: CallSugar, - ctor: &fn(+v: @expr) -> expr_) -> @expr { + ctor: &fn(v: @expr) -> expr_) -> @expr { let lo = self.last_span; // Parse the callee `foo` in // for foo || { @@ -2472,7 +2472,7 @@ pub impl Parser { }) } - fn parse_stmt(&self, +first_item_attrs: ~[attribute]) -> @stmt { + fn parse_stmt(&self, first_item_attrs: ~[attribute]) -> @stmt { maybe_whole!(self, nt_stmt); fn check_expected_item(p: &Parser, current_attrs: &[attribute]) { @@ -2612,7 +2612,7 @@ pub impl Parser { // parse the rest of a block expression or function body fn parse_block_tail_(&self, lo: BytePos, s: blk_check_mode, - +first_item_attrs: ~[attribute]) -> blk { + first_item_attrs: ~[attribute]) -> blk { let mut stmts = ~[]; let mut expr = None; @@ -2658,7 +2658,7 @@ pub impl Parser { expr = Some(e); } copy t => { - if classify::stmt_ends_with_semi(*stmt) { + if classify::stmt_ends_with_semi(stmt) { self.fatal( fmt!( "expected `;` or `}` after \ @@ -2696,7 +2696,7 @@ pub impl Parser { _ => { // All other kinds of statements: stmts.push(stmt); - if classify::stmt_ends_with_semi(*stmt) { + if classify::stmt_ends_with_semi(stmt) { self.expect(&token::SEMI); } } @@ -2891,7 +2891,7 @@ pub impl Parser { &fn(&Parser) -> arg_or_capture_item ) -> (self_ty, fn_decl) { fn maybe_parse_self_ty( - cnstr: &fn(+v: mutability) -> ast::self_ty_, + cnstr: &fn(v: mutability) -> ast::self_ty_, p: &Parser ) -> ast::self_ty_ { // We need to make sure it isn't a mode or a type @@ -3064,9 +3064,9 @@ pub impl Parser { (id, generics) } - fn mk_item(&self, +lo: BytePos, +hi: BytePos, +ident: ident, - +node: item_, vis: visibility, - +attrs: ~[attribute]) -> @item { + fn mk_item(&self, lo: BytePos, hi: BytePos, ident: ident, + node: item_, vis: visibility, + attrs: ~[attribute]) -> @item { @ast::item { ident: ident, attrs: attrs, id: self.get_id(), @@ -3305,7 +3305,7 @@ pub impl Parser { None) } - fn token_is_pound_or_doc_comment(&self, ++tok: token::Token) -> bool { + fn token_is_pound_or_doc_comment(&self, tok: token::Token) -> bool { match tok { token::POUND | token::DOC_COMMENT(_) => true, _ => false @@ -3340,7 +3340,7 @@ pub impl Parser { a_var } - fn parse_dtor(&self, +attrs: ~[attribute]) -> class_contents { + fn parse_dtor(&self, attrs: ~[attribute]) -> class_contents { let lo = self.last_span.lo; let body = self.parse_block(); dtor_decl(body, attrs, mk_sp(lo, self.last_span.hi)) @@ -3392,7 +3392,7 @@ pub impl Parser { // given a termination token and a vector of already-parsed // attributes (of length 0 or 1), parse all of the items in a module fn parse_mod_items(&self, term: token::Token, - +first_item_attrs: ~[attribute]) -> _mod { + first_item_attrs: ~[attribute]) -> _mod { // parse all of the items up to closing or an attribute. // view items are legal here. let ParsedItemsAndViewItems { @@ -3553,7 +3553,7 @@ pub impl Parser { outer_attrs, id_sp) } - fn eval_src_mod_from_path(&self, prefix: Path, +path: Path, + fn eval_src_mod_from_path(&self, prefix: Path, path: Path, outer_attrs: ~[ast::attribute], id_sp: span ) -> (ast::item_, ~[ast::attribute]) { @@ -3576,7 +3576,7 @@ pub impl Parser { let m0 = p0.parse_mod_items(token::EOF, first_item_outer_attrs); return (ast::item_mod(m0), mod_attrs); - fn cdir_path_opt(+default: ~str, attrs: ~[ast::attribute]) -> ~str { + fn cdir_path_opt(default: ~str, attrs: ~[ast::attribute]) -> ~str { match ::attr::first_attr_value_str_by_name(attrs, ~"path") { Some(d) => copy *d, None => default @@ -3584,7 +3584,7 @@ pub impl Parser { } } - fn parse_item_foreign_fn(&self, +attrs: ~[attribute]) -> @foreign_item { + fn parse_item_foreign_fn(&self, attrs: ~[attribute]) -> @foreign_item { let lo = self.span.lo; let vis = self.parse_visibility(); let purity = self.parse_fn_purity(); @@ -3601,7 +3601,7 @@ pub impl Parser { } fn parse_item_foreign_const(&self, vis: ast::visibility, - +attrs: ~[attribute]) -> @foreign_item { + attrs: ~[attribute]) -> @foreign_item { let lo = self.span.lo; // XXX: Obsolete; remove after snap. @@ -3638,7 +3638,7 @@ pub impl Parser { else { self.unexpected(); } } - fn parse_foreign_item(&self, +attrs: ~[attribute]) -> @foreign_item { + fn parse_foreign_item(&self, attrs: ~[attribute]) -> @foreign_item { let vis = self.parse_visibility(); if self.is_keyword(&~"const") || self.is_keyword(&~"static") { self.parse_item_foreign_const(vis, attrs) @@ -3648,8 +3648,8 @@ pub impl Parser { } fn parse_foreign_mod_items(&self, sort: ast::foreign_mod_sort, - +abis: AbiSet, - +first_item_attrs: ~[attribute]) + abis: AbiSet, + first_item_attrs: ~[attribute]) -> foreign_mod { // Shouldn't be any view items since we've already parsed an item attr let ParsedItemsAndViewItems { @@ -3987,7 +3987,7 @@ pub impl Parser { // flags; on failure, return iovi_none. fn parse_item_or_view_item( &self, - +attrs: ~[attribute], + attrs: ~[attribute], items_allowed: bool, foreign_items_allowed: bool, macros_allowed: bool @@ -4198,7 +4198,7 @@ pub impl Parser { return iovi_none; } - fn parse_item(&self, +attrs: ~[attribute]) -> Option<@ast::item> { + fn parse_item(&self, attrs: ~[attribute]) -> Option<@ast::item> { match self.parse_item_or_view_item(attrs, true, false, true) { iovi_none => None, @@ -4337,7 +4337,7 @@ pub impl Parser { // parse a view item. fn parse_view_item( &self, - +attrs: ~[attribute], + attrs: ~[attribute], vis: visibility ) -> @view_item { let lo = self.span.lo; @@ -4363,7 +4363,7 @@ pub impl Parser { // - mod_items uses VIEW_ITEMS_AND_ITEMS_ALLOWED // - block_tail_ uses IMPORTS_AND_ITEMS_ALLOWED // - foreign_mod_items uses FOREIGN_ITEMS_ALLOWED - fn parse_items_and_view_items(&self, +first_item_attrs: ~[attribute], + fn parse_items_and_view_items(&self, first_item_attrs: ~[attribute], mode: view_item_parse_mode, macros_allowed: bool) -> ParsedItemsAndViewItems { diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs index e742bdc056a..eff7524e194 100644 --- a/src/libsyntax/print/pp.rs +++ b/src/libsyntax/print/pp.rs @@ -104,7 +104,7 @@ pub impl token { } } -pub fn tok_str(++t: token) -> ~str { +pub fn tok_str(t: token) -> ~str { match t { STRING(s, len) => return fmt!("STR(%s,%d)", *s, len), BREAK(_) => return ~"BREAK", @@ -398,7 +398,7 @@ pub impl Printer { self.right %= self.buf_len; assert!((self.right != self.left)); } - fn advance_left(&mut self, ++x: token, L: int) { + fn advance_left(&mut self, x: token, L: int) { debug!("advnce_left ~[%u,%u], sizeof(%u)=%d", self.left, self.right, self.left, L); if L >= 0 { diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 88ecabe28f5..8cf73599562 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -134,7 +134,7 @@ pub fn print_crate(cm: @CodeMap, print_crate_(s, crate); } -pub fn print_crate_(s: @ps, &&crate: @ast::crate) { +pub fn print_crate_(s: @ps, crate: @ast::crate) { print_mod(s, &crate.node.module, crate.node.attrs); print_remaining_comments(s); eof(s.s); @@ -164,7 +164,7 @@ pub fn tts_to_str(tts: &[ast::token_tree], intr: @ident_interner) -> ~str { to_str(tts, print_tts, intr) } -pub fn stmt_to_str(s: ast::stmt, intr: @ident_interner) -> ~str { +pub fn stmt_to_str(s: &ast::stmt, intr: @ident_interner) -> ~str { to_str(s, print_stmt, intr) } @@ -177,7 +177,7 @@ pub fn generics_to_str(generics: &ast::Generics, to_str(generics, print_generics, intr) } -pub fn path_to_str(&&p: @ast::Path, intr: @ident_interner) -> ~str { +pub fn path_to_str(p: @ast::Path, intr: @ident_interner) -> ~str { to_str(p, |a,b| print_path(a, b, false), intr) } @@ -312,7 +312,7 @@ pub fn synth_comment(s: @ps, text: ~str) { word(s.s, ~"*/"); } -pub fn commasep<IN>(s: @ps, b: breaks, elts: &[IN], op: &fn(@ps, IN)) { +pub fn commasep<IN: Copy>(s: @ps, b: breaks, elts: &[IN], op: &fn(@ps, IN)) { box(s, 0u, b); let mut first = true; for elts.each |elt| { @@ -323,8 +323,8 @@ pub fn commasep<IN>(s: @ps, b: breaks, elts: &[IN], op: &fn(@ps, IN)) { } -pub fn commasep_cmnt<IN>(s: @ps, b: breaks, elts: &[IN], op: &fn(@ps, IN), - get_span: &fn(IN) -> codemap::span) { +pub fn commasep_cmnt<IN: Copy>(s: @ps, b: breaks, elts: &[IN], op: &fn(@ps, IN), + get_span: &fn(IN) -> codemap::span) { box(s, 0u, b); let len = elts.len(); let mut i = 0u; @@ -343,7 +343,7 @@ pub fn commasep_cmnt<IN>(s: @ps, b: breaks, elts: &[IN], op: &fn(@ps, IN), } pub fn commasep_exprs(s: @ps, b: breaks, exprs: &[@ast::expr]) { - fn expr_span(&&expr: @ast::expr) -> codemap::span { return expr.span; } + fn expr_span(expr: @ast::expr) -> codemap::span { return expr.span; } commasep_cmnt(s, b, exprs, print_expr, expr_span); } @@ -371,7 +371,7 @@ pub fn print_opt_lifetime(s: @ps, lifetime: Option<@ast::Lifetime>) { } } -pub fn print_type(s: @ps, &&ty: @ast::Ty) { +pub fn print_type(s: @ps, ty: @ast::Ty) { maybe_print_comment(s, ty.span.lo); ibox(s, 0u); match ty.node { @@ -465,7 +465,7 @@ pub fn print_foreign_item(s: @ps, item: @ast::foreign_item) { } } -pub fn print_item(s: @ps, &&item: @ast::item) { +pub fn print_item(s: @ps, item: @ast::item) { hardbreak_if_not_bol(s); maybe_print_comment(s, item.span.lo); print_outer_attributes(s, item.attrs); @@ -760,7 +760,7 @@ pub fn print_tt(s: @ps, tt: ast::token_tree) { } } -pub fn print_tts(s: @ps, &&tts: &[ast::token_tree]) { +pub fn print_tts(s: @ps, tts: &[ast::token_tree]) { ibox(s, 0); for tts.eachi |i, tt| { if i != 0 { @@ -872,7 +872,7 @@ pub fn print_attribute(s: @ps, attr: ast::attribute) { } -pub fn print_stmt(s: @ps, st: ast::stmt) { +pub fn print_stmt(s: @ps, st: &ast::stmt) { maybe_print_comment(s, st.span.lo); match st.node { ast::stmt_decl(decl, _) => { @@ -950,7 +950,7 @@ pub fn print_possibly_embedded_block_(s: @ps, for blk.node.view_items.each |vi| { print_view_item(s, *vi); } for blk.node.stmts.each |st| { - print_stmt(s, **st); + print_stmt(s, *st); } match blk.node.expr { Some(expr) => { @@ -1089,7 +1089,7 @@ pub fn print_call_post(s: @ps, } } -pub fn print_expr(s: @ps, &&expr: @ast::expr) { +pub fn print_expr(s: @ps, expr: @ast::expr) { fn print_field(s: @ps, field: ast::field) { ibox(s, indent_unit); if field.node.mutbl == ast::m_mutbl { word_nbsp(s, ~"mut"); } @@ -1454,7 +1454,7 @@ pub fn print_decl(s: @ps, decl: @ast::decl) { word_nbsp(s, ~"mut"); } - fn print_local(s: @ps, &&loc: @ast::local) { + fn print_local(s: @ps, loc: @ast::local) { ibox(s, indent_unit); print_local_decl(s, loc); end(s); @@ -1485,7 +1485,7 @@ pub fn print_for_decl(s: @ps, loc: @ast::local, coll: @ast::expr) { print_expr(s, coll); } -pub fn print_path(s: @ps, &&path: @ast::Path, colons_before_params: bool) { +pub fn print_path(s: @ps, path: @ast::Path, colons_before_params: bool) { maybe_print_comment(s, path.span.lo); if path.global { word(s.s, ~"::"); } let mut first = true; @@ -1513,15 +1513,15 @@ pub fn print_path(s: @ps, &&path: @ast::Path, colons_before_params: bool) { } } -pub fn print_irrefutable_pat(s: @ps, &&pat: @ast::pat) { +pub fn print_irrefutable_pat(s: @ps, pat: @ast::pat) { print_pat(s, pat, false) } -pub fn print_refutable_pat(s: @ps, &&pat: @ast::pat) { +pub fn print_refutable_pat(s: @ps, pat: @ast::pat) { print_pat(s, pat, true) } -pub fn print_pat(s: @ps, &&pat: @ast::pat, refutable: bool) { +pub fn print_pat(s: @ps, pat: @ast::pat, refutable: bool) { maybe_print_comment(s, pat.span.lo); let ann_node = node_pat(s, pat); (s.ann.pre)(ann_node); @@ -1758,12 +1758,12 @@ pub fn print_bounds(s: @ps, bounds: @OptVec<ast::TyParamBound>) { } } -pub fn print_lifetime(s: @ps, &&lifetime: &ast::Lifetime) { +pub fn print_lifetime(s: @ps, lifetime: &ast::Lifetime) { word(s.s, ~"'"); print_ident(s, lifetime.ident); } -pub fn print_generics(s: @ps, &&generics: &ast::Generics) { +pub fn print_generics(s: @ps, generics: &ast::Generics) { let total = generics.lifetimes.len() + generics.ty_params.len(); if total > 0 { word(s.s, ~"<"); @@ -1790,7 +1790,7 @@ pub fn print_generics(s: @ps, &&generics: &ast::Generics) { } } -pub fn print_meta_item(s: @ps, &&item: @ast::meta_item) { +pub fn print_meta_item(s: @ps, item: @ast::meta_item) { ibox(s, indent_unit); match item.node { ast::meta_word(name) => word(s.s, *name), @@ -1814,7 +1814,7 @@ pub fn print_meta_item(s: @ps, &&item: @ast::meta_item) { end(s); } -pub fn print_view_path(s: @ps, &&vp: @ast::view_path) { +pub fn print_view_path(s: @ps, vp: @ast::view_path) { match vp.node { ast::view_path_simple(ident, path, namespace, _) => { if namespace == ast::module_ns { @@ -2006,7 +2006,7 @@ pub fn print_remaining_comments(s: @ps) { } } -pub fn print_literal(s: @ps, &&lit: @ast::lit) { +pub fn print_literal(s: @ps, lit: @ast::lit) { maybe_print_comment(s, lit.span.lo); match next_lit(s, lit.span.lo) { Some(ref ltrl) => { @@ -2137,7 +2137,7 @@ pub fn print_string(s: @ps, st: &str) { word(s.s, ~"\""); } -pub fn to_str<T>(t: T, f: @fn(@ps, T), intr: @ident_interner) -> ~str { +pub fn to_str<T: Copy>(t: T, f: @fn(@ps, T), intr: @ident_interner) -> ~str { do io::with_str_writer |wr| { let s = rust_printer(wr, intr); f(s, t); diff --git a/src/libsyntax/syntax.rc b/src/libsyntax/syntax.rc index c1b857a6cdb..6e70bd22b4f 100644 --- a/src/libsyntax/syntax.rc +++ b/src/libsyntax/syntax.rc @@ -17,11 +17,10 @@ #[license = "MIT/ASL2"]; #[crate_type = "lib"]; -#[legacy_modes]; - #[allow(vecs_implicitly_copyable)]; #[allow(non_camel_case_types)]; -#[allow(deprecated_mode)]; +#[deny(deprecated_mode)]; +#[deny(deprecated_pattern)]; #[no_core]; diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index c4c187bc4c7..0aaa08f2e78 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -101,7 +101,7 @@ pub struct Visitor<E> { pub type visitor<E> = @Visitor<E>; -pub fn default_visitor<E>() -> visitor<E> { +pub fn default_visitor<E: Copy>() -> visitor<E> { return @Visitor { visit_mod: |a,b,c,d,e|visit_mod::<E>(a, b, c, d, e), visit_view_item: |a,b,c|visit_view_item::<E>(a, b, c), @@ -127,18 +127,18 @@ pub fn default_visitor<E>() -> visitor<E> { }; } -pub fn visit_crate<E>(c: crate, e: E, v: vt<E>) { +pub fn visit_crate<E: Copy>(c: &crate, e: E, v: vt<E>) { (v.visit_mod)(&c.node.module, c.span, crate_node_id, e, v); } -pub fn visit_mod<E>(m: &_mod, _sp: span, _id: node_id, e: E, v: vt<E>) { +pub fn visit_mod<E: Copy>(m: &_mod, _sp: span, _id: node_id, e: E, v: vt<E>) { for m.view_items.each |vi| { (v.visit_view_item)(*vi, e, v); } for m.items.each |i| { (v.visit_item)(*i, e, v); } } pub fn visit_view_item<E>(_vi: @view_item, _e: E, _v: vt<E>) { } -pub fn visit_local<E>(loc: @local, e: E, v: vt<E>) { +pub fn visit_local<E: Copy>(loc: @local, e: E, v: vt<E>) { (v.visit_pat)(loc.node.pat, e, v); (v.visit_ty)(loc.node.ty, e, v); match loc.node.init { @@ -147,11 +147,11 @@ pub fn visit_local<E>(loc: @local, e: E, v: vt<E>) { } } -fn visit_trait_ref<E>(tref: @ast::trait_ref, e: E, v: vt<E>) { +fn visit_trait_ref<E: Copy>(tref: @ast::trait_ref, e: E, v: vt<E>) { visit_path(tref.path, e, v); } -pub fn visit_item<E>(i: @item, e: E, v: vt<E>) { +pub fn visit_item<E: Copy>(i: @item, e: E, v: vt<E>) { match i.node { item_const(t, ex) => { (v.visit_ty)(t, e, v); @@ -216,10 +216,10 @@ pub fn visit_item<E>(i: @item, e: E, v: vt<E>) { } } -pub fn visit_enum_def<E>(enum_definition: ast::enum_def, - tps: &Generics, - e: E, - v: vt<E>) { +pub fn visit_enum_def<E: Copy>(enum_definition: ast::enum_def, + tps: &Generics, + e: E, + v: vt<E>) { for enum_definition.variants.each |vr| { match vr.node.kind { tuple_variant_kind(ref variant_args) => { @@ -237,7 +237,7 @@ pub fn visit_enum_def<E>(enum_definition: ast::enum_def, pub fn skip_ty<E>(_t: @Ty, _e: E, _v: vt<E>) {} -pub fn visit_ty<E>(t: @Ty, e: E, v: vt<E>) { +pub fn visit_ty<E: Copy>(t: @Ty, e: E, v: vt<E>) { match t.node { ty_box(mt) | ty_uniq(mt) | ty_vec(mt) | ty_ptr(mt) | ty_rptr(_, mt) => { @@ -265,11 +265,11 @@ pub fn visit_ty<E>(t: @Ty, e: E, v: vt<E>) { } } -pub fn visit_path<E>(p: @Path, e: E, v: vt<E>) { +pub fn visit_path<E: Copy>(p: @Path, e: E, v: vt<E>) { for p.types.each |tp| { (v.visit_ty)(*tp, e, v); } } -pub fn visit_pat<E>(p: @pat, e: E, v: vt<E>) { +pub fn visit_pat<E: Copy>(p: @pat, e: E, v: vt<E>) { match p.node { pat_enum(path, ref children) => { visit_path(path, e, v); @@ -315,7 +315,7 @@ pub fn visit_pat<E>(p: @pat, e: E, v: vt<E>) { } } -pub fn visit_foreign_item<E>(ni: @foreign_item, e: E, v: vt<E>) { +pub fn visit_foreign_item<E: Copy>(ni: @foreign_item, e: E, v: vt<E>) { match ni.node { foreign_item_fn(ref fd, _, ref generics) => { visit_fn_decl(fd, e, v); @@ -327,8 +327,8 @@ pub fn visit_foreign_item<E>(ni: @foreign_item, e: E, v: vt<E>) { } } -pub fn visit_ty_param_bounds<E>(bounds: @OptVec<TyParamBound>, - e: E, v: vt<E>) { +pub fn visit_ty_param_bounds<E: Copy>(bounds: @OptVec<TyParamBound>, + e: E, v: vt<E>) { for bounds.each |bound| { match *bound { TraitTyParamBound(ty) => visit_trait_ref(ty, e, v), @@ -337,13 +337,13 @@ pub fn visit_ty_param_bounds<E>(bounds: @OptVec<TyParamBound>, } } -pub fn visit_generics<E>(generics: &Generics, e: E, v: vt<E>) { +pub fn visit_generics<E: Copy>(generics: &Generics, e: E, v: vt<E>) { for generics.ty_params.each |tp| { visit_ty_param_bounds(tp.bounds, e, v); } } -pub fn visit_fn_decl<E>(fd: &fn_decl, e: E, v: vt<E>) { +pub fn visit_fn_decl<E: Copy>(fd: &fn_decl, e: E, v: vt<E>) { for fd.inputs.each |a| { (v.visit_pat)(a.pat, e, v); (v.visit_ty)(a.ty, e, v); @@ -355,7 +355,7 @@ pub fn visit_fn_decl<E>(fd: &fn_decl, e: E, v: vt<E>) { // visit_fn() and check for fk_method(). I named this visit_method_helper() // because it is not a default impl of any method, though I doubt that really // clarifies anything. - Niko -pub fn visit_method_helper<E>(m: &method, e: E, v: vt<E>) { +pub fn visit_method_helper<E: Copy>(m: &method, e: E, v: vt<E>) { (v.visit_fn)( &fk_method( /* FIXME (#2543) */ copy m.ident, @@ -390,28 +390,28 @@ pub fn visit_struct_dtor_helper<E>(dtor: struct_dtor, generics: &Generics, } -pub fn visit_fn<E>(fk: &fn_kind, decl: &fn_decl, body: &blk, _sp: span, - _id: node_id, e: E, v: vt<E>) { +pub fn visit_fn<E: Copy>(fk: &fn_kind, decl: &fn_decl, body: &blk, _sp: span, + _id: node_id, e: E, v: vt<E>) { visit_fn_decl(decl, e, v); let generics = generics_of_fn(fk); (v.visit_generics)(&generics, e, v); (v.visit_block)(body, e, v); } -pub fn visit_ty_method<E>(m: &ty_method, e: E, v: vt<E>) { +pub fn visit_ty_method<E: Copy>(m: &ty_method, e: E, v: vt<E>) { for m.decl.inputs.each |a| { (v.visit_ty)(a.ty, e, v); } (v.visit_generics)(&m.generics, e, v); (v.visit_ty)(m.decl.output, e, v); } -pub fn visit_trait_method<E>(m: &trait_method, e: E, v: vt<E>) { +pub fn visit_trait_method<E: Copy>(m: &trait_method, e: E, v: vt<E>) { match *m { required(ref ty_m) => (v.visit_ty_method)(ty_m, e, v), provided(m) => visit_method_helper(m, e, v) } } -pub fn visit_struct_def<E>( +pub fn visit_struct_def<E: Copy>( sd: @struct_def, _nm: ast::ident, generics: &Generics, @@ -433,15 +433,15 @@ pub fn visit_struct_def<E>( } } -pub fn visit_struct_field<E>(sf: @struct_field, e: E, v: vt<E>) { +pub fn visit_struct_field<E: Copy>(sf: @struct_field, e: E, v: vt<E>) { (v.visit_ty)(sf.node.ty, e, v); } -pub fn visit_struct_method<E>(m: @method, e: E, v: vt<E>) { +pub fn visit_struct_method<E: Copy>(m: @method, e: E, v: vt<E>) { visit_method_helper(m, e, v); } -pub fn visit_block<E>(b: &blk, e: E, v: vt<E>) { +pub fn visit_block<E: Copy>(b: &blk, e: E, v: vt<E>) { for b.node.view_items.each |vi| { (v.visit_view_item)(*vi, e, v); } @@ -460,7 +460,7 @@ pub fn visit_stmt<E>(s: @stmt, e: E, v: vt<E>) { } } -pub fn visit_decl<E>(d: @decl, e: E, v: vt<E>) { +pub fn visit_decl<E: Copy>(d: @decl, e: E, v: vt<E>) { match d.node { decl_local(ref locs) => { for locs.each |loc| { @@ -475,7 +475,7 @@ pub fn visit_expr_opt<E>(eo: Option<@expr>, e: E, v: vt<E>) { match eo { None => (), Some(ex) => (v.visit_expr)(ex, e, v) } } -pub fn visit_exprs<E>(exprs: &[@expr], e: E, v: vt<E>) { +pub fn visit_exprs<E: Copy>(exprs: &[@expr], e: E, v: vt<E>) { for exprs.each |ex| { (v.visit_expr)(*ex, e, v); } } @@ -483,7 +483,7 @@ pub fn visit_mac<E>(_m: mac, _e: E, _v: vt<E>) { /* no user-serviceable parts inside */ } -pub fn visit_expr<E>(ex: @expr, e: E, v: vt<E>) { +pub fn visit_expr<E: Copy>(ex: @expr, e: E, v: vt<E>) { match ex.node { expr_vstore(x, _) => (v.visit_expr)(x, e, v), expr_vec(ref es, _) => visit_exprs(*es, e, v), @@ -588,7 +588,7 @@ pub fn visit_expr<E>(ex: @expr, e: E, v: vt<E>) { (v.visit_expr_post)(ex, e, v); } -pub fn visit_arm<E>(a: &arm, e: E, v: vt<E>) { +pub fn visit_arm<E: Copy>(a: &arm, e: E, v: vt<E>) { for a.pats.each |p| { (v.visit_pat)(*p, e, v); } visit_expr_opt(a.guard, e, v); (v.visit_block)(&a.body, e, v); @@ -655,67 +655,67 @@ pub fn mk_simple_visitor(v: simple_visitor) -> vt<()> { m: &_mod, sp: span, id: node_id, - &&e: (), + e: (), v: vt<()> ) { f(m, sp, id); visit_mod(m, sp, id, e, v); } - fn v_view_item(f: @fn(@view_item), vi: @view_item, &&e: (), v: vt<()>) { + fn v_view_item(f: @fn(@view_item), vi: @view_item, e: (), v: vt<()>) { f(vi); visit_view_item(vi, e, v); } - fn v_foreign_item(f: @fn(@foreign_item), ni: @foreign_item, &&e: (), + fn v_foreign_item(f: @fn(@foreign_item), ni: @foreign_item, e: (), v: vt<()>) { f(ni); visit_foreign_item(ni, e, v); } - fn v_item(f: @fn(@item), i: @item, &&e: (), v: vt<()>) { + fn v_item(f: @fn(@item), i: @item, e: (), v: vt<()>) { f(i); visit_item(i, e, v); } - fn v_local(f: @fn(@local), l: @local, &&e: (), v: vt<()>) { + fn v_local(f: @fn(@local), l: @local, e: (), v: vt<()>) { f(l); visit_local(l, e, v); } - fn v_block(f: @fn(&ast::blk), bl: &ast::blk, &&e: (), v: vt<()>) { + fn v_block(f: @fn(&ast::blk), bl: &ast::blk, e: (), v: vt<()>) { f(bl); visit_block(bl, e, v); } - fn v_stmt(f: @fn(@stmt), st: @stmt, &&e: (), v: vt<()>) { + fn v_stmt(f: @fn(@stmt), st: @stmt, e: (), v: vt<()>) { f(st); visit_stmt(st, e, v); } - fn v_arm(f: @fn(&arm), a: &arm, &&e: (), v: vt<()>) { + fn v_arm(f: @fn(&arm), a: &arm, e: (), v: vt<()>) { f(a); visit_arm(a, e, v); } - fn v_pat(f: @fn(@pat), p: @pat, &&e: (), v: vt<()>) { + fn v_pat(f: @fn(@pat), p: @pat, e: (), v: vt<()>) { f(p); visit_pat(p, e, v); } - fn v_decl(f: @fn(@decl), d: @decl, &&e: (), v: vt<()>) { + fn v_decl(f: @fn(@decl), d: @decl, e: (), v: vt<()>) { f(d); visit_decl(d, e, v); } - fn v_expr(f: @fn(@expr), ex: @expr, &&e: (), v: vt<()>) { + fn v_expr(f: @fn(@expr), ex: @expr, e: (), v: vt<()>) { f(ex); visit_expr(ex, e, v); } - fn v_expr_post(f: @fn(@expr), ex: @expr, &&_e: (), _v: vt<()>) { + fn v_expr_post(f: @fn(@expr), ex: @expr, _e: (), _v: vt<()>) { f(ex); } - fn v_ty(f: @fn(@Ty), ty: @Ty, &&e: (), v: vt<()>) { + fn v_ty(f: @fn(@Ty), ty: @Ty, e: (), v: vt<()>) { f(ty); visit_ty(ty, e, v); } - fn v_ty_method(f: @fn(&ty_method), ty: &ty_method, &&e: (), v: vt<()>) { + fn v_ty_method(f: @fn(&ty_method), ty: &ty_method, e: (), v: vt<()>) { f(ty); visit_ty_method(ty, e, v); } fn v_trait_method(f: @fn(&trait_method), m: &trait_method, - &&e: (), + e: (), v: vt<()>) { f(m); visit_trait_method(m, e, v); @@ -726,7 +726,7 @@ pub fn mk_simple_visitor(v: simple_visitor) -> vt<()> { nm: ident, generics: &Generics, id: node_id, - &&e: (), + e: (), v: vt<()> ) { f(sd, nm, generics, id); @@ -735,7 +735,7 @@ pub fn mk_simple_visitor(v: simple_visitor) -> vt<()> { fn v_generics( f: @fn(&Generics), ps: &Generics, - &&e: (), + e: (), v: vt<()> ) { f(ps); @@ -748,20 +748,20 @@ pub fn mk_simple_visitor(v: simple_visitor) -> vt<()> { body: &blk, sp: span, id: node_id, - &&e: (), + e: (), v: vt<()> ) { f(fk, decl, body, sp, id); visit_fn(fk, decl, body, sp, id, e, v); } - let visit_ty: @fn(@Ty, &&x: (), vt<()>) = + let visit_ty: @fn(@Ty, x: (), vt<()>) = |a,b,c| v_ty(v.visit_ty, a, b, c); - fn v_struct_field(f: @fn(@struct_field), sf: @struct_field, &&e: (), + fn v_struct_field(f: @fn(@struct_field), sf: @struct_field, e: (), v: vt<()>) { f(sf); visit_struct_field(sf, e, v); } - fn v_struct_method(f: @fn(@method), m: @method, &&e: (), v: vt<()>) { + fn v_struct_method(f: @fn(@method), m: @method, e: (), v: vt<()>) { f(m); visit_struct_method(m, e, v); } |