diff --git a/src/comp/front/test.rs b/src/comp/front/test.rs
index 6d0badaf1296..a527f402e2e5 100644
--- a/src/comp/front/test.rs
+++ b/src/comp/front/test.rs
@@ -10,9 +10,9 @@ export modify_for_testing;
 
 type node_id_gen = @fn() -> ast::node_id;
 
-type test_ctxt = rec(node_id_gen next_node_id,
-                     mutable ast::ident[] path,
-                     mutable ast::ident[][] testfns);
+type test_ctxt = @rec(node_id_gen next_node_id,
+                      mutable ast::ident[] path,
+                      mutable ast::ident[][] testfns);
 
 // Traverse the crate, collecting all the test functions, eliding any
 // existing main functions, and synthesizing a main test harness
@@ -30,9 +30,9 @@ fn modify_for_testing(@ast::crate crate) -> @ast::crate {
         ret this_node_id;
     } (next_node_id);
 
-    let test_ctxt cx = rec(next_node_id = next_node_id_fn,
-                  mutable path = ~[],
-                  mutable testfns = ~[]);
+    let test_ctxt cx = @rec(next_node_id = next_node_id_fn,
+                            mutable path = ~[],
+                            mutable testfns = ~[]);
 
     auto precursor = rec(fold_crate = bind fold_crate(cx, _, _),
                          fold_item = bind fold_item(cx, _, _)
@@ -55,51 +55,6 @@ fn fold_crate(&test_ctxt cx, &ast::crate_ c,
             with folded);
 }
 
