librustc: Introduce a new visitor type based on traits and port syntax to it.

This is preparation for removing `@fn`.

This does *not* use default methods yet, because I don't know
whether they work. If they do, a forthcoming PR will use them.

This also changes the precedence of `as`.

Author: pcwalton

doc/tutorial.md

@@ -1455,7 +1455,7 @@ compiler needs assistance, though, the arguments and return types may be
 annotated.
 
 ~~~~
-let square = |x: int| -> uint { x * x as uint };
+let square = |x: int| -> uint { (x * x) as uint };
 ~~~~
 
 There are several forms of closure, each with its own role. The most

src/librustc/metadata/creader.rs

@@ -17,14 +17,14 @@ use metadata::filesearch::FileSearch;
 use metadata::loader;
 
 use std::hashmap::HashMap;
+use syntax::ast;
 use syntax::attr;
 use syntax::attr::AttrMetaMethods;
 use syntax::codemap::{span, dummy_sp};
 use syntax::diagnostic::span_handler;
 use syntax::parse::token;
 use syntax::parse::token::ident_interner;
-use syntax::visit;
-use syntax::ast;
+use syntax::oldvisit;
 
 // Traverses an AST, reading all the information about use'd crates and extern
 // libraries necessary for later resolving, typechecking, linking, etc.
@@ -46,12 +46,12 @@ pub fn read_crates(diag: @span_handler,
         intr: intr
     };
     let v =
-        visit::mk_simple_visitor(@visit::SimpleVisitor {
+        oldvisit::mk_simple_visitor(@oldvisit::SimpleVisitor {
             visit_view_item: |a| visit_view_item(e, a),
             visit_item: |a| visit_item(e, a),
-            .. *visit::default_simple_visitor()});
+            .. *oldvisit::default_simple_visitor()});
     visit_crate(e, crate);
-    visit::visit_crate(crate, ((), v));
+    oldvisit::visit_crate(crate, ((), v));
     dump_crates(*e.crate_cache);
     warn_if_multiple_versions(e, diag, *e.crate_cache);
 }

src/librustc/metadata/encoder.rs

@@ -39,7 +39,7 @@ use syntax::attr;
 use syntax::attr::AttrMetaMethods;
 use syntax::diagnostic::span_handler;
 use syntax::parse::token::special_idents;
-use syntax::{ast_util, visit};
+use syntax::{ast_util, oldvisit};
 use syntax::parse::token;
 use syntax;
 use writer = extra::ebml::writer;
