diff --git a/src/comp/back/link.rs b/src/comp/back/link.rs
index 20cf266beca..7a933aa20f8 100644
--- a/src/comp/back/link.rs
+++ b/src/comp/back/link.rs
@@ -340,10 +340,8 @@ fn build_link_meta(sess: &session::session, c: &ast::crate, output: &str,
         ret alt metas.name {
               some(v) { v }
               none. {
-                let 
-                    // FIXME: Remove this vec->ivec conversion.
-
-                    name =
+                // FIXME: Remove this vec->ivec conversion.
+                let name =
                     {
                         let os_vec =
                             str::split(fs::basename(output), '.' as u8);
diff --git a/src/comp/driver/rustc.rs b/src/comp/driver/rustc.rs
index 34c8f7f3163..3dacbd3b9d0 100644
--- a/src/comp/driver/rustc.rs
+++ b/src/comp/driver/rustc.rs
@@ -65,9 +65,8 @@ fn build_configuration(sess: session::session, argv0: str, input: str) ->
     // some default and generated configuration items
     let default_cfg = default_configuration(sess, argv0, input);
     let user_cfg = sess.get_opts().cfg;
-    let 
-        // If the user wants a test runner, then add the test cfg
-        gen_cfg =
+    // If the user wants a test runner, then add the test cfg
+    let gen_cfg =
         {
             if sess.get_opts().test && !attr::contains_name(user_cfg, "test")
                {
diff --git a/src/comp/front/config.rs b/src/comp/front/config.rs
index 1107e69875f..e1e580f191e 100644
--- a/src/comp/front/config.rs
+++ b/src/comp/front/config.rs
@@ -101,9 +101,7 @@ fn in_cfg(cfg: &ast::crate_cfg, attrs: &ast::attribute[]) -> bool {
     // Pull the inner meta_items from the #[cfg(meta_item, ...)]  attributes,
     // so we can match against them. This is the list of configurations for
     // which the item is valid
-    let 
-
-        item_cfg_metas =
+    let item_cfg_metas =
         {
             fn extract_metas(inner_items: &(@ast::meta_item)[],
                              cfg_item: &@ast::meta_item) ->
diff --git a/src/comp/lib/llvm.rs b/src/comp/lib/llvm.rs
index 019179d45ec..76e234cae9a 100644
--- a/src/comp/lib/llvm.rs
+++ b/src/comp/lib/llvm.rs
@@ -1395,11 +1395,10 @@ obj builder(B: BuilderRef, terminated: @mutable bool) {
 
     fn is_terminated() -> bool {
         ret *terminated;
-    }drop 
-
-          {
+    }
+    drop {
          llvm::LLVMDisposeBuilder(B);
-     }
+    }
 }
 
 /* Memory-managed object interface to type handles. */
diff --git a/src/comp/metadata/creader.rs b/src/comp/metadata/creader.rs
index abbc887cd12..b0fa97f7ea9 100644
--- a/src/comp/metadata/creader.rs
+++ b/src/comp/metadata/creader.rs
@@ -122,22 +122,20 @@ fn find_library_crate(sess: &session::session, ident: &ast::ident,
 
     attr::require_unique_names(sess, metas);
 
-    let 
-        // FIXME: Probably want a warning here since the user
-        // is using the wrong type of meta item
-        crate_name =
-        {
-            let name_items = attr::find_meta_items_by_name(metas, "name");
-            alt ivec::last(name_items) {
-              some(i) {
-                alt attr::get_meta_item_value_str(i) {
-                  some(n) { n }
-                  _ { ident }
-                }
-              }
-              none. { ident }
+    // FIXME: Probably want a warning here since the user
+    // is using the wrong type of meta item
+    let crate_name = {
+        let name_items = attr::find_meta_items_by_name(metas, "name");
+        alt ivec::last(name_items) {
+          some(i) {
+            alt attr::get_meta_item_value_str(i) {
+              some(n) { n }
+              _ { ident }
             }
-        };
+          }
+          none. { ident }
+        }
+    };
 
     let nn = default_native_lib_naming(sess, sess.get_opts().static);
     let x =
diff --git a/src/comp/metadata/decoder.rs b/src/comp/metadata/decoder.rs
index d7d82c1fa36..ab9c07981b9 100644
--- a/src/comp/metadata/decoder.rs
+++ b/src/comp/metadata/decoder.rs
@@ -164,9 +164,8 @@ fn lookup_def(cnum: ast::crate_num, data: @u8[], did_: &ast::def_id) ->
     let item = lookup_item(did_.node, data);
     let kind_ch = item_kind(item);
     let did = {crate: cnum, node: did_.node};
-    let 
-        // We treat references to tags as references to types.
-        def =
+    // We treat references to tags as references to types.
+    let def =
         alt kind_ch as char {
           'c' { ast::def_const(did) }
           'f' { ast::def_fn(did, ast::impure_fn) }
diff --git a/src/comp/middle/alias.rs b/src/comp/middle/alias.rs
index f958b88e76e..ee56a3958bc 100644
--- a/src/comp/middle/alias.rs
+++ b/src/comp/middle/alias.rs
@@ -39,10 +39,9 @@ tag local_info { arg(ast::mode); objfield(ast::mutability); }
 type ctx = {tcx: ty::ctxt, local_map: std::map::hashmap[node_id, local_info]};
 
 fn check_crate(tcx: ty::ctxt, crate: &@ast::crate) {
-    let 
-        // Stores information about object fields and function
-        // arguments that's otherwise not easily available.
-        cx =
+    // Stores information about object fields and function
+    // arguments that's otherwise not easily available.
+    let cx =
         @{tcx: tcx, local_map: std::map::new_int_hash()};
     let v =
         @{visit_fn: bind visit_fn(cx, _, _, _, _, _, _, _),
diff --git a/src/comp/middle/freevars.rs b/src/comp/middle/freevars.rs
index d157499734e..c49d0ff2834 100644
--- a/src/comp/middle/freevars.rs
+++ b/src/comp/middle/freevars.rs
@@ -73,12 +73,12 @@ fn collect_freevars(def_map: &resolve::def_map, sess: &session::session,
 
     let e: env =
         @{mutable refs: ~[], decls: decls, def_map: def_map, sess: sess};
-    walker(visit::mk_simple_visitor(@{visit_local: bind walk_local(e, _),
-                                      visit_pat: bind walk_pat(e, _),
-                                      visit_expr: bind walk_expr(e, _),
-                                      visit_fn: bind walk_fn(e, _, _, _, _, _)
-                                         with
-                                             *visit::default_simple_visitor()}));
+    walker(visit::mk_simple_visitor
+           (@{visit_local: bind walk_local(e, _),
+              visit_pat: bind walk_pat(e, _),
+              visit_expr: bind walk_expr(e, _),
+              visit_fn: bind walk_fn(e, _, _, _, _, _)
+              with *visit::default_simple_visitor()}));
 
     // Calculate (refs - decls). This is the set of captured upvars.
     // We build a vec of the node ids of the uses and a set of the
diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs
index 43b6f8d1d06..c690889dd36 100644
--- a/src/comp/middle/trans.rs
+++ b/src/comp/middle/trans.rs
@@ -830,10 +830,9 @@ fn trans_malloc_boxed(cx: &@block_ctxt, t: ty::t) -> result {
     // size of; box_ptr is the type that's converted to a TypeRef and used as
     // the pointer cast target in trans_raw_malloc.
 
-    let 
-        // The mk_int here is the space being
-        // reserved for the refcount.
-        boxed_body =
+    // The mk_int here is the space being
+    // reserved for the refcount.
+    let boxed_body =
         ty::mk_imm_tup(bcx_tcx(cx), ~[ty::mk_int(bcx_tcx(cx)), t]);
     let box_ptr = ty::mk_imm_box(bcx_tcx(cx), t);
     let sz = size_of(cx, boxed_body);
@@ -1243,21 +1242,20 @@ fn incr_refcnt_of_boxed(cx: &@block_ctxt, box_ptr: ValueRef) -> result {
 fn make_free_glue(cx: &@block_ctxt, v0: ValueRef, t: &ty::t) {
     // NB: v is an *alias* of type t here, not a direct value.
 
-    let 
-        // FIXME: switch gc/non-gc on layer of the type.
-        // FIXME: switch gc/non-gc on layer of the type.
-        // TODO: call upcall_kill
+    // FIXME: switch gc/non-gc on layer of the type.
+    // FIXME: switch gc/non-gc on layer of the type.
+    // TODO: call upcall_kill
 
 
-        // Call through the obj's own fields-drop glue first.
+    // Call through the obj's own fields-drop glue first.
 
-        // Then free the body.
-        // FIXME: switch gc/non-gc on layer of the type.
-        // Call through the closure's own fields-drop glue first.
+    // Then free the body.
+    // FIXME: switch gc/non-gc on layer of the type.
+    // Call through the closure's own fields-drop glue first.
 
-        // Then free the body.
-        // FIXME: switch gc/non-gc on layer of the type.
-        rs =
+    // Then free the body.
+    // FIXME: switch gc/non-gc on layer of the type.
+    let rs =
         alt ty::struct(bcx_tcx(cx), t) {
           ty::ty_str. { let v = cx.build.Load(v0); trans_non_gc_free(cx, v) }
           ty::ty_vec(_) {
@@ -1361,9 +1359,7 @@ fn maybe_free_ivec_heap_part(cx: &@block_ctxt, v0: ValueRef, unit_ty: ty::t)
 fn make_drop_glue(cx: &@block_ctxt, v0: ValueRef, t: &ty::t) {
     // NB: v0 is an *alias* of type t here, not a direct value.
     let ccx = bcx_ccx(cx);
-    let 
-
-        rs =
+    let rs =
         alt ty::struct(ccx.tcx, t) {
           ty::ty_str. { decr_refcnt_maybe_free(cx, v0, v0, t) }
           ty::ty_vec(_) { decr_refcnt_maybe_free(cx, v0, v0, t) }
@@ -1453,7 +1449,9 @@ fn trans_res_drop(cx: @block_ctxt, rs: ValueRef, did: &ast::def_id,
     // value here, but the dtor expects a type that still has opaque pointers
     // for type variables.
     let val_llty =
-        lib::llvm::fn_ty_param_tys(llvm::LLVMGetElementType(llvm::LLVMTypeOf(dtor_addr))).(std::ivec::len(args));
+        lib::llvm::fn_ty_param_tys(llvm::LLVMGetElementType
+                                   (llvm::LLVMTypeOf(dtor_addr)))
+                                    .(std::ivec::len(args));
     let val_cast = cx.build.BitCast(val.val, val_llty);
     cx.build.FastCall(dtor_addr, args + ~[val_cast]);
 
@@ -3345,9 +3343,8 @@ mod ivec {
             maybe_on_heap_cx.build.PointerCast(vptr,
                                                T_ptr(T_ivec_heap(llunitty)));
         let heap_ptr_ptr =
-            maybe_on_heap_cx.build.InBoundsGEP(stub_ptr,
-                                               ~[C_int(0),
-                                                 C_uint(abi::ivec_heap_stub_elt_ptr)]);
+            maybe_on_heap_cx.build.InBoundsGEP
+            (stub_ptr, ~[C_int(0), C_uint(abi::ivec_heap_stub_elt_ptr)]);
         let heap_ptr = maybe_on_heap_cx.build.Load(heap_ptr_ptr);
         let heap_ptr_is_nonnull =
             maybe_on_heap_cx.build.ICmp(lib::llvm::LLVMIntNE, heap_ptr,
@@ -3358,9 +3355,8 @@ mod ivec {
 
         // Ok, the vector is on the heap. Copy the heap part.
         let alen_ptr =
-            on_heap_cx.build.InBoundsGEP(stub_ptr,
-                                         ~[C_int(0),
-                                           C_uint(abi::ivec_heap_stub_elt_alen)]);
+            on_heap_cx.build.InBoundsGEP
+            (stub_ptr, ~[C_int(0), C_uint(abi::ivec_heap_stub_elt_alen)]);
         let alen = on_heap_cx.build.Load(alen_ptr);
 
         let heap_part_sz =
@@ -3598,17 +3594,15 @@ fn trans_if(cx: &@block_ctxt, cond: &@ast::expr, thn: &ast::blk,
     let then_cx = new_scope_block_ctxt(cx, "then");
     let then_res = trans_block(then_cx, thn, output);
     let else_cx = new_scope_block_ctxt(cx, "else");
-    let 
-        // Synthesize a block here to act as the else block
-        // containing an if expression. Needed in order for the
-        // else scope to behave like a normal block scope. A tad
-        // ugly.
-        // Calling trans_block directly instead of trans_expr
-        // because trans_expr will create another scope block
-        // context for the block, but we've already got the
-        // 'else' context
-
-        else_res =
+    // Synthesize a block here to act as the else block
+    // containing an if expression. Needed in order for the
+    // else scope to behave like a normal block scope. A tad
+    // ugly.
+    // Calling trans_block directly instead of trans_expr
+    // because trans_expr will create another scope block
+    // context for the block, but we've already got the
+    // 'else' context
+    let else_res =
         alt els {
           some(elexpr) {
             alt elexpr.node {
@@ -4908,7 +4902,7 @@ fn trans_call(cx: &@block_ctxt, f: &@ast::expr,
     let llretslot = args_res.retslot;
     /*
     log "calling: " + val_str(bcx_ccx(cx).tn, faddr);
-    
+
     for (ValueRef arg in llargs) {
         log "arg: " + val_str(bcx_ccx(cx).tn, arg);
     }
@@ -5334,9 +5328,9 @@ fn trans_expr_out(cx: &@block_ctxt, e: &@ast::expr, output: out_method) ->
       }
       _ {
         // The expression is an lvalue. Fall through.
-        assert (ty::is_lval(e)); // make sure it really is and that we
-                                 // didn't forget to add a case for a new expr!
-
+        assert (ty::is_lval(e));
+        // make sure it really is and that we
+        // didn't forget to add a case for a new expr!
       }
     }
     // lval cases fall through to trans_lval and then
@@ -6352,8 +6346,8 @@ fn copy_args_to_allocas(fcx: @fn_ctxt, args: &ast::arg[],
             alt bcx.fcx.llargs.find(aarg.id) {
               some(x) { argval = x; }
               _ {
-                bcx_ccx(bcx).sess.span_fatal(aarg.ty.span,
-                                             "unbound arg ID in copy_args_to_allocas");
+                bcx_ccx(bcx).sess.span_fatal
+                    (aarg.ty.span, "unbound arg ID in copy_args_to_allocas");
               }
             }
             bcx.build.Store(argval, a);
@@ -6374,8 +6368,8 @@ fn add_cleanups_for_args(bcx: &@block_ctxt, args: &ast::arg[],
             alt bcx.fcx.llargs.find(aarg.id) {
               some(x) { argval = x; }
               _ {
-                bcx_ccx(bcx).sess.span_fatal(aarg.ty.span,
-                                             "unbound arg ID in copy_args_to_allocas");
+                bcx_ccx(bcx).sess.span_fatal
+                    (aarg.ty.span, "unbound arg ID in copy_args_to_allocas");
               }
             }
             add_clean(bcx, argval, arg_tys.(arg_n).ty);
@@ -7227,9 +7221,8 @@ fn trans_tag_variant(cx: @local_ctxt, tag_id: ast::node_id,
     let bcx = new_top_block_ctxt(fcx);
     let lltop = bcx.llbb;
 
-    let 
-        // Cast the tag to a type we can GEP into.
-        llblobptr =
+    // Cast the tag to a type we can GEP into.
+    let llblobptr =
         if is_degen {
             fcx.llretptr
         } else {
diff --git a/src/comp/middle/trans_alt.rs b/src/comp/middle/trans_alt.rs
index dbf8e472e53..ead0bcaf0b6 100644
--- a/src/comp/middle/trans_alt.rs
+++ b/src/comp/middle/trans_alt.rs
@@ -294,9 +294,8 @@ fn compile_submatch(bcx: @block_ctxt, m: &match, vals: ValueRef[],
             if ivec::len(ty::tag_variants(ccx.tcx, vdef.tg)) == 1u {
                 kind = single;
             } else {
-                let tagptr =
-                    bcx.build.PointerCast(val,
-                                          trans_common::T_opaque_tag_ptr(ccx.tn));
+                let tagptr = bcx.build.PointerCast
+                    (val, trans_common::T_opaque_tag_ptr(ccx.tn));
                 let discrimptr = bcx.build.GEP(tagptr, ~[C_int(0), C_int(0)]);
                 test_val = bcx.build.Load(discrimptr);
                 kind = switch;
diff --git a/src/comp/middle/tstate/bitvectors.rs b/src/comp/middle/tstate/bitvectors.rs
index a14a7a25539..d125427776a 100644
--- a/src/comp/middle/tstate/bitvectors.rs
+++ b/src/comp/middle/tstate/bitvectors.rs
@@ -159,9 +159,7 @@ fn relax_precond_block(fcx: &fn_ctxt, i: node_id, b: &blk) {
     fn quit(keepgoing: @mutable bool, i: &@item) { *keepgoing = false; }
     fn kg(keepgoing: @mutable bool) -> bool { ret *keepgoing; }
 
-    let 
-
-        v =
+    let v =
         {visit_block_pre: bind relax_precond_block_non_recursive(fcx, i, _),
          visit_expr_pre: bind relax_precond_expr(fcx, i, _),
          visit_stmt_pre: bind relax_precond_stmt(fcx, i, _),
diff --git a/src/comp/middle/tstate/pre_post_conditions.rs b/src/comp/middle/tstate/pre_post_conditions.rs
index c849ac8b33f..d9910d8217d 100644
--- a/src/comp/middle/tstate/pre_post_conditions.rs
+++ b/src/comp/middle/tstate/pre_post_conditions.rs
@@ -641,7 +641,7 @@ fn find_pre_post_block(fcx: &fn_ctxt, b: blk) {
      This will mean that:
      x = 0;
      break;
-    
+
      won't have a postcondition that says x is initialized, but that's ok.
      */
 
diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs
index 1b3bc84b2c7..674e5c9b9cb 100644
--- a/src/comp/middle/ty.rs
+++ b/src/comp/middle/ty.rs
@@ -1987,8 +1987,9 @@ mod unify {
 
             let result_mode;
             if expected_input.mode != actual_input.mode {
-                ret fn_common_res_err(ures_err(terr_mode_mismatch(expected_input.mode,
-                                                                  actual_input.mode)));
+                ret fn_common_res_err
+                    (ures_err(terr_mode_mismatch(expected_input.mode,
+                                                 actual_input.mode)));
             } else { result_mode = expected_input.mode; }
             let result = unify_step(cx, expected_input.ty, actual_input.ty);
             alt result {
@@ -2817,10 +2818,10 @@ fn ast_constr_to_constr[T](tcx: ty::ctxt, c: &@ast::constr_general[T]) ->
                     {path: c.node.path, args: c.node.args, id: pred_id});
       }
       _ {
-        tcx.sess.span_fatal(c.span,
-                            "Predicate " + path_to_str(c.node.path) +
-                                " is unbound or bound to a non-function or an \
-                        impure function");
+        tcx.sess.span_fatal
+            (c.span, "Predicate " + path_to_str(c.node.path) +
+             " is unbound or bound to a non-function or an \
+              impure function");
       }
     }
 }
diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs
index 432930be56d..d567b9d45bc 100644
--- a/src/comp/middle/typeck.rs
+++ b/src/comp/middle/typeck.rs
@@ -164,14 +164,14 @@ fn instantiate_path(fcx: &@fn_ctxt, pth: &ast::path,
     if ty_substs_len > 0u {
         let param_var_len = ivec::len(ty_param_vars);
         if param_var_len == 0u {
-            fcx.ccx.tcx.sess.span_fatal(sp,
-                                        "this item does not take type parameters");
+            fcx.ccx.tcx.sess.span_fatal
+                (sp, "this item does not take type parameters");
         } else if (ty_substs_len > param_var_len) {
-            fcx.ccx.tcx.sess.span_fatal(sp,
-                                        "too many type parameter provided for this item");
+            fcx.ccx.tcx.sess.span_fatal
+                (sp, "too many type parameter provided for this item");
         } else if (ty_substs_len < param_var_len) {
-            fcx.ccx.tcx.sess.span_fatal(sp,
-                                        "not enough type parameters provided for this item");
+            fcx.ccx.tcx.sess.span_fatal
+                (sp, "not enough type parameters provided for this item");
         }
         let ty_substs: ty::t[] = ~[];
         let i = 0u;
@@ -868,11 +868,10 @@ mod collect {
         let abi = @mutable none[ast::native_abi];
         let cx = @{tcx: tcx};
         let visit =
-            visit::mk_simple_visitor(@{visit_item: bind convert(cx, abi, _),
-                                       visit_native_item:
-                                           bind convert_native(cx, abi, _)
-                                          with
-                                              *visit::default_simple_visitor()});
+            visit::mk_simple_visitor
+            (@{visit_item: bind convert(cx, abi, _),
+               visit_native_item: bind convert_native(cx, abi, _)
+               with *visit::default_simple_visitor()});
         visit::visit_crate(*crate, (), visit);
     }
 }
@@ -1426,14 +1425,13 @@ fn check_pat(fcx: &@fn_ctxt, map: &ast::pat_id_map, pat: &@ast::pat,
                 // TODO (issue #448): Wrap a #fmt string over multiple
                 // lines...
 
-                fcx.ccx.tcx.sess.span_fatal(pat.span,
-                                            #fmt("this pattern has %u field%s, \
-                                                but the corresponding \
-                                                variant has no fields",
-                                                 subpats_len,
-                                                 if subpats_len == 1u {
-                                                     ""
-                                                 } else { "s" }));
+                fcx.ccx.tcx.sess.span_fatal
+                    (pat.span, #fmt("this pattern has %u field%s, \
+                                     but the corresponding \
+                                     variant has no fields",
+                                    subpats_len,
+                                    if subpats_len == 1u { "" }
+                                    else { "s" }));
             }
             write::ty_fixup(fcx, pat.id, path_tpot);
           }
@@ -1464,11 +1462,10 @@ fn check_pat(fcx: &@fn_ctxt, map: &ast::pat_id_map, pat: &@ast::pat,
         let f_count = ivec::len(fields);
         let ex_f_count = ivec::len(ex_fields);
         if ex_f_count < f_count || !etc && ex_f_count > f_count {
-            fcx.ccx.tcx.sess.span_fatal(pat.span,
-                                        #fmt("mismatched types: expected a record \
-                                     with %u fields, found one with %u \
-                                     fields",
-                                             ex_f_count, f_count));
+            fcx.ccx.tcx.sess.span_fatal
+                (pat.span, #fmt("mismatched types: expected a record \
+                                 with %u fields, found one with %u \
+                                 fields", ex_f_count, f_count));
         }
         fn matches(name: &str, f: &ty::field) -> bool {
             ret str::eq(name, f.ident);
@@ -1521,8 +1518,8 @@ fn require_pure_call(ccx: @crate_ctxt, caller_purity: &ast::purity,
         alt ccx.tcx.def_map.find(callee.id) {
           some(ast::def_fn(_, ast::pure_fn.)) { ret; }
           _ {
-            ccx.tcx.sess.span_fatal(sp,
-                                    "Pure function calls function not known to be pure");
+            ccx.tcx.sess.span_fatal
+                (sp, "Pure function calls function not known to be pure");
           }
         }
       }
@@ -1614,10 +1611,10 @@ fn check_expr(fcx: &@fn_ctxt, expr: &@ast::expr) {
                        arg_tys.(i).mode == mo_val {
                     // For why the check is necessary, see the
                     // none case in trans_bind_thunk
-                    fcx.ccx.tcx.sess.span_fatal(sp,
-                                                call_kind_str(call_kind) +
-                                                    " arguments with types containing parameters \
-                             must be passed by alias");
+                    fcx.ccx.tcx.sess.span_fatal
+                        (sp, call_kind_str(call_kind) +
+                         " arguments with types containing parameters \
+                          must be passed by alias");
                 }
               }
             }
@@ -1785,10 +1782,10 @@ fn check_expr(fcx: &@fn_ctxt, expr: &@ast::expr) {
                 let variants = ty::tag_variants(fcx.ccx.tcx, id);
                 if ivec::len(variants) != 1u ||
                        ivec::len(variants.(0).args) != 1u {
-                    fcx.ccx.tcx.sess.span_fatal(expr.span,
-                                                "can only dereference tags " +
-                                                    "with a single variant which has a "
-                                                    + "single argument");
+                    fcx.ccx.tcx.sess.span_fatal
+                        (expr.span, "can only dereference tags " +
+                         "with a single variant which has a "
+                         + "single argument");
                 }
                 oper_t =
                     ty::substitute_type_params(fcx.ccx.tcx, tps,
@@ -1983,10 +1980,9 @@ fn check_expr(fcx: &@fn_ctxt, expr: &@ast::expr) {
           ty::ty_ivec(vec_elt_ty) { elt_ty = vec_elt_ty.ty; }
           ty::ty_istr. { elt_ty = ty::mk_mach(fcx.ccx.tcx, ast::ty_u8); }
           _ {
-            fcx.ccx.tcx.sess.span_fatal(expr.span,
-                                        "mismatched types: expected vector or string but "
-                                            + "found " +
-                                            ty_to_str(fcx.ccx.tcx, ety));
+            fcx.ccx.tcx.sess.span_fatal
+                (expr.span, "mismatched types: expected vector or string but "
+                 + "found " + ty_to_str(fcx.ccx.tcx, ety));
           }
         }
         check_for_or_for_each(fcx, decl, elt_ty, body, id);
@@ -2440,10 +2436,9 @@ fn check_expr(fcx: &@fn_ctxt, expr: &@ast::expr) {
                       _ {
                         // The user is trying to extend a
                         // non-object.
-                        fcx.ccx.tcx.sess.span_fatal(e.span,
-                                                    syntax::print::pprust::expr_to_str(e)
-                                                        +
-                                                        " does not have object type");
+                        fcx.ccx.tcx.sess.span_fatal
+                            (e.span, syntax::print::pprust::expr_to_str(e) +
+                             " does not have object type");
                       }
                     }
                   }
diff --git a/src/comp/syntax/ext/fmt.rs b/src/comp/syntax/ext/fmt.rs
index 4374030d10a..8fb396392d7 100644
--- a/src/comp/syntax/ext/fmt.rs
+++ b/src/comp/syntax/ext/fmt.rs
@@ -329,9 +329,9 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: vec[piece],
     let expected_nargs = n + 1u; // n conversions + the fmt string
 
     if expected_nargs < nargs {
-        cx.span_fatal(sp,
-                      #fmt("too many arguments to #fmt. found %u, expected %u",
-                           nargs, expected_nargs));
+        cx.span_fatal
+            (sp, #fmt("too many arguments to #fmt. found %u, expected %u",
+                      nargs, expected_nargs));
     }
     ret tmp_expr;
 }
diff --git a/src/comp/syntax/fold.rs b/src/comp/syntax/fold.rs
index 4bb95450a7a..d52c234205c 100644
--- a/src/comp/syntax/fold.rs
+++ b/src/comp/syntax/fold.rs
@@ -317,10 +317,9 @@ fn noop_fold_expr(e: &expr_, fld: ast_fold) -> expr_ {
 
         ret {fields:
                  alt ao.fields {
-                   option::none[anon_obj_field[]]. { ao.fields }
-                   option::some[anon_obj_field[]](v) {
-                     option::some[anon_obj_field[]](ivec::map(fold_anon_obj_field,
-                                                              v))
+                   option::none. { ao.fields }
+                   option::some(v) {
+                     option::some(ivec::map(fold_anon_obj_field, v))
                    }
                  },
              methods: ivec::map(fld.fold_method, ao.methods),
diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs
index c93f8ce52a9..0b402e2e054 100644
--- a/src/comp/syntax/parse/parser.rs
+++ b/src/comp/syntax/parse/parser.rs
@@ -1812,15 +1812,14 @@ fn parse_dtor(p: &parser) -> @ast::method {
     let b: ast::blk = parse_block(p);
     let inputs: ast::arg[] = ~[];
     let output: @ast::ty = @spanned(lo, lo, ast::ty_nil);
-    let 
-
-        // I guess dtors can't have constraints?
-        d: ast::fn_decl =
-        {inputs: inputs,
-         output: output,
-         purity: ast::impure_fn,
-         cf: ast::return,
-         constraints: ~[]};
+    // I guess dtors can't have constraints?
+    let d: ast::fn_decl = {
+        inputs: inputs,
+        output: output,
+        purity: ast::impure_fn,
+        cf: ast::return,
+        constraints: ~[]
+    };
     let f: ast::_fn = {decl: d, proto: ast::proto_fn, body: b};
     let m: ast::method_ = {ident: "drop", meth: f, id: p.get_id()};
     ret @spanned(lo, f.body.span.hi, m);
@@ -1877,9 +1876,8 @@ fn parse_item_res(p: &parser, lyr: ast::layer, attrs: &ast::attribute[]) ->
 
 fn parse_mod_items(p: &parser, term: token::token,
                    first_item_attrs: &ast::attribute[]) -> ast::_mod {
-    let 
-        // Shouldn't be any view items since we've already parsed an item attr
-        view_items =
+    // Shouldn't be any view items since we've already parsed an item attr
+    let view_items =
         if ivec::len(first_item_attrs) == 0u { parse_view(p) } else { ~[] };
     let items: (@ast::item)[] = ~[];
     let initial_attrs = first_item_attrs;
@@ -1960,11 +1958,10 @@ fn parse_native_item(p: &parser, attrs: &ast::attribute[]) ->
 }
 
 fn parse_native_mod_items(p: &parser, native_name: &str, abi: ast::native_abi,
-                          first_item_attrs: &ast::attribute[]) ->
-   ast::native_mod {
-    let 
-        // Shouldn't be any view items since we've already parsed an item attr
-        view_items =
+                          first_item_attrs: &ast::attribute[])
+    -> ast::native_mod {
+    // Shouldn't be any view items since we've already parsed an item attr
+    let view_items =
         if ivec::len(first_item_attrs) == 0u {
             parse_native_view(p)
         } else { ~[] };
diff --git a/src/lib/extfmt.rs b/src/lib/extfmt.rs
index 00302ea9e26..f9db8eda693 100644
--- a/src/lib/extfmt.rs
+++ b/src/lib/extfmt.rs
@@ -215,11 +215,9 @@ mod ct {
        {ty: ty, next: uint} {
         if i >= lim { error("missing type in conversion"); }
         let tstr = str::substr(s, i, 1u);
-        let 
-
-            // TODO: Do we really want two signed types here?
-            // How important is it to be printf compatible?
-            t =
+        // TODO: Do we really want two signed types here?
+        // How important is it to be printf compatible?
+        let t =
             if str::eq(tstr, "b") {
                 ty_bool
             } else if (str::eq(tstr, "s")) {
@@ -305,13 +303,11 @@ mod rt {
         ret pad(cv, str::from_char(c), pad_nozero);
     }
     fn conv_str(cv: &conv, s: str) -> str {
-        let 
+        // For strings, precision is the maximum characters
+        // displayed
 
-            // For strings, precision is the maximum characters
-            // displayed
-
-            // FIXME: substr works on bytes, not chars!
-            unpadded =
+        // FIXME: substr works on bytes, not chars!
+        let unpadded =
             alt cv.precision {
               count_implied. { s }
               count_is(max) {
diff --git a/src/lib/ivec.rs b/src/lib/ivec.rs
index 71dc9cf7a65..c710d220a6b 100644
--- a/src/lib/ivec.rs
+++ b/src/lib/ivec.rs
@@ -90,10 +90,12 @@ pred is_not_empty[T](v: &T[mutable? ]) -> bool { ret !is_empty(v); }
 // Accessors
 
 /// Returns the first element of a vector
-fn head[T](v: &T[mutable? ]) -> T { ret v.(0); }
+fn head[T](v: &T[mutable?]) : is_not_empty(v) -> T { ret v.(0); }
 
 /// Returns all but the first element of a vector
-fn tail[T](v: &T[mutable? ]) -> T[mutable? ] { ret slice(v, 1u, len(v)); }
+fn tail[T](v: &T[mutable? ]) : is_not_empty(v)  -> T[mutable?] {
+    ret slice(v, 1u, len(v));
+}
 
 /// Returns the last element of `v`.
 fn last[T](v: &T[mutable? ]) -> option::t[T] {
diff --git a/src/lib/str.rs b/src/lib/str.rs
index ca0a81add80..0adf3561165 100644
--- a/src/lib/str.rs
+++ b/src/lib/str.rs
@@ -396,7 +396,7 @@ fn slice(s: str, begin: uint, end: uint) -> str {
     ret rustrt::str_slice(s, begin, end);
 }
 
-fn safe_slice(s: str, begin: uint, end: uint) -> str {
+fn safe_slice(s: str, begin: uint, end: uint): le(begin, end) -> str {
     assert (end <=
                 str::byte_len(s)); // would need some magic to
                                    // make this a precondition
@@ -505,7 +505,7 @@ fn to_upper(s: str) -> str {
 }
 
 // FIXME: This is super-inefficient
-fn replace(s: str, from: str, to: str) -> str {
+fn replace(s: str, from: str, to: str) : is_not_empty(from) -> str {
     // FIXME (694): Shouldn't have to check this
     check (is_not_empty(from));
     if byte_len(s) == 0u {
diff --git a/src/lib/test.rs b/src/lib/test.rs
index 801d7cff073..03606debc1d 100644
--- a/src/lib/test.rs
+++ b/src/lib/test.rs
@@ -58,7 +58,7 @@ type test_opts = {filter: option::t[str], run_ignored: bool};
 type opt_res = either::t[test_opts, str];
 
 // Parses command line arguments into test options
-fn parse_opts(args: &str[]) -> opt_res {
+fn parse_opts(args: &str[]) : ivec::is_not_empty(args) -> opt_res {
 
     // FIXME (#649): Shouldn't have to check here
     check (ivec::is_not_empty(args));
diff --git a/src/test/bench/shootout-nbody.rs b/src/test/bench/shootout-nbody.rs
index 4168df1f934..08ef4995ad4 100644
--- a/src/test/bench/shootout-nbody.rs
+++ b/src/test/bench/shootout-nbody.rs
@@ -6,16 +6,13 @@ native "llvm" mod llvm {
 }
 
 fn main() {
-
-    let 
-        //
-        // Leave these commented out to
-        // finish in a reasonable time
-        // during 'make check' under valgrind
-        // 5000000
-        // 50000000
-        inputs: vec[int] =
-        [50000, 500000];
+    //
+    // Leave these commented out to
+    // finish in a reasonable time
+    // during 'make check' under valgrind
+    // 5000000
+    // 50000000
+    let inputs: vec[int] = [50000, 500000];
 
     let bodies: vec[Body::props] = NBodySystem::MakeNBodySystem();
 
@@ -35,9 +32,8 @@ fn main() {
 mod NBodySystem {
 
     fn MakeNBodySystem() -> vec[Body::props] {
-        let 
-            // these each return a Body::props
-            bodies: vec[Body::props] =
+        // these each return a Body::props
+        let bodies: vec[Body::props] =
             [Body::sun(), Body::jupiter(), Body::saturn(), Body::uranus(),
              Body::neptune()];
 
diff --git a/src/test/compile-fail/attr-bad-meta.rs b/src/test/compile-fail/attr-bad-meta.rs
index 400d420c0aa..85714affba6 100644
--- a/src/test/compile-fail/attr-bad-meta.rs
+++ b/src/test/compile-fail/attr-bad-meta.rs
@@ -1,6 +1,6 @@
-./src/test/compile-fail/attr-bad-meta.rs:5:6:5:7: error: expecting ], found *
-./src/test/compile-fail/attr-bad-meta.rs:5 #[attr*]
-                                                 ^
-rt: ---
-rt: f00e:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main:                        domain main @0xa6bf04c root task failed
+// xfail-stage0
+// error-pattern:expecting ]
+
+// asterisk is bogus
+#[attr*]
+mod m { }
\ No newline at end of file
diff --git a/src/test/compile-fail/attr-before-stmt.rs b/src/test/compile-fail/attr-before-stmt.rs
index 184d8b0326c..29dd83b8af0 100644
--- a/src/test/compile-fail/attr-before-stmt.rs
+++ b/src/test/compile-fail/attr-before-stmt.rs
@@ -1,6 +1,10 @@
-./src/test/compile-fail/attr-before-stmt.rs:6:2:6:6: error: expected item
-./src/test/compile-fail/attr-before-stmt.rs:6   auto x = 10;
-                                                ^~~~
-rt: ---
-rt: 0bb1:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: 0bb1:main:                        domain main @0x8ef904c root task failed
+// xfail-stage0
+// error-pattern:expected item
+
+fn f() {
+  #[foo = "bar"]
+  let x = 10;
+}
+
+fn main() {
+}
diff --git a/src/test/compile-fail/attr-before-view-item.rs b/src/test/compile-fail/attr-before-view-item.rs
index e0e8b660ef6..56e2ab7f54f 100644
--- a/src/test/compile-fail/attr-before-view-item.rs
+++ b/src/test/compile-fail/attr-before-view-item.rs
@@ -1,6 +1,8 @@
-./src/test/compile-fail/attr-before-view-item.rs:5:0:5:3: error: expected item but found use
-./src/test/compile-fail/attr-before-view-item.rs:5 use std;
-                                                   ^~~
-rt: ---
-rt: 0bb1:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: 0bb1:main:                        domain main @0xa78604c root task failed
+// xfail-stage0
+// error-pattern:expected item
+
+#[foo = "bar"]
+use std;
+
+fn main() {
+}
diff --git a/src/test/compile-fail/attr-before-view-item2.rs b/src/test/compile-fail/attr-before-view-item2.rs
index 7c3494842a1..ad4071a07aa 100644
--- a/src/test/compile-fail/attr-before-view-item2.rs
+++ b/src/test/compile-fail/attr-before-view-item2.rs
@@ -1,6 +1,10 @@
-./src/test/compile-fail/attr-before-view-item2.rs:6:2:6:5: error: expected item but found use
-./src/test/compile-fail/attr-before-view-item2.rs:6   use std;
-                                                      ^~~
-rt: ---
-rt: 0bb1:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: 0bb1:main:                        domain main @0xa1fd04c root task failed
+// xfail-stage0
+// error-pattern:expected item
+
+mod m {
+  #[foo = "bar"]
+  use std;
+}
+
+fn main() {
+}
diff --git a/src/test/compile-fail/attr-dangling-in-fn.rs b/src/test/compile-fail/attr-dangling-in-fn.rs
index 4886d5d4d36..c31b3250d76 100644
--- a/src/test/compile-fail/attr-dangling-in-fn.rs
+++ b/src/test/compile-fail/attr-dangling-in-fn.rs
@@ -1,6 +1,9 @@
-./src/test/compile-fail/attr-dangling-in-fn.rs:6:0:6:1: error: expected item
-./src/test/compile-fail/attr-dangling-in-fn.rs:6 }
-                                                 ^
-rt: ---
-rt: f00e:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main:                        domain main @0x9fb104c root task failed
+// xfail-stage0
+// error-pattern:expected item
+
+fn f() {
+  #[foo = "bar"]
+}
+
+fn main() {
+}
diff --git a/src/test/compile-fail/attr-dangling-in-mod.rs b/src/test/compile-fail/attr-dangling-in-mod.rs
index 7684dc82e60..bd072402d25 100644
--- a/src/test/compile-fail/attr-dangling-in-mod.rs
+++ b/src/test/compile-fail/attr-dangling-in-mod.rs
@@ -1,6 +1,7 @@
-./src/test/compile-fail/attr-dangling-in-mod.rs:7:14:7:14: error: expected item but found <eof>
-./src/test/compile-fail/attr-dangling-in-mod.rs:7 #[foo = "bar"]
-                                                                ^
-rt: ---
-rt: 0bb1:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: 0bb1:main:                        domain main @0xa2d504c root task failed
+// xfail-stage0
+// error-pattern:expected item
+
+fn main() {
+}
+
+#[foo = "bar"]
diff --git a/src/test/compile-fail/bad-alt.rs b/src/test/compile-fail/bad-alt.rs
index 0d2632ab448..0762953569e 100644
--- a/src/test/compile-fail/bad-alt.rs
+++ b/src/test/compile-fail/bad-alt.rs
@@ -1,6 +1,6 @@
-./src/test/compile-fail/bad-alt.rs:5:7:5:8: error: expecting {, found ;
-./src/test/compile-fail/bad-alt.rs:5   alt x;
-                                            ^
-rt: ---
-rt: 0bb1:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: 0bb1:main:                        domain main @0x9e0f04c root task failed
+// error-pattern: expecting
+
+fn main() {
+  let int x = 5;
+  alt x;
+}
diff --git a/src/test/compile-fail/bad-name.rs b/src/test/compile-fail/bad-name.rs
index b16a806273c..a53b8284d59 100644
--- a/src/test/compile-fail/bad-name.rs
+++ b/src/test/compile-fail/bad-name.rs
@@ -1,6 +1,5 @@
-./src/test/compile-fail/bad-name.rs:4:7:4:8: error: expecting ident
-./src/test/compile-fail/bad-name.rs:4   let x.y[int].z foo;
-                                             ^
-rt: ---
-rt: f00e:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main:                        domain main @0x8d6004c root task failed
+// error-pattern: expecting
+
+fn main() {
+  let x.y[int].z foo;
+}
diff --git a/src/test/compile-fail/constrained-type-missing-check.rs b/src/test/compile-fail/constrained-type-missing-check.rs
index afc3f85541b..cebe5b3b189 100644
--- a/src/test/compile-fail/constrained-type-missing-check.rs
+++ b/src/test/compile-fail/constrained-type-missing-check.rs
@@ -11,7 +11,7 @@ type bubu = {x: int, y: int};
 
 pred less_than(x: int, y: int) -> bool { ret x < y; }
 
-type ordered_range = {low: int, high: int} :  : less_than(low, high);
+type ordered_range = {low: int, high: int} : less_than(low, high);
 
 fn main() {
     // Should fail to compile, b/c we're not doing the check
diff --git a/src/test/compile-fail/do-while-pred-constraints.rs b/src/test/compile-fail/do-while-pred-constraints.rs
index b91e2aa782a..7d8774dbb1f 100644
--- a/src/test/compile-fail/do-while-pred-constraints.rs
+++ b/src/test/compile-fail/do-while-pred-constraints.rs
@@ -1,16 +1,25 @@
 // xfail-stage0
 // error-pattern: Unsatisfied precondition constraint (for example, even(y
 
-fn print_even(y: int) { log y; }
+fn print_even(y: int) : even(y) {
+  log y;
+}
 
-pred even(y: int) -> bool { true }
+pred even(y: int) -> bool {
+  true
+}
 
 fn main() {
-
-    let y: int = 42;
-    check (even(y));
-    do  {
-        print_even(y);
-        do  { do  { do  { y += 1; } while true } while true } while true
-    } while true
-}
\ No newline at end of file
+  let y: int = 42;
+  check even(y);
+  do {
+    print_even(y);
+    do {
+      do {
+    do {
+      y += 1;
+    } while (true);
+      } while (true);
+    } while (true);
+  } while (true);
+}
diff --git a/src/test/compile-fail/ext-after-attrib.rs b/src/test/compile-fail/ext-after-attrib.rs
index 530e912e1ab..446fb836717 100644
--- a/src/test/compile-fail/ext-after-attrib.rs
+++ b/src/test/compile-fail/ext-after-attrib.rs
@@ -1,6 +1,8 @@
-./src/test/compile-fail/ext-after-attrib.rs:7:1:7:4: error: expecting [, found fmt
-./src/test/compile-fail/ext-after-attrib.rs:7 #fmt("baz")
-                                               ^~~
-rt: ---
-rt: f00e:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main:                        domain main @0xa47a04c root task failed
+// xfail-stage0
+// error-pattern:expecting [, found fmt
+
+// Don't know how to deal with a syntax extension appearing after an
+// item attribute. Probably could use a better error message.
+#[foo = "bar"]
+#fmt("baz")
+fn main() { }
\ No newline at end of file
diff --git a/src/test/compile-fail/ext-noname.rs b/src/test/compile-fail/ext-noname.rs
index 0846633b25e..82395c710a8 100644
--- a/src/test/compile-fail/ext-noname.rs
+++ b/src/test/compile-fail/ext-noname.rs
@@ -1,6 +1,5 @@
-./src/test/compile-fail/ext-noname.rs:4:3:4:4: error: expected a syntax expander name
-./src/test/compile-fail/ext-noname.rs:4   #();
-                                           ^
-rt: ---
-rt: 0bb1:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: 0bb1:main:                        domain main @0x91a204c root task failed
+// error-pattern:expected a syntax expander name
+
+fn main() {
+  #();
+}
\ No newline at end of file
diff --git a/src/test/compile-fail/extenv-no-args.rs b/src/test/compile-fail/extenv-no-args.rs
index d9230783e98..5b0be3c9871 100644
--- a/src/test/compile-fail/extenv-no-args.rs
+++ b/src/test/compile-fail/extenv-no-args.rs
@@ -1,3 +1,5 @@
 // error-pattern:malformed #env call
 
-fn main() { #env; }
\ No newline at end of file
+fn main() {
+    #env();
+}
diff --git a/src/test/compile-fail/extfmt-no-args.rs b/src/test/compile-fail/extfmt-no-args.rs
index d6e146a0d14..8bc3f23f2f0 100644
--- a/src/test/compile-fail/extfmt-no-args.rs
+++ b/src/test/compile-fail/extfmt-no-args.rs
@@ -1,3 +1,5 @@
 // error-pattern:format string
 
-fn main() { #fmt; }
\ No newline at end of file
+fn main() {
+    #fmt();
+}
\ No newline at end of file
diff --git a/src/test/compile-fail/fail-simple.rs b/src/test/compile-fail/fail-simple.rs
index 50c59d143c9..768cc1e1bf4 100644
--- a/src/test/compile-fail/fail-simple.rs
+++ b/src/test/compile-fail/fail-simple.rs
@@ -1,6 +1,6 @@
-./src/test/compile-fail/fail-simple.rs:5:9:5:10: error: unexpected token: ;
-./src/test/compile-fail/fail-simple.rs:5   fail @ ;
-                                                  ^
-rt: ---
-rt: f00e:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main:                        domain main @0x994f04c root task failed
+// -*- rust -*-
+
+// error-pattern:unexpected token
+fn main() {
+  fail @ ;
+}
diff --git a/src/test/compile-fail/if-check-precond-fail.rs b/src/test/compile-fail/if-check-precond-fail.rs
index 0d190374642..df8f1147fde 100644
--- a/src/test/compile-fail/if-check-precond-fail.rs
+++ b/src/test/compile-fail/if-check-precond-fail.rs
@@ -6,7 +6,7 @@ pred even(x: uint) -> bool {
     } else if (x == 2u) { ret true; } else { ret even(x - 2u); }
 }
 
-fn print_even(x: uint) { log x; }
+fn print_even(x: uint) : even(x) { log x; }
 
 fn foo(x: uint) { if check even(x) { fail; } else { print_even(x); } }
 
diff --git a/src/test/compile-fail/macro-2.rs b/src/test/compile-fail/macro-2.rs
index a2ff7ef8f49..8a5d2536183 100644
--- a/src/test/compile-fail/macro-2.rs
+++ b/src/test/compile-fail/macro-2.rs
@@ -1,11 +1,7 @@
 // xfail-stage0
 //error-pattern:is an expr, expected an identifier
 fn main() {
-    #macro([#mylambda(x, body),
-            {
-                fn f(x: int) -> int { ret body }
-                f
-            }]);
+  #macro([#mylambda(x, body), {fn f(x: int) -> int {ret body}; f}]);
 
-    assert (#mylambda(y * 1, y * 2)(8) == 16);
+  assert(#mylambda(y*1, y*2)(8) == 16);
 }
\ No newline at end of file
diff --git a/src/test/compile-fail/macro.rs b/src/test/compile-fail/macro.rs
index 2118e5ce7fe..5beb996ebbf 100644
--- a/src/test/compile-fail/macro.rs
+++ b/src/test/compile-fail/macro.rs
@@ -2,8 +2,7 @@
 //error-pattern:no clauses match
 
 fn main() {
-    #macro([#trivial, 1 * 2 * 4 * 2 * 1]);
+  #macro([#trivial(), 1*2*4*2*1]);
 
-    assert (#trivial(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16) ==
-                16);
-}
\ No newline at end of file
+  assert(#trivial(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16) == 16);
+}
diff --git a/src/test/compile-fail/multiline-comment-line-tracking.rs b/src/test/compile-fail/multiline-comment-line-tracking.rs
index 220a5e5d0aa..a345425fc98 100644
--- a/src/test/compile-fail/multiline-comment-line-tracking.rs
+++ b/src/test/compile-fail/multiline-comment-line-tracking.rs
@@ -1,6 +1,10 @@
-./src/test/compile-fail/multiline-comment-line-tracking.rs:9:2:9:3: error: unexpected token: %
-./src/test/compile-fail/multiline-comment-line-tracking.rs:9   %; // parse error on line 9, but is reported on line 6 instead.
-                                                               ^
-rt: ---
-rt: f00e:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main:                        domain main @0x969e04c root task failed
+// -*- rust -*-
+// error-pattern:9:2
+
+/* 1
+ * 2
+ * 3
+ */
+fn main() {
+  %; // parse error on line 9, but is reported on line 6 instead.
+}
diff --git a/src/test/compile-fail/not-a-pred-3.rs b/src/test/compile-fail/not-a-pred-3.rs
index 6852429b24e..5ec15e9c653 100644
--- a/src/test/compile-fail/not-a-pred-3.rs
+++ b/src/test/compile-fail/not-a-pred-3.rs
@@ -8,5 +8,6 @@ obj f() {
 
 fn main() {
     let z = f();
-    check (z.g(42)); // should fail to typecheck, as z.g isn't an explicit name
+    // should fail to typecheck, as z.g isn't an explicit name
+    check (z.g(42));
 }
\ No newline at end of file
diff --git a/src/test/compile-fail/not-a-pred.rs b/src/test/compile-fail/not-a-pred.rs
index a3421c65613..5e29596a712 100644
--- a/src/test/compile-fail/not-a-pred.rs
+++ b/src/test/compile-fail/not-a-pred.rs
@@ -2,7 +2,7 @@
 // xfail-stage0
 // error-pattern: Non-predicate in constraint: lt
 
-fn f(a: int, b: int) { }
+fn f(a: int, b: int) : lt(a,b) { }
 
 obj lt(a: int, b: int) { }
 
diff --git a/src/test/compile-fail/not-pred-args.rs b/src/test/compile-fail/not-pred-args.rs
index 81a0cb08af1..e73cd18dac7 100644
--- a/src/test/compile-fail/not-pred-args.rs
+++ b/src/test/compile-fail/not-pred-args.rs
@@ -5,6 +5,7 @@
 pred f(q: int) -> bool { ret true; }
 
 fn main() {
-    // should fail to typecheck, as pred args must be slot variables or literals
+    // should fail to typecheck, as pred args must be slot variables
+    // or literals
     check (f(42 * 17));
 }
\ No newline at end of file
diff --git a/src/test/compile-fail/pred-assign.rs b/src/test/compile-fail/pred-assign.rs
index c70ee8e5e67..167572f0016 100644
--- a/src/test/compile-fail/pred-assign.rs
+++ b/src/test/compile-fail/pred-assign.rs
@@ -3,7 +3,7 @@
 
 // error-pattern: Unsatisfied precondition constraint (for example, lt(a, b)
 
-fn f(a: int, b: int) { }
+fn f(a: int, b: int) : lt(a,b) { }
 
 pred lt(a: int, b: int) -> bool { ret a < b; }
 
diff --git a/src/test/compile-fail/pred-on-wrong-slots.rs b/src/test/compile-fail/pred-on-wrong-slots.rs
index adf0f027fbc..a3b583bd6dd 100644
--- a/src/test/compile-fail/pred-on-wrong-slots.rs
+++ b/src/test/compile-fail/pred-on-wrong-slots.rs
@@ -3,7 +3,7 @@
 
 // error-pattern: lt(a, c)
 
-fn f(a: int, b: int) { }
+fn f(a: int, b: int) : lt(a,b) { }
 
 pred lt(a: int, b: int) -> bool { ret a < b; }
 
diff --git a/src/test/compile-fail/pred-swap.rs b/src/test/compile-fail/pred-swap.rs
index 4d3881c0087..110db69fee2 100644
--- a/src/test/compile-fail/pred-swap.rs
+++ b/src/test/compile-fail/pred-swap.rs
@@ -3,7 +3,7 @@
 
 // error-pattern: Unsatisfied precondition constraint (for example, lt(a, b)
 
-fn f(a: int, b: int) { }
+fn f(a: int, b: int) : lt(a,b) { }
 
 pred lt(a: int, b: int) -> bool { ret a < b; }
 
diff --git a/src/test/compile-fail/self-missing-method.rs b/src/test/compile-fail/self-missing-method.rs
index 32aee6fbb6b..af69d2ac1a4 100644
--- a/src/test/compile-fail/self-missing-method.rs
+++ b/src/test/compile-fail/self-missing-method.rs
@@ -1,6 +1,12 @@
-./src/test/compile-fail/self-missing-method.rs:6:14:6:15: error: expecting ., found (
-./src/test/compile-fail/self-missing-method.rs:6           self();
-                                                               ^
-rt: ---
-rt: 0bb1:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: 0bb1:main:                        domain main @0x8f5904c root task failed
+// error-pattern:expecting ., found (
+fn main() {
+
+  obj foo() {
+      fn m() {
+          self();
+      }
+  }
+
+  let a = foo;
+  a.m();
+}
diff --git a/src/test/compile-fail/slot-as-pred.rs b/src/test/compile-fail/slot-as-pred.rs
index ae50c6bf3ac..65a8863fbad 100644
--- a/src/test/compile-fail/slot-as-pred.rs
+++ b/src/test/compile-fail/slot-as-pred.rs
@@ -2,7 +2,7 @@
 // xfail-stage0
 // error-pattern: unresolved name: lt
 
-fn f(a: int, b: int) { }
+fn f(a: int, b: int) : lt(a,b) { }
 
 fn main() {
     let lt: int;
diff --git a/src/test/compile-fail/tail-non-call.rs b/src/test/compile-fail/tail-non-call.rs
index 632ea716b7b..559065a00f4 100644
--- a/src/test/compile-fail/tail-non-call.rs
+++ b/src/test/compile-fail/tail-non-call.rs
@@ -1,6 +1,10 @@
-./src/test/compile-fail/tail-non-call.rs:5:6:5:7: error: Non-call expression in tail call
-./src/test/compile-fail/tail-non-call.rs:5   be x;
-                                                 ^
-rt: ---
-rt: f00e:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main:                        domain main @0x9d9404c root task failed
+// error-pattern: Non-call expression in tail call
+
+fn f() -> int {
+  let x = 1;
+  be x;
+}
+
+fn main() {
+  let y = f();
+}
diff --git a/src/test/compile-fail/unbalanced-comment.rs b/src/test/compile-fail/unbalanced-comment.rs
index 55d4bfb2d5c..c9d3e0c9b6a 100644
--- a/src/test/compile-fail/unbalanced-comment.rs
+++ b/src/test/compile-fail/unbalanced-comment.rs
@@ -1,6 +1,11 @@
-./src/test/compile-fail/unbalanced-comment.rs:11:1:11:1: error: unterminated block comment
-./src/test/compile-fail/unbalanced-comment.rs:11 }
-                                                  ^
-rt: ---
-rt: f00e:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/lexer.rs:153
-rt: f00e:main:                        domain main @0x96ef04c root task failed
+// -*- rust -*-
+
+// error-pattern: unterminated block comment
+
+/*
+ * This is an un-balanced /* multi-line comment.
+ */
+
+fn main() {
+  log "hello, world.";
+}
diff --git a/src/test/compile-fail/while-loop-pred-constraints.rs b/src/test/compile-fail/while-loop-pred-constraints.rs
index 0defbe2e40c..0cfda830ee9 100644
--- a/src/test/compile-fail/while-loop-pred-constraints.rs
+++ b/src/test/compile-fail/while-loop-pred-constraints.rs
@@ -1,7 +1,7 @@
 // xfail-stage0
 // error-pattern: Unsatisfied precondition constraint (for example, even(y
 
-fn print_even(y: int) { log y; }
+fn print_even(y: int) : even(y) { log y; }
 
 pred even(y: int) -> bool { true }
 
diff --git a/src/test/run-fail/fn-constraint-claim.rs b/src/test/run-fail/fn-constraint-claim.rs
index ecf1ca54c92..2271e9dcc65 100644
--- a/src/test/run-fail/fn-constraint-claim.rs
+++ b/src/test/run-fail/fn-constraint-claim.rs
@@ -5,6 +5,11 @@ use std;
 import std::str::*;
 import std::uint::*;
 
-fn nop(a: uint, b: uint) { fail "quux"; }
+fn nop(a: uint, b: uint) : le(a, b) { fail "quux"; }
 
-fn main() { let a: uint = 5u; let b: uint = 4u; claim (le(a, b)); nop(a, b); }
\ No newline at end of file
+fn main() {
+    let a: uint = 5u;
+    let b: uint = 4u;
+    claim (le(a, b));
+    nop(a, b);
+}
diff --git a/src/test/run-fail/task-comm-14.rs b/src/test/run-fail/task-comm-14.rs
index c46d8b18cb1..c1e6b73aefc 100644
--- a/src/test/run-fail/task-comm-14.rs
+++ b/src/test/run-fail/task-comm-14.rs
@@ -1,6 +1,33 @@
-./src/test/run-fail/task-comm-14.rs:5:0:5:2: error: expected item but found io
-./src/test/run-fail/task-comm-14.rs:5 io fn main() {
-                                      ^~
-rt: ---
-rt: 0bb1:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: 0bb1:main:                        domain main @0x919b04c root task failed
+// xfail-stage0
+// xfail-stage1
+// xfail-stage2
+// xfail-stage3
+io fn main() {
+    let port[int] po = port();
+
+    // Spawn 10 tasks each sending us back one int.
+    let int i = 10;
+    while (i > 0) {
+        log i;
+        spawn "child" child(i, chan(po));
+        i = i - 1;
+    }
+
+    // Spawned tasks are likely killed before they get a chance to send
+    // anything back, so we deadlock here.
+
+    i = 10;
+    let int value = 0;
+    while (i > 0) {
+        log i;
+        po |> value;
+        i = i - 1;
+    }
+
+    log "main thread exiting";
+}
+
+io fn child(int x, chan[int] ch) {
+    log x;
+    ch <| x;
+}
diff --git a/src/test/run-pass/alt-type-simple.rs b/src/test/run-pass/alt-type-simple.rs
index f30a75819dd..bee450e9893 100644
--- a/src/test/run-pass/alt-type-simple.rs
+++ b/src/test/run-pass/alt-type-simple.rs
@@ -1,6 +1,15 @@
-./src/test/run-pass/alt-type-simple.rs:6:6:6:10: error: found type in expression position
-./src/test/run-pass/alt-type-simple.rs:6   alt type (f) {
-                                               ^~~~
-rt: ---
-rt: f00e:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main:                        domain main @0x9b0204c root task failed
+// xfail-stage0
+// xfail-stage1
+// xfail-stage2
+// xfail-stage3
+fn altsimple(any x) {
+  alt type (f) {
+    case (int i) { print("int"); }
+    case (str s) { print("str"); }
+  }
+}
+
+fn main() {
+  altsimple(5);
+  altsimple("asdfasdfsDF");
+}
diff --git a/src/test/run-pass/anon-obj-overriding.rs b/src/test/run-pass/anon-obj-overriding.rs
index 9c8afbfea02..19860158ce4 100644
--- a/src/test/run-pass/anon-obj-overriding.rs
+++ b/src/test/run-pass/anon-obj-overriding.rs
@@ -10,9 +10,7 @@ fn main() {
     let my_a = a();
 
     // An anonymous object that overloads the 'foo' method.
-    let 
-
-        my_b =
+    let my_b =
         obj () {
             fn foo() -> int { ret 3; }
             with
diff --git a/src/test/run-pass/block-expr-precedence.rs b/src/test/run-pass/block-expr-precedence.rs
index 84fb21f0c42..2164ef25a0a 100644
--- a/src/test/run-pass/block-expr-precedence.rs
+++ b/src/test/run-pass/block-expr-precedence.rs
@@ -43,7 +43,7 @@
 
 fn main() {
 
-  auto num = 12;
+  let num = 12;
 
   assert if (true) { 12 } else { 12 } - num == 0;
   assert 12 - if (true) { 12 } else { 12 } == 0;
diff --git a/src/test/run-pass/clone-with-exterior.rs b/src/test/run-pass/clone-with-exterior.rs
index 27d38484591..01ffc0963ee 100644
--- a/src/test/run-pass/clone-with-exterior.rs
+++ b/src/test/run-pass/clone-with-exterior.rs
@@ -1,6 +1,14 @@
-./src/test/run-pass/clone-with-exterior.rs:12:28:12:29: error: expecting (, found f
-./src/test/run-pass/clone-with-exterior.rs:12   let task p = spawn thread f(z);
-                                                                          ^
-rt: ---
-rt: f00e:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main:                        domain main @0x8f2504c root task failed
+// xfail-stage0
+// xfail-stage1
+// xfail-stage2
+// xfail-stage3
+fn f(@rec(int a, int b) x) {
+  assert (x.a == 10);
+  assert (x.b == 12);
+}
+
+fn main() {
+  let @rec(int a, int b) z = rec(a=10, b=12);
+  let task p = spawn thread f(z);
+  join p;
+}
\ No newline at end of file
diff --git a/src/test/run-pass/constrained-type.rs b/src/test/run-pass/constrained-type.rs
index 43831168ed6..6f3c6a51dfe 100644
--- a/src/test/run-pass/constrained-type.rs
+++ b/src/test/run-pass/constrained-type.rs
@@ -7,6 +7,6 @@ type bubu = {x: int, y: int};
 
 pred less_than(x: int, y: int) -> bool { ret x < y; }
 
-type ordered_range = {low: int, high: int} :  : less_than(low, high);
+type ordered_range = {low: int, high: int} : less_than(*.low, *.high);
 
 fn main() { }
\ No newline at end of file
diff --git a/src/test/run-pass/destructor-ordering.rs b/src/test/run-pass/destructor-ordering.rs
index aadde397d53..ae504a7916f 100644
--- a/src/test/run-pass/destructor-ordering.rs
+++ b/src/test/run-pass/destructor-ordering.rs
@@ -1,6 +1,123 @@
-./src/test/run-pass/destructor-ordering.rs:25:0:25:2: error: expected item but found io
-./src/test/run-pass/destructor-ordering.rs:25 io fn check_order(port[order_info] expected_p) {
-                                              ^~
-rt: ---
-rt: 17b9:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: 17b9:main:                        domain main @0x96d304c root task failed
+// xfail-stage0
+// xfail-stage1
+// xfail-stage2
+// xfail-stage3
+// This test checks that destructors run in the right order.  Because
+// stateful objects can't have destructors, we have the destructors
+// record their expected order into a channel when they execute (so
+// the object becomes 'io' rather than 'state').  Then each test case
+// asserts that the channel produces values in ascending order.
+//
+// FIXME: Write an int->str function and concatenate the whole failure
+// message into a single log statement (or, even better, a print).
+//
+// FIXME: check_order should take only 1 line in a test, not 2+a block
+// block. Since destructor-having objects can't refer to mutable state
+// (like the port), we'd need a with-like construct to do the same for
+// stateful objects within a scope.
+//
+// FIXME #21: Each test should execute in its own task, so it can fail
+// independently, writing its error message to a channel that the
+// parent task aggregates.
+
+type order_info = rec(int order, str msg);
+
+io fn check_order(port[order_info] expected_p) {
+  chan(expected_p) <| rec(order=-1, msg="");
+  let mutable int actual = 0;
+  // FIXME #121: Workaround for while(true) bug.
+  auto expected; expected_p |> expected;
+  auto done = -1;  // FIXME: Workaround for typechecking bug.
+  while(expected.order != done) {
+    if (expected.order != actual) {
+      log expected.order;
+      log " != ";
+      log actual;
+      log expected.msg;
+      fail;
+    }
+    actual += 1;
+    expected_p |> expected;
+  }
+}
+
+
+obj dorder(chan[order_info] expected, int order, str message) {
+  drop {
+    expected <| rec(order=order, msg=message);
+  }
+}
+
+io fn test_simple() {
+  let port[order_info] tracker_p = port();
+  auto tracker = chan(tracker_p);
+  dorder(tracker, 1, "Reverse decl order");
+  dorder(tracker, 0, "Reverse decl order");
+  check_order(tracker_p);
+}
+
+io fn test_block() {
+  let port[order_info] tracker_p = port();
+  auto tracker = chan(tracker_p);
+  {
+    dorder(tracker, 2, "Before block");
+    {
+      dorder(tracker, 0, "Inside block");
+    }
+    dorder(tracker, 1, "After block");
+  }
+  check_order(tracker_p);
+}
+
+io fn test_decl_v_init() {
+  let port[order_info] tracker_p = port();
+  auto tracker = chan(tracker_p);
+  {
+    auto var1;
+    auto var2;
+    var2 = dorder(tracker, 0, "decl, not init");
+    var1 = dorder(tracker, 1, "decl, not init");
+  }
+  check_order(tracker_p);
+}
+
+io fn test_overwritten_obj() {
+  let port[order_info] tracker_p = port();
+  auto tracker = chan(tracker_p);
+  {
+    auto var1 = dorder(tracker, 0, "overwritten object destroyed first");
+    auto var2 = dorder(tracker, 2, "destroyed at end of scope");
+    var1 = dorder(tracker, 3, "overwriter deleted in rev decl order");
+    {
+      dorder(tracker, 1, "overwritten object destroyed before end of scope");
+    }
+  }
+  check_order(tracker_p);
+}
+
+// Used to embed dorder objects into an expression.  Note that the
+// parameters don't get destroyed.
+fn combine_dorders(dorder d1, dorder d2) -> int {
+  ret 1;
+}
+io fn test_expression_destroyed_right_to_left() {
+  let port[order_info] tracker_p = port();
+  auto tracker = chan(tracker_p);
+  {
+    combine_dorders(dorder(tracker, 4, ""), dorder(tracker, 3, ""))
+      / combine_dorders(dorder(tracker, 2, ""), dorder(tracker, 1, ""));
+    {
+      dorder(tracker, 0,
+             "expression objects live to end of block, not statement");
+    }
+  }
+  check_order(tracker_p);
+}
+
+io fn main() {
+  test_simple();
+  test_block();
+  test_decl_v_init();
+  test_overwritten_obj();
+  test_expression_destroyed_right_to_left();
+}
diff --git a/src/test/run-pass/if-check-precond.rs b/src/test/run-pass/if-check-precond.rs
index 32d9b0e1899..bb7fdd30817 100644
--- a/src/test/run-pass/if-check-precond.rs
+++ b/src/test/run-pass/if-check-precond.rs
@@ -5,7 +5,7 @@ pred even(x: uint) -> bool {
     } else if (x == 2u) { ret true; } else { ret even(x - 2u); }
 }
 
-fn print_even(x: uint) { log x; }
+fn print_even(x: uint) : even(x) { log x; }
 
 fn foo(x: uint) { if check even(x) { print_even(x); } else { fail; } }
 
diff --git a/src/test/run-pass/if-ret.rs b/src/test/run-pass/if-ret.rs
index 81cb300d22a..0137bf912af 100644
--- a/src/test/run-pass/if-ret.rs
+++ b/src/test/run-pass/if-ret.rs
@@ -1,4 +1,4 @@
 // xfail-stage0
-fn foo() { if ret { } }
+fn foo() { if (ret) { } }
 
 fn main() { foo(); }
\ No newline at end of file
diff --git a/src/test/run-pass/item-attributes.rs b/src/test/run-pass/item-attributes.rs
index 8f8770c11b0..43a1701f39e 100644
--- a/src/test/run-pass/item-attributes.rs
+++ b/src/test/run-pass/item-attributes.rs
@@ -83,7 +83,7 @@ mod test_stmt_single_attr_outer {
         #[attr = "val"]
         mod mod1 {
         }
-        
+
         #[attr = "val"]
         native "rust" mod rustrt {
         }
@@ -115,7 +115,7 @@ mod test_stmt_multi_attr_outer {
         #[attr2 = "val"]
         mod mod1 {
         }
-        
+
         #[attr1 = "val"]
         #[attr2 = "val"]
         native "rust" mod rustrt {
diff --git a/src/test/run-pass/macro-2.rs b/src/test/run-pass/macro-2.rs
index 13cc026b2ca..0cd21a830eb 100644
--- a/src/test/run-pass/macro-2.rs
+++ b/src/test/run-pass/macro-2.rs
@@ -1,11 +1,7 @@
 // xfail-stage0
 
 fn main() {
-    #macro([#mylambda(x, body),
-            {
-                fn f(x: int) -> int { ret body }
-                f
-            }]);
+  #macro([#mylambda(x,body), {fn f(x: int) -> int { ret body }; f}]);
 
-    assert (#mylambda(y, y * 2)(8) == 16);
+  assert(#mylambda(y,y*2)(8) == 16);
 }
\ No newline at end of file
diff --git a/src/test/run-pass/macro-3.rs b/src/test/run-pass/macro-3.rs
index 25098f3aac1..c14d8943083 100644
--- a/src/test/run-pass/macro-3.rs
+++ b/src/test/run-pass/macro-3.rs
@@ -1,7 +1,7 @@
 // xfail-stage0
 
 fn main() {
-    #macro([#trivial, 1 * 2 * 4 * 2 * 1]);
+  #macro([#trivial(), 1*2*4*2*1]);
 
-    assert (#trivial == 16);
-}
\ No newline at end of file
+  assert(#trivial() == 16);
+}
diff --git a/src/test/run-pass/macro.rs b/src/test/run-pass/macro.rs
index 688723bab0f..f82e37deea2 100644
--- a/src/test/run-pass/macro.rs
+++ b/src/test/run-pass/macro.rs
@@ -1,3 +1,6 @@
 // xfail-stage0
 
-fn main() { #macro([#m1(a), a * 4]); assert (#m1(2) == 8); }
\ No newline at end of file
+fn main() {
+  #macro([#m1(a), a*4]);
+  assert (#m1(2) == 8);
+}
diff --git a/src/test/run-pass/many.rs b/src/test/run-pass/many.rs
index 9213799f82b..6affa165aea 100644
--- a/src/test/run-pass/many.rs
+++ b/src/test/run-pass/many.rs
@@ -1,6 +1,25 @@
-./src/test/run-pass/many.rs:21:12:21:14: error: expecting ;, found |>
-./src/test/run-pass/many.rs:21   let int p |> y;
-                                           ^~
-rt: ---
-rt: f00e:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main:                        domain main @0x8da604c root task failed
+// xfail-stage0
+// xfail-stage1
+// xfail-stage2
+// xfail-stage3
+// -*- rust -*-
+
+fn sub(chan[int] parent, int id) {
+  if (id == 0) {
+    parent <| 0;
+  } else {
+    let port[int] p = port();
+    auto child = spawn sub(chan(p), id-1);
+    let int y; p |> y;
+    parent <| y + 1;
+  }
+}
+
+fn main() {
+  let port[int] p = port();
+  auto child = spawn sub(chan(p), 500);
+  let int p |> y;
+  log "transmission complete";
+  log y;
+  assert (y == 500);
+}
diff --git a/src/test/run-pass/nil-pattern.rs b/src/test/run-pass/nil-pattern.rs
index 92ede8d8dd0..cf8153c0fe4 100644
--- a/src/test/run-pass/nil-pattern.rs
+++ b/src/test/run-pass/nil-pattern.rs
@@ -1,2 +1,2 @@
 // xfail-stage0
-fn main() { let x = (); alt x { () { } } }
\ No newline at end of file
+fn main() { let x = (); alt x { (()) { } } }
\ No newline at end of file
diff --git a/src/test/run-pass/spawn-module-qualified.rs b/src/test/run-pass/spawn-module-qualified.rs
index 5c7106b28eb..24711da7c0b 100644
--- a/src/test/run-pass/spawn-module-qualified.rs
+++ b/src/test/run-pass/spawn-module-qualified.rs
@@ -1,6 +1,13 @@
-./src/test/run-pass/spawn-module-qualified.rs:7:7:7:8: error: expected ';' or '}' after expression but found x
-./src/test/run-pass/spawn-module-qualified.rs:7   join x;
-                                                       ^
-rt: ---
-rt: 0bb1:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: 0bb1:main:                        domain main @0xa98404c root task failed
+// xfail-stage0
+// xfail-stage1
+// xfail-stage2
+// xfail-stage3
+fn main() {
+  auto x = spawn m::child(10);
+  join x;
+}
+mod m {
+  fn child(int i) {
+    log i;
+  }
+}
diff --git a/src/test/run-pass/syntax-extension-shell.rs b/src/test/run-pass/syntax-extension-shell.rs
index d495f7e9f90..59ef847cced 100644
--- a/src/test/run-pass/syntax-extension-shell.rs
+++ b/src/test/run-pass/syntax-extension-shell.rs
@@ -1,6 +1,8 @@
-./src/test/run-pass/syntax-extension-shell.rs:6:18:6:19: error: expecting (, found {
-./src/test/run-pass/syntax-extension-shell.rs:6   auto s = #shell { uname -a };
-                                                                  ^
-rt: ---
-rt: f00e:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main:                        domain main @0x910c04c root task failed
+// xfail-stage0
+// xfail-stage1
+// xfail-stage2
+// xfail-stage3
+fn main() {
+  auto s = #shell { uname -a };
+  log s;
+}
diff --git a/src/test/run-pass/task-killjoin.rs b/src/test/run-pass/task-killjoin.rs
index e12526a89e6..bad47e2aed9 100644
--- a/src/test/run-pass/task-killjoin.rs
+++ b/src/test/run-pass/task-killjoin.rs
@@ -1,6 +1,41 @@
-./src/test/run-pass/task-killjoin.rs:22:36:22:46: error: expecting (, found supervised
-./src/test/run-pass/task-killjoin.rs:22     let task t = spawn "supervised" supervised();
-                                                                            ^~~~~~~~~~
-rt: ---
-rt: f00e:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main:                        domain main @0xa7b604c root task failed
+// xfail-stage0
+// xfail-stage1
+// xfail-stage2
+// xfail-stage3
+
+// Create a task that is supervised by another task,
+// join the supervised task from the supervising task,
+// then fail the supervised task. The supervised task
+// will kill the supervising task, waking it up. The
+// supervising task no longer needs to be wakened when
+// the supervised task exits.
+
+fn supervised() {
+    // Yield to make sure the supervisor joins before we
+    // fail. This is currently not needed because the supervisor
+    // runs first, but I can imagine that changing.
+    yield;
+    fail;
+}
+
+fn supervisor() {
+    let task t = spawn "supervised" supervised();
+    join t;
+}
+
+fn main() {
+    // Start the test in another domain so that
+    // the process doesn't return a failure status as a result
+    // of the main task being killed.
+    let task dom2 = spawn thread "supervisor" supervisor();
+    join dom2;
+}
+
+// Local Variables:
+// mode: rust;
+// fill-column: 78;
+// indent-tabs-mode: nil
+// c-basic-offset: 4
+// buffer-file-coding-system: utf-8-unix
+// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
+// End:
diff --git a/src/test/run-pass/threads.rs b/src/test/run-pass/threads.rs
index 82ba2ded69e..885b0e87e47 100644
--- a/src/test/run-pass/threads.rs
+++ b/src/test/run-pass/threads.rs
@@ -1,6 +1,20 @@
-./src/test/run-pass/threads.rs:11:17:11:24: error: expecting (, found "child"
-./src/test/run-pass/threads.rs:11     spawn thread "child" child(i);
-                                                   ^~~~~~~
-rt: ---
-rt: f00e:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main:                        domain main @0x999804c root task failed
+// xfail-stage0
+// xfail-stage1
+// xfail-stage2
+// xfail-stage3
+
+// -*- rust -*-
+
+fn main() {
+  let int i = 10;
+  while (i > 0) {
+    spawn thread "child" child(i);
+    i = i - 1;
+  }
+  log "main thread exiting";
+}
+
+fn child(int x) {
+  log x;
+}
+
diff --git a/src/test/run-pass/typestate-transitive.rs b/src/test/run-pass/typestate-transitive.rs
index acc9f0c28c2..f2eda37e0d0 100644
--- a/src/test/run-pass/typestate-transitive.rs
+++ b/src/test/run-pass/typestate-transitive.rs
@@ -1,7 +1,7 @@
 pred p(i: int) -> bool { true }
 
-fn f(i: int) -> int { i }
+fn f(i: int) : p(i) -> int { i }
 
-fn g(i: int) -> int { f(i) }
+fn g(i: int) : p(i) -> int { f(i) }
 
 fn main() { }
\ No newline at end of file
diff --git a/src/test/run-pass/user.rs b/src/test/run-pass/user.rs
index 1af1995720b..02d184e25ca 100644
--- a/src/test/run-pass/user.rs
+++ b/src/test/run-pass/user.rs
@@ -1,6 +1,18 @@
-./src/test/run-pass/user.rs:9:16:9:17: error: unexpected token: _
-./src/test/run-pass/user.rs:9          uuid = _, ver = _);
-                                              ^
-rt: ---
-rt: f00e:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main:                        domain main @0x907604c root task failed
+// xfail-stage0
+// xfail-stage1
+// xfail-stage2
+// xfail-stage3
+// -*- rust -*-
+
+use std (name = "std",
+         url = "http://rust-lang.org/src/std",
+         uuid = _, ver = _);
+
+fn main() {
+  auto s = std::str.alloc(10 as uint);
+  s += "hello ";
+  log s;
+  s += "there";
+  log s;
+  auto z = std::vec.alloc[int](10 as uint);
+}
diff --git a/src/test/run-pass/vec-slice.rs b/src/test/run-pass/vec-slice.rs
index 5c572a0f547..9434eed3847 100644
--- a/src/test/run-pass/vec-slice.rs
+++ b/src/test/run-pass/vec-slice.rs
@@ -1,6 +1,10 @@
-./src/test/run-pass/vec-slice.rs:7:16:7:17: error: expecting ), found ,
-./src/test/run-pass/vec-slice.rs:7   auto v2 = v.(1,2);
-                                                   ^
-rt: ---
-rt: f00e:main:main:                   upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main:                        domain main @0xa73404c root task failed
+// xfail-stage0
+// xfail-stage1
+// xfail-stage2
+// xfail-stage3
+fn main() {
+  let vec[int] v = [1,2,3,4,5];
+  auto v2 = v.(1,2);
+  assert (v2.(0) == 2);
+  assert (v2.(1) == 3);
+}
\ No newline at end of file
diff --git a/src/test/stdtest/deque.rs b/src/test/stdtest/deque.rs
index d43d4b7b603..2b4da0cdf6b 100644
--- a/src/test/stdtest/deque.rs
+++ b/src/test/stdtest/deque.rs
@@ -178,7 +178,7 @@ fn test() {
                               two(17, 42));
     /*
      * FIXME: Segfault.  Also appears to be caused only after upcall_grow_task
-    
+
     log "*** test parameterized: taggypar[int]";
     let eqfn[taggypar[int]] eq4 = taggypareq[int];
     test_parameterized[taggypar[int]](eq4,
@@ -187,7 +187,7 @@ fn test() {
                                       threepar[int](1, 2, 3),
                                       twopar[int](17, 42));
     log "*** end test parameterized: taggypar[int]";
-    
+
      */
 
     log "*** test parameterized: reccy";
diff --git a/src/test/stdtest/map.rs b/src/test/stdtest/map.rs
index 44edb3f9111..0031f338f1f 100644
--- a/src/test/stdtest/map.rs
+++ b/src/test/stdtest/map.rs
@@ -197,7 +197,7 @@ fn test_removal() {
         /**
          * FIXME (issue #150): we want to check the removed value as in the
          * following:
-        
+
         let util.option[uint] v = hm.remove(i);
         alt (v) {
           case (util.some[uint](u)) {
@@ -205,7 +205,7 @@ fn test_removal() {
           }
           case (util.none[uint]()) { fail; }
         }
-        
+
          * but we util.option is a tag type so util.some and util.none are
          * off limits until we parse the dwarf for tag types.
          */