---

yaml
---
r: 5870
b: refs/heads/master
c: 3b54dcf
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 1abebf042a0dc8fcbf6c313e20046ca68e3d09ed
+refs/heads/master: 3b54dcfa79833dc3dc2569cc39d79b6d9ffde0d5

trunk/src/comp/front/test.rs

@@ -224,10 +224,19 @@ fn empty_fn_ty() -> ast::ty {
 
 // The ast::ty of [std::test::test_desc]
 fn mk_test_desc_vec_ty(cx: test_ctxt) -> @ast::ty {
+    let test_fn_ty: ast::ty = nospan(
+        ast::ty_path(
+            nospan({
+                global: false,
+                idents: ["std", "test", "default_test_fn"],
+                types: []
+            }),
+            cx.next_node_id()));
+
     let test_desc_ty_path: ast::path =
         nospan({global: false,
                 idents: ["std", "test", "test_desc"],
-                types: []});
+                types: [@test_fn_ty]});
 
     let test_desc_ty: ast::ty =
         nospan(ast::ty_path(test_desc_ty_path, cx.next_node_id()));
@@ -273,8 +282,10 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr {
          node: ast::expr_path(fn_path),
          span: span};
 
+    let fn_wrapper_expr = mk_test_wrapper(cx, fn_expr, span);
+
     let fn_field: ast::field =
-        nospan({mut: ast::imm, ident: "fn", expr: @fn_expr});
+        nospan({mut: ast::imm, ident: "fn", expr: fn_wrapper_expr});
 
     let ignore_lit: ast::lit = nospan(ast::lit_bool(test.ignore));
 
@@ -293,6 +304,51 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr {
     ret @desc_rec;
 }
 
+// Produces a bare function that wraps the test function
+// FIXME: This can go away once fn is the type of bare function
+fn mk_test_wrapper(cx: test_ctxt,
+                   fn_path_expr: ast::expr,
+                   span: span) -> @ast::expr {
+    let call_expr: ast::expr = {
+        id: cx.next_node_id(),
+        node: ast::expr_call(@fn_path_expr, []),
+        span: span
+    };
+
+    let call_stmt: ast::stmt = nospan(
+        ast::stmt_expr(@call_expr, cx.next_node_id()));
+
+    let wrapper_decl: ast::fn_decl = {
+        inputs: [],
+        output: @nospan(ast::ty_nil),
+        purity: ast::impure_fn,
+        il: ast::il_normal,
+        cf: ast::return_val,
+        constraints: []
+    };
+
+    let wrapper_body: ast::blk = nospan({
+        stmts: [@call_stmt],
+        expr: option::none,
+        id: cx.next_node_id(),
+        rules: ast::default_blk
+    });
+
+    let wrapper_fn: ast::_fn = {
+        decl: wrapper_decl,
+        proto: ast::proto_bare,
+        body: wrapper_body
+    };
+
+    let wrapper_expr: ast::expr = {
+        id: cx.next_node_id(),
+        node: ast::expr_fn(wrapper_fn),
+        span: span
+    };
+
+    ret @wrapper_expr;
+}
+
 fn mk_main(cx: test_ctxt) -> @ast::item {
 
     let args_mt: ast::mt = {ty: @nospan(ast::ty_str), mut: ast::imm};

trunk/src/compiletest/compiletest.rs

@@ -1,3 +1,6 @@
+// FIXME: The way this module sets up tests is a relic and more convoluted
+// than it needs to be
+
 import std::option;
 import std::getopts;
 import std::test;
@@ -124,8 +127,10 @@ fn test_opts(config: config) -> test::test_opts {
      run_ignored: config.run_ignored}
 }
 