@@ -1199,12 +1199,12 @@ fn encode_info_for_items(ecx: &EncodeContext,
     // See comment in `encode_side_tables_for_ii` in astencode
     let ecx_ptr : *() = unsafe { cast::transmute(ecx) };
 
-    visit::visit_crate(crate, ((), visit::mk_vt(@visit::Visitor {
+    oldvisit::visit_crate(crate, ((), oldvisit::mk_vt(@oldvisit::Visitor {
         visit_expr: |_e, (_cx, _v)| { },
         visit_item: {
             let ebml_w = (*ebml_w).clone();
             |i, (cx, v)| {
-                visit::visit_item(i, (cx, v));
+                oldvisit::visit_item(i, (cx, v));
                 match items.get_copy(&i.id) {
                     ast_map::node_item(_, pt) => {
                         let mut ebml_w = ebml_w.clone();
@@ -1219,7 +1219,7 @@ fn encode_info_for_items(ecx: &EncodeContext,
         visit_foreign_item: {
             let ebml_w = (*ebml_w).clone();
             |ni, (cx, v)| {
-                visit::visit_foreign_item(ni, (cx, v));
+                oldvisit::visit_foreign_item(ni, (cx, v));
                 match items.get_copy(&ni.id) {
                     ast_map::node_foreign_item(_, abi, _, pt) => {
                         debug!("writing foreign item %s::%s",
@@ -1243,7 +1243,7 @@ fn encode_info_for_items(ecx: &EncodeContext,
                 }
             }
         },
-        ..*visit::default_visitor()
+        ..*oldvisit::default_visitor()
     })));
     ebml_w.end_tag();
     return /*bad*/(*index).clone();

src/librustc/middle/borrowck/check_loans.rs

@@ -27,7 +27,7 @@ use syntax::ast::{m_mutbl, m_imm, m_const};
 use syntax::ast;
 use syntax::ast_util;
 use syntax::codemap::span;
-use syntax::visit;
+use syntax::oldvisit;
 use util::ppaux::Repr;
 
 #[deriving(Clone)]
@@ -54,12 +54,14 @@ pub fn check_loans(bccx: @BorrowckCtxt,
         reported: @mut HashSet::new(),
     };
 
-    let vt = visit::mk_vt(@visit::Visitor {visit_expr: check_loans_in_expr,
-                                           visit_local: check_loans_in_local,
-                                           visit_block: check_loans_in_block,
-                                           visit_pat: check_loans_in_pat,
-                                           visit_fn: check_loans_in_fn,
-                                           .. *visit::default_visitor()});
+    let vt = oldvisit::mk_vt(@oldvisit::Visitor {
+        visit_expr: check_loans_in_expr,
+        visit_local: check_loans_in_local,
+        visit_block: check_loans_in_block,
+        visit_pat: check_loans_in_pat,
+        visit_fn: check_loans_in_fn,
+        .. *oldvisit::default_visitor()
+    });
     (vt.visit_block)(body, (clcx, vt));
 }
 
@@ -612,27 +614,27 @@ impl<'self> CheckLoanCtxt<'self> {
     }
 }
 
-fn check_loans_in_fn<'a>(fk: &visit::fn_kind,
+fn check_loans_in_fn<'a>(fk: &oldvisit::fn_kind,
                          decl: &ast::fn_decl,
                          body: &ast::Block,
                          sp: span,
                          id: ast::NodeId,
                          (this, visitor): (CheckLoanCtxt<'a>,
-                                           visit::vt<CheckLoanCtxt<'a>>)) {
+                                           oldvisit::vt<CheckLoanCtxt<'a>>)) {
     match *fk {
-        visit::fk_item_fn(*) |
-        visit::fk_method(*) => {
+        oldvisit::fk_item_fn(*) |
+        oldvisit::fk_method(*) => {
             // Don't process nested items.
             return;
         }
 
-        visit::fk_anon(*) |
-        visit::fk_fn_block(*) => {
+        oldvisit::fk_anon(*) |
+        oldvisit::fk_fn_block(*) => {
             check_captured_variables(this, id, sp);
         }
     }
 
-    visit::visit_fn(fk, decl, body, sp, id, (this, visitor));
+    oldvisit::visit_fn(fk, decl, body, sp, id, (this, visitor));
 
     fn check_captured_variables(this: CheckLoanCtxt,
                                 closure_id: ast::NodeId,
@@ -677,14 +679,14 @@ fn check_loans_in_fn<'a>(fk: &visit::fn_kind,
 
 fn check_loans_in_local<'a>(local: @ast::Local,
                             (this, vt): (CheckLoanCtxt<'a>,
-                                         visit::vt<CheckLoanCtxt<'a>>)) {
-    visit::visit_local(local, (this, vt));
+                                         oldvisit::vt<CheckLoanCtxt<'a>>)) {
+    oldvisit::visit_local(local, (this, vt));
 }
 
 fn check_loans_in_expr<'a>(expr: @ast::expr,
                            (this, vt): (CheckLoanCtxt<'a>,
-                                        visit::vt<CheckLoanCtxt<'a>>)) {
-    visit::visit_expr(expr, (this, vt));
+                                        oldvisit::vt<CheckLoanCtxt<'a>>)) {
+    oldvisit::visit_expr(expr, (this, vt));
 
     debug!("check_loans_in_expr(expr=%s)",
            expr.repr(this.tcx()));
@@ -737,17 +739,17 @@ fn check_loans_in_expr<'a>(expr: @ast::expr,
 
 fn check_loans_in_pat<'a>(pat: @ast::pat,
                           (this, vt): (CheckLoanCtxt<'a>,
-                                       visit::vt<CheckLoanCtxt<'a>>))
+                                       oldvisit::vt<CheckLoanCtxt<'a>>))
 {
     this.check_for_conflicting_loans(pat.id);
     this.check_move_out_from_id(pat.id, pat.span);
-    visit::visit_pat(pat, (this, vt));
+    oldvisit::visit_pat(pat, (this, vt));
 }
 
 fn check_loans_in_block<'a>(blk: &ast::Block,
                             (this, vt): (CheckLoanCtxt<'a>,
-                                         visit::vt<CheckLoanCtxt<'a>>))
+                                         oldvisit::vt<CheckLoanCtxt<'a>>))
 {
-    visit::visit_block(blk, (this, vt));
+    oldvisit::visit_block(blk, (this, vt));
     this.check_for_conflicting_loans(blk.id);
 }

src/librustc/middle/borrowck/gather_loans/mod.rs

@@ -31,7 +31,7 @@ use syntax::ast;
 use syntax::ast_util::id_range;
 use syntax::codemap::span;
 use syntax::print::pprust;
-use syntax::visit;
+use syntax::oldvisit;
 
 mod lifetime;
 mod restrictions;
@@ -85,46 +85,48 @@ pub fn gather_loans(bccx: @BorrowckCtxt,
         move_data: @mut MoveData::new()
     };
     glcx.gather_fn_arg_patterns(decl, body);
-    let v = visit::mk_vt(@visit::Visitor {visit_expr: gather_loans_in_expr,
-                                          visit_block: gather_loans_in_block,
-                                          visit_fn: gather_loans_in_fn,
-                                          visit_stmt: add_stmt_to_map,
-                                          visit_pat: add_pat_to_id_range,
-                                          visit_local: gather_loans_in_local,
-                                          .. *visit::default_visitor()});
+    let v = oldvisit::mk_vt(@oldvisit::Visitor {
+        visit_expr: gather_loans_in_expr,
+        visit_block: gather_loans_in_block,
+        visit_fn: gather_loans_in_fn,
+        visit_stmt: add_stmt_to_map,
+        visit_pat: add_pat_to_id_range,
+        visit_local: gather_loans_in_local,
+        .. *oldvisit::default_visitor()
+    });
     (v.visit_block)(body, (glcx, v));
     return (glcx.id_range, glcx.all_loans, glcx.move_data);
 }
 
 fn add_pat_to_id_range(p: @ast::pat,
                        (this, v): (@mut GatherLoanCtxt,
-                                   visit::vt<@mut GatherLoanCtxt>)) {
+                                   oldvisit::vt<@mut GatherLoanCtxt>)) {
     // NB: This visitor function just adds the pat ids into the id
     // range. We gather loans that occur in patterns using the
     // `gather_pat()` method below. Eventually these two should be
     // brought together.
     this.id_range.add(p.id);
-    visit::visit_pat(p, (this, v));
+    oldvisit::visit_pat(p, (this, v));
 }
 
-fn gather_loans_in_fn(fk: &visit::fn_kind,
+fn gather_loans_in_fn(fk: &oldvisit::fn_kind,
                       decl: &ast::fn_decl,
                       body: &ast::Block,
                       sp: span,
                       id: ast::NodeId,
                       (this, v): (@mut GatherLoanCtxt,
-                                  visit::vt<@mut GatherLoanCtxt>)) {
+                                  oldvisit::vt<@mut GatherLoanCtxt>)) {
     match fk {
         // Do not visit items here, the outer loop in borrowck/mod
         // will visit them for us in turn.
-        &visit::fk_item_fn(*) | &visit::fk_method(*) => {
+        &oldvisit::fk_item_fn(*) | &oldvisit::fk_method(*) => {
             return;
         }
 
         // Visit closures as part of the containing item.
-        &visit::fk_anon(*) | &visit::fk_fn_block(*) => {
+        &oldvisit::fk_anon(*) | &oldvisit::fk_fn_block(*) => {
             this.push_repeating_id(body.id);
-            visit::visit_fn(fk, decl, body, sp, id, (this, v));
+            oldvisit::visit_fn(fk, decl, body, sp, id, (this, v));
             this.pop_repeating_id(body.id);
             this.gather_fn_arg_patterns(decl, body);
         }
@@ -133,14 +135,14 @@ fn gather_loans_in_fn(fk: &visit::fn_kind,
 
 fn gather_loans_in_block(blk: &ast::Block,
                          (this, vt): (@mut GatherLoanCtxt,
-                                      visit::vt<@mut GatherLoanCtxt>)) {
+                                      oldvisit::vt<@mut GatherLoanCtxt>)) {
     this.id_range.add(blk.id);
-    visit::visit_block(blk, (this, vt));
+    oldvisit::visit_block(blk, (this, vt));
 }
 
 fn gather_loans_in_local(local: @ast::Local,
                          (this, vt): (@mut GatherLoanCtxt,
-                                      visit::vt<@mut GatherLoanCtxt>)) {
+                                      oldvisit::vt<@mut GatherLoanCtxt>)) {
     match local.init {
         None => {
             // Variable declarations without initializers are considered "moves":
@@ -171,12 +173,12 @@ fn gather_loans_in_local(local: @ast::Local,
         }
     }
 
-    visit::visit_local(local, (this, vt));
+    oldvisit::visit_local(local, (this, vt));
 }
 
 fn gather_loans_in_expr(ex: @ast::expr,
                         (this, vt): (@mut GatherLoanCtxt,
-                                     visit::vt<@mut GatherLoanCtxt>)) {
+                                     oldvisit::vt<@mut GatherLoanCtxt>)) {
     let bccx = this.bccx;
     let tcx = bccx.tcx;
 
@@ -216,7 +218,7 @@ fn gather_loans_in_expr(ex: @ast::expr,
         // for the lifetime `scope_r` of the resulting ptr:
         let scope_r = ty_region(tcx, ex.span, ty::expr_ty(tcx, ex));
         this.guarantee_valid(ex.id, ex.span, base_cmt, mutbl, scope_r);
-        visit::visit_expr(ex, (this, vt));
+        oldvisit::visit_expr(ex, (this, vt));
       }
 
       ast::expr_assign(l, _) | ast::expr_assign_op(_, _, l, _) => {
@@ -233,7 +235,7 @@ fn gather_loans_in_expr(ex: @ast::expr,
                   // with moves etc, just ignore.
               }
           }
-          visit::visit_expr(ex, (this, vt));
+          oldvisit::visit_expr(ex, (this, vt));
       }
 
       ast::expr_match(ex_v, ref arms) => {
@@ -243,7 +245,7 @@ fn gather_loans_in_expr(ex: @ast::expr,
                 this.gather_pat(cmt, *pat, Some((arm.body.id, ex.id)));
             }
         }
-        visit::visit_expr(ex, (this, vt));
+        oldvisit::visit_expr(ex, (this, vt));
       }
 
       ast::expr_index(_, _, arg) |
@@ -257,7 +259,7 @@ fn gather_loans_in_expr(ex: @ast::expr,
           let scope_r = ty::re_scope(ex.id);
           let arg_cmt = this.bccx.cat_expr(arg);
           this.guarantee_valid(arg.id, arg.span, arg_cmt, m_imm, scope_r);
-          visit::visit_expr(ex, (this, vt));
+          oldvisit::visit_expr(ex, (this, vt));
       }
 
       // see explanation attached to the `root_ub` field:
@@ -276,17 +278,17 @@ fn gather_loans_in_expr(ex: @ast::expr,
       // see explanation attached to the `root_ub` field:
       ast::expr_loop(ref body, _) => {
           this.push_repeating_id(body.id);
-          visit::visit_expr(ex, (this, vt));
+          oldvisit::visit_expr(ex, (this, vt));
           this.pop_repeating_id(body.id);
       }
 
       ast::expr_fn_block(*) => {
           gather_moves::gather_captures(this.bccx, this.move_data, ex);
-          visit::visit_expr(ex, (this, vt));
+          oldvisit::visit_expr(ex, (this, vt));
       }
 
       _ => {
-        visit::visit_expr(ex, (this, vt));
+        oldvisit::visit_expr(ex, (this, vt));
       }
     }
 }
@@ -762,12 +764,12 @@ impl GatherLoanCtxt {
 // This is just the most convenient place to do it.
 fn add_stmt_to_map(stmt: @ast::stmt,
                    (this, vt): (@mut GatherLoanCtxt,
-                                visit::vt<@mut GatherLoanCtxt>)) {
+                                oldvisit::vt<@mut GatherLoanCtxt>)) {
     match stmt.node {
         ast::stmt_expr(_, id) | ast::stmt_semi(_, id) => {
             this.bccx.stmt_map.insert(id);
         }
         _ => ()
     }
-    visit::visit_stmt(stmt, (this, vt));
+    oldvisit::visit_stmt(stmt, (this, vt));
 }