Move everything syntax-related to syntax/, break deps on rest of compiler

src/comp/syntax is currently just a sub-module of rustc, but it will,
in the near future, be its own crate. This includes:

 - The AST data structure
 - The parser
 - The pretty-printer
 - Visit, walk, and fold
 - The syntax extension system
 - Some utility stuff that should be in the stdlib*

*) Stdlib extensions currently require a snapshot before they can be
   used, and the win build is very broken right now. This is temporary
   and will be cleaned up when one of those problems goes away.

A lot of code was moved by this patch, mostly towards a more organized
layout. Some package paths did get longer, and I guess the new layout
will take some getting used to. Sorry about that!

Please try not to re-introduce any dependencies in syntax/ on any of
the other src/comp/ subdirs.

2 files changed, 46 insertions, 71 deletions

diff --git a/src/comp/driver/rustc.rs b/src/comp/driver/rustc.rs
index 10f374d2392..9ad42103a90 100644
--- a/src/comp/driver/rustc.rs
+++ b/src/comp/driver/rustc.rs
@@ -2,19 +2,19 @@
 
 // -*- rust -*-
 import metadata::creader;
-import front::parser;
-import front::token;
-import front::eval;
-import front::ast;
+import syntax::parse::parser;
+import syntax::parse::token;
+import syntax::ast;
+import syntax::codemap;
 import front::attr;
 import middle::trans;
 import middle::resolve;
 import middle::ty;
 import middle::typeck;
 import middle::tstate::ck;
-import pretty::pp;
-import pretty::pprust;
-import pretty::ppaux;
+import syntax::print::pp;
+import syntax::print::pprust;
+import util::ppaux;
 import back::link;
 import lib::llvm;
 import util::common;
@@ -76,12 +76,14 @@ fn parse_cfgspecs(&vec[str] cfgspecs) -> ast::crate_cfg {
     ret vec::map(to_meta_word, cfgspecs);
 }
 