-type tests_and_conv_fn =
-    {tests: [test::test_desc], to_task: fn(fn()) -> test::joinable};
+type tests_and_conv_fn = {
+    tests: [test::test_desc<fn()>],
+    to_task: fn(fn()) -> test::joinable
+};
 
 fn make_tests(cx: cx) -> tests_and_conv_fn {
     log #fmt["making tests from %s", cx.config.src_base];
@@ -162,7 +167,7 @@ fn is_test(config: config, testfile: str) -> bool {
 }
 
 fn make_test(cx: cx, testfile: str, configport: port<[u8]>) ->
-   test::test_desc {
+   test::test_desc<fn()> {
     {name: make_test_name(cx.config, testfile),
      fn: make_test_closure(testfile, chan(configport)),
      ignore: header::is_test_ignored(cx.config, testfile)}
@@ -172,94 +177,31 @@ fn make_test_name(config: config, testfile: str) -> str {
     #fmt["[%s] %s", mode_str(config.mode), testfile]
 }
 
-/*
-So this is kind of crappy:
-
-A test is just defined as a function, as you might expect, but tests have to
-run in their own tasks. Unfortunately, if your test needs dynamic data then it
-needs to be a closure, and transferring closures across tasks without
-committing a host of memory management transgressions is just impossible.
-
-To get around this, the standard test runner allows you the opportunity do
-your own conversion from a test function to a task. It gives you your function
-and you give it back a task.
-
-So that's what we're going to do. Here's where it gets stupid. To get the
-the data out of the test function we are going to run the test function,
-which will do nothing but send the data for that test to a port we've set
-up. Then we'll spawn that data into another task and return the task.
-Really convoluted. Need to think up of a better definition for tests.
-*/
-
-fn make_test_closure(testfile: str, configchan: chan<[u8]>) -> test::test_fn {
+fn make_test_closure(testfile: str,
+                     configchan: chan<[u8]>) -> test::test_fn<fn()> {
     bind send_config(testfile, configchan)
 }
 
 fn send_config(testfile: str, configchan: chan<[u8]>) {
     send(configchan, str::bytes(testfile));
 }
 
-/*
-FIXME: Good god forgive me.
-
-So actually shuttling structural data across tasks isn't possible at this
-time, but we can send strings! Sadly, I need the whole config record, in the
-test task so, instead of fixing the mechanism in the compiler I'm going to
-break up the config record and pass everything individually to the spawned
-function.
-*/
-
 fn closure_to_task(cx: cx, configport: port<[u8]>, testfn: fn()) ->
    test::joinable {
     testfn();
     let testfile = recv(configport);
 
-    let compile_lib_path = cx.config.compile_lib_path;
-    let run_lib_path = cx.config.run_lib_path;
-    let rustc_path = cx.config.rustc_path;
-    let src_base = cx.config.src_base;
-    let build_base = cx.config.build_base;
-    let stage_id = cx.config.stage_id;
-    let mode = mode_str(cx.config.mode);
-    let run_ignored = cx.config.run_ignored;
-    let filter = opt_str(cx.config.filter);
-    let runtool = opt_str(cx.config.runtool);
-    let rustcflags = opt_str(cx.config.rustcflags);
-    let verbose = cx.config.verbose;
-    let chan = cx.procsrv.chan;
-
-    let testthunk =
-        bind run_test_task(compile_lib_path, run_lib_path, rustc_path,
-                           src_base, build_base, stage_id, mode, run_ignored,
-                           filter, runtool, rustcflags, verbose, chan,
-                           testfile);
-    ret task::spawn_joinable(testthunk);
+    ret task::spawn_joinable2(
+        (cx.config, cx.procsrv.chan, testfile), run_test_task);
 }
 
-fn run_test_task(-compile_lib_path: str, -run_lib_path: str, -rustc_path: str,
-                 -src_base: str, -build_base: str, -stage_id: str, -mode: str,
-                 -run_ignored: bool, -opt_filter: str, -opt_runtool: str,
-                 -opt_rustcflags: str, -verbose: bool,
-                 -procsrv_chan: procsrv::reqchan, -testfile: [u8]) {
+fn# run_test_task(args: (common::config, procsrv::reqchan, [u8])) {
 
-    test::configure_test_task();
+    let (config, procsrv_chan, testfile) = args;
 
-    let config =
-        {compile_lib_path: compile_lib_path,
-         run_lib_path: run_lib_path,
-         rustc_path: rustc_path,
-         src_base: src_base,
-         build_base: build_base,
-         stage_id: stage_id,
-         mode: str_mode(mode),
-         run_ignored: run_ignored,
-         filter: str_opt(opt_filter),
-         runtool: str_opt(opt_runtool),
-         rustcflags: str_opt(opt_rustcflags),
-         verbose: verbose};
+    test::configure_test_task();
 
     let procsrv = procsrv::from_chan(procsrv_chan);
-
     let cx = {config: config, procsrv: procsrv};
 
     runtest::run(cx, testfile);

trunk/src/compiletest/procsrv.rs

@@ -37,13 +37,14 @@ type response = {pid: int, infd: int, outfd: int, errfd: int};
 
 fn mk() -> handle {
     let setupport = port();
-    let task =
-        task::spawn_joinable(bind fn (setupchan: chan<chan<request>>) {
-                                      let reqport = port();
-                                      let reqchan = chan(reqport);
-                                      send(setupchan, reqchan);
-                                      worker(reqport);
-                                  }(chan(setupport)));
+    let task = task::spawn_joinable2(
+        chan(setupport),
+        fn# (setupchan: chan<chan<request>>) {
+            let reqport = port();
+            let reqchan = chan(reqport);
+            send(setupchan, reqchan);
+            worker(reqport);
+        });
     ret {task: option::some(task), chan: recv(setupport)};
 }