-fn add_test_module(&test_ctxt cx, &ast::_mod m) -> ast::_mod {
-    auto testmod = mk_test_module(cx);
-    ret rec(items=m.items + ~[testmod] with m);
-}
-
-fn mk_test_module(&test_ctxt cx) -> @ast::item {
-    auto mainfn = mk_main(cx);
-    let ast::_mod testmod = rec(view_items=~[], items=~[mainfn]);
-    auto item_ = ast::item_mod(testmod);
-    let ast::item item = rec(ident = "__test",
-                             attrs = ~[],
-                             id = cx.next_node_id(),
-                             node = item_,
-                             span = rec(lo=0u, hi=0u));
-    ret @item;
-}
-
-fn mk_main(&test_ctxt cx) -> @ast::item {
-    auto ret_ty = @rec(node=ast::ty_nil,
-                       span=rec(lo=0u, hi=0u));
-
-    let ast::fn_decl decl = rec(inputs = ~[],
-                                output = ret_ty,
-                                purity = ast::impure_fn,
-                                cf = ast::return,
-                                constraints = ~[]);
-    auto proto = ast::proto_fn;
-
-    let ast::block_ body_ = rec(stmts = ~[],
-                                 expr = option::none,
-                                 id = cx.next_node_id());
-    auto body = rec(node = body_, span = rec(lo=0u, hi=0u));
-
-    auto fn_ = rec(decl = decl,
-                   proto = proto,
-                   body = body);
-
-    auto item_ = ast::item_fn(fn_, ~[]);
-    let ast::item item = rec(ident = "main",
-                             attrs = ~[],
-                             id = cx.next_node_id(),
-                             node = item_,
-                             span = rec(lo=0u, hi=0u));
-    ret @item;
-}
 
 fn fold_item(&test_ctxt cx, &@ast::item i,
              fold::ast_fold fld) -> @ast::item {
@@ -110,6 +65,7 @@ fn fold_item(&test_ctxt cx, &@ast::item i,
     if (is_test_fn(i)) {
         log "this is a test function";
         cx.testfns += ~[cx.path];
+        log #fmt("have %u test functions", ivec::len(cx.testfns));
     }
 
     auto res = fold::noop_fold_item(i, fld);
@@ -136,6 +92,231 @@ fn is_test_fn(&@ast::item i) -> bool {
     ret has_test_attr && has_test_signature(i);
 }
 
+fn add_test_module(&test_ctxt cx, &ast::_mod m) -> ast::_mod {
+    auto testmod = mk_test_module(cx);
+    ret rec(items=m.items + ~[testmod] with m);
+}
+
+/*
+
+We're going to be building a module that looks more or less like:
+
+mod __test {
+
+  fn main(vec[str] args) -> int {
+    std::test::test_main(args, tests())
+  }
+
+  fn tests() -> std::test::test_desc[] {
+    ... the list of tests in the crate ...
+  }
+}
+
+*/
+
+fn mk_test_module(&test_ctxt cx) -> @ast::item {
+    // A function that generates a vector of test descriptors to feed to the
+    // test runner
+    auto testsfn = mk_tests(cx);
+    // The synthesized main function which will call the console test runner
+    // with our list of tests
+    auto mainfn = mk_main(cx);
+    let ast::_mod testmod = rec(view_items=~[],
+                                items=~[mainfn, testsfn]);
+    auto item_ = ast::item_mod(testmod);
+    let ast::item item = rec(ident = "__test",
+                             attrs = ~[],
+                             id = cx.next_node_id(),
+                             node = item_,
+                             span = rec(lo=0u, hi=0u));
+    ret @item;
+}
+
+fn nospan[T](&T t) -> ast::spanned[T] {
+    ret rec(node=t,
+            span=rec(lo=0u,hi=0u));
+}
+
+fn mk_tests(&test_ctxt cx) -> @ast::item {
+    auto ret_ty = mk_test_desc_ivec_ty();
+
+    let ast::fn_decl decl = rec(inputs = ~[],
+                                output = ret_ty,
+                                purity = ast::impure_fn,
+                                cf = ast::return,
+                                constraints = ~[]);
+    auto proto = ast::proto_fn;
+    
+    // The vector of test_descs for this crate
+    auto test_descs = mk_test_desc_vec(cx);
+
+    let ast::block_ body_= rec(stmts = ~[],
+                               expr = option::some(test_descs),
+                               id = cx.next_node_id());
+    auto body = nospan(body_);
+
+    auto fn_ = rec(decl = decl,
+                   proto = proto,
+                   body = body);
+
+    auto item_ = ast::item_fn(fn_, ~[]);
+    let ast::item item = rec(ident = "tests",
+                             attrs = ~[],
+                             id = cx.next_node_id(),
+                             node = item_,
+                             span = rec(lo=0u, hi=0u));
+    ret @item;
+}
+
+fn empty_fn_ty() -> ast::ty {
+    auto proto = ast::proto_fn;
+    auto input_ty = ~[];
+    auto ret_ty = @nospan(ast::ty_nil);
+    auto cf = ast::return;
+    auto constrs = ~[];
+    ret nospan(ast::ty_fn(proto, input_ty, ret_ty, cf, constrs));
+}
+
+// The ast::ty of std::test::test_desc
+fn mk_test_desc_ivec_ty() -> @ast::ty {
+    // Oh this is brutal to build by hand
+    let ast::mt name_mt = rec(ty = @nospan(ast::ty_str),
+                              mut = ast::imm);
+    let ast::mt fn_mt = rec(ty = @empty_fn_ty(),
+                            mut = ast::imm);
+
+    let ast::ty_field_ name_ty_field_ = rec(ident = "name",
+                                            mt = name_mt);
+
+    let ast::ty_field_ fn_ty_field_ = rec(ident = "fn",
+                                          mt = fn_mt);
+    
+    let ast::ty_field[] test_desc_fields = ~[nospan(name_ty_field_),
+                                             nospan(fn_ty_field_)];
+    let ast::ty test_desc_ty = nospan(ast::ty_rec(test_desc_fields));
+
+    let ast::mt ivec_mt = rec(ty = @test_desc_ty,
+                              mut = ast::imm);
+
+    ret @nospan(ast::ty_ivec(ivec_mt));
+}
+
+fn mk_test_desc_vec(&test_ctxt cx) -> @ast::expr {
+    log #fmt("building test vector from %u tests",
+             ivec::len(cx.testfns));
+    auto descs = ~[];
+    for (ast::ident[] testpath in cx.testfns) {
+        log #fmt("encoding %s", ast::path_name_i(testpath));
+        auto path = testpath;
+        descs += ~[mk_test_desc_rec(cx, path)];
+    }
+
+    ret @rec(id = cx.next_node_id(),
+             node = ast::expr_vec(descs, ast::imm, ast::sk_unique),
+             span = rec(lo=0u,hi=0u));
+}
+
+fn mk_test_desc_rec(&test_ctxt cx, ast::ident[] path) -> @ast::expr {
+
+    let ast::lit name_lit = nospan(ast::lit_str(ast::path_name_i(path),
+                                                ast::sk_rc));
+    let ast::expr name_expr = rec(id = cx.next_node_id(),
+                                  node = ast::expr_lit(@name_lit),
+                                  span = rec(lo=0u, hi=0u));
+
+    let ast::field name_field = nospan(rec(mut = ast::imm,
+                                           ident = "name",
+                                           expr = @name_expr));
+
+    let ast::path fn_path = nospan(rec(idents = path,
+                                       types = ~[]));
+
+    let ast::expr fn_expr = rec(id = cx.next_node_id(),
+                                node = ast::expr_path(fn_path),
+                                span = rec(lo=0u, hi=0u));
+
+    let ast::field fn_field = nospan(rec(mut = ast::imm,
+                                         ident = "fn",
+                                         expr = @fn_expr));
+
+    let ast::expr_ desc_rec_ = ast::expr_rec(~[name_field, fn_field],
+                                             option::none);
+    let ast::expr desc_rec = rec(id = cx.next_node_id(),
+                                 node = desc_rec_,
+                                 span = rec(lo=0u, hi=0u));
+    ret @desc_rec;
+}
+
+fn mk_main(&test_ctxt cx) -> @ast::item {
+    auto ret_ty = @rec(node=ast::ty_int,
+                       span=rec(lo=0u, hi=0u));
+
+    let ast::fn_decl decl = rec(inputs = ~[],
+                                output = ret_ty,
+                                purity = ast::impure_fn,
+                                cf = ast::return,
+                                constraints = ~[]);
+    auto proto = ast::proto_fn;
+
+    auto test_main_call_expr = mk_test_main_call(cx);
+
+    let ast::block_ body_ = rec(stmts = ~[],
+                                expr = option::some(test_main_call_expr),
+                                id = cx.next_node_id());
+    auto body = rec(node = body_, span = rec(lo=0u, hi=0u));
+
+    auto fn_ = rec(decl = decl,
+                   proto = proto,
+                   body = body);
+
+    auto item_ = ast::item_fn(fn_, ~[]);
+    let ast::item item = rec(ident = "main",
+                             attrs = ~[],
+                             id = cx.next_node_id(),
+                             node = item_,
+                             span = rec(lo=0u, hi=0u));
+    ret @item;
+}
+
+fn mk_test_main_call(&test_ctxt cx) -> @ast::expr {
+
+    let ast::path test_path = nospan(rec(idents = ~["tests"],
+                                         types = ~[]));
+
+    let ast::expr_ test_path_expr_ = ast::expr_path(test_path);
+
+    let ast::expr test_path_expr = rec(id = cx.next_node_id(),
+                                       node = test_path_expr_,
+                                       span = rec(lo=0u, hi=0u));
+
+    let ast::expr_ test_call_expr_ = ast::expr_call(@test_path_expr, ~[]);
+
+    let ast::expr test_call_expr = rec(id = cx.next_node_id(),
+                                       node = test_call_expr_,
+                                       span = rec(lo=0u, hi=0u));
+
+    let ast::path test_main_path = nospan(rec(idents = ~["std",
+                                                         "test",
+                                                         "test_main"],
+                                              types = ~[]));
+
+    let ast::expr_ test_main_path_expr_
+        = ast::expr_path(test_main_path);
+
+    let ast::expr test_main_path_expr = rec(id = cx.next_node_id(),
+                                            node = test_main_path_expr_,
+                                            span = rec(lo=0u, hi=0u));
+
+    let ast::expr_ test_main_call_expr_ 
+        = ast::expr_call(@test_main_path_expr, ~[@test_call_expr]);
+
+    let ast::expr test_main_call_expr = rec(id = cx.next_node_id(),
+                                            node = test_main_call_expr_,
+                                            span = rec(lo=0u, hi=0u));
+
+    ret @test_main_call_expr;
+}
+
 // Local Variables:
 // mode: rust
 // fill-column: 78;
diff --git a/src/lib/test.rs b/src/lib/test.rs
index cfee1f820722..57c1c531c9b1 100644
--- a/src/lib/test.rs
+++ b/src/lib/test.rs
@@ -27,7 +27,7 @@ type test_desc = rec(test_name name,
 
 // The default console test runner. It accepts the command line
 // arguments and a vector of test_descs (generated at compile time).
-fn test_main(&vec[str] args, &test_desc[] tests) -> int {
+fn test_main(&test_desc[] tests) -> int {
     if (run_tests(tests)) {
         ret 0;
     } else {