-fn parse_input(session::session sess, parser::parser p, str input) ->
-   @ast::crate {
+fn parse_input(session::session sess, &ast::crate_cfg cfg, str input)
+    -> @ast::crate {
     ret if (str::ends_with(input, ".rc")) {
-            parser::parse_crate_from_crate_file(p)
+            parser::parse_crate_from_crate_file
+                (input, cfg, sess.get_codemap())
         } else if (str::ends_with(input, ".rs")) {
-            parser::parse_crate_from_source_file(p)
+            parser::parse_crate_from_source_file
+                (input, cfg, sess.get_codemap())
         } else { sess.fatal("unknown input file type: " + input); fail };
 }
 
@@ -99,9 +101,8 @@ fn time[T](bool do_it, str what, fn() -> T  thunk) -> T {
 fn compile_input(session::session sess, ast::crate_cfg cfg, str input,
                  str output) {
     auto time_passes = sess.get_opts().time_passes;
-    auto p = parser::new_parser(sess, cfg, input, 0u, 0);
     auto crate =
-        time(time_passes, "parsing", bind parse_input(sess, p, input));
+        time(time_passes, "parsing", bind parse_input(sess, cfg, input));
     if (sess.get_opts().output_type == link::output_type_none) { ret; }
     crate = time(time_passes, "configuration",
                  bind front::config::strip_unconfigured_items(crate));
@@ -129,17 +130,17 @@ fn compile_input(session::session sess, ast::crate_cfg cfg, str input,
 
 fn pretty_print_input(session::session sess, ast::crate_cfg cfg,
                       str input, pp_mode ppm) {
-    fn ann_paren_for_expr(&ppaux::ann_node node) {
+    fn ann_paren_for_expr(&pprust::ann_node node) {
         alt (node) {
-            case (ppaux::node_expr(?s, ?expr)) {
+            case (pprust::node_expr(?s, ?expr)) {
                 pprust::popen(s);
             }
             case (_) {}
         }
     }
-    fn ann_typed_post(&ty::ctxt tcx, &ppaux::ann_node node) {
+    fn ann_typed_post(&ty::ctxt tcx, &pprust::ann_node node) {
         alt (node) {
-            case (ppaux::node_expr(?s, ?expr)) {
+            case (pprust::node_expr(?s, ?expr)) {
                 pp::space(s.s);
                 pp::word(s.s, "as");
                 pp::space(s.s);
@@ -149,18 +150,18 @@ fn pretty_print_input(session::session sess, ast::crate_cfg cfg,
             case (_) {}
         }
     }
-    fn ann_identified_post(&ppaux::ann_node node) {
+    fn ann_identified_post(&pprust::ann_node node) {
         alt (node) {
-            case (ppaux::node_item(?s, ?item)) {
+            case (pprust::node_item(?s, ?item)) {
                 pp::space(s.s);
                 pprust::synth_comment(s, int::to_str(item.id, 10u));
             }
-            case (ppaux::node_block(?s, ?blk)) {
+            case (pprust::node_block(?s, ?blk)) {
                 pp::space(s.s);
                 pprust::synth_comment(s, "block " +
                                       int::to_str(blk.node.id, 10u));
             }
-            case (ppaux::node_expr(?s, ?expr)) {
+            case (pprust::node_expr(?s, ?expr)) {
                 pp::space(s.s);
                 pprust::synth_comment(s, int::to_str(expr.id, 10u));
                 pprust::pclose(s);
@@ -169,8 +170,7 @@ fn pretty_print_input(session::session sess, ast::crate_cfg cfg,
         }
     }
 
-    auto p = front::parser::new_parser(sess, cfg, input, 0u, 0);
-    auto crate = parse_input(sess, p, input);
+    auto crate = parse_input(sess, cfg, input);
     auto ann;
     alt (ppm) {
         case (ppm_typed) {
@@ -186,10 +186,11 @@ fn pretty_print_input(session::session sess, ast::crate_cfg cfg,
                       post=ann_identified_post);
         }
         case (ppm_normal) {
-            ann = ppaux::no_ann();
+            ann = pprust::no_ann();
         }
     }
-    pprust::print_crate(sess, crate, input, std::io::stdout(), ann);
+    pprust::print_crate(sess.get_codemap(), crate, input,
+                        std::io::stdout(), ann);
 }
 
 fn version(str argv0) {
@@ -268,9 +269,9 @@ fn build_target_config() -> @session::config {
     let @session::config target_cfg =
         @rec(os=get_os(triple),
              arch=get_arch(triple),
-             int_type=common::ty_i32,
-             uint_type=common::ty_u32,
-             float_type=common::ty_f64);
+             int_type=ast::ty_i32,
+             uint_type=ast::ty_u32,
+             float_type=ast::ty_f64);
     ret target_cfg;
 }
 
@@ -342,11 +343,11 @@ fn build_session_options(str binary, getopts::match match, str binary_dir) ->
 
 fn build_session(@session::options sopts) -> session::session {
     auto target_cfg = build_target_config();
-    auto crate_cache = common::new_int_hash[session::crate_metadata]();
+    auto crate_cache = syntax::_std::new_int_hash[session::crate_metadata]();
     auto target_crate_num = 0;
     auto sess =
         session::session(target_crate_num, target_cfg, sopts, crate_cache, [],
-                         [], [], front::codemap::new_codemap(), 0u);
+                         [], [], codemap::new_codemap(), 0u);
     ret sess;
 }
 
diff --git a/src/comp/driver/session.rs b/src/comp/driver/session.rs
index 8d296f355ae..8ef558f2fde 100644
--- a/src/comp/driver/session.rs
+++ b/src/comp/driver/session.rs
@@ -1,10 +1,9 @@
 
-import front::ast;
-import front::codemap;
-import util::common::span;
-import util::common::ty_mach;
+import syntax::ast;
+import syntax::codemap;
+import codemap::span;
+import syntax::ast::ty_mach;
 import std::uint;
-import std::term;
 import std::io;
 import std::map;
 import std::option;
@@ -42,30 +41,6 @@ type options =
 
 type crate_metadata = rec(str name, vec[u8] data);
 
-fn span_to_str(span sp, codemap::codemap cm) -> str {
-    auto lo = codemap::lookup_pos(cm, sp.lo);
-    auto hi = codemap::lookup_pos(cm, sp.hi);
-    ret #fmt("%s:%u:%u:%u:%u", lo.filename, lo.line, lo.col, hi.line, hi.col);
-}
-
-fn emit_diagnostic(option::t[span] sp, str msg, str kind, u8 color,
-                   codemap::codemap cm) {
-    auto ss = "<input>:0:0:0:0";
-    alt (sp) {
-        case (some(?ssp)) { ss = span_to_str(ssp, cm); }
-        case (none) { }
-    }
-    io::stdout().write_str(ss + ": ");
-    if (term::color_supported()) {
-        term::fg(io::stdout().get_buf_writer(), color);
-    }
-    io::stdout().write_str(#fmt("%s:", kind));
-    if (term::color_supported()) {
-        term::reset(io::stdout().get_buf_writer());
-    }
-    io::stdout().write_str(#fmt(" %s\n", msg));
-}
-
 obj session(ast::crate_num cnum,
             @config targ_cfg,
             @options opts,
@@ -80,20 +55,19 @@ obj session(ast::crate_num cnum,
     fn get_targ_crate_num() -> ast::crate_num { ret cnum; }
     fn span_fatal(span sp, str msg) -> ! {
         // FIXME: Use constants, but rustboot doesn't know how to export them.
-
-        emit_diagnostic(some(sp), msg, "error", 9u8, cm);
+        codemap::emit_error(some(sp), msg, cm);
         fail;
     }
     fn fatal(str msg) -> ! {
-        emit_diagnostic(none[span], msg, "error", 9u8, cm);
+        codemap::emit_error(none, msg, cm);
         fail;
     }
     fn span_err(span sp, str msg) {
-        emit_diagnostic(some(sp), msg, "error", 9u8, cm);
+        codemap::emit_error(some(sp), msg, cm);
         err_count += 1u;
     }
     fn err(str msg) {
-        emit_diagnostic(none, msg, "error", 9u8, cm);
+        codemap::emit_error(none, msg, cm);
         err_count += 1u;
     }
     fn abort_if_errors() {
@@ -103,19 +77,17 @@ obj session(ast::crate_num cnum,
     }
     fn span_warn(span sp, str msg) {
         // FIXME: Use constants, but rustboot doesn't know how to export them.
-
-        emit_diagnostic(some(sp), msg, "warning", 11u8, cm);
+        codemap::emit_warning(some(sp), msg, cm);
     }
     fn warn(str msg) {
-        emit_diagnostic(none[span], msg, "warning", 11u8, cm);
+        codemap::emit_warning(none, msg, cm);
     }
     fn span_note(span sp, str msg) {
         // FIXME: Use constants, but rustboot doesn't know how to export them.
-
-        emit_diagnostic(some(sp), msg, "note", 10u8, cm);
+        codemap::emit_note(some(sp), msg, cm);
     }
     fn note(str msg) {
-        emit_diagnostic(none, msg, "note", 10u8, cm);
+        codemap::emit_note(none, msg, cm);
     }
     fn span_bug(span sp, str msg) -> ! {
         self.span_fatal(sp, #fmt("internal compiler error %s", msg));
@@ -172,7 +144,9 @@ obj session(ast::crate_num cnum,
     fn lookup_pos(uint pos) -> codemap::loc {
         ret codemap::lookup_pos(cm, pos);
     }
-    fn span_str(span sp) -> str { ret span_to_str(sp, self.get_codemap()); }
+    fn span_str(span sp) -> str {
+        ret codemap::span_to_str(sp, self.get_codemap());
+    }
 }
 // Local Variables:
 // fill-column: 78;