diff --git a/src/comp/back/link.rs b/src/comp/back/link.rs
index 1bd4c4006206..f93107d6a170 100644
--- a/src/comp/back/link.rs
+++ b/src/comp/back/link.rs
@@ -296,7 +296,7 @@ fn build_link_meta(sess: &session::session, c: &ast::crate, output: &str,
         let cmh_items: [@ast::meta_item] = ~[];
         let linkage_metas = attr::find_linkage_metas(c.node.attrs);
         attr::require_unique_names(sess, linkage_metas);
-        for meta: @ast::meta_item  in linkage_metas {
+        for meta: @ast::meta_item in linkage_metas {
             if attr::get_meta_item_name(meta) == "name" {
                 alt attr::get_meta_item_value_str(meta) {
                   some(v) { name = some(v); }
@@ -326,7 +326,7 @@ fn build_link_meta(sess: &session::session, c: &ast::crate, output: &str,
         let cmh_items = attr::sort_meta_items(metas.cmh_items);
 
         sha.reset();
-        for m_: @ast::meta_item  in cmh_items {
+        for m_: @ast::meta_item in cmh_items {
             let m = m_;
             alt m.node {
               ast::meta_name_value(key, value) {
@@ -429,7 +429,7 @@ fn mangle(ss: &[str]) -> str {
 
     let n = "_ZN"; // Begin name-sequence.
 
-    for s: str  in ss { n += #fmt("%u%s", str::byte_len(s), s); }
+    for s: str in ss { n += #fmt("%u%s", str::byte_len(s), s); }
     n += "E"; // End name-sequence.
 
     ret n;
diff --git a/src/comp/back/upcall.rs b/src/comp/back/upcall.rs
index 622d8d5c0d70..6984efaa113b 100644
--- a/src/comp/back/upcall.rs
+++ b/src/comp/back/upcall.rs
@@ -68,7 +68,7 @@ fn declare_upcalls(tn: type_names, tydesc_type: TypeRef,
     fn decl(tn: type_names, llmod: ModuleRef, name: str, tys: [TypeRef],
           rv: TypeRef) -> ValueRef {
         let arg_tys: [TypeRef] = ~[];
-        for t: TypeRef  in tys { arg_tys += ~[t]; }
+        for t: TypeRef in tys { arg_tys += ~[t]; }
         let fn_ty = T_fn(arg_tys, rv);
         ret trans::decl_cdecl_fn(llmod, "upcall_" + name, fn_ty);
     }
diff --git a/src/comp/driver/rustc.rs b/src/comp/driver/rustc.rs
index 5b6d1e80a80a..e6324aa73d65 100644
--- a/src/comp/driver/rustc.rs
+++ b/src/comp/driver/rustc.rs
@@ -82,7 +82,7 @@ fn parse_cfgspecs(cfgspecs: &[str]) -> ast::crate_cfg {
     // FIXME: It would be nice to use the parser to parse all varieties of
     // meta_item here. At the moment we just support the meta_word variant.
     let words = ~[];
-    for s: str  in cfgspecs { words += ~[attr::mk_word_item(s)]; }
+    for s: str in cfgspecs { words += ~[attr::mk_word_item(s)]; }
     ret words;
 }
 
@@ -334,7 +334,7 @@ fn build_session_options(binary: str, match: getopts::match, binary_dir: str)
 
     let library_search_paths = ~[binary_dir + "/lib"];
     let lsp_vec = getopts::opt_strs(match, "L");
-    for lsp: str  in lsp_vec { library_search_paths += ~[lsp]; }
+    for lsp: str in lsp_vec { library_search_paths += ~[lsp]; }
 
     let parse_only = opt_present(match, "parse-only");
     let no_trans = opt_present(match, "no-trans");
@@ -591,7 +591,7 @@ fn main(args: vec[str]) {
     }
 
     let cstore = sess.get_cstore();
-    for cratepath: str  in cstore::get_used_crate_files(cstore) {
+    for cratepath: str in cstore::get_used_crate_files(cstore) {
         if str::ends_with(cratepath, ".rlib") {
             gcc_args += ~[cratepath];
             cont;
@@ -603,10 +603,10 @@ fn main(args: vec[str]) {
     }
 
     let ula = cstore::get_used_link_args(cstore);
-    for arg: str  in ula { gcc_args += ~[arg]; }
+    for arg: str in ula { gcc_args += ~[arg]; }
 
     let used_libs = cstore::get_used_libraries(cstore);
-    for l: str  in used_libs { gcc_args += ~["-l" + l]; }
+    for l: str in used_libs { gcc_args += ~["-l" + l]; }
 
     if sopts.library {
         gcc_args += ~[lib_cmd];
diff --git a/src/comp/front/attr.rs b/src/comp/front/attr.rs
index 13ea252d9cd1..6a12972affdf 100644
--- a/src/comp/front/attr.rs
+++ b/src/comp/front/attr.rs
@@ -31,7 +31,7 @@ export mk_attr;
 // linkage
 fn find_linkage_metas(attrs: &[ast::attribute]) -> [@ast::meta_item] {
     let metas: [@ast::meta_item] = ~[];
-    for attr: ast::attribute  in find_attrs_by_name(attrs, "link") {
+    for attr: ast::attribute in find_attrs_by_name(attrs, "link") {
         alt attr.node.value.node {
           ast::meta_list(_, items) { metas += items; }
           _ { log "ignoring link attribute that has incorrect type"; }
@@ -96,7 +96,7 @@ fn attr_meta(attr: &ast::attribute) -> @ast::meta_item { @attr.node.value }
 // Get the meta_items from inside a vector of attributes
 fn attr_metas(attrs: &[ast::attribute]) -> [@ast::meta_item] {
     let mitems = ~[];
-    for a: ast::attribute  in attrs { mitems += ~[attr_meta(a)]; }
+    for a: ast::attribute in attrs { mitems += ~[attr_meta(a)]; }
     ret mitems;
 }
 
@@ -124,7 +124,7 @@ fn eq(a: @ast::meta_item, b: @ast::meta_item) -> bool {
 fn contains(haystack: &[@ast::meta_item], needle: @ast::meta_item) -> bool {
     log #fmt("looking for %s",
              syntax::print::pprust::meta_item_to_str(*needle));
-    for item: @ast::meta_item  in haystack {
+    for item: @ast::meta_item in haystack {
         log #fmt("looking in %s",
                  syntax::print::pprust::meta_item_to_str(*item));
         if eq(item, needle) { log "found it!"; ret true; }
@@ -153,12 +153,12 @@ fn sort_meta_items(items: &[@ast::meta_item]) -> [@ast::meta_item] {
 
     // This is sort of stupid here, converting to a vec of mutables and back
     let v: [mutable @ast::meta_item] = ~[mutable];
-    for mi: @ast::meta_item  in items { v += ~[mutable mi]; }
+    for mi: @ast::meta_item in items { v += ~[mutable mi]; }
 
     std::sort::quick_sort(lteq, v);
 
     let v2: [@ast::meta_item] = ~[];
-    for mi: @ast::meta_item  in v { v2 += ~[mi]; }
+    for mi: @ast::meta_item in v { v2 += ~[mi]; }
     ret v2;
 }
 
@@ -179,7 +179,7 @@ fn remove_meta_items_by_name(items: &[@ast::meta_item], name: str) ->
 fn require_unique_names(sess: &session::session,
                         metas: &[@ast::meta_item]) {
     let map = map::mk_hashmap[str, ()](str::hash, str::eq);
-    for meta: @ast::meta_item  in metas {
+    for meta: @ast::meta_item in metas {
         let name = get_meta_item_name(meta);
         if map.contains_key(name) {
             sess.span_fatal(meta.span,
diff --git a/src/comp/front/config.rs b/src/comp/front/config.rs
index fb5222b0c575..b65b221cae4e 100644
--- a/src/comp/front/config.rs
+++ b/src/comp/front/config.rs
@@ -118,7 +118,7 @@ fn in_cfg(cfg: &ast::crate_cfg, attrs: &[ast::attribute]) -> bool {
             ivec::foldl(extract_metas, ~[], cfg_metas)
         };
 
-    for cfg_mi: @ast::meta_item  in item_cfg_metas {
+    for cfg_mi: @ast::meta_item in item_cfg_metas {
         if attr::contains(cfg, cfg_mi) { ret true; }
     }
 
diff --git a/src/comp/front/test.rs b/src/comp/front/test.rs
index d2153da4c799..5d6cc62c37dc 100644
--- a/src/comp/front/test.rs
+++ b/src/comp/front/test.rs
@@ -229,7 +229,7 @@ fn mk_test_desc_ivec_ty(cx: &test_ctxt) -> @ast::ty {
 fn mk_test_desc_vec(cx: &test_ctxt) -> @ast::expr {
     log #fmt("building test vector from %u tests", ivec::len(cx.testfns));
     let descs = ~[];
-    for test: test  in cx.testfns {
+    for test: test in cx.testfns {
         let test_ = test; // Satisfy alias analysis
         descs += ~[mk_test_desc_rec(cx, test_)];
     }
diff --git a/src/comp/lib/llvm.rs b/src/comp/lib/llvm.rs
index 02fe2c6c59dd..cefff79f0b5d 100644
--- a/src/comp/lib/llvm.rs
+++ b/src/comp/lib/llvm.rs
@@ -1469,7 +1469,7 @@ fn type_to_str_inner(names: type_names, outer0: &[TypeRef], ty: TypeRef) ->
     fn tys_str(names: type_names, outer: &[TypeRef], tys: &[TypeRef]) -> str {
         let s: str = "";
         let first: bool = true;
-        for t: TypeRef  in tys {
+        for t: TypeRef in tys {
             if first { first = false; } else { s += ", "; }
             s += type_to_str_inner(names, outer, t);
         }
@@ -1531,7 +1531,7 @@ fn type_to_str_inner(names: type_names, outer0: &[TypeRef], ty: TypeRef) ->
 
       11 {
         let i: uint = 0u;
-        for tout: TypeRef  in outer0 {
+        for tout: TypeRef in outer0 {
             i += 1u;
             if tout as int == ty as int {
                 let n: uint = ivec::len[TypeRef](outer0) - i;
diff --git a/src/comp/metadata/common.rs b/src/comp/metadata/common.rs
index 128ebea3f287..9d6a2c745f8e 100644
--- a/src/comp/metadata/common.rs
+++ b/src/comp/metadata/common.rs
@@ -69,7 +69,7 @@ fn hash_node_id(node_id: &int) -> uint { ret 177573u ^ (node_id as uint); }
 
 fn hash_path(s: &str) -> uint {
     let h = 5381u;
-    for ch: u8  in str::bytes(s) { h = (h << 5u) + h ^ (ch as uint); }
+    for ch: u8 in str::bytes(s) { h = (h << 5u) + h ^ (ch as uint); }
     ret h;
 }
 
diff --git a/src/comp/metadata/creader.rs b/src/comp/metadata/creader.rs
index 23df29199e7f..38cf9e619f39 100644
--- a/src/comp/metadata/creader.rs
+++ b/src/comp/metadata/creader.rs
@@ -96,7 +96,7 @@ fn metadata_matches(crate_data: &@[u8], metas: &[@ast::meta_item]) -> bool {
     log #fmt("matching %u metadata requirements against %u items",
              ivec::len(metas), ivec::len(linkage_metas));
 
-    for needed: @ast::meta_item  in metas {
+    for needed: @ast::meta_item in metas {
         if !attr::contains(linkage_metas, needed) {
             log #fmt("missing %s", pprust::meta_item_to_str(*needed));
             ret false;
@@ -156,9 +156,9 @@ fn find_library_crate_aux(nn: &{prefix: str, suffix: str}, crate_name: str,
     // stomach from here, and writing a C++ wrapper is more work than just
     // manually filtering fs::list_dir here.
 
-    for library_search_path: str  in library_search_paths {
+    for library_search_path: str in library_search_paths {
         log #fmt("searching %s", library_search_path);
-        for path: str  in fs::list_dir(library_search_path) {
+        for path: str in fs::list_dir(library_search_path) {
             log #fmt("searching %s", path);
             let f: str = fs::basename(path);
             if !(str::starts_with(f, prefix) && str::ends_with(f, nn.suffix))
@@ -250,7 +250,7 @@ fn resolve_crate_deps(e: env, cdata: &@[u8]) -> cstore::cnum_map {
     // The map from crate numbers in the crate we're resolving to local crate
     // numbers
     let cnum_map = new_int_hash[ast::crate_num]();
-    for dep: decoder::crate_dep  in decoder::get_crate_deps(cdata) {
+    for dep: decoder::crate_dep in decoder::get_crate_deps(cdata) {
         let extrn_cnum = dep.cnum;
         let cname = dep.ident;
         log #fmt("resolving dep %s", cname);
diff --git a/src/comp/metadata/decoder.rs b/src/comp/metadata/decoder.rs
index 6d45ec64afd5..2fadfaab7a71 100644
--- a/src/comp/metadata/decoder.rs
+++ b/src/comp/metadata/decoder.rs
@@ -46,7 +46,7 @@ fn lookup_hash(d: &ebml::doc, eq_fn: fn(&[u8]) -> bool , hash: uint) ->
 
     let result: [ebml::doc] = ~[];
     let belt = tag_index_buckets_bucket_elt;
-    for each elt: ebml::doc  in ebml::tagged_docs(bucket, belt) {
+    for each elt: ebml::doc in ebml::tagged_docs(bucket, belt) {
         let pos = ebml::be_uint_from_bytes(elt.data, elt.start, 4u);
         if eq_fn(ivec::slice[u8](*elt.data, elt.start + 4u, elt.end)) {
             result += ~[ebml::doc_at(d.data, pos)];
@@ -138,7 +138,7 @@ fn tag_variant_ids(item: &ebml::doc, this_cnum: ast::crate_num) ->
    [ast::def_id] {
     let ids: [ast::def_id] = ~[];
     let v = tag_items_data_item_variant;
-    for each p: ebml::doc  in ebml::tagged_docs(item, v) {
+    for each p: ebml::doc in ebml::tagged_docs(item, v) {
         let ext = parse_def_id(ebml::doc_data(p));
         ids += ~[{crate: this_cnum, node: ext.node}];
     }
@@ -156,7 +156,7 @@ fn resolve_path(path: &[ast::ident], data: @[u8]) -> [ast::def_id] {
     let paths = ebml::get_doc(md, tag_paths);
     let eqer = bind eq_item(_, s);
     let result: [ast::def_id] = ~[];
-    for doc: ebml::doc  in lookup_hash(paths, eqer, hash_path(s)) {
+    for doc: ebml::doc in lookup_hash(paths, eqer, hash_path(s)) {
         let did_doc = ebml::get_doc(doc, tag_def_id);
         result += ~[parse_def_id(ebml::doc_data(did_doc))];
     }
@@ -233,13 +233,13 @@ fn get_tag_variants(data: &@[u8], def: ast::def_id, tcx: &ty::ctxt,
     let item = find_item(def.node, items);
     let infos: [ty::variant_info] = ~[];
     let variant_ids = tag_variant_ids(item, external_crate_id);
-    for did: ast::def_id  in variant_ids {
+    for did: ast::def_id in variant_ids {
         let item = find_item(did.node, items);
         let ctor_ty = item_type(item, external_crate_id, tcx, extres);
         let arg_tys: [ty::t] = ~[];
         alt ty::struct(tcx, ctor_ty) {
           ty::ty_fn(_, args, _, _, _) {
-            for a: ty::arg  in args { arg_tys += ~[a.ty]; }
+            for a: ty::arg in args { arg_tys += ~[a.ty]; }
           }
           _ {
             // Nullary tag variant.
@@ -344,7 +344,7 @@ fn get_attributes(md: &ebml::doc) -> [ast::attribute] {
 }
 
 fn list_meta_items(meta_items: &ebml::doc, out: io::writer) {
-    for mi: @ast::meta_item  in get_meta_items(meta_items) {
+    for mi: @ast::meta_item in get_meta_items(meta_items) {
         out.write_str(#fmt("%s\n", pprust::meta_item_to_str(*mi)));
     }
 }
@@ -352,7 +352,7 @@ fn list_meta_items(meta_items: &ebml::doc, out: io::writer) {
 fn list_crate_attributes(md: &ebml::doc, out: io::writer) {
     out.write_str("=Crate Attributes=\n");
 
-    for attr: ast::attribute  in get_attributes(md) {
+    for attr: ast::attribute in get_attributes(md) {
         out.write_str(#fmt("%s\n", pprust::attribute_to_str(attr)));
     }
 
@@ -382,7 +382,7 @@ fn get_crate_deps(data: @[u8]) -> [crate_dep] {
 fn list_crate_deps(data: @[u8], out: io::writer) {
     out.write_str("=External Dependencies=\n");
 
-    for dep: crate_dep  in get_crate_deps(data) {
+    for dep: crate_dep in get_crate_deps(data) {
         out.write_str(#fmt("%d %s\n", dep.cnum, dep.ident));
     }
 
@@ -398,7 +398,7 @@ fn list_crate_items(bytes: &@[u8], md: &ebml::doc, out: io::writer) {
     for each bucket: ebml::doc  in
              ebml::tagged_docs(bs, tag_index_buckets_bucket) {
         let et = tag_index_buckets_bucket_elt;
-        for each elt: ebml::doc  in ebml::tagged_docs(bucket, et) {
+        for each elt: ebml::doc in ebml::tagged_docs(bucket, et) {
             let data = read_path(elt);
             let def = ebml::doc_at(bytes, data.pos);
             let did_doc = ebml::get_doc(def, tag_def_id);
diff --git a/src/comp/metadata/encoder.rs b/src/comp/metadata/encoder.rs
index cf6d011d3764..2976745327f4 100644
--- a/src/comp/metadata/encoder.rs
+++ b/src/comp/metadata/encoder.rs
@@ -40,7 +40,7 @@ type entry[T] = {val: T, pos: uint};
 
 fn encode_tag_variant_paths(ebml_w: &ebml::writer, variants: &[variant],
                             path: &[str], index: &mutable [entry[str]]) {
-    for variant: variant  in variants {
+    for variant: variant in variants {
         add_to_index(ebml_w, path, index, variant.node.name);
         ebml::start_tag(ebml_w, tag_paths_data_item);
         encode_name(ebml_w, variant.node.name);
@@ -60,7 +60,7 @@ fn add_to_index(ebml_w: &ebml::writer, path: &[str],
 fn encode_native_module_item_paths(ebml_w: &ebml::writer,
                                    nmod: &native_mod, path: &[str],
                                    index: &mutable [entry[str]]) {
-    for nitem: @native_item  in nmod.items {
+    for nitem: @native_item in nmod.items {
         add_to_index(ebml_w, path, index, nitem.ident);
         ebml::start_tag(ebml_w, tag_paths_data_item);
         encode_name(ebml_w, nitem.ident);
@@ -71,7 +71,7 @@ fn encode_native_module_item_paths(ebml_w: &ebml::writer,
 
 fn encode_module_item_paths(ebml_w: &ebml::writer, module: &_mod,
                             path: &[str], index: &mutable [entry[str]]) {
-    for it: @item  in module.items {
+    for it: @item in module.items {
         if !is_exported(it.ident, module) { cont; }
         alt it.node {
           item_const(_, _) {
@@ -228,7 +228,7 @@ fn encode_tag_variant_info(ecx: &@encode_ctxt, ebml_w: &ebml::writer,
                            id: node_id, variants: &[variant],
                            index: &mutable [entry[int]],
                            ty_params: &[ty_param]) {
-    for variant: variant  in variants {
+    for variant: variant in variants {
         index += ~[{val: variant.node.id, pos: ebml_w.writer.tell()}];
         ebml::start_tag(ebml_w, tag_items_data_item);
         encode_def_id(ebml_w, local_def(variant.node.id));
@@ -298,7 +298,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: &ebml::writer,
         encode_family(ebml_w, 't' as u8);
         encode_type_param_kinds(ebml_w, tps);
         encode_type(ecx, ebml_w, node_id_to_monotype(ecx.ccx.tcx, item.id));
-        for v: variant  in variants {
+        for v: variant in variants {
             encode_variant_id(ebml_w, local_def(v.node.id));
         }
         ebml::end_tag(ebml_w);
@@ -395,14 +395,14 @@ fn encode_info_for_items(ecx: &@encode_ctxt, ebml_w: &ebml::writer) ->
 fn create_index[T](index: &[entry[T]], hash_fn: fn(&T) -> uint ) ->
    [@[entry[T]]] {
     let buckets: [@mutable [entry[T]]] = ~[];
-    for each i: uint  in uint::range(0u, 256u) { buckets += ~[@mutable ~[]]; }
-    for elt: entry[T]  in index {
+    for each i: uint in uint::range(0u, 256u) { buckets += ~[@mutable ~[]]; }
+    for elt: entry[T] in index {
         let h = hash_fn(elt.val);
         *buckets.(h % 256u) += ~[elt];
     }
 
     let buckets_frozen = ~[];
-    for bucket: @mutable [entry[T]]  in buckets {
+    for bucket: @mutable [entry[T]] in buckets {
         buckets_frozen += ~[@*bucket];
     }
     ret buckets_frozen;
@@ -414,10 +414,10 @@ fn encode_index[T](ebml_w: &ebml::writer, buckets: &[@[entry[T]]],
     ebml::start_tag(ebml_w, tag_index);
     let bucket_locs: [uint] = ~[];
     ebml::start_tag(ebml_w, tag_index_buckets);
-    for bucket: @[entry[T]]  in buckets {
+    for bucket: @[entry[T]] in buckets {
         bucket_locs += ~[ebml_w.writer.tell()];
         ebml::start_tag(ebml_w, tag_index_buckets_bucket);
-        for elt: entry[T]  in *bucket {
+        for elt: entry[T] in *bucket {
             ebml::start_tag(ebml_w, tag_index_buckets_bucket_elt);
             writer.write_be_uint(elt.pos, 4u);
             write_fn(writer, elt.val);
@@ -427,7 +427,7 @@ fn encode_index[T](ebml_w: &ebml::writer, buckets: &[@[entry[T]]],
     }
     ebml::end_tag(ebml_w);
     ebml::start_tag(ebml_w, tag_index_table);
-    for pos: uint  in bucket_locs { writer.write_be_uint(pos, 4u); }
+    for pos: uint in bucket_locs { writer.write_be_uint(pos, 4u); }
     ebml::end_tag(ebml_w);
     ebml::end_tag(ebml_w);
 }
@@ -467,7 +467,7 @@ fn encode_meta_item(ebml_w: &ebml::writer, mi: &meta_item) {
         ebml::start_tag(ebml_w, tag_meta_item_name);
         ebml_w.writer.write(str::bytes(name));
         ebml::end_tag(ebml_w);
-        for inner_item: @meta_item  in items {
+        for inner_item: @meta_item in items {
             encode_meta_item(ebml_w, *inner_item);
         }
         ebml::end_tag(ebml_w);
@@ -477,7 +477,7 @@ fn encode_meta_item(ebml_w: &ebml::writer, mi: &meta_item) {
 
 fn encode_attributes(ebml_w: &ebml::writer, attrs: &[attribute]) {
     ebml::start_tag(ebml_w, tag_attributes);
-    for attr: attribute  in attrs {
+    for attr: attribute in attrs {
         ebml::start_tag(ebml_w, tag_attribute);
         encode_meta_item(ebml_w, attr.node.value);
         ebml::end_tag(ebml_w);
@@ -516,7 +516,7 @@ fn synthesize_crate_attrs(ecx: &@encode_ctxt, crate: &@crate) -> [attribute] {
 
     let attrs: [attribute] = ~[];
     let found_link_attr = false;
-    for attr: attribute  in crate.node.attrs {
+    for attr: attribute in crate.node.attrs {
         attrs +=
             if attr::get_attr_name(attr) != "link" {
                 ~[attr]
@@ -544,7 +544,7 @@ fn encode_crate_deps(ebml_w: &ebml::writer, cstore: &cstore::cstore) {
 
         // Pull the cnums and names out of cstore
         let pairs: [mutable numname] = ~[mutable];
-        for each hashkv: hashkv  in cstore::iter_crate_data(cstore) {
+        for each hashkv: hashkv in cstore::iter_crate_data(cstore) {
             pairs += ~[mutable {crate: hashkv.key, ident: hashkv.val.name}];
         }
 
@@ -556,7 +556,7 @@ fn encode_crate_deps(ebml_w: &ebml::writer, cstore: &cstore::cstore) {
 
         // Sanity-check the crate numbers
         let expected_cnum = 1;
-        for n: numname  in pairs {
+        for n: numname in pairs {
             assert (n.crate == expected_cnum);
             expected_cnum += 1;
         }
@@ -573,7 +573,7 @@ fn encode_crate_deps(ebml_w: &ebml::writer, cstore: &cstore::cstore) {
     // FIXME: This is not nearly enough to support correct versioning
     // but is enough to get transitive crate dependencies working.
     ebml::start_tag(ebml_w, tag_crate_deps);
-    for cname: str  in get_ordered_names(cstore) {
+    for cname: str in get_ordered_names(cstore) {
         ebml::start_tag(ebml_w, tag_crate_dep);
         ebml_w.writer.write(str::bytes(cname));
         ebml::end_tag(ebml_w);
diff --git a/src/comp/metadata/tydecode.rs b/src/comp/metadata/tydecode.rs
index 435efb3e1678..d72d7b2c869e 100644
--- a/src/comp/metadata/tydecode.rs
+++ b/src/comp/metadata/tydecode.rs
@@ -420,8 +420,8 @@ fn parse_def_id(buf: &[u8]) -> ast::def_id {
 
     let crate_part_vec = ~[];
     let def_part_vec = ~[];
-    for b: u8  in crate_part { crate_part_vec += ~[b]; }
-    for b: u8  in def_part { def_part_vec += ~[b]; }
+    for b: u8 in crate_part { crate_part_vec += ~[b]; }
+    for b: u8 in def_part { def_part_vec += ~[b]; }
 
     let crate_num = uint::parse_buf(crate_part_vec, 10u) as int;
     let def_num = uint::parse_buf(def_part_vec, 10u) as int;
diff --git a/src/comp/metadata/tyencode.rs b/src/comp/metadata/tyencode.rs
index ce8c760da99d..c9750dfbb863 100644
--- a/src/comp/metadata/tyencode.rs
+++ b/src/comp/metadata/tyencode.rs
@@ -117,7 +117,7 @@ fn enc_sty(w: &io::writer, cx: &@ctxt, st: &ty::sty) {
         w.write_str("t[");
         w.write_str(cx.ds(def));
         w.write_char('|');
-        for t: ty::t  in tys { enc_ty(w, cx, t); }
+        for t: ty::t in tys { enc_ty(w, cx, t); }
         w.write_char(']');
       }
       ty::ty_tup(ts) {
@@ -134,7 +134,7 @@ fn enc_sty(w: &io::writer, cx: &@ctxt, st: &ty::sty) {
       ty::ty_chan(t) { w.write_char('C'); enc_ty(w, cx, t); }
       ty::ty_rec(fields) {
         w.write_str("R[");
-        for field: ty::field  in fields {
+        for field: ty::field in fields {
             w.write_str(field.ident);
             w.write_char('=');
             enc_mt(w, cx, field.mt);
@@ -158,7 +158,7 @@ fn enc_sty(w: &io::writer, cx: &@ctxt, st: &ty::sty) {
       }
       ty::ty_obj(methods) {
         w.write_str("O[");
-        for m: ty::method  in methods {
+        for m: ty::method in methods {
             enc_proto(w, m.proto);
             w.write_str(m.ident);
             enc_ty_fn(w, cx, m.inputs, m.output, m.cf, m.constrs);
@@ -170,7 +170,7 @@ fn enc_sty(w: &io::writer, cx: &@ctxt, st: &ty::sty) {
         w.write_str(cx.ds(def));
         w.write_char('|');
         enc_ty(w, cx, ty);
-        for t: ty::t  in tps { enc_ty(w, cx, t); }
+        for t: ty::t in tps { enc_ty(w, cx, t); }
         w.write_char(']');
       }
       ty::ty_var(id) { w.write_char('X'); w.write_str(int::str(id)); }
@@ -192,7 +192,7 @@ fn enc_sty(w: &io::writer, cx: &@ctxt, st: &ty::sty) {
       ty::ty_constr(ty, cs) {
         w.write_str("A[");
         enc_ty(w, cx, ty);
-        for tc: @ty::type_constr  in cs { enc_ty_constr(w, cx, tc); }
+        for tc: @ty::type_constr in cs { enc_ty_constr(w, cx, tc); }
         w.write_char(']');
       }
     }
@@ -208,7 +208,7 @@ fn enc_proto(w: &io::writer, proto: proto) {
 fn enc_ty_fn(w: &io::writer, cx: &@ctxt, args: &[ty::arg], out: &ty::t,
              cf: &controlflow, constrs: &[@ty::constr]) {
     w.write_char('[');
-    for arg: ty::arg  in args {
+    for arg: ty::arg in args {
         alt arg.mode {
           ty::mo_alias(mut) {
             w.write_char('&');
@@ -223,7 +223,7 @@ fn enc_ty_fn(w: &io::writer, cx: &@ctxt, args: &[ty::arg], out: &ty::t,
     }
     w.write_char(']');
     let colon = true;
-    for c: @ty::constr  in constrs {
+    for c: @ty::constr in constrs {
         if colon {
             w.write_char(':');
             colon = false;
@@ -241,7 +241,7 @@ fn enc_constr(w: &io::writer, cx: &@ctxt, c: &@ty::constr) {
     w.write_str(cx.ds(c.node.id));
     w.write_char('|');
     let semi = false;
-    for a: @constr_arg  in c.node.args {
+    for a: @constr_arg in c.node.args {
         if semi { w.write_char(';'); } else { semi = true; }
         alt a.node {
           carg_base. { w.write_char('*'); }
@@ -258,7 +258,7 @@ fn enc_ty_constr(w: &io::writer, cx: &@ctxt, c: &@ty::type_constr) {
     w.write_str(cx.ds(c.node.id));
     w.write_char('|');
     let semi = false;
-    for a: @ty::ty_constr_arg  in c.node.args {
+    for a: @ty::ty_constr_arg in c.node.args {
         if semi { w.write_char(';'); } else { semi = true; }
         alt a.node {
           carg_base. { w.write_char('*'); }
diff --git a/src/comp/middle/alias.rs b/src/comp/middle/alias.rs
index eecea8bf029a..e7d15d71a3b1 100644
--- a/src/comp/middle/alias.rs
+++ b/src/comp/middle/alias.rs
@@ -54,7 +54,7 @@ fn check_crate(tcx: ty::ctxt, crate: &@ast::crate) {
 fn visit_fn(cx: &@ctx, f: &ast::_fn, tp: &[ast::ty_param], sp: &span,
             name: &fn_ident, id: ast::node_id, sc: &scope, v: &vt[scope]) {
     visit::visit_fn_decl(f.decl, sc, v);
-    for arg_: ast::arg  in f.decl.inputs {
+    for arg_: ast::arg in f.decl.inputs {
         cx.local_map.insert(arg_.id, arg(arg_.mode));
     }
     let scope = alt (f.proto) {
@@ -85,7 +85,7 @@ fn visit_fn(cx: &@ctx, f: &ast::_fn, tp: &[ast::ty_param], sp: &span,
 fn visit_item(cx: &@ctx, i: &@ast::item, sc: &scope, v: &vt[scope]) {
     alt i.node {
       ast::item_obj(o, _, _) {
-        for f: ast::obj_field  in o.fields {
+        for f: ast::obj_field in o.fields {
             cx.local_map.insert(f.id, objfield(f.mut));
         }
       }
@@ -173,7 +173,7 @@ fn check_call(cx: &ctx, f: &@ast::expr, args: &[@ast::expr], sc: &scope) ->
     let unsafe_ts: [ty::t] = ~[];
     let unsafe_t_offsets: [uint] = ~[];
     let i = 0u;
-    for arg_t: ty::arg  in arg_ts {
+    for arg_t: ty::arg in arg_ts {
         if arg_t.mode != ty::mo_val {
             let arg = args.(i);
             let root = expr_root(cx, arg, false);
@@ -232,11 +232,11 @@ fn check_call(cx: &ctx, f: &@ast::expr, args: &[@ast::expr], sc: &scope) ->
         }
     }
     let j = 0u;
-    for unsafe: ty::t  in unsafe_ts {
+    for unsafe: ty::t in unsafe_ts {
         let offset = unsafe_t_offsets.(j);
         j += 1u;
         let i = 0u;
-        for arg_t: ty::arg  in arg_ts {
+        for arg_t: ty::arg in arg_ts {
             let mut_alias = arg_t.mode == ty::mo_alias(true);
             if i != offset &&
                    ty_can_unsafely_include(cx, unsafe, arg_t.ty, mut_alias) {
@@ -250,10 +250,10 @@ fn check_call(cx: &ctx, f: &@ast::expr, args: &[@ast::expr], sc: &scope) ->
     }
     // Ensure we're not passing a root by mutable alias.
 
-    for root: {arg: uint, node: node_id}  in mut_roots {
+    for root: {arg: uint, node: node_id} in mut_roots {
         let mut_alias_to_root = false;
         let mut_alias_to_root_count = 0u;
-        for r: node_id  in roots {
+        for r: node_id in roots {
             if root.node == r {
                 mut_alias_to_root_count += 1u;
                 if mut_alias_to_root_count > 1u {
@@ -277,7 +277,7 @@ fn check_tail_call(cx: &ctx, call: &@ast::expr) {
     let args;
     let f = alt call.node { ast::expr_call(f, args_) { args = args_; f } };
     let i = 0u;
-    for arg_t: ty::arg  in fty_args(cx, ty::expr_ty(cx.tcx, f)) {
+    for arg_t: ty::arg in fty_args(cx, ty::expr_ty(cx.tcx, f)) {
         if arg_t.mode != ty::mo_val {
             let mut_a = arg_t.mode == ty::mo_alias(true);
             let ok = true;
@@ -316,7 +316,7 @@ fn check_alt(cx: &ctx, input: &@ast::expr, arms: &[ast::arm], sc: &scope,
         alt path_def_id(cx, root.ex) { some(did) { ~[did.node] } _ { ~[] } };
     let forbidden_tp: [ty::t] =
         alt inner_mut(root.ds) { some(t) { ~[t] } _ { ~[] } };
-    for a: ast::arm  in arms {
+    for a: ast::arm in arms {
         let dnums = arm_defnums(a);
         let new_sc = sc;
         if ivec::len(dnums) > 0u {
@@ -390,7 +390,7 @@ fn check_var(cx: &ctx, ex: &@ast::expr, p: &ast::path, id: ast::node_id,
     if !def_is_local(def, true) { ret; }
     let my_defnum = ast::def_id_of_def(def).node;
     let var_t = ty::expr_ty(cx.tcx, ex);
-    for r: restrict  in *sc {
+    for r: restrict in *sc {
         // excludes variables introduced since the alias was made
         // FIXME This does not work anymore, now that we have macros.
         if my_defnum < r.block_defnum {
@@ -475,7 +475,7 @@ fn is_immutable_alias(cx: &ctx, sc: &scope, dnum: node_id) -> bool {
       some(arg(ast::alias(false))) { ret true; }
       _ { }
     }
-    for r: restrict  in *sc {
+    for r: restrict in *sc {
         if ivec::member(dnum, r.bindings) { ret true; }
     }
     ret false;
@@ -487,7 +487,7 @@ fn is_immutable_objfield(cx: &ctx, dnum: node_id) -> bool {
 
 fn test_scope(cx: &ctx, sc: &scope, r: &restrict, p: &ast::path) {
     let prob = r.ok;
-    for dep: uint  in r.depends_on {
+    for dep: uint in r.depends_on {
         if prob != valid { break; }
         prob = sc.(dep).ok;
     }
@@ -509,8 +509,8 @@ fn test_scope(cx: &ctx, sc: &scope, r: &restrict, p: &ast::path) {
 fn deps(sc: &scope, roots: &[node_id]) -> [uint] {
     let i = 0u;
     let result = ~[];
-    for r: restrict  in *sc {
-        for dn: node_id  in roots {
+    for r: restrict in *sc {
+        for dn: node_id in roots {
             if ivec::member(dn, r.bindings) { result += ~[i]; }
         }
         i += 1u;
@@ -568,7 +568,7 @@ fn expr_root(cx: &ctx, ex: @ast::expr, autoderef: bool) ->
             let mut = false;
             alt ty::struct(cx.tcx, auto_unbox.t) {
               ty::ty_rec(fields) {
-                for fld: ty::field  in fields {
+                for fld: ty::field in fields {
                     if str::eq(ident, fld.ident) {
                         mut = fld.mt.mut != ast::imm;
                         break;
@@ -626,12 +626,12 @@ fn expr_root(cx: &ctx, ex: @ast::expr, autoderef: bool) ->
 }
 
 fn mut_field(ds: &@[deref]) -> bool {
-    for d: deref  in *ds { if d.mut { ret true; } }
+    for d: deref in *ds { if d.mut { ret true; } }
     ret false;
 }
 
 fn inner_mut(ds: &@[deref]) -> option::t[ty::t] {
-    for d: deref  in *ds { if d.mut { ret some(d.outer_t); } }
+    for d: deref in *ds { if d.mut { ret some(d.outer_t); } }
     ret none;
 }
 
@@ -661,7 +661,7 @@ fn ty_can_unsafely_include(cx: &ctx, needle: ty::t, haystack: ty::t,
         if needle == haystack { ret true; }
         alt ty::struct(tcx, haystack) {
           ty::ty_tag(_, ts) {
-            for t: ty::t  in ts {
+            for t: ty::t in ts {
                 if helper(tcx, needle, t, mut) { ret true; }
             }
             ret false;
@@ -671,7 +671,7 @@ fn ty_can_unsafely_include(cx: &ctx, needle: ty::t, haystack: ty::t,
           }
           ty::ty_uniq(t) { ret helper(tcx, needle, t, false); }
           ty::ty_rec(fields) {
-            for f: ty::field  in fields {
+            for f: ty::field in fields {
                 if helper(tcx, needle, f.mt.ty, get_mut(mut, f.mt)) {
                     ret true;
                 }
diff --git a/src/comp/middle/ast_map.rs b/src/comp/middle/ast_map.rs
index 9e37364ab65b..e1d9e398cc88 100644
--- a/src/comp/middle/ast_map.rs
+++ b/src/comp/middle/ast_map.rs
@@ -93,7 +93,7 @@ fn new_smallintmap_adapter[@K,
 
         iter items() -> @{key: K, val: V} {
             let idx = 0u;
-            for item: option::t[V]  in map.v {
+            for item: option::t[V] in map.v {
                 alt item {
                   option::some(elt) {
                     let value = elt;
@@ -106,7 +106,7 @@ fn new_smallintmap_adapter[@K,
             }
         }
         iter keys() -> K {
-            for each p: @{key: K, val: V}  in self.items() { put p.key; }
+            for each p: @{key: K, val: V} in self.items() { put p.key; }
         }
     }
 
diff --git a/src/comp/middle/check_alt.rs b/src/comp/middle/check_alt.rs
index 739633c795fb..f891b82c4534 100644
--- a/src/comp/middle/check_alt.rs
+++ b/src/comp/middle/check_alt.rs
@@ -17,12 +17,12 @@ fn check_expr(tcx: &ty::ctxt, ex: &@expr, s: &(), v: &visit::vt[()]) {
 
 fn check_arms(tcx: &ty::ctxt, arms: &[arm]) {
     let i = 0;
-    for arm: arm  in arms {
-        for arm_pat: @pat  in arm.pats {
+    for arm: arm in arms {
+        for arm_pat: @pat in arm.pats {
             let reachable = true;
             let j = 0;
             while j < i {
-                for prev_pat: @pat  in arms.(j).pats {
+                for prev_pat: @pat in arms.(j).pats {
                     if pattern_supersedes(tcx, prev_pat, arm_pat) {
                         reachable = false;
                     }
@@ -41,7 +41,7 @@ fn pattern_supersedes(tcx: &ty::ctxt, a: &@pat, b: &@pat) -> bool {
     fn patterns_supersede(tcx: &ty::ctxt, as: &[@pat], bs: &[@pat]) ->
        bool {
         let i = 0;
-        for a: @pat  in as {
+        for a: @pat in as {
             if !pattern_supersedes(tcx, a, bs.(i)) { ret false; }
             i += 1;
         }
@@ -50,9 +50,9 @@ fn pattern_supersedes(tcx: &ty::ctxt, a: &@pat, b: &@pat) -> bool {
     fn field_patterns_supersede(tcx: &ty::ctxt, fas: &[field_pat],
                                 fbs: &[field_pat]) -> bool {
         let wild = @{id: 0, node: pat_wild, span: dummy_sp()};
-        for fa: field_pat  in fas {
+        for fa: field_pat in fas {
             let pb = wild;
-            for fb: field_pat  in fbs {
+            for fb: field_pat in fbs {
                 if fa.ident == fb.ident { pb = fb.pat; }
             }
             if !pattern_supersedes(tcx, fa.pat, pb) { ret false; }
diff --git a/src/comp/middle/freevars.rs b/src/comp/middle/freevars.rs
index fa1cc2aa0934..b0c42d5d2ac1 100644
--- a/src/comp/middle/freevars.rs
+++ b/src/comp/middle/freevars.rs
@@ -42,12 +42,12 @@ fn collect_freevars(def_map: &resolve::def_map, sess: &session::session,
                     walker: &fn(&visit::vt[()]) ,
                     initial_decls: [ast::node_id]) -> freevar_info {
     let decls = new_int_hash();
-    for decl: ast::node_id  in initial_decls { set_add(decls, decl); }
+    for decl: ast::node_id in initial_decls { set_add(decls, decl); }
     let refs = @mutable ~[];
 
     let walk_fn = lambda(f: &ast::_fn, tps: &[ast::ty_param], sp: &span,
                          i: &ast::fn_ident, nid: ast::node_id) {
-        for a: ast::arg  in f.decl.inputs { set_add(decls, a.id); }
+        for a: ast::arg in f.decl.inputs { set_add(decls, a.id); }
     };
     let walk_expr = lambda(expr: &@ast::expr) {
         alt expr.node {
@@ -87,7 +87,7 @@ fn collect_freevars(def_map: &resolve::def_map, sess: &session::session,
     // node ids of the definitions.
     let canonical_refs = ~[];
     let defs = new_int_hash();
-    for ref_id_: ast::node_id  in *refs {
+    for ref_id_: ast::node_id in *refs {
         let ref_id = ref_id_;
         let def_id = ast::def_id_of_def(def_map.get(ref_id)).node;
         if !decls.contains_key(def_id) && !defs.contains_key(def_id) {
diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs
index 9a6a6cb088f5..9e51e4428388 100644
--- a/src/comp/middle/resolve.rs
+++ b/src/comp/middle/resolve.rs
@@ -239,7 +239,7 @@ fn map_crate(e: &@env, c: &@ast::crate) {
 }
 
 fn resolve_imports(e: &env) {
-    for each it: @{key: ast::node_id, val: import_state}  in e.imports.items()
+    for each it: @{key: ast::node_id, val: import_state} in e.imports.items()
              {
         alt it.val {
           todo(item, sc) { resolve_import(e, item, sc); }
@@ -345,7 +345,7 @@ fn visit_fn_with_scope(e: &@env, f: &ast::_fn, tp: &[ast::ty_param],
     // here's where we need to set up the mapping
     // for f's constrs in the table.
 
-    for c: @ast::constr  in f.decl.constraints {
+    for c: @ast::constr in f.decl.constraints {
         resolve_constr(e, id, c, sc, v);
     }
     visit::visit_fn(f, tp, sp, name, id,
@@ -531,7 +531,7 @@ fn unresolved_err(e: &env, sc: &scopes, sp: &span, name: &ident, kind: &str) {
         fail;
     }
     let err_scope = find_fn_or_mod_scope(sc);
-    for rs: {ident: str, sc: scope}  in e.reported {
+    for rs: {ident: str, sc: scope} in e.reported {
         if str::eq(rs.ident, name) && err_scope == rs.sc { ret; }
     }
     e.reported += ~[{ident: name, sc: err_scope}];
@@ -704,7 +704,7 @@ fn lookup_in_scope(e: &env, sc: scopes, sp: &span, name: &ident,
 fn lookup_in_ty_params(name: &ident, ty_params: &[ast::ty_param]) ->
    option::t[def] {
     let i = 0u;
-    for tp: ast::ty_param  in ty_params {
+    for tp: ast::ty_param in ty_params {
         if str::eq(tp.ident, name) { ret some(ast::def_ty_arg(i,tp.kind)); }
         i += 1u;
     }
@@ -727,7 +727,7 @@ fn lookup_in_fn(name: &ident, decl: &ast::fn_decl,
    option::t[def] {
     alt ns {
       ns_value. {
-        for a: ast::arg  in decl.inputs {
+        for a: ast::arg in decl.inputs {
             if str::eq(a.ident, name) {
                 ret some(ast::def_arg(local_def(a.id)));
             }
@@ -743,7 +743,7 @@ fn lookup_in_obj(name: &ident, ob: &ast::_obj, ty_params: &[ast::ty_param],
                  ns: namespace) -> option::t[def] {
     alt ns {
       ns_value. {
-        for f: ast::obj_field  in ob.fields {
+        for f: ast::obj_field in ob.fields {
             if str::eq(f.ident, name) {
                 ret some(ast::def_obj_field(local_def(f.id)));
             }
@@ -779,7 +779,7 @@ fn lookup_in_block(name: &ident, b: &ast::blk_, ns: namespace) ->
                             ret some(ast::def_ty(local_def(it.id)));
                         }
                     } else if (ns == ns_value) {
-                        for v: ast::variant  in variants {
+                        for v: ast::variant in variants {
                             if str::eq(v.node.name, name) {
                                 let i = v.node.id;
                                 ret some(ast::def_variant(local_def(it.id),
@@ -971,7 +971,7 @@ fn lookup_glob_in_mod(e: &env, info: @indexed_mod, sp: &span, id: &ident,
         } else if (ivec::len(matches) == 1u) {
             ret some(matches.(0).def);
         } else {
-            for match: glob_imp_def  in matches {
+            for match: glob_imp_def in matches {
                 let sp = match.item.span;
                 e.sess.span_note(sp, #fmt("'%s' is imported here", id));
             }
@@ -1053,7 +1053,7 @@ fn add_to_index(index: &hashmap[ident, list[mod_index_entry]], id: &ident,
 
 fn index_mod(md: &ast::_mod) -> mod_index {
     let index = new_str_hash[list[mod_index_entry]]();
-    for it: @ast::view_item  in md.view_items {
+    for it: @ast::view_item in md.view_items {
         alt it.node {
           ast::view_item_import(ident, _, _) | ast::view_item_use(ident, _, _)
           {
@@ -1065,7 +1065,7 @@ fn index_mod(md: &ast::_mod) -> mod_index {
           }
         }
     }
-    for it: @ast::item  in md.items {
+    for it: @ast::item in md.items {
         alt it.node {
           ast::item_const(_, _) | ast::item_fn(_, _) | ast::item_mod(_) |
           ast::item_native_mod(_) | ast::item_ty(_, _) |
@@ -1075,7 +1075,7 @@ fn index_mod(md: &ast::_mod) -> mod_index {
           ast::item_tag(variants, _) {
             add_to_index(index, it.ident, mie_item(it));
             let variant_idx: uint = 0u;
-            for v: ast::variant  in variants {
+            for v: ast::variant in variants {
                 add_to_index(index, v.node.name,
                              mie_tag_variant(it, variant_idx));
                 variant_idx += 1u;
@@ -1088,7 +1088,7 @@ fn index_mod(md: &ast::_mod) -> mod_index {
 
 fn index_nmod(md: &ast::native_mod) -> mod_index {
     let index = new_str_hash[list[mod_index_entry]]();
-    for it: @ast::view_item  in md.view_items {
+    for it: @ast::view_item in md.view_items {
         alt it.node {
           ast::view_item_use(ident, _, _) | ast::view_item_import(ident, _, _)
           {
@@ -1097,7 +1097,7 @@ fn index_nmod(md: &ast::native_mod) -> mod_index {
           ast::view_item_import_glob(_, _) | ast::view_item_export(_, _) { }
         }
     }
-    for it: @ast::native_item  in md.items {
+    for it: @ast::native_item in md.items {
         add_to_index(index, it.ident, mie_native_item(it));
     }
     ret index;
@@ -1125,7 +1125,7 @@ fn ns_for_def(d: def) -> namespace {
 
 fn lookup_external(e: &env, cnum: int, ids: &[ident], ns: namespace) ->
    option::t[def] {
-    for d: def  in csearch::lookup_defs(e.sess.get_cstore(), cnum, ids) {
+    for d: def in csearch::lookup_defs(e.sess.get_cstore(), cnum, ids) {
         e.ext_map.insert(ast::def_id_of_def(d), ids);
         if ns == ns_for_def(d) { ret some(d); }
     }
@@ -1211,7 +1211,7 @@ fn check_item(e: &@env, i: &@ast::item, x: &(), v: &vt[()]) {
       ast::item_obj(ob, ty_params, _) {
         fn field_name(field: &ast::obj_field) -> ident { ret field.ident; }
         ensure_unique(*e, i.span, ob.fields, field_name, "object field");
-        for m: @ast::method  in ob.methods {
+        for m: @ast::method in ob.methods {
             check_fn(*e, m.span, m.node.meth);
         }
         ensure_unique(*e, i.span, typaram_names(ty_params),
@@ -1249,7 +1249,7 @@ fn check_arm(e: &@env, a: &ast::arm, x: &(), v: &vt[()]) {
             e.sess.span_err(a.pats.(i).span,
                             "inconsistent number of bindings");
         } else {
-            for name: ident  in ch.seen {
+            for name: ident in ch.seen {
                 if is_none(ivec::find(bind str::eq(name, _), seen0)) {
                     // Fight the alias checker
                     let name_ = name;
@@ -1267,7 +1267,7 @@ fn check_block(e: &@env, b: &ast::blk, x: &(), v: &vt[()]) {
     let values = checker(*e, "value");
     let types = checker(*e, "type");
     let mods = checker(*e, "module");
-    for st: @ast::stmt  in b.node.stmts {
+    for st: @ast::stmt in b.node.stmts {
         alt st.node {
           ast::stmt_decl(d, _) {
             alt d.node {
@@ -1280,7 +1280,7 @@ fn check_block(e: &@env, b: &ast::blk, x: &(), v: &vt[()]) {
                 alt it.node {
                   ast::item_tag(variants, _) {
                     add_name(types, it.span, it.ident);
-                    for v: ast::variant  in variants {
+                    for v: ast::variant in variants {
                         add_name(values, v.span, v.node.name);
                     }
                   }
@@ -1340,7 +1340,7 @@ fn checker(e: &env, kind: str) -> checker {
 }
 
 fn add_name(ch: &checker, sp: &span, name: &ident) {
-    for s: ident  in ch.seen {
+    for s: ident in ch.seen {
         if str::eq(s, name) {
             ch.sess.span_fatal(sp, "duplicate " + ch.kind + " name: " + name);
         }
@@ -1353,7 +1353,7 @@ fn ident_id(i: &ident) -> ident { ret i; }
 fn ensure_unique[T](e: &env, sp: &span, elts: &[T], id: fn(&T) -> ident ,
                     kind: &str) {
     let ch = checker(e, kind);
-    for elt: T  in elts { add_name(ch, sp, id(elt)); }
+    for elt: T in elts { add_name(ch, sp, id(elt)); }
 }
 
 // Local Variables:
diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs
index b8351127d866..f077516bdf6a 100644
--- a/src/comp/middle/trans.rs
+++ b/src/comp/middle/trans.rs
@@ -95,7 +95,7 @@ fn type_of(cx: &@crate_ctxt, sp: &span, t: &ty::t) -> TypeRef {
 fn type_of_explicit_args(cx: &@crate_ctxt, sp: &span, inputs: &[ty::arg]) ->
    [TypeRef] {
     let atys: [TypeRef] = ~[];
-    for arg: ty::arg  in inputs {
+    for arg: ty::arg in inputs {
         let t: TypeRef = type_of_inner(cx, sp, arg.ty);
         t = alt arg.mode {
           ty::mo_alias(_) { T_ptr(t) }
@@ -231,7 +231,7 @@ fn type_of_inner(cx: &@crate_ctxt, sp: &span, t: &ty::t) -> TypeRef {
       ty::ty_task. { llty = T_taskptr(*cx); }
       ty::ty_rec(fields) {
         let tys: [TypeRef] = ~[];
-        for f: ty::field  in fields {
+        for f: ty::field in fields {
             tys += ~[type_of_inner(cx, sp, f.mt.ty)];
         }
         llty = T_struct(tys);
@@ -305,7 +305,7 @@ fn type_of_or_i8(bcx: &@block_ctxt, typ: ty::t) -> TypeRef {
 // gas doesn't!
 fn sanitize(s: &str) -> str {
     let result = "";
-    for c: u8  in s {
+    for c: u8 in s {
         if c == '@' as u8 {
             result += "boxed_";
         } else {
@@ -401,7 +401,7 @@ fn trans_native_call(b: &builder, glues: @glue_fns, lltaskptr: ValueRef,
     let n: int = std::ivec::len[ValueRef](args) as int;
     let llnative: ValueRef = get_simple_extern_fn(externs, llmod, name, n);
     let call_args: [ValueRef] = ~[];
-    for a: ValueRef  in args { call_args += ~[b.ZExtOrBitCast(a, T_int())]; }
+    for a: ValueRef in args { call_args += ~[b.ZExtOrBitCast(a, T_int())]; }
     ret b.Call(llnative, call_args);
 }
 
@@ -528,7 +528,7 @@ fn static_size_of_tag(cx: &@crate_ctxt, sp: &span, t: &ty::t) -> uint {
 
         let max_size = 0u;
         let variants = ty::tag_variants(cx.tcx, tid);
-        for variant: ty::variant_info  in variants {
+        for variant: ty::variant_info in variants {
             let tup_ty =
                 simplify_type(cx, ty::mk_tup(cx.tcx, variant.args));
             // Perform any type parameter substitutions.
@@ -562,7 +562,7 @@ fn dynamic_size_of(cx: &@block_ctxt, t: ty::t) -> result {
         let off = C_int(0);
         let max_align = C_int(1);
         let bcx = cx;
-        for e: ty::t  in elts {
+        for e: ty::t in elts {
             let elt_align = align_of(bcx, e);
             bcx = elt_align.bcx;
             let elt_size = size_of(bcx, e);
@@ -581,7 +581,7 @@ fn dynamic_size_of(cx: &@block_ctxt, t: ty::t) -> result {
       }
       ty::ty_rec(flds) {
         let tys: [ty::t] = ~[];
-        for f: ty::field  in flds { tys += ~[f.mt.ty]; }
+        for f: ty::field in flds { tys += ~[f.mt.ty]; }
         ret align_elements(cx, tys);
       }
       ty::ty_tup(elts) {
@@ -596,12 +596,12 @@ fn dynamic_size_of(cx: &@block_ctxt, t: ty::t) -> result {
         let max_size: ValueRef = alloca(bcx, T_int());
         bcx.build.Store(C_int(0), max_size);
         let variants = ty::tag_variants(bcx_tcx(bcx), tid);
-        for variant: ty::variant_info  in variants {
+        for variant: ty::variant_info in variants {
             // Perform type substitution on the raw argument types.
 
             let raw_tys: [ty::t] = variant.args;
             let tys: [ty::t] = ~[];
-            for raw_ty: ty::t  in raw_tys {
+            for raw_ty: ty::t in raw_tys {
                 let t = ty::substitute_type_params(bcx_tcx(cx), tps, raw_ty);
                 tys += ~[t];
             }
@@ -640,7 +640,7 @@ fn dynamic_align_of(cx: &@block_ctxt, t: &ty::t) -> result {
       ty::ty_rec(flds) {
         let a = C_int(1);
         let bcx = cx;
-        for f: ty::field  in flds {
+        for f: ty::field in flds {
             let align = align_of(bcx, f.mt.ty);
             bcx = align.bcx;
             a = umax(bcx, a, align.val);
@@ -674,7 +674,7 @@ fn dynamic_align_of(cx: &@block_ctxt, t: &ty::t) -> result {
 // in C_int()
 fn GEPi(cx: &@block_ctxt, base: ValueRef, ixs: &[int]) -> ValueRef {
     let v: [ValueRef] = ~[];
-    for i: int  in ixs { v += ~[C_int(i)]; }
+    for i: int in ixs { v += ~[C_int(i)]; }
     ret cx.build.InBoundsGEP(base, v);
 }
 
@@ -765,7 +765,7 @@ fn GEP_tup_like(cx: &@block_ctxt, t: &ty::t, base: ValueRef, ixs: &[int]) ->
     let s = split_type(bcx_ccx(cx), t, ixs, 0u);
 
     let args = ~[];
-    for typ: ty::t  in s.prefix { args += ~[typ]; }
+    for typ: ty::t in s.prefix { args += ~[typ]; }
     let prefix_ty = ty::mk_tup(bcx_tcx(cx), args);
 
     let bcx = cx;
@@ -789,7 +789,7 @@ fn GEP_tag(cx: @block_ctxt, llblobptr: ValueRef, tag_id: &ast::def_id,
 
     let i = 0;
     let true_arg_tys: [ty::t] = ~[];
-    for aty: ty::t  in arg_tys {
+    for aty: ty::t in arg_tys {
         let arg_ty = ty::substitute_type_params(bcx_tcx(cx), ty_substs, aty);
         true_arg_tys += ~[arg_ty];
         if i == ix { elem_ty = arg_ty; }
@@ -909,7 +909,7 @@ fn linearize_ty_params(cx: &@block_ctxt, t: &ty::t) ->
         alt ty::struct(bcx_tcx(r.cx), t) {
           ty::ty_param(pid,_) {
             let seen: bool = false;
-            for d: uint  in r.defs { if d == pid { seen = true; } }
+            for d: uint in r.defs { if d == pid { seen = true; } }
             if !seen {
                 r.vals += ~[r.cx.fcx.lltydescs.(pid)];
                 r.defs += ~[pid];
@@ -983,7 +983,7 @@ fn get_derived_tydesc(cx: &@block_ctxt, t: &ty::t, escapes: bool,
         let tdp = bcx.build.GEP(tydescs, ~[C_int(0), C_int(i)]);
         bcx.build.Store(root, tdp);
         i += 1;
-        for td: ValueRef  in tys.descs {
+        for td: ValueRef in tys.descs {
             let tdp = bcx.build.GEP(tydescs, ~[C_int(0), C_int(i)]);
             bcx.build.Store(td, tdp);
             i += 1;
@@ -1002,7 +1002,7 @@ fn get_derived_tydesc(cx: &@block_ctxt, t: &ty::t, escapes: bool,
             alloca(bcx, T_array(T_ptr(bcx_ccx(bcx).tydesc_type),
                                 n_params + 1u));
         let i = 0;
-        for td: ValueRef  in tys.descs {
+        for td: ValueRef in tys.descs {
             let tdp = bcx.build.GEP(llparamtydescs, ~[C_int(0), C_int(i)]);
             bcx.build.Store(td, tdp);
             i += 1;
@@ -1173,7 +1173,7 @@ fn make_generic_glue_inner(cx: &@local_ctxt, sp: &span, t: &ty::t,
 
     // TODO: Implement some kind of freeze operation in the standard library.
     let lltydescs_frozen = ~[];
-    for lltydesc: ValueRef  in lltydescs { lltydescs_frozen += ~[lltydesc]; }
+    for lltydesc: ValueRef in lltydescs { lltydescs_frozen += ~[lltydesc]; }
     fcx.lltydescs = lltydescs_frozen;
 
     let bcx = new_top_block_ctxt(fcx);
@@ -1201,7 +1201,7 @@ fn make_generic_glue(cx: &@local_ctxt, sp: &span, t: &ty::t, llfn: ValueRef,
 }
 
 fn emit_tydescs(ccx: &@crate_ctxt) {
-    for each pair: @{key: ty::t, val: @tydesc_info}  in ccx.tydescs.items() {
+    for each pair: @{key: ty::t, val: @tydesc_info} in ccx.tydescs.items() {
         let glue_fn_ty = T_ptr(T_glue_fn(*ccx));
         let cmp_fn_ty = T_ptr(T_cmp_glue_fn(*ccx));
         let ti = pair.val;
@@ -1518,7 +1518,7 @@ fn trans_res_drop(cx: @block_ctxt, rs: ValueRef, did: &ast::def_id,
         cx.build.Load(cx.build.GEP(dtor_pair,
                                    ~[C_int(0), C_int(abi::fn_field_box)]));
     let args = ~[cx.fcx.llretptr, cx.fcx.lltaskptr, dtor_env];
-    for tp: ty::t  in tps {
+    for tp: ty::t in tps {
         let ti: option::t[@tydesc_info] = none;
         let td = get_tydesc(cx, tp, false, ti);
         args += ~[td.val];
@@ -1814,7 +1814,7 @@ fn iter_structural_ty_full(cx: &@block_ctxt, av: ValueRef, t: &ty::t,
         alt ty::struct(ccx.tcx, fn_ty) {
           ty::ty_fn(_, args, _, _, _) {
             let j = 0;
-            for a: ty::arg  in args {
+            for a: ty::arg in args {
                 let rslt = GEP_tag(cx, a_tup, tid, variant.id, tps, j);
                 let llfldp_a = rslt.val;
                 cx = rslt.bcx;
@@ -1883,7 +1883,7 @@ fn iter_structural_ty_full(cx: &@block_ctxt, av: ValueRef, t: &ty::t,
         let llswitch = bcx.build.Switch(lldiscrim_a, unr_cx.llbb, n_variants);
         let next_cx = new_sub_block_ctxt(bcx, "tag-iter-next");
         let i = 0u;
-        for variant: ty::variant_info  in variants {
+        for variant: ty::variant_info in variants {
             let variant_cx =
                 new_sub_block_ctxt(bcx,
                                    "tag-iter-variant-" +
@@ -2041,7 +2041,7 @@ fn lazily_emit_all_tydesc_glue(cx: &@block_ctxt,
 
 fn lazily_emit_all_generic_info_tydesc_glues(cx: &@block_ctxt,
                                              gi: &generic_info) {
-    for ti: option::t[@tydesc_info]  in gi.static_tis {
+    for ti: option::t[@tydesc_info] in gi.static_tis {
         lazily_emit_all_tydesc_glue(cx, ti);
     }
 }
@@ -3386,7 +3386,7 @@ fn join_results(parent_cx: &@block_ctxt, t: TypeRef, ins: &[result]) ->
     let live: [result] = ~[];
     let vals: [ValueRef] = ~[];
     let bbs: [BasicBlockRef] = ~[];
-    for r: result  in ins {
+    for r: result in ins {
         if !is_terminated(r.bcx) {
             live += ~[r];
             vals += ~[r.val];
@@ -3407,14 +3407,14 @@ fn join_results(parent_cx: &@block_ctxt, t: TypeRef, ins: &[result]) ->
     // We have >1 incoming edges. Make a join block and br+phi them into it.
 
     let join_cx = new_sub_block_ctxt(parent_cx, "join");
-    for r: result  in live { r.bcx.build.Br(join_cx.llbb); }
+    for r: result in live { r.bcx.build.Br(join_cx.llbb); }
     let phi = join_cx.build.Phi(t, vals, bbs);
     ret rslt(join_cx, phi);
 }
 
 fn join_branches(parent_cx: &@block_ctxt, ins: &[result]) -> @block_ctxt {
     let out = new_sub_block_ctxt(parent_cx, "join");
-    for r: result  in ins {
+    for r: result in ins {
         if !is_terminated(r.bcx) { r.bcx.build.Br(out.llbb); }
     }
     ret out;
@@ -3571,7 +3571,7 @@ fn build_environment(bcx: @block_ctxt, lltydescs: [ValueRef],
         GEP_tup_like(bcx, closure_ty, closure,
                      ~[0, abi::closure_elt_bindings]);
     bcx = bindings.bcx;
-    for lv: lval_result  in bound_vals {
+    for lv: lval_result in bound_vals {
         let bound = GEP_tup_like(bcx, bindings_ty, bindings.val,
                                  ~[0, i as int]);
         bcx = bound.bcx;
@@ -3591,7 +3591,7 @@ fn build_environment(bcx: @block_ctxt, lltydescs: [ValueRef],
                      ~[0, abi::closure_elt_ty_params]);
     bcx = ty_params_slot.bcx;
     i = 0u;
-    for td: ValueRef  in lltydescs {
+    for td: ValueRef in lltydescs {
         let ty_param_slot = GEPi(bcx, ty_params_slot.val, ~[0, i as int]);
         bcx.build.Store(td, ty_param_slot);
         i += 1u;
@@ -3612,7 +3612,7 @@ fn build_closure(cx: &@block_ctxt, upvars: &@[ast::node_id], copying: bool)
             closure_tys += ~[option::get(cx.fcx.iterbodyty)];
         }
         // Package up the upvars
-        for nid: ast::node_id  in *upvars {
+        for nid: ast::node_id in *upvars {
             closure_vals += ~[trans_var(cx, cx.sp, nid)];
             let ty = ty::node_id_to_monotype(bcx_tcx(cx), nid);
             if !copying { ty = ty::mk_mut_ptr(bcx_tcx(cx), ty); }
@@ -3689,7 +3689,7 @@ fn load_environment(enclosing_cx: &@block_ctxt, fcx: &@fn_ctxt,
         i += 1u;
     }
     // Load the acutal upvars.
-    for upvar_id: ast::node_id  in *upvars {
+    for upvar_id: ast::node_id in *upvars {
         let upvarptr =
             GEP_tup_like(bcx, ty, llclosure, path + ~[i as int]);
         bcx = upvarptr.bcx;
@@ -3875,7 +3875,7 @@ fn lval_generic_fn(cx: &@block_ctxt, tpt: &ty::ty_param_kinds_and_ty,
         let bcx = lv.res.bcx;
         let tydescs: [ValueRef] = ~[];
         let tis: [option::t[@tydesc_info]] = ~[];
-        for t: ty::t  in tys {
+        for t: ty::t in tys {
             // TODO: Doesn't always escape.
 
             let ti = none[@tydesc_info];
@@ -4368,7 +4368,7 @@ fn trans_bind_thunk(cx: &@local_ctxt, sp: &span, incoming_fty: &ty::t,
     let outgoing_arg_index: uint = 0u;
     let llout_arg_tys: [TypeRef] =
         type_of_explicit_args(cx.ccx, sp, outgoing_args);
-    for arg: option::t[@ast::expr]  in args {
+    for arg: option::t[@ast::expr] in args {
         let out_arg = outgoing_args.(outgoing_arg_index);
         let llout_arg_ty = llout_arg_tys.(outgoing_arg_index);
         let is_val = out_arg.mode == ty::mo_val;
@@ -4452,7 +4452,7 @@ fn trans_bind_1(cx: &@block_ctxt, f: &@ast::expr, f_res: &lval_result,
                 args: &[option::t[@ast::expr]], id: ast::node_id) ->
    result {
     let bound: [@ast::expr] = ~[];
-    for argopt: option::t[@ast::expr]  in args {
+    for argopt: option::t[@ast::expr] in args {
         alt argopt { none. { } some(e) { bound += ~[e]; } }
     }
 
@@ -4487,7 +4487,7 @@ fn trans_bind_1(cx: &@block_ctxt, f: &@ast::expr, f_res: &lval_result,
     let bound_tys: [ty::t] = ~[outgoing_fty];
     let bound_vals: [lval_result] = ~[bound_f];
     // Translate the bound expressions.
-    for e: @ast::expr  in bound {
+    for e: @ast::expr in bound {
         let lv = trans_lval(bcx, e);
         bcx = lv.res.bcx;
         bound_vals += ~[lv];
@@ -4660,7 +4660,7 @@ fn trans_args(cx: &@block_ctxt, llenv: ValueRef,
     // to cast her view of the arguments to the caller's view.
     let arg_tys = type_of_explicit_args(bcx_ccx(cx), cx.sp, args);
     let i = 0u;
-    for e: @ast::expr  in es {
+    for e: @ast::expr in es {
         if bcx.build.is_terminated() {
             // This means an earlier arg was divergent.
             // So this arg can't be evaluated.
@@ -4816,7 +4816,7 @@ fn trans_vec(cx: &@block_ctxt, args: &[@ast::expr], id: ast::node_id) ->
                        std::ivec::init_elt[ty::t](unit_ty,
                                                   std::ivec::len(args)));
     let i: int = 0;
-    for e: @ast::expr  in args {
+    for e: @ast::expr in args {
         let src = trans_lval(bcx, e);
         bcx = src.res.bcx;
         let dst_res = GEP_tup_like(bcx, pseudo_tup_ty, body, ~[0, i]);
@@ -4924,7 +4924,7 @@ fn trans_ivec(bcx: @block_ctxt, args: &[@ast::expr], id: ast::node_id) ->
     // Store the individual elements.
 
     let i = 0u;
-    for e: @ast::expr  in args {
+    for e: @ast::expr in args {
         let lv = trans_lval(bcx, e);
         bcx = lv.res.bcx;
         let lleltptr;
@@ -4961,12 +4961,12 @@ fn trans_rec(cx: &@block_ctxt, fields: &[ast::field],
     }
     let ty_fields: [ty::field] = ~[];
     alt ty::struct(bcx_tcx(cx), t) { ty::ty_rec(flds) { ty_fields = flds; } }
-    for tf: ty::field  in ty_fields {
+    for tf: ty::field in ty_fields {
         let e_ty = tf.mt.ty;
         let dst_res = GEP_tup_like(bcx, t, rec_val, ~[0, i]);
         bcx = dst_res.bcx;
         let expr_provided = false;
-        for f: ast::field  in fields {
+        for f: ast::field in fields {
             if str::eq(f.node.ident, tf.ident) {
                 expr_provided = true;
                 let lv = trans_lval(bcx, f.node.expr);
@@ -5525,7 +5525,7 @@ fn trans_stmt(cx: &@block_ctxt, s: &ast::stmt) -> result {
       ast::stmt_decl(d, _) {
         alt d.node {
           ast::decl_local(locals) {
-            for local: @ast::local  in locals {
+            for local: @ast::local in locals {
                 bcx = init_local(bcx, local).bcx;
             }
           }
@@ -5624,7 +5624,7 @@ fn trans_block_cleanups(cx: &@block_ctxt, cleanup_cx: &@block_ctxt) ->
 iter block_locals(b: &ast::blk) -> @ast::local {
     // FIXME: putting from inside an iter block doesn't work, so we can't
     // use the index here.
-    for s: @ast::stmt  in b.node.stmts {
+    for s: @ast::stmt in b.node.stmts {
         alt s.node {
           ast::stmt_decl(d, _) {
             alt d.node {
@@ -5725,7 +5725,7 @@ fn trans_block(cx: &@block_ctxt, b: &ast::blk, output: &out_method) ->
         bcx.fcx.lllocals.insert(local.node.id, r.val);
     }
     let r = rslt(bcx, C_nil());
-    for s: @ast::stmt  in b.node.stmts {
+    for s: @ast::stmt in b.node.stmts {
         r = trans_stmt(bcx, *s);
         bcx = r.bcx;
 
@@ -5868,7 +5868,7 @@ fn create_llargs_for_fn_args(cx: &@fn_ctxt, proto: ast::proto,
       some(tt) { cx.llself = some[val_self_pair]({v: cx.llenv, t: tt}); }
       none. {
         let i = 0u;
-        for tp: ast::ty_param  in ty_params {
+        for tp: ast::ty_param in ty_params {
             let llarg = llvm::LLVMGetParam(cx.llfn, arg_n);
             assert (llarg as int != 0);
             cx.lltydescs += ~[llarg];
@@ -5891,7 +5891,7 @@ fn create_llargs_for_fn_args(cx: &@fn_ctxt, proto: ast::proto,
 
     // Populate the llargs field of the function context with the ValueRefs
     // that we get from llvm::LLVMGetParam for each argument.
-    for arg: ast::arg  in args {
+    for arg: ast::arg in args {
         let llarg = llvm::LLVMGetParam(cx.llfn, arg_n);
         assert (llarg as int != 0);
         cx.llargs.insert(arg.id, llarg);
@@ -5903,7 +5903,7 @@ fn copy_args_to_allocas(fcx: @fn_ctxt, args: &[ast::arg],
                         arg_tys: &[ty::arg]) {
     let bcx = new_raw_block_ctxt(fcx, fcx.llcopyargs);
     let arg_n: uint = 0u;
-    for aarg: ast::arg  in args {
+    for aarg: ast::arg in args {
         if aarg.mode == ast::val {
             let argval;
             alt bcx.fcx.llargs.find(aarg.id) {
@@ -5925,7 +5925,7 @@ fn copy_args_to_allocas(fcx: @fn_ctxt, args: &[ast::arg],
 fn add_cleanups_for_args(bcx: &@block_ctxt, args: &[ast::arg],
                          arg_tys: &[ty::arg]) {
     let arg_n: uint = 0u;
-    for aarg: ast::arg  in args {
+    for aarg: ast::arg in args {
         if aarg.mode == ast::val || aarg.mode == ast::move {
             let argval;
             alt bcx.fcx.llargs.find(aarg.id) {
@@ -5955,7 +5955,7 @@ fn arg_tys_of_fn(ccx: &@crate_ctxt, id: ast::node_id) -> [ty::arg] {
 fn populate_fn_ctxt_from_llself(fcx: @fn_ctxt, llself: val_self_pair) {
     let bcx = llstaticallocas_block_ctxt(fcx);
     let field_tys: [ty::t] = ~[];
-    for f: ast::obj_field  in bcx.fcx.lcx.obj_fields {
+    for f: ast::obj_field in bcx.fcx.lcx.obj_fields {
         field_tys += ~[node_id_type(bcx_ccx(bcx), f.id)];
     }
     // Synthesize a tuple type for the fields so that GEP_tup_like() can work
@@ -5986,7 +5986,7 @@ fn populate_fn_ctxt_from_llself(fcx: @fn_ctxt, llself: val_self_pair) {
         obj_fields = vi2p(bcx, obj_fields, T_ptr(llfields_ty));
     } else { obj_fields = vi2p(bcx, obj_fields, T_ptr(T_i8())); }
     let i: int = 0;
-    for p: ast::ty_param  in fcx.lcx.obj_typarams {
+    for p: ast::ty_param in fcx.lcx.obj_typarams {
         let lltyparam: ValueRef =
             bcx.build.GEP(obj_typarams, ~[C_int(0), C_int(i)]);
         lltyparam = bcx.build.Load(lltyparam);
@@ -5994,7 +5994,7 @@ fn populate_fn_ctxt_from_llself(fcx: @fn_ctxt, llself: val_self_pair) {
         i += 1;
     }
     i = 0;
-    for f: ast::obj_field  in fcx.lcx.obj_fields {
+    for f: ast::obj_field in fcx.lcx.obj_fields {
         let rslt = GEP_tup_like(bcx, fields_tup_ty, obj_fields, ~[0, i]);
         bcx = llstaticallocas_block_ctxt(fcx);
         let llfield = rslt.val;
@@ -6166,7 +6166,7 @@ fn trans_tag_variant(cx: @local_ctxt, tag_id: ast::node_id,
 
     let fn_args: [ast::arg] = ~[];
     let i = 0u;
-    for varg: ast::variant_arg  in variant.node.args {
+    for varg: ast::variant_arg in variant.node.args {
         fn_args +=
             ~[{mode: ast::alias(false),
                ty: varg.ty,
@@ -6188,7 +6188,7 @@ fn trans_tag_variant(cx: @local_ctxt, tag_id: ast::node_id,
                               fn_args, ty_params);
     let ty_param_substs: [ty::t] = ~[];
     i = 0u;
-    for tp: ast::ty_param  in ty_params {
+    for tp: ast::ty_param in ty_params {
         ty_param_substs += ~[ty::mk_param(cx.ccx.tcx, i, tp.kind)];
         i += 1u;
     }
@@ -6210,7 +6210,7 @@ fn trans_tag_variant(cx: @local_ctxt, tag_id: ast::node_id,
             bcx.build.GEP(lltagptr, ~[C_int(0), C_int(1)])
         };
     i = 0u;
-    for va: ast::variant_arg  in variant.node.args {
+    for va: ast::variant_arg in variant.node.args {
         let rslt =
             GEP_tag(bcx, llblobptr, ast::local_def(tag_id),
                     ast::local_def(variant.node.id), ty_param_substs,
@@ -6313,7 +6313,7 @@ fn trans_item(cx: @local_ctxt, item: &ast::item) {
         let sub_cx = extend_path(cx, item.ident);
         let degen = std::ivec::len(variants) == 1u;
         let i = 0;
-        for variant: ast::variant  in variants {
+        for variant: ast::variant in variants {
             trans_tag_variant(sub_cx, item.id, variant, i, degen, tps);
             i += 1;
         }
@@ -6330,7 +6330,7 @@ fn trans_item(cx: @local_ctxt, item: &ast::item) {
 // only as a convenience for humans working with the code, to organize names
 // and control visibility.
 fn trans_mod(cx: @local_ctxt, m: &ast::_mod) {
-    for item: @ast::item  in m.items { trans_item(cx, *item); }
+    for item: @ast::item in m.items { trans_item(cx, *item); }
 }
 
 fn get_pair_fn_ty(llpairty: TypeRef) -> TypeRef {
@@ -6525,7 +6525,7 @@ fn decl_native_fn_and_pair(ccx: &@crate_ctxt, sp: &span, path: &[str],
     if uses_retptr { call_args += ~[bcx.fcx.llretptr]; }
 
     let arg_n = 3u;
-    for each i: uint  in uint::range(0u, num_ty_param) {
+    for each i: uint in uint::range(0u, num_ty_param) {
         let llarg = llvm::LLVMGetParam(fcx.llfn, arg_n);
         fcx.lltydescs += ~[llarg];
         assert (llarg as int != 0);
@@ -6558,7 +6558,7 @@ fn decl_native_fn_and_pair(ccx: &@crate_ctxt, sp: &span, path: &[str],
                                first_arg_n: uint, uses_retptr: bool, cc: uint)
        -> {val: ValueRef, rptr: ValueRef} {
         let call_arg_tys: [TypeRef] = ~[];
-        for arg: ValueRef  in call_args { call_arg_tys += ~[val_ty(arg)]; }
+        for arg: ValueRef in call_args { call_arg_tys += ~[val_ty(arg)]; }
 
         let llnativefnty;
         if uses_retptr {
@@ -6586,7 +6586,7 @@ fn decl_native_fn_and_pair(ccx: &@crate_ctxt, sp: &span, path: &[str],
 
     let drop_args: [{val: ValueRef, ty: ty::t}] = ~[];
     let i = arg_n;
-    for arg: ty::arg  in args {
+    for arg: ty::arg in args {
         let llarg = llvm::LLVMGetParam(fcx.llfn, i);
         assert (llarg as int != 0);
         if cast_to_i32 {
@@ -6638,7 +6638,7 @@ fn decl_native_fn_and_pair(ccx: &@crate_ctxt, sp: &span, path: &[str],
 
     if !rty_is_nil && !uses_retptr { bcx.build.Store(r, rptr); }
 
-    for d: {val: ValueRef, ty: ty::t}  in drop_args {
+    for d: {val: ValueRef, ty: ty::t} in drop_args {
         bcx = drop_ty(bcx, d.val, d.ty).bcx;
     }
     bcx.build.RetVoid();
@@ -6690,7 +6690,7 @@ fn collect_item_2(ccx: &@crate_ctxt, i: &@ast::item, pt: &[str],
       }
       ast::item_obj(ob, tps, ctor_id) {
         decl_fn_and_pair(ccx, i.span, new_pt, "obj_ctor", tps, ctor_id);
-        for m: @ast::method  in ob.methods {
+        for m: @ast::method in ob.methods {
             ccx.obj_methods.insert(m.node.id, ());
         }
       }
@@ -6724,7 +6724,7 @@ fn collect_tag_ctor(ccx: @crate_ctxt, i: &@ast::item, pt: &[str],
     visit::visit_item(i, new_pt, v);
     alt i.node {
       ast::item_tag(variants, tps) {
-        for variant: ast::variant  in variants {
+        for variant: ast::variant in variants {
             if std::ivec::len(variant.node.args) != 0u {
                 decl_fn_and_pair(ccx, i.span, new_pt + ~[variant.node.name],
                                  "tag", tps, variant.node.id);
@@ -6891,7 +6891,7 @@ fn create_module_map(ccx: &@crate_ctxt) -> ValueRef {
     llvm::LLVMSetLinkage(map,
                          lib::llvm::LLVMInternalLinkage as llvm::Linkage);
     let elts: [ValueRef] = ~[];
-    for each item: @{key: str, val: ValueRef}  in ccx.module_data.items() {
+    for each item: @{key: str, val: ValueRef} in ccx.module_data.items() {
         let elt = C_struct(~[p2i(C_cstr(ccx, item.key)), p2i(item.val)]);
         elts += ~[elt];
     }
@@ -7040,7 +7040,7 @@ fn trans_crate(sess: &session::session, crate: &@ast::crate, tcx: &ty::ctxt,
         log_err #fmt("n_real_glues: %u", ccx.stats.n_real_glues);
 
 
-        for timing: {ident: str, time: int}  in *ccx.stats.fn_times {
+        for timing: {ident: str, time: int} in *ccx.stats.fn_times {
             log_err #fmt("time: %s took %d ms", timing.ident, timing.time);
         }
     }
diff --git a/src/comp/middle/trans_alt.rs b/src/comp/middle/trans_alt.rs
index 015e515c834a..5f770b21ca89 100644
--- a/src/comp/middle/trans_alt.rs
+++ b/src/comp/middle/trans_alt.rs
@@ -47,7 +47,7 @@ fn variant_opt(ccx: &@crate_ctxt, pat_id: ast::node_id) -> opt {
     let vdef = ast::variant_def_ids(ccx.tcx.def_map.get(pat_id));
     let variants = ty::tag_variants(ccx.tcx, vdef.tg);
     let i = 0u;
-    for v: ty::variant_info  in variants {
+    for v: ty::variant_info in variants {
         if vdef.var == v.id { ret var(i, vdef); }
         i += 1u;
     }
@@ -81,7 +81,7 @@ type enter_pat = fn(&@ast::pat) -> option::t[[@ast::pat]] ;
 
 fn enter_match(m: &match, col: uint, val: ValueRef, e: &enter_pat) -> match {
     let result = ~[];
-    for br: match_branch  in m {
+    for br: match_branch in m {
         alt e(br.pats.(col)) {
           some(sub) {
             let pats =
@@ -132,9 +132,9 @@ fn enter_rec(m: &match, col: uint, fields: &[ast::ident], val: ValueRef) ->
         alt p.node {
           ast::pat_rec(fpats, _) {
             let pats = ~[];
-            for fname: ast::ident  in fields {
+            for fname: ast::ident in fields {
                 let pat = dummy;
-                for fpat: ast::field_pat  in fpats {
+                for fpat: ast::field_pat in fpats {
                     if str::eq(fpat.ident, fname) { pat = fpat.pat; break; }
                 }
                 pats += ~[pat];
@@ -172,12 +172,12 @@ fn enter_box(m: &match, col: uint, val: ValueRef) -> match {
 
 fn get_options(ccx: &@crate_ctxt, m: &match, col: uint) -> [opt] {
     fn add_to_set(set: &mutable [opt], val: &opt) {
-        for l: opt  in set { if opt_eq(l, val) { ret; } }
+        for l: opt in set { if opt_eq(l, val) { ret; } }
         set += ~[val];
     }
 
     let found = ~[];
-    for br: match_branch  in m {
+    for br: match_branch in m {
         alt br.pats.(col).node {
           ast::pat_lit(l) { add_to_set(found, lit(l)); }
           ast::pat_tag(_, _) {
@@ -219,10 +219,10 @@ fn extract_variant_args(bcx: @block_ctxt, pat_id: ast::node_id,
 
 fn collect_record_fields(m: &match, col: uint) -> [ast::ident] {
     let fields = ~[];
-    for br: match_branch  in m {
+    for br: match_branch in m {
         alt br.pats.(col).node {
           ast::pat_rec(fs, _) {
-            for f: ast::field_pat  in fs {
+            for f: ast::field_pat in fs {
                 if !ivec::any(bind str::eq(f.ident, _), fields) {
                     fields += ~[f.ident];
                 }
@@ -235,7 +235,7 @@ fn collect_record_fields(m: &match, col: uint) -> [ast::ident] {
 }
 
 fn any_box_pat(m: &match, col: uint) -> bool {
-    for br: match_branch  in m {
+    for br: match_branch in m {
         alt br.pats.(col).node { ast::pat_box(_) { ret true; } _ { } }
     }
     ret false;
@@ -296,7 +296,7 @@ fn compile_submatch(bcx: @block_ctxt, m: &match, vals: [ValueRef],
         ivec::slice(vals, col + 1u, ivec::len(vals));
     let ccx = bcx.fcx.lcx.ccx;
     let pat_id = 0;
-    for br: match_branch  in m {
+    for br: match_branch in m {
         // Find a real id (we're adding placeholder wildcard patterns, but
         // each column is guaranteed to have at least one real pattern)
         if pat_id == 0 { pat_id = br.pats.(col).id; }
@@ -385,7 +385,7 @@ fn compile_submatch(bcx: @block_ctxt, m: &match, vals: [ValueRef],
         } else { C_int(0) }; // Placeholder for when not using a switch
 
      // Compile subtrees for each option
-    for opt: opt  in opts {
+    for opt: opt in opts {
         let opt_cx = new_sub_block_ctxt(bcx, "match_case");
         alt kind {
           single. { bcx.build.Br(opt_cx.llbb); }
@@ -432,7 +432,7 @@ fn compile_submatch(bcx: @block_ctxt, m: &match, vals: [ValueRef],
 fn make_phi_bindings(bcx: &@block_ctxt, map: &[exit_node],
                      ids: &ast::pat_id_map) -> bool {
     fn assoc(key: str, list: &bind_map) -> option::t[ValueRef] {
-        for elt: {ident: ast::ident, val: ValueRef}  in list {
+        for elt: {ident: ast::ident, val: ValueRef} in list {
             if str::eq(elt.ident, key) { ret some(elt.val); }
         }
         ret none;
@@ -440,10 +440,10 @@ fn make_phi_bindings(bcx: &@block_ctxt, map: &[exit_node],
 
     let our_block = bcx.llbb as uint;
     let success = true;
-    for each item: @{key: ast::ident, val: ast::node_id}  in ids.items() {
+    for each item: @{key: ast::ident, val: ast::node_id} in ids.items() {
         let llbbs = ~[];
         let vals = ~[];
-        for ex: exit_node  in map {
+        for ex: exit_node in map {
             if ex.to as uint == our_block {
                 alt assoc(item.key, ex.bound) {
                   some(val) { llbbs += ~[ex.from]; vals += ~[val]; }
@@ -475,10 +475,10 @@ fn trans_alt(cx: &@block_ctxt, expr: &@ast::expr, arms: &[ast::arm],
         }
     }
 
-    for a: ast::arm  in arms {
+    for a: ast::arm in arms {
         let body = new_scope_block_ctxt(cx, "case_body");
         bodies += ~[body];
-        for p: @ast::pat  in a.pats {
+        for p: @ast::pat in a.pats {
             match += ~[@{pats: ~[p], body: body.llbb, mutable bound: ~[]}];
         }
     }
@@ -502,7 +502,7 @@ fn trans_alt(cx: &@block_ctxt, expr: &@ast::expr, arms: &[ast::arm],
 
     let i = 0u;
     let arm_results = ~[];
-    for a: ast::arm  in arms {
+    for a: ast::arm in arms {
         let body_cx = bodies.(i);
         if make_phi_bindings(body_cx, exit_map, ast::pat_id_map(a.pats.(0))) {
             let block_res = trans::trans_block(body_cx, a.body, output);
diff --git a/src/comp/middle/trans_comm.rs b/src/comp/middle/trans_comm.rs
index 019461b0fc76..c0a4e15ed8b4 100644
--- a/src/comp/middle/trans_comm.rs
+++ b/src/comp/middle/trans_comm.rs
@@ -109,7 +109,7 @@ fn trans_spawn(cx: &@block_ctxt, dom: &ast::spawn_dom, name: &option::t[str],
 
     let arg_tys: [ty::t] = ~[];
     let arg_vals: [ValueRef] = ~[];
-    for e: @ast::expr  in args {
+    for e: @ast::expr in args {
         let e_ty = ty::expr_ty(cx.fcx.lcx.ccx.tcx, e);
         let arg = trans_expr(bcx, e);
 
@@ -127,7 +127,7 @@ fn trans_spawn(cx: &@block_ctxt, dom: &ast::spawn_dom, name: &option::t[str],
 
     let llargs = alloc_ty(bcx, args_ty);
     let i = 0u;
-    for v: ValueRef  in arg_vals {
+    for v: ValueRef in arg_vals {
         let target = bcx.build.GEP(llargs.val, ~[C_int(0), C_int(i as int)]);
 
         bcx.build.Store(v, target);
diff --git a/src/comp/middle/trans_common.rs b/src/comp/middle/trans_common.rs
index e00680270428..0361535f3709 100644
--- a/src/comp/middle/trans_common.rs
+++ b/src/comp/middle/trans_common.rs
@@ -298,7 +298,7 @@ fn revoke_clean(cx: &@block_ctxt, val: ValueRef) {
     let sc_cx = find_scope_cx(cx);
     let found = -1;
     let i = 0;
-    for c: cleanup  in sc_cx.cleanups {
+    for c: cleanup in sc_cx.cleanups {
         alt c {
           clean_temp(v, _) {
             if v as uint == val as uint { found = i; break; }
diff --git a/src/comp/middle/trans_dps.rs b/src/comp/middle/trans_dps.rs
index 1aef9947925a..d5020d1fe41c 100644
--- a/src/comp/middle/trans_dps.rs
+++ b/src/comp/middle/trans_dps.rs
@@ -416,11 +416,11 @@ fn trans_recv(bcx: &@block_ctxt, dest: &dest, expr: &@ast::expr) ->
 
 fn trans_block(cx: &@block_ctxt, dest: &dest, blk: &ast::blk) -> @block_ctxt {
     let bcx = cx;
-    for each local: @ast::local  in trans::block_locals(blk) {
+    for each local: @ast::local in trans::block_locals(blk) {
         bcx = trans::alloc_local(bcx, local).bcx;
     }
 
-    for stmt: @ast::stmt  in blk.node.stmts {
+    for stmt: @ast::stmt in blk.node.stmts {
         bcx = trans_stmt(bcx, stmt);
 
 
@@ -456,7 +456,7 @@ fn trans_lit_str_common(ccx: &@crate_ctxt, s: &str, expand: bool) ->
     let len = str::byte_len(s);
 
     let array = ~[];
-    for ch: u8  in s { array += ~[tc::C_u8(ch as uint)]; }
+    for ch: u8 in s { array += ~[tc::C_u8(ch as uint)]; }
     array += ~[tc::C_u8(0u)];
 
     if expand {
@@ -567,7 +567,7 @@ fn trans_stmt(cx: &@block_ctxt, stmt: &@ast::stmt) -> @block_ctxt {
       ast::stmt_decl(d, _) {
         alt d.node {
           ast::decl_local(locals) {
-            for local: @ast::local  in locals {
+            for local: @ast::local in locals {
                 bcx = trans_init_local(bcx, local);
             }
           }
diff --git a/src/comp/middle/trans_objects.rs b/src/comp/middle/trans_objects.rs
index 00134f784f2f..1e9726e9001a 100644
--- a/src/comp/middle/trans_objects.rs
+++ b/src/comp/middle/trans_objects.rs
@@ -44,7 +44,7 @@ fn trans_obj(cx: @local_ctxt, sp: &span, ob: &ast::_obj,
     // The fields of our object will become the arguments to the function
     // we're creating.
     let fn_args: [ast::arg] = ~[];
-    for f: ast::obj_field  in ob.fields {
+    for f: ast::obj_field in ob.fields {
         fn_args +=
             ~[{mode: ast::alias(false), ty: f.ty, ident: f.ident, id: f.id}];
     }
@@ -104,11 +104,11 @@ fn trans_obj(cx: @local_ctxt, sp: &span, ob: &ast::_obj,
         bcx.build.Store(C_null(llbox_ty), pair_box);
     } else {
         let obj_fields: [ty::t] = ~[];
-        for a: ty::arg  in arg_tys { obj_fields += ~[a.ty]; }
+        for a: ty::arg in arg_tys { obj_fields += ~[a.ty]; }
 
         let tps: [ty::t] = ~[];
         let tydesc_ty = ty::mk_type(ccx.tcx);
-        for tp: ast::ty_param  in ty_params { tps += ~[tydesc_ty]; }
+        for tp: ast::ty_param in ty_params { tps += ~[tydesc_ty]; }
 
         // Synthesize an object body type and hand it off to
         // trans_malloc_boxed, which allocates a box, including space for a
@@ -154,7 +154,7 @@ fn trans_obj(cx: @local_ctxt, sp: &span, ob: &ast::_obj,
         // TODO: can we just get typarams_ty out of body_ty instead?
         let typarams_ty: ty::t = ty::mk_tup(ccx.tcx, tps);
         let i: int = 0;
-        for tp: ast::ty_param  in ty_params {
+        for tp: ast::ty_param in ty_params {
             let typaram = bcx.fcx.lltydescs.(i);
             let capture =
                 GEP_tup_like(bcx, typarams_ty, body_typarams.val, ~[0, i]);
@@ -169,7 +169,7 @@ fn trans_obj(cx: @local_ctxt, sp: &span, ob: &ast::_obj,
                          ~[0, abi::obj_body_elt_fields]);
         bcx = body_fields.bcx;
         i = 0;
-        for f: ast::obj_field  in ob.fields {
+        for f: ast::obj_field in ob.fields {
             alt bcx.fcx.llargs.find(f.id) {
               some(arg1) {
                 let arg = load_if_immediate(bcx, arg1, arg_tys.(i).ty);
@@ -217,7 +217,7 @@ fn trans_anon_obj(bcx: @block_ctxt, sp: &span, anon_obj: &ast::anon_obj,
       none. { }
       some(fields) {
         additional_fields = fields;
-        for f: ast::anon_obj_field  in fields {
+        for f: ast::anon_obj_field in fields {
             additional_field_tys += ~[node_id_type(ccx, f.id)];
             additional_field_vals += ~[trans_expr(bcx, f.expr)];
         }
@@ -342,7 +342,7 @@ fn trans_anon_obj(bcx: @block_ctxt, sp: &span, anon_obj: &ast::anon_obj,
                          ~[0, abi::obj_body_elt_fields]);
         bcx = body_fields.bcx;
         let i: int = 0;
-        for f: ast::anon_obj_field  in additional_fields {
+        for f: ast::anon_obj_field in additional_fields {
             // FIXME (part of issue #538): make this work eventually, when we
             // have additional field exprs in the AST.
             load_if_immediate(bcx, additional_field_vals.(i).val,
@@ -483,7 +483,7 @@ fn create_vtbl(cx: @local_ctxt, sp: &span, outer_obj_ty: ty::t,
         // Gather up methods on the inner object.
         alt ty::struct(cx.ccx.tcx, inner_obj_ty) {
           ty::ty_obj(inner_obj_methods) {
-            for m: ty::method  in inner_obj_methods {
+            for m: ty::method in inner_obj_methods {
                 meths += ~[fwding_mthd(@m)];
             }
           }
@@ -699,7 +699,7 @@ fn process_bkwding_mthd(cx: @local_ctxt, sp: &span, m: @ty::method,
 
     let a: uint = 3u; // retptr, task ptr, env come first
     let passed_arg: ValueRef = llvm::LLVMGetParam(llbackwarding_fn, a);
-    for arg: ty::arg  in m.inputs {
+    for arg: ty::arg in m.inputs {
         if arg.mode == ty::mo_val {
             passed_arg = load_if_immediate(bcx, passed_arg, arg.ty);
         }
@@ -871,7 +871,7 @@ fn process_fwding_mthd(cx: @local_ctxt, sp: &span, m: @ty::method,
 
     let a: uint = 3u; // retptr, task ptr, env come first
     let passed_arg: ValueRef = llvm::LLVMGetParam(llforwarding_fn, a);
-    for arg: ty::arg  in m.inputs {
+    for arg: ty::arg in m.inputs {
         if arg.mode == ty::mo_val {
             passed_arg = load_if_immediate(bcx, passed_arg, arg.ty);
         }
diff --git a/src/comp/middle/tstate/annotate.rs b/src/comp/middle/tstate/annotate.rs
index 4c50f5780c0f..1d9fa0563637 100644
--- a/src/comp/middle/tstate/annotate.rs
+++ b/src/comp/middle/tstate/annotate.rs
@@ -59,7 +59,7 @@ fn node_ids_in_fn(f: &_fn, tps: &[ty_param], sp: &span, i: &fn_ident,
 }
 
 fn init_vecs(ccx: &crate_ctxt, node_ids: &[node_id], len: uint) {
-    for i: node_id  in node_ids {
+    for i: node_id in node_ids {
         log int::str(i) + " |-> " + uint::str(len);
         add_node(ccx, i, empty_ann(len));
     }
diff --git a/src/comp/middle/tstate/auxiliary.rs b/src/comp/middle/tstate/auxiliary.rs
index 10b5f9605302..52600781ed2b 100644
--- a/src/comp/middle/tstate/auxiliary.rs
+++ b/src/comp/middle/tstate/auxiliary.rs
@@ -61,7 +61,7 @@ fn def_id_to_str(d: def_id) -> str {
 fn comma_str(args: &[@constr_arg_use]) -> str {
     let rslt = "";
     let comma = false;
-    for a: @constr_arg_use  in args {
+    for a: @constr_arg_use in args {
         if comma { rslt += ", "; } else { comma = true; }
         alt a.node {
           carg_base. { rslt += "*"; }
@@ -87,7 +87,7 @@ fn constraint_to_str(tcx: &ty::ctxt, c: &sp_constr) -> str {
 fn tritv_to_str(fcx: fn_ctxt, v: &tritv::t) -> str {
     let s = "";
     let comma = false;
-    for p: norm_constraint  in constraints(fcx) {
+    for p: norm_constraint in constraints(fcx) {
         alt tritv_get(v, p.bit_num) {
           dont_care. { }
           t {
@@ -106,7 +106,7 @@ fn log_tritv(fcx: &fn_ctxt, v: &tritv::t) { log tritv_to_str(fcx, v); }
 fn first_difference_string(fcx: &fn_ctxt, expected: &tritv::t,
                            actual: &tritv::t) -> str {
     let s: str = "";
-    for c: norm_constraint  in constraints(fcx) {
+    for c: norm_constraint in constraints(fcx) {
         if tritv_get(expected, c.bit_num) == ttrue &&
                tritv_get(actual, c.bit_num) != ttrue {
             ret constraint_to_str(fcx.ccx.tcx, c.c);
@@ -119,7 +119,7 @@ fn log_tritv_err(fcx: fn_ctxt, v: tritv::t) { log_err tritv_to_str(fcx, v); }
 
 fn tos(v: &[uint]) -> str {
     let rslt = "";
-    for i: uint  in v {
+    for i: uint in v {
         if i == 0u {
             rslt += "0";
         } else if (i == 1u) { rslt += "1"; } else { rslt += "?"; }
@@ -561,7 +561,7 @@ fn norm_a_constraint(id: def_id, c: &constraint) -> [norm_constraint] {
       }
       cpred(p, descs) {
         let rslt: [norm_constraint] = ~[];
-        for pd: pred_args  in *descs {
+        for pd: pred_args in *descs {
             rslt +=
                 ~[{bit_num: pd.node.bit_num,
                    c: respan(pd.span, npred(p, id, pd.node.args))}];
@@ -590,7 +590,7 @@ fn match_args(fcx: &fn_ctxt, occs: &@mutable [pred_args],
               occ: &[@constr_arg_use]) -> uint {
     log "match_args: looking at " +
             constr_args_to_str(fn (i: &inst) -> str { ret i.ident; }, occ);
-    for pd: pred_args  in *occs {
+    for pd: pred_args in *occs {
         log "match_args: candidate " + pred_args_to_str(pd);
         fn eq(p: &inst, q: &inst) -> bool { ret p.node == q.node; }
         if ty::args_eq(eq, pd.node.args, occ) { ret pd.node.bit_num; }
@@ -642,7 +642,7 @@ fn exprs_to_constr_args(tcx: ty::ctxt, args: &[@expr]) ->
    [@constr_arg_use] {
     let f = bind expr_to_constr_arg(tcx, _);
     let rslt: [@constr_arg_use] = ~[];
-    for e: @expr  in args { rslt += ~[f(e)]; }
+    for e: @expr in args { rslt += ~[f(e)]; }
     rslt
 }
 
@@ -682,7 +682,7 @@ fn pred_args_to_str(p: &pred_args) -> str {
 fn substitute_constr_args(cx: &ty::ctxt, actuals: &[@expr], c: &@ty::constr)
    -> tsconstr {
     let rslt: [@constr_arg_use] = ~[];
-    for a: @constr_arg  in c.node.args {
+    for a: @constr_arg in c.node.args {
         rslt += ~[substitute_arg(cx, actuals, a)];
     }
     ret npred(c.node.path, c.node.id, rslt);
@@ -707,7 +707,7 @@ fn substitute_arg(cx: &ty::ctxt, actuals: &[@expr], a: @constr_arg) ->
 fn pred_args_matches(pattern: &[constr_arg_general_[inst]],
                      desc: &pred_args) -> bool {
     let i = 0u;
-    for c: @constr_arg_use  in desc.node.args {
+    for c: @constr_arg_use in desc.node.args {
         let n = pattern.(i);
         alt c.node {
           carg_ident(p) {
@@ -731,7 +731,7 @@ fn pred_args_matches(pattern: &[constr_arg_general_[inst]],
 
 fn find_instance_(pattern: &[constr_arg_general_[inst]],
                   descs: &[pred_args]) -> option::t[uint] {
-    for d: pred_args  in descs {
+    for d: pred_args in descs {
         if pred_args_matches(pattern, d) { ret some(d.node.bit_num); }
     }
     ret none;
@@ -749,7 +749,7 @@ fn find_instances(fcx: &fn_ctxt, subst: &subst, c: &constraint) ->
     alt c {
       cinit(_, _, _) {/* this is dealt with separately */ }
       cpred(p, descs) {
-        for d: pred_args  in *descs {
+        for d: pred_args in *descs {
             if args_mention(d.node.args, find_in_subst_bool, subst) {
                 let old_bit_num = d.node.bit_num;
                 let new = replace(subst, d);
@@ -765,7 +765,7 @@ fn find_instances(fcx: &fn_ctxt, subst: &subst, c: &constraint) ->
 }
 
 fn find_in_subst(id: node_id, s: &subst) -> option::t[inst] {
-    for p: {from: inst, to: inst}  in s {
+    for p: {from: inst, to: inst} in s {
         if id == p.from.node { ret some(p.to); }
     }
     ret none;
@@ -777,7 +777,7 @@ fn find_in_subst_bool(s: &subst, id: node_id) -> bool {
 
 fn insts_to_str(stuff: &[constr_arg_general_[inst]]) -> str {
     let rslt = "<";
-    for i: constr_arg_general_[inst]  in stuff {
+    for i: constr_arg_general_[inst] in stuff {
         rslt +=
             " " +
                 alt i {
@@ -792,7 +792,7 @@ fn insts_to_str(stuff: &[constr_arg_general_[inst]]) -> str {
 
 fn replace(subst: subst, d: pred_args) -> [constr_arg_general_[inst]] {
     let rslt: [constr_arg_general_[inst]] = ~[];
-    for c: @constr_arg_use  in d.node.args {
+    for c: @constr_arg_use in d.node.args {
         alt c.node {
           carg_ident(p) {
             alt find_in_subst(p.node, subst) {
@@ -906,7 +906,7 @@ fn copy_in_poststate_two(fcx: &fn_ctxt, src_post: &poststate,
         // replace any occurrences of the src def_id with the
         // dest def_id
         let insts = find_instances(fcx, subst, p.val);
-        for p: {from: uint, to: uint}  in insts {
+        for p: {from: uint, to: uint} in insts {
             if promises_(p.from, src_post) {
                 set_in_poststate_(p.to, target_post);
             }
@@ -922,7 +922,7 @@ fn forget_in_postcond(fcx: &fn_ctxt, parent_exp: node_id, dead_v: node_id) {
     let d = local_node_id_to_local_def_id(fcx, dead_v);
     alt d {
       some(d_id) {
-        for c: norm_constraint  in constraints(fcx) {
+        for c: norm_constraint in constraints(fcx) {
             if constraint_mentions(fcx, c, d_id) {
                 clear_in_postcond(c.bit_num,
                                   node_id_to_ts_ann(fcx.ccx,
@@ -941,7 +941,7 @@ fn forget_in_postcond_still_init(fcx: &fn_ctxt, parent_exp: node_id,
     let d = local_node_id_to_local_def_id(fcx, dead_v);
     alt d {
       some(d_id) {
-        for c: norm_constraint  in constraints(fcx) {
+        for c: norm_constraint in constraints(fcx) {
             if non_init_constraint_mentions(fcx, c, d_id) {
                 clear_in_postcond(c.bit_num,
                                   node_id_to_ts_ann(fcx.ccx,
@@ -961,7 +961,7 @@ fn forget_in_poststate(fcx: &fn_ctxt, p: &poststate, dead_v: node_id) ->
     let changed = false;
     alt d {
       some(d_id) {
-        for c: norm_constraint  in constraints(fcx) {
+        for c: norm_constraint in constraints(fcx) {
             if constraint_mentions(fcx, c, d_id) {
                 changed |= clear_in_poststate_(c.bit_num, p);
             }
@@ -980,7 +980,7 @@ fn forget_in_poststate_still_init(fcx: &fn_ctxt, p: &poststate,
     let changed = false;
     alt d {
       some(d_id) {
-        for c: norm_constraint  in constraints(fcx) {
+        for c: norm_constraint in constraints(fcx) {
             if non_init_constraint_mentions(fcx, c, d_id) {
                 changed |= clear_in_poststate_(c.bit_num, p);
             }
@@ -992,7 +992,7 @@ fn forget_in_poststate_still_init(fcx: &fn_ctxt, p: &poststate,
 }
 
 fn any_eq(v: &[node_id], d: node_id) -> bool {
-    for i: node_id  in v { if i == d { ret true; } }
+    for i: node_id in v { if i == d { ret true; } }
     false
 }
 
@@ -1032,7 +1032,7 @@ fn args_mention[T](args: &[@constr_arg_use], q: fn(&[T], node_id) -> bool ,
     ret ivec::any(bind mentions(s,q,_), args);
     */
 
-    for a: @constr_arg_use  in args {
+    for a: @constr_arg_use in args {
         alt a.node { carg_ident(p1) { if q(s, p1.node) { ret true; } } _ { } }
     }
     ret false;
@@ -1042,7 +1042,7 @@ fn use_var(fcx: &fn_ctxt, v: &node_id) { *fcx.enclosing.used_vars += ~[v]; }
 
 // FIXME: This should be a function in std::ivec::.
 fn vec_contains(v: &@mutable [node_id], i: &node_id) -> bool {
-    for d: node_id  in *v { if d == i { ret true; } }
+    for d: node_id in *v { if d == i { ret true; } }
     ret false;
 }
 
@@ -1058,7 +1058,7 @@ fn do_nothing[T](f: &_fn, tp: &[ty_param], sp: &span, i: &fn_ident,
 
 fn args_to_constr_args(sp: &span, args: &[arg]) -> [@constr_arg_use] {
     let actuals: [@constr_arg_use] = ~[];
-    for a: arg  in args {
+    for a: arg in args {
         actuals += ~[@respan(sp, carg_ident({ident: a.ident, node: a.id}))];
     }
     ret actuals;
diff --git a/src/comp/middle/tstate/bitvectors.rs b/src/comp/middle/tstate/bitvectors.rs
index 3f4a80c01c39..25e5a27abd88 100644
--- a/src/comp/middle/tstate/bitvectors.rs
+++ b/src/comp/middle/tstate/bitvectors.rs
@@ -80,7 +80,7 @@ fn seq_postconds(fcx: &fn_ctxt, ps: &[postcond]) -> postcond {
     let sz = ivec::len(ps);
     if sz >= 1u {
         let prev = tritv_clone(ps.(0));
-        for p: postcond  in ivec::slice(ps, 1u, sz) { seq_tritv(prev, p); }
+        for p: postcond in ivec::slice(ps, 1u, sz) { seq_tritv(prev, p); }
         ret prev;
     } else { ret ann::empty_poststate(num_constraints(fcx.enclosing)); }
 }
diff --git a/src/comp/middle/tstate/ck.rs b/src/comp/middle/tstate/ck.rs
index 948dac658cd7..92afaf7cc3ef 100644
--- a/src/comp/middle/tstate/ck.rs
+++ b/src/comp/middle/tstate/ck.rs
@@ -49,7 +49,7 @@ import states::find_pre_post_state_fn;
 fn check_unused_vars(fcx: &fn_ctxt) {
 
     // FIXME: could be more efficient
-    for c: norm_constraint  in constraints(fcx) {
+    for c: norm_constraint in constraints(fcx) {
         alt c.c.node {
           ninit(id, v) {
             if !vec_contains(fcx.enclosing.used_vars, id) {
diff --git a/src/comp/middle/tstate/collect_locals.rs b/src/comp/middle/tstate/collect_locals.rs
index f60745d596a2..35d9d6574036 100644
--- a/src/comp/middle/tstate/collect_locals.rs
+++ b/src/comp/middle/tstate/collect_locals.rs
@@ -30,7 +30,7 @@ fn collect_pred(e: &@expr, cx: &ctxt, v: &visit::vt[ctxt]) {
       // If it's a call, generate appropriate instances of the
       // call's constraints.
       expr_call(operator, operands) {
-        for c: @ty::constr  in constraints_expr(cx.tcx, operator) {
+        for c: @ty::constr in constraints_expr(cx.tcx, operator) {
             let ct: sp_constr =
                 respan(c.span,
                        aux::substitute_constr_args(cx.tcx, operands, c));
@@ -98,13 +98,13 @@ fn mk_fn_info(ccx: &crate_ctxt, f: &_fn, tp: &[ty_param], f_sp: &span,
     /* now we have to add bit nums for both the constraints
        and the variables... */
 
-    for c: sp_constr  in { *cx.cs } {
+    for c: sp_constr in { *cx.cs } {
         next = add_constraint(cx.tcx, c, next, res_map);
     }
     /* if this function has any constraints, instantiate them to the
        argument names and add them */
     let sc;
-    for c: @constr  in f.decl.constraints {
+    for c: @constr in f.decl.constraints {
         sc = ast_constr_to_sp_constr(cx.tcx, f.decl.inputs, c);
         next = add_constraint(cx.tcx, sc, next, res_map);
     }
diff --git a/src/comp/middle/tstate/pre_post_conditions.rs b/src/comp/middle/tstate/pre_post_conditions.rs
index b769b0f36b84..853110275a60 100644
--- a/src/comp/middle/tstate/pre_post_conditions.rs
+++ b/src/comp/middle/tstate/pre_post_conditions.rs
@@ -65,7 +65,7 @@ fn find_pre_post_obj(ccx: &crate_ctxt, o: _obj) {
              ccx: ccx};
         find_pre_post_fn(fcx, m.node.meth);
     }
-    for m: @method  in o.methods { do_a_method(ccx, m); }
+    for m: @method in o.methods { do_a_method(ccx, m); }
 }
 
 fn find_pre_post_item(ccx: &crate_ctxt, i: &item) {
@@ -120,7 +120,7 @@ fn find_pre_post_exprs(fcx: &fn_ctxt, args: &[@expr], id: node_id) {
         log_expr(*args.(0));
     }
     fn do_one(fcx: fn_ctxt, e: &@expr) { find_pre_post_expr(fcx, e); }
-    for e: @expr  in args { do_one(fcx, e); }
+    for e: @expr in args { do_one(fcx, e); }
 
     fn get_pp(ccx: crate_ctxt, e: &@expr) -> pre_and_post {
         ret expr_pp(ccx, e);
@@ -341,7 +341,7 @@ fn find_pre_post_expr(fcx: &fn_ctxt, e: @expr) {
 
         find_pre_post_exprs(fcx, args, e.id);
         /* see if the call has any constraints on its type */
-        for c: @ty::constr  in constraints_expr(fcx.ccx.tcx, operator) {
+        for c: @ty::constr in constraints_expr(fcx.ccx.tcx, operator) {
             let i =
                 bit_num(fcx, substitute_constr_args(fcx.ccx.tcx, args, c));
             require(i, expr_pp(fcx.ccx, e));
@@ -391,7 +391,7 @@ fn find_pre_post_expr(fcx: &fn_ctxt, e: @expr) {
         let rslt = expr_pp(fcx.ccx, e);
         clear_pp(rslt);
         let upvars = freevars::get_freevars(fcx.ccx.tcx, e.id);
-        for id: node_id  in *upvars { handle_var(fcx, rslt, id, "upvar"); }
+        for id: node_id in *upvars { handle_var(fcx, rslt, id, "upvar"); }
       }
       expr_block(b) {
         find_pre_post_block(fcx, b);
@@ -512,7 +512,7 @@ fn find_pre_post_expr(fcx: &fn_ctxt, e: @expr) {
             ret block_pp(fcx.ccx, an_alt.body);
         }
         let alt_pps = ~[];
-        for a: arm  in alts { alt_pps += ~[do_an_alt(fcx, a)]; }
+        for a: arm in alts { alt_pps += ~[do_an_alt(fcx, a)]; }
         fn combine_pp(antec: pre_and_post, fcx: fn_ctxt, pp: &pre_and_post,
                       next: &pre_and_post) -> pre_and_post {
             union(pp.precondition, seq_preconds(fcx, ~[antec, next]));
@@ -607,7 +607,7 @@ fn find_pre_post_stmt(fcx: &fn_ctxt, s: &stmt) {
       stmt_decl(adecl, id) {
         alt adecl.node {
           decl_local(alocals) {
-            for alocal: @local  in alocals {
+            for alocal: @local in alocals {
                 alt alocal.node.init {
                   some(an_init) {
                     /* LHS always becomes initialized,
@@ -694,13 +694,13 @@ fn find_pre_post_block(fcx: &fn_ctxt, b: blk) {
         log "is:";
         log_pp(stmt_pp(fcx.ccx, *s));
     }
-    for s: @stmt  in b.node.stmts { do_one_(fcx, s); }
+    for s: @stmt in b.node.stmts { do_one_(fcx, s); }
     fn do_inner_(fcx: fn_ctxt, e: &@expr) { find_pre_post_expr(fcx, e); }
     let do_inner = bind do_inner_(fcx, _);
     option::map[@expr, ()](do_inner, b.node.expr);
 
     let pps: [pre_and_post] = ~[];
-    for s: @stmt  in b.node.stmts { pps += ~[stmt_pp(fcx.ccx, *s)]; }
+    for s: @stmt in b.node.stmts { pps += ~[stmt_pp(fcx.ccx, *s)]; }
     alt b.node.expr {
       none. {/* no-op */ }
       some(e) { pps += ~[expr_pp(fcx.ccx, e)]; }
@@ -709,7 +709,7 @@ fn find_pre_post_block(fcx: &fn_ctxt, b: blk) {
     let block_precond = seq_preconds(fcx, pps);
 
     let postconds = ~[];
-    for pp: pre_and_post  in pps { postconds += ~[get_post(pp)]; }
+    for pp: pre_and_post in pps { postconds += ~[get_post(pp)]; }
 
     /* A block may be empty, so this next line ensures that the postconds
        vector is non-empty. */
diff --git a/src/comp/middle/tstate/states.rs b/src/comp/middle/tstate/states.rs
index 8776c0107bae..6ff42167e6a5 100644
--- a/src/comp/middle/tstate/states.rs
+++ b/src/comp/middle/tstate/states.rs
@@ -556,7 +556,7 @@ fn find_pre_post_state_expr(fcx: &fn_ctxt, pres: &prestate, e: @expr) ->
         let a_post;
         if ivec::len(alts) > 0u {
             a_post = false_postcond(num_constrs);
-            for an_alt: arm  in alts {
+            for an_alt: arm in alts {
                 changed |=
                     find_pre_post_state_block(fcx, e_post, an_alt.body);
                 intersect(a_post, block_poststate(fcx.ccx, an_alt.body));
@@ -712,7 +712,7 @@ fn find_pre_post_state_block(fcx: &fn_ctxt, pres0: &prestate, b: &blk) ->
      initializes.  Then <pres> becomes the new poststate. */
 
     let changed = false;
-    for s: @stmt  in b.node.stmts {
+    for s: @stmt in b.node.stmts {
         changed |= find_pre_post_state_stmt(fcx, pres, s);
         pres = stmt_poststate(fcx.ccx, *s);
     }
@@ -755,7 +755,7 @@ fn find_pre_post_state_fn(fcx: &fn_ctxt, f: &_fn) -> bool {
     // Instantiate any constraints on the arguments so we can use them
     let block_pre = block_prestate(fcx.ccx, f.body);
     let tsc;
-    for c: @constr  in f.decl.constraints {
+    for c: @constr in f.decl.constraints {
         tsc = ast_constr_to_ts_constr(fcx.ccx.tcx, f.decl.inputs, c);
         set_in_prestate_constr(fcx, tsc, block_pre);
     }
diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs
index 3319d57a9446..3652b68ef239 100644
--- a/src/comp/middle/ty.rs
+++ b/src/comp/middle/ty.rs
@@ -455,7 +455,7 @@ fn mk_raw_ty(cx: &ctxt, st: &sty, in_cname: &option::t[str]) -> @raw_t {
     }
     fn derive_flags_sig(cx: &ctxt, has_params: &mutable bool,
                         has_vars: &mutable bool, args: &[arg], tt: &t) {
-        for a: arg  in args { derive_flags_arg(cx, has_params, has_vars, a); }
+        for a: arg in args { derive_flags_arg(cx, has_params, has_vars, a); }
         derive_flags_t(cx, has_params, has_vars, tt);
     }
     alt st {
@@ -475,7 +475,7 @@ fn mk_raw_ty(cx: &ctxt, st: &sty, in_cname: &option::t[str]) -> @raw_t {
       ty_param(_,_) { has_params = true; }
       ty_var(_) { has_vars = true; }
       ty_tag(_, tys) {
-        for tt: t  in tys { derive_flags_t(cx, has_params, has_vars, tt); }
+        for tt: t in tys { derive_flags_t(cx, has_params, has_vars, tt); }
       }
       ty_box(m) { derive_flags_mt(cx, has_params, has_vars, m); }
       ty_uniq(tt) { derive_flags_t(cx, has_params, has_vars, tt); }
@@ -485,7 +485,7 @@ fn mk_raw_ty(cx: &ctxt, st: &sty, in_cname: &option::t[str]) -> @raw_t {
       ty_port(tt) { derive_flags_t(cx, has_params, has_vars, tt); }
       ty_chan(tt) { derive_flags_t(cx, has_params, has_vars, tt); }
       ty_rec(flds) {
-        for f: field  in flds {
+        for f: field in flds {
             derive_flags_mt(cx, has_params, has_vars, f.mt);
         }
       }
@@ -501,13 +501,13 @@ fn mk_raw_ty(cx: &ctxt, st: &sty, in_cname: &option::t[str]) -> @raw_t {
         derive_flags_sig(cx, has_params, has_vars, args, tt);
       }
       ty_obj(meths) {
-        for m: method  in meths {
+        for m: method in meths {
             derive_flags_sig(cx, has_params, has_vars, m.inputs, m.output);
         }
       }
       ty_res(_, tt, tps) {
         derive_flags_t(cx, has_params, has_vars, tt);
-        for tt: t  in tps { derive_flags_t(cx, has_params, has_vars, tt); }
+        for tt: t in tps { derive_flags_t(cx, has_params, has_vars, tt); }
       }
       ty_constr(tt, _) { derive_flags_t(cx, has_params, has_vars, tt); }
     }
@@ -673,31 +673,31 @@ fn walk_ty(cx: &ctxt, walker: ty_walk, ty: t) {
       ty_port(subty) { walk_ty(cx, walker, subty); }
       ty_chan(subty) { walk_ty(cx, walker, subty); }
       ty_tag(tid, subtys) {
-        for subty: t  in subtys { walk_ty(cx, walker, subty); }
+        for subty: t in subtys { walk_ty(cx, walker, subty); }
       }
       ty_rec(fields) {
-        for fl: field  in fields { walk_ty(cx, walker, fl.mt.ty); }
+        for fl: field in fields { walk_ty(cx, walker, fl.mt.ty); }
       }
       ty_tup(ts) {
         for tt in ts { walk_ty(cx, walker, tt); }
       }
       ty_fn(proto, args, ret_ty, _, _) {
-        for a: arg  in args { walk_ty(cx, walker, a.ty); }
+        for a: arg in args { walk_ty(cx, walker, a.ty); }
         walk_ty(cx, walker, ret_ty);
       }
       ty_native_fn(abi, args, ret_ty) {
-        for a: arg  in args { walk_ty(cx, walker, a.ty); }
+        for a: arg in args { walk_ty(cx, walker, a.ty); }
         walk_ty(cx, walker, ret_ty);
       }
       ty_obj(methods) {
-        for m: method  in methods {
-            for a: arg  in m.inputs { walk_ty(cx, walker, a.ty); }
+        for m: method in methods {
+            for a: arg in m.inputs { walk_ty(cx, walker, a.ty); }
             walk_ty(cx, walker, m.output);
         }
       }
       ty_res(_, sub, tps) {
         walk_ty(cx, walker, sub);
-        for tp: t  in tps { walk_ty(cx, walker, tp); }
+        for tp: t in tps { walk_ty(cx, walker, tp); }
       }
       ty_constr(sub, _) {
         walk_ty(cx, walker, sub);
@@ -755,12 +755,12 @@ fn fold_ty(cx: &ctxt, fld: fold_mode, ty_0: t) -> t {
       ty_chan(subty) { ty = mk_chan(cx, fold_ty(cx, fld, subty)); }
       ty_tag(tid, subtys) {
         let new_subtys: [t] = ~[];
-        for subty: t  in subtys { new_subtys += ~[fold_ty(cx, fld, subty)]; }
+        for subty: t in subtys { new_subtys += ~[fold_ty(cx, fld, subty)]; }
         ty = copy_cname(cx, mk_tag(cx, tid, new_subtys), ty);
       }
       ty_rec(fields) {
         let new_fields: [field] = ~[];
-        for fl: field  in fields {
+        for fl: field in fields {
             let new_ty = fold_ty(cx, fld, fl.mt.ty);
             let new_mt = {ty: new_ty, mut: fl.mt.mut};
             new_fields += ~[{ident: fl.ident, mt: new_mt}];
@@ -776,7 +776,7 @@ fn fold_ty(cx: &ctxt, fld: fold_mode, ty_0: t) -> t {
       }
       ty_fn(proto, args, ret_ty, cf, constrs) {
         let new_args: [arg] = ~[];
-        for a: arg  in args {
+        for a: arg in args {
             let new_ty = fold_ty(cx, fld, a.ty);
             new_args += ~[{mode: a.mode, ty: new_ty}];
         }
@@ -787,7 +787,7 @@ fn fold_ty(cx: &ctxt, fld: fold_mode, ty_0: t) -> t {
       }
       ty_native_fn(abi, args, ret_ty) {
         let new_args: [arg] = ~[];
-        for a: arg  in args {
+        for a: arg in args {
             let new_ty = fold_ty(cx, fld, a.ty);
             new_args += ~[{mode: a.mode, ty: new_ty}];
         }
@@ -798,9 +798,9 @@ fn fold_ty(cx: &ctxt, fld: fold_mode, ty_0: t) -> t {
       }
       ty_obj(methods) {
         let new_methods: [method] = ~[];
-        for m: method  in methods {
+        for m: method in methods {
             let new_args: [arg] = ~[];
-            for a: arg  in m.inputs {
+            for a: arg in m.inputs {
                 new_args += ~[{mode: a.mode, ty: fold_ty(cx, fld, a.ty)}];
             }
             new_methods +=
@@ -815,7 +815,7 @@ fn fold_ty(cx: &ctxt, fld: fold_mode, ty_0: t) -> t {
       }
       ty_res(did, subty, tps) {
         let new_tps = ~[];
-        for tp: t  in tps { new_tps += ~[fold_ty(cx, fld, tp)]; }
+        for tp: t in tps { new_tps += ~[fold_ty(cx, fld, tp)]; }
         ty =
             copy_cname(cx, mk_res(cx, did, fold_ty(cx, fld, subty), new_tps),
                        ty);
@@ -1014,7 +1014,7 @@ fn type_has_pointers(cx: &ctxt, ty: &t) -> bool {
       ty_type. {/* no-op */ }
       ty_native(_) {/* no-op */ }
       ty_rec(flds) {
-        for f: field  in flds {
+        for f: field in flds {
             if type_has_pointers(cx, f.mt.ty) {
                 result = true;
                 break;
@@ -1028,8 +1028,8 @@ fn type_has_pointers(cx: &ctxt, ty: &t) -> bool {
       }
       ty_tag(did, tps) {
         let variants = tag_variants(cx, did);
-        for variant: variant_info  in variants {
-            for aty: t  in variant.args {
+        for variant: variant_info in variants {
+            for aty: t in variant.args {
                 // Perform any type parameter substitutions.
                 let arg_ty = substitute_type_params(cx, tps, aty);
                 if type_has_pointers(cx, arg_ty) {
@@ -1129,7 +1129,7 @@ fn type_kind(cx: &ctxt, ty: &t) -> ast::kind {
 
       // Records lower to the lowest of their members.
       ty_rec(flds) {
-        for f: field  in flds {
+        for f: field in flds {
             result = kind::lower_kind(result, type_kind(cx, f.mt.ty));
             if result == ast::kind_pinned { break; }
         }
@@ -1138,8 +1138,8 @@ fn type_kind(cx: &ctxt, ty: &t) -> ast::kind {
       // Tags lower to the lowest of their variants.
       ty_tag(did, tps) {
         let variants = tag_variants(cx, did);
-        for variant: variant_info  in variants {
-            for aty: t  in variant.args {
+        for variant: variant_info in variants {
+            for aty: t in variant.args {
                 // Perform any type parameter substitutions.
                 let arg_ty = substitute_type_params(cx, tps, aty);
                 result = kind::lower_kind(result, type_kind(cx, arg_ty));
@@ -1226,7 +1226,7 @@ fn type_has_dynamic_size(cx: &ctxt, ty: &t) -> bool {
       ty_native_fn(_, _, _) { ret false; }
       ty_obj(_) { ret false; }
       ty_res(_, sub, tps) {
-        for tp: t  in tps { if type_has_dynamic_size(cx, tp) { ret true; } }
+        for tp: t in tps { if type_has_dynamic_size(cx, tp) { ret true; } }
         ret type_has_dynamic_size(cx, sub);
       }
       ty_var(_) { fail "ty_var in type_has_dynamic_size()"; }
@@ -1331,8 +1331,8 @@ fn type_owns_heap_mem(cx: &ctxt, ty: &t) -> bool {
       // structural types
       ty_tag(did, tps) {
         let variants = tag_variants(cx, did);
-        for variant: variant_info  in variants {
-            for aty: t  in variant.args {
+        for variant: variant_info in variants {
+            for aty: t in variant.args {
                 // Perform any type parameter substitutions.
                 let arg_ty = substitute_type_params(cx, tps, aty);
                 if type_owns_heap_mem(cx, arg_ty) { result = true; }
@@ -1340,7 +1340,7 @@ fn type_owns_heap_mem(cx: &ctxt, ty: &t) -> bool {
         }
       }
       ty_rec(flds) {
-        for f: field  in flds {
+        for f: field in flds {
             if type_owns_heap_mem(cx, f.mt.ty) { result = true; }
         }
       }
@@ -1491,7 +1491,7 @@ fn hash_type_structure(st: &sty) -> uint {
     }
     fn hash_type_constr_args(id: uint, args: [@ty_constr_arg]) -> uint {
         let h = id;
-        for a: @ty_constr_arg  in args {
+        for a: @ty_constr_arg in args {
             alt a.node {
               carg_base. { h += h << 5u; }
               carg_lit(_) {
@@ -1510,7 +1510,7 @@ fn hash_type_structure(st: &sty) -> uint {
 
     fn hash_fn(id: uint, args: &[arg], rty: &t) -> uint {
         let h = id;
-        for a: arg  in args { h += h << 5u + hash_ty(a.ty); }
+        for a: arg in args { h += h << 5u + hash_ty(a.ty); }
         h += h << 5u + hash_ty(rty);
         ret h;
     }
@@ -1539,7 +1539,7 @@ fn hash_type_structure(st: &sty) -> uint {
       ty_istr. { ret 17u; }
       ty_tag(did, tys) {
         let h = hash_def(18u, did);
-        for typ: t  in tys { h += h << 5u + hash_ty(typ); }
+        for typ: t in tys { h += h << 5u + hash_ty(typ); }
         ret h;
       }
       ty_box(mt) { ret hash_subty(19u, mt.ty); }
@@ -1550,7 +1550,7 @@ fn hash_type_structure(st: &sty) -> uint {
       ty_task. { ret 24u; }
       ty_rec(fields) {
         let h = 26u;
-        for f: field  in fields { h += h << 5u + hash_ty(f.mt.ty); }
+        for f: field in fields { h += h << 5u + hash_ty(f.mt.ty); }
         ret h;
       }
       ty_tup(ts) {
@@ -1566,7 +1566,7 @@ fn hash_type_structure(st: &sty) -> uint {
       ty_native_fn(_, args, rty) { ret hash_fn(28u, args, rty); }
       ty_obj(methods) {
         let h = 29u;
-        for m: method  in methods { h += h << 5u + str::hash(m.ident); }
+        for m: method in methods { h += h << 5u + str::hash(m.ident); }
         ret h;
       }
       ty_var(v) { ret hash_uint(30u, v as uint); }
@@ -1577,12 +1577,12 @@ fn hash_type_structure(st: &sty) -> uint {
       ty_ptr(mt) { ret hash_subty(35u, mt.ty); }
       ty_res(did, sub, tps) {
         let h = hash_subty(hash_def(18u, did), sub);
-        for tp: t  in tps { h += h << 5u + hash_ty(tp); }
+        for tp: t in tps { h += h << 5u + hash_ty(tp); }
         ret h;
       }
       ty_constr(t, cs) {
         let h = 36u;
-        for c: @type_constr  in cs { h += h << 5u + hash_type_constr(h, c); }
+        for c: @type_constr in cs { h += h << 5u + hash_type_constr(h, c); }
         ret h;
       }
       ty_uniq(t) {
@@ -1629,7 +1629,7 @@ fn arg_eq[T](eq: &fn(&T, &T) -> bool , a: @sp_constr_arg[T],
 fn args_eq[T](eq: fn(&T, &T) -> bool , a: &[@sp_constr_arg[T]],
               b: &[@sp_constr_arg[T]]) -> bool {
     let i: uint = 0u;
-    for arg: @sp_constr_arg[T]  in a {
+    for arg: @sp_constr_arg[T] in a {
         if !arg_eq(eq, arg, b.(i)) { ret false; }
         i += 1u;
     }
@@ -1645,7 +1645,7 @@ fn constr_eq(c: &@constr, d: &@constr) -> bool {
 fn constrs_eq(cs: &[@constr], ds: &[@constr]) -> bool {
     if ivec::len(cs) != ivec::len(ds) { ret false; }
     let i = 0u;
-    for c: @constr  in cs { if !constr_eq(c, ds.(i)) { ret false; } i += 1u; }
+    for c: @constr in cs { if !constr_eq(c, ds.(i)) { ret false; } i += 1u; }
     ret true;
 }
 
@@ -1805,7 +1805,7 @@ fn equal_type_structures(a: &sty, b: &sty) -> bool {
                 ret false;
             }
             let i = 0u;
-            for tp_a: t  in tps_a {
+            for tp_a: t in tps_a {
                 if !eq_ty(tp_a, tps_b.(i)) { ret false; }
                 i += 1u;
             }
@@ -1927,7 +1927,7 @@ fn count_ty_params(cx: &ctxt, ty: t) -> uint {
         alt struct(cx, ty) {
           ty_param(param_idx,_) {
             let seen = false;
-            for other_param_idx: uint  in *param_indices {
+            for other_param_idx: uint in *param_indices {
                 if param_idx == other_param_idx { seen = true; }
             }
             if !seen { *param_indices += ~[param_idx]; }
@@ -2044,14 +2044,14 @@ fn stmt_node_id(s: &@ast::stmt) -> ast::node_id {
 fn field_idx(sess: &session::session, sp: &span, id: &ast::ident,
              fields: &[field]) -> uint {
     let i: uint = 0u;
-    for f: field  in fields { if str::eq(f.ident, id) { ret i; } i += 1u; }
+    for f: field in fields { if str::eq(f.ident, id) { ret i; } i += 1u; }
     sess.span_fatal(sp, "unknown field '" + id + "' of record");
 }
 
 fn method_idx(sess: &session::session, sp: &span, id: &ast::ident,
               meths: &[method]) -> uint {
     let i: uint = 0u;
-    for m: method  in meths { if str::eq(m.ident, id) { ret i; } i += 1u; }
+    for m: method in meths { if str::eq(m.ident, id) { ret i; } i += 1u; }
     sess.span_fatal(sp, "unknown method '" + id + "' of obj");
 }
 
@@ -2219,7 +2219,7 @@ mod unify {
         }
         let i = 0u;
         let rslt;
-        for c: @type_constr  in expected {
+        for c: @type_constr in expected {
             rslt = unify_constr(base_t, c, actual.(i));
             alt rslt { ures_ok(_) { } ures_err(_) { ret rslt; } }
             i += 1u;
@@ -2236,7 +2236,7 @@ mod unify {
         if expected_arg_len != actual_arg_len { ret err_res; }
         let i = 0u;
         let actual;
-        for a: @ty_constr_arg  in expected.node.args {
+        for a: @ty_constr_arg in expected.node.args {
             actual = actual_constr.node.args.(i);
             alt a.node {
               carg_base. {
@@ -2651,7 +2651,7 @@ mod unify {
                   ures_ok(res_inner) {
                     let i = 0u;
                     let res_tps = ~[];
-                    for ex_tp: t  in ex_tps {
+                    for ex_tp: t in ex_tps {
                         let result = unify_step(cx, ex_tp, act_tps.(i));
                         alt result {
                           ures_ok(rty) { res_tps += ~[rty]; }
@@ -3012,11 +3012,11 @@ fn tag_variants(cx: &ctxt, id: &ast::def_id) -> [variant_info] {
         alt item.node {
           ast::item_tag(variants, _) {
             let result: [variant_info] = ~[];
-            for variant: ast::variant  in variants {
+            for variant: ast::variant in variants {
                 let ctor_ty = node_id_to_monotype(cx, variant.node.id);
                 let arg_tys: [t] = ~[];
                 if std::ivec::len(variant.node.args) > 0u {
-                    for a: arg  in ty_fn_args(cx, ctor_ty) {
+                    for a: arg in ty_fn_args(cx, ctor_ty) {
                         arg_tys += ~[a.ty];
                     }
                 }
diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs
index ef289ebe5c09..c2efce8d7b1e 100644
--- a/src/comp/middle/typeck.rs
+++ b/src/comp/middle/typeck.rs
@@ -294,7 +294,7 @@ fn ast_ty_to_ty(tcx: &ty::ctxt, getter: &ty_getter, ast_ty: &@ast::ty) ->
         //
 
         let param_bindings: [ty::t] = ~[];
-        for ast_ty: @ast::ty  in args {
+        for ast_ty: @ast::ty in args {
             param_bindings += ~[ast_ty_to_ty(tcx, getter, ast_ty)];
         }
         if ivec::len(param_bindings) !=
@@ -346,7 +346,7 @@ fn ast_ty_to_ty(tcx: &ty::ctxt, getter: &ty_getter, ast_ty: &@ast::ty) ->
       }
       ast::ty_rec(fields) {
         let flds: [field] = ~[];
-        for f: ast::ty_field  in fields {
+        for f: ast::ty_field in fields {
             let tm = ast_mt_to_mt(tcx, getter, f.node.mt);
             flds += ~[{ident: f.node.ident, mt: tm}];
         }
@@ -354,13 +354,13 @@ fn ast_ty_to_ty(tcx: &ty::ctxt, getter: &ty_getter, ast_ty: &@ast::ty) ->
       }
       ast::ty_fn(proto, inputs, output, cf, constrs) {
         let i = ~[];
-        for ta: ast::ty_arg  in inputs {
+        for ta: ast::ty_arg in inputs {
             i += ~[ast_arg_to_arg(tcx, getter, ta)];
         }
         let out_ty = ast_ty_to_ty(tcx, getter, output);
 
         let out_constrs = ~[];
-        for constr: @ast::constr  in constrs {
+        for constr: @ast::constr in constrs {
             out_constrs += ~[ty::ast_constr_to_constr(tcx, constr)];
         }
         typ = ty::mk_fn(tcx, proto, i, out_ty, cf, out_constrs);
@@ -384,15 +384,15 @@ fn ast_ty_to_ty(tcx: &ty::ctxt, getter: &ty_getter, ast_ty: &@ast::ty) ->
       }
       ast::ty_obj(meths) {
         let tmeths: [ty::method] = ~[];
-        for m: ast::ty_method  in meths {
+        for m: ast::ty_method in meths {
             let ins = ~[];
-            for ta: ast::ty_arg  in m.node.inputs {
+            for ta: ast::ty_arg in m.node.inputs {
                 ins += ~[ast_arg_to_arg(tcx, getter, ta)];
             }
             let out = ast_ty_to_ty(tcx, getter, m.node.output);
 
             let out_constrs = ~[];
-            for constr: @ast::constr  in m.node.constrs {
+            for constr: @ast::constr in m.node.constrs {
                 out_constrs += ~[ty::ast_constr_to_constr(tcx, constr)];
             }
             let new_m: ty::method =
@@ -408,7 +408,7 @@ fn ast_ty_to_ty(tcx: &ty::ctxt, getter: &ty_getter, ast_ty: &@ast::ty) ->
       }
       ast::ty_constr(t, cs) {
         let out_cs = ~[];
-        for constr: @ast::ty_constr  in cs {
+        for constr: @ast::ty_constr in cs {
             out_cs += ~[ty::ast_constr_to_constr(tcx, constr)];
         }
         typ = ty::mk_constr(tcx, ast_ty_to_ty(tcx, getter, t), out_cs);
@@ -554,11 +554,11 @@ mod collect {
                      def_id: &option::t[ast::def_id]) ->
        ty::ty_param_kinds_and_ty {
         let input_tys = ~[];
-        for a: ast::arg  in decl.inputs { input_tys += ~[ty_of_arg(a)]; }
+        for a: ast::arg in decl.inputs { input_tys += ~[ty_of_arg(a)]; }
         let output_ty = convert(decl.output);
 
         let out_constrs = ~[];
-        for constr: @ast::constr  in decl.constraints {
+        for constr: @ast::constr in decl.constraints {
             out_constrs += ~[ty::ast_constr_to_constr(cx.tcx, constr)];
         }
         let t_fn =
@@ -574,7 +574,7 @@ mod collect {
                             ty_params: &[ast::ty_param], def_id: &ast::def_id)
        -> ty::ty_param_kinds_and_ty {
         let input_tys = ~[];
-        for a: ast::arg  in decl.inputs { input_tys += ~[ty_of_arg(a)]; }
+        for a: ast::arg in decl.inputs { input_tys += ~[ty_of_arg(a)]; }
         let output_ty = convert(decl.output);
 
         let t_fn = ty::mk_native_fn(cx.tcx, abi, input_tys, output_ty);
@@ -619,14 +619,14 @@ mod collect {
         let convert = bind ast_ty_to_ty(cx.tcx, get, _);
 
         let inputs = ~[];
-        for a: ast::arg  in m.node.meth.decl.inputs {
+        for a: ast::arg in m.node.meth.decl.inputs {
             inputs += ~[ty_of_arg(cx, a)];
         }
 
         let output = convert(m.node.meth.decl.output);
 
         let out_constrs = ~[];
-        for constr: @ast::constr  in m.node.meth.decl.constraints {
+        for constr: @ast::constr in m.node.meth.decl.constraints {
             out_constrs += ~[ty::ast_constr_to_constr(cx.tcx, constr)];
         }
         ret {proto: proto_to_ty_proto(m.node.meth.proto),
@@ -649,7 +649,7 @@ mod collect {
         let t_obj = ty_of_obj(cx, id, ob, ty_params);
 
         let t_inputs: [arg] = ~[];
-        for f: ast::obj_field  in ob.fields {
+        for f: ast::obj_field in ob.fields {
             let g = bind getter(cx, _);
             let t_field = ast_ty_to_ty(cx.tcx, g, f.ty);
             t_inputs += ~[{mode: ty::mo_alias(false), ty: t_field}];
@@ -747,7 +747,7 @@ mod collect {
         // Create a set of parameter types shared among all the variants.
 
         let ty_param_tys: [ty::t] = mk_ty_params(cx, ty_params);
-        for variant: ast::variant  in variants {
+        for variant: ast::variant in variants {
             // Nullary tag constructors get turned into constants; n-ary tag
             // constructors get turned into functions.
 
@@ -760,7 +760,7 @@ mod collect {
 
                 let f = bind getter(cx, _);
                 let args: [arg] = ~[];
-                for va: ast::variant_arg  in variant.node.args {
+                for va: ast::variant_arg in variant.node.args {
                     let arg_ty = ast_ty_to_ty(cx.tcx, f, va.ty);
                     args += ~[{mode: ty::mo_alias(false), ty: arg_ty}];
                 }
@@ -777,7 +777,7 @@ mod collect {
     }
     fn get_obj_method_types(cx: &@ctxt, object: &ast::_obj) -> [ty::method] {
         let meths = ~[];
-        for m: @ast::method  in object.methods {
+        for m: @ast::method in object.methods {
             meths += ~[ty_of_method(cx, m)];
         }
         ret meths;
@@ -995,7 +995,7 @@ mod demand {
 
         let ty_param_substs: [mutable ty::t] = ~[mutable];
         let ty_param_subst_var_ids: [int] = ~[];
-        for ty_param_subst: ty::t  in ty_param_substs_0 {
+        for ty_param_subst: ty::t in ty_param_substs_0 {
             // Generate a type variable and unify it with the type parameter
             // substitution. We will then pull out these type variables.
             let t_0 = next_ty_var(fcx);
@@ -1008,7 +1008,7 @@ mod demand {
                      ty_param_subst_var_ids: &[int]) ->
            ty_param_substs_and_ty {
             let result_ty_param_substs: [ty::t] = ~[];
-            for var_id: int  in ty_param_subst_var_ids {
+            for var_id: int in ty_param_subst_var_ids {
                 let tp_subst = ty::mk_var(fcx.ccx.tcx, var_id);
                 result_ty_param_substs += ~[tp_subst];
             }
@@ -1055,7 +1055,7 @@ fn variant_arg_types(ccx: &@crate_ctxt, sp: &span, vid: &ast::def_id,
 
 
         // N-ary variant.
-        for arg: ty::arg  in ins {
+        for arg: ty::arg in ins {
             let arg_ty =
                 ty::substitute_type_params(ccx.tcx, tag_ty_params, arg.ty);
             result += ~[arg_ty];
@@ -1111,7 +1111,7 @@ mod writeback {
           none[[ty::t]]. { new_substs_opt = none[[ty::t]]; }
           some[[ty::t]](substs) {
             let new_substs: [ty::t] = ~[];
-            for subst: ty::t  in substs {
+            for subst: ty::t in substs {
                 alt resolve_type_vars_in_type(fcx, sp, subst) {
                   some(t) { new_substs += ~[t]; }
                   none. { wbcx.success = false; ret; }
@@ -1256,7 +1256,7 @@ fn gather_locals(ccx: &@crate_ctxt, f: &ast::_fn, id: &ast::node_id,
       }
       none. {/* no fields */ }
     }
-    for f: ast::obj_field  in obj_fields {
+    for f: ast::obj_field in obj_fields {
         let field_ty = ty::node_id_to_type(ccx.tcx, f.id);
         assign(f.id, f.ident, some(field_ty));
     }
@@ -1264,7 +1264,7 @@ fn gather_locals(ccx: &@crate_ctxt, f: &ast::_fn, id: &ast::node_id,
     // Add formal parameters.
     let args = ty::ty_fn_args(ccx.tcx, ty::node_id_to_type(ccx.tcx, id));
     let i = 0u;
-    for arg: ty::arg  in args {
+    for arg: ty::arg in args {
         assign(f.decl.inputs.(i).id, f.decl.inputs.(i).ident, some(arg.ty));
         i += 1u;
     }
@@ -1391,7 +1391,7 @@ fn check_pat(fcx: &@fn_ctxt, map: &ast::pat_id_map, pat: &@ast::pat,
                 // TODO: ivec::iter2
 
                 let i = 0u;
-                for subpat: @ast::pat  in subpats {
+                for subpat: @ast::pat in subpats {
                     check_pat(fcx, map, subpat, arg_types.(i));
                     i += 1u;
                 }
@@ -1442,7 +1442,7 @@ fn check_pat(fcx: &@fn_ctxt, map: &ast::pat_id_map, pat: &@ast::pat,
         fn matches(name: &str, f: &ty::field) -> bool {
             ret str::eq(name, f.ident);
         }
-        for f: ast::field_pat  in fields {
+        for f: ast::field_pat in fields {
             alt ivec::find(bind matches(f.ident, _), ex_fields) {
               some(field) { check_pat(fcx, map, f.pat, field.mt.ty); }
               none. {
@@ -1619,7 +1619,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
         let check_args = lambda(check_blocks: bool) -> bool {
             let i = 0u;
             let bot = false;
-            for a_opt: option::t[@ast::expr]  in args {
+            for a_opt: option::t[@ast::expr] in args {
                 alt a_opt {
                   some(a) {
                     let is_block =
@@ -1655,7 +1655,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
     fn check_call(fcx: &@fn_ctxt, sp: &span, f: &@ast::expr,
                   args: &[@ast::expr], call_kind: call_kind) -> bool {
         let args_opt_0: [option::t[@ast::expr]] = ~[];
-        for arg: @ast::expr  in args {
+        for arg: @ast::expr in args {
             args_opt_0 += ~[some[@ast::expr](arg)];
         }
 
@@ -1727,7 +1727,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
                                        in constraint");
                   }
                 }
-                for operand: @ast::expr  in operands {
+                for operand: @ast::expr in operands {
                     if !ast::is_constraint_arg(operand) {
                         let s =
                             "Constraint args must be \
@@ -2048,16 +2048,16 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
         // Typecheck the patterns first, so that we get types for all the
         // bindings.
         let pattern_ty = ty::expr_ty(tcx, expr);
-        for arm: ast::arm  in arms {
+        for arm: ast::arm in arms {
             let id_map = ast::pat_id_map(arm.pats.(0));
-            for p: @ast::pat  in arm.pats {
+            for p: @ast::pat in arm.pats {
                 check_pat(fcx, id_map, p, pattern_ty);
             }
         }
         // Now typecheck the blocks.
         let result_ty = next_ty_var(fcx);
         let arm_non_bot = false;
-        for arm: ast::arm  in arms {
+        for arm: ast::arm in arms {
             if !check_block(fcx, arm.body) { arm_non_bot = true; }
             let bty = block_ty(tcx, arm.body);
             result_ty = demand::simple(fcx, arm.body.span, result_ty, bty);
@@ -2173,7 +2173,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
           some(sty) {
             alt sty {
               ty::ty_obj(methods) {
-                for method: ty::method  in methods {
+                for method: ty::method in methods {
                     if method.ident == ident {
                         t = ty::method_ty_to_fn_ty(tcx, method);
                     }
@@ -2251,7 +2251,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
       ast::expr_rec(fields, base) {
         alt base { none. {/* no-op */ } some(b_0) { check_expr(fcx, b_0); } }
         let fields_t: [spanned[field]] = ~[];
-        for f: ast::field  in fields {
+        for f: ast::field in fields {
             bot |= check_expr(fcx, f.node.expr);
             let expr_t = expr_ty(tcx, f.node.expr);
             let expr_mt = {ty: expr_t, mut: f.node.mut};
@@ -2279,9 +2279,9 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
               }
             }
             write::ty_only_fixup(fcx, id, bexpr_t);
-            for f: spanned[ty::field]  in fields_t {
+            for f: spanned[ty::field] in fields_t {
                 let found = false;
-                for bf: ty::field  in base_fields {
+                for bf: ty::field in base_fields {
                     if str::eq(f.node.ident, bf.ident) {
                         demand::simple(fcx, f.span, bf.mt.ty, f.node.mt.ty);
                         found = true;
@@ -2384,14 +2384,14 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
             let convert = bind ast_ty_to_ty_crate(ccx, _);
 
             let inputs = ~[];
-            for aa: ast::arg  in m.node.meth.decl.inputs {
+            for aa: ast::arg in m.node.meth.decl.inputs {
                 inputs += ~[ty_of_arg(ccx, aa)];
             }
 
             let output = convert(m.node.meth.decl.output);
 
             let out_constrs = ~[];
-            for constr: @ast::constr  in m.node.meth.decl.constraints {
+            for constr: @ast::constr in m.node.meth.decl.constraints {
                 out_constrs += ~[ty::ast_constr_to_constr(ccx.tcx, constr)];
             }
 
@@ -2406,7 +2406,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
         let method_types: [ty::method] = ~[];
         {
             // Outer methods.
-            for m: @ast::method  in ao.methods {
+            for m: @ast::method in ao.methods {
                 method_types += ~[ty_of_method(fcx.ccx, m)];
             }
 
@@ -2495,7 +2495,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
         }
 
         // Typecheck the methods.
-        for method: @ast::method  in ao.methods {
+        for method: @ast::method in ao.methods {
             check_method(fcx.ccx, method);
         }
 
@@ -2704,7 +2704,7 @@ fn check_item(ccx: @crate_ctxt, it: &@ast::item) {
         ccx.obj_infos += ~[regular_obj(ob.fields, it.id)];
 
         // Typecheck the methods.
-        for method: @ast::method  in ob.methods { check_method(ccx, method); }
+        for method: @ast::method in ob.methods { check_method(ccx, method); }
 
         // Now remove the info from the stack.
         ivec::pop[obj_info](ccx.obj_infos);
diff --git a/src/comp/syntax/ast.rs b/src/comp/syntax/ast.rs
index 82ca1772c739..ce20360e9ec5 100644
--- a/src/comp/syntax/ast.rs
+++ b/src/comp/syntax/ast.rs
@@ -618,11 +618,11 @@ tag native_item_ {
 
 fn is_exported(i: ident, m: _mod) -> bool {
     let nonlocal = true;
-    for it: @ast::item  in m.items {
+    for it: @ast::item in m.items {
         if it.ident == i { nonlocal = false; }
         alt it.node {
           item_tag(variants, _) {
-            for v: variant  in variants {
+            for v: variant in variants {
                 if v.node.name == i { nonlocal = false; }
             }
           }
@@ -631,7 +631,7 @@ fn is_exported(i: ident, m: _mod) -> bool {
         if !nonlocal { break; }
     }
     let count = 0u;
-    for vi: @ast::view_item  in m.view_items {
+    for vi: @ast::view_item in m.view_items {
         alt vi.node {
           ast::view_item_export(id, _) {
             if str::eq(i, id) {
diff --git a/src/comp/syntax/codemap.rs b/src/comp/syntax/codemap.rs
index e3c061a0bb8d..7e41865afa45 100644
--- a/src/comp/syntax/codemap.rs
+++ b/src/comp/syntax/codemap.rs
@@ -142,7 +142,7 @@ fn maybe_highlight_lines(sp: &option::t[span], cm: &codemap,
             elided = true;
         }
         // Print the offending lines
-        for line: uint  in display_lines {
+        for line: uint in display_lines {
             io::stdout().write_str(#fmt("%s:%u ", fm.name, line + 1u));
             let s = get_line(fm, line as int, file);
             if !str::ends_with(s, "\n") { s += "\n"; }
@@ -203,7 +203,7 @@ fn span_to_lines(sp: span, cm: codemap::codemap) -> @file_lines {
     let lo = lookup_char_pos(cm, sp.lo);
     let hi = lookup_char_pos(cm, sp.hi);
     let lines = ~[];
-    for each i: uint  in uint::range(lo.line - 1u, hi.line as uint) {
+    for each i: uint in uint::range(lo.line - 1u, hi.line as uint) {
         lines += ~[i];
     }
     ret @{name: lo.filename, lines: lines};
@@ -227,7 +227,7 @@ fn get_line(fm: filemap, line: int, file: &str) -> str {
 }
 
 fn get_filemap(cm: codemap, filename: str) -> filemap {
-    for fm: filemap  in cm.files { if fm.name == filename { ret fm; } }
+    for fm: filemap in cm.files { if fm.name == filename { ret fm; } }
     //XXjdm the following triggers a mismatched type bug
     //      (or expected function, found _|_)
     fail; // ("asking for " + filename + " which we don't know about");
diff --git a/src/comp/syntax/ext/fmt.rs b/src/comp/syntax/ext/fmt.rs
index 27fcece7fb54..cc3d4fef52ee 100644
--- a/src/comp/syntax/ext/fmt.rs
+++ b/src/comp/syntax/ext/fmt.rs
@@ -86,7 +86,7 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
                      fields: &[{ident: ast::ident, ex: @ast::expr}]) ->
        @ast::expr {
         let astfields: [ast::field] = ~[];
-        for field: {ident: ast::ident, ex: @ast::expr}  in fields {
+        for field: {ident: ast::ident, ex: @ast::expr} in fields {
             let ident = field.ident;
             let val = field.ex;
             let astfield =
@@ -115,7 +115,7 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
         fn make_flags(cx: &ext_ctxt, sp: span, flags: &[flag]) ->
            @ast::expr {
             let flagexprs: [@ast::expr] = ~[];
-            for f: flag  in flags {
+            for f: flag in flags {
                 let fstr;
                 alt f {
                   flag_left_justify. { fstr = "flag_left_justify"; }
@@ -205,7 +205,7 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
           option::none. { }
           _ { cx.span_unimpl(sp, unsupported); }
         }
-        for f: flag  in cnv.flags {
+        for f: flag in cnv.flags {
             alt f {
               flag_left_justify. { }
               flag_sign_always. {
@@ -259,7 +259,7 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
           some(p) { log "param: " + std::int::to_str(p, 10u); }
           _ { log "param: none"; }
         }
-        for f: flag  in c.flags {
+        for f: flag in c.flags {
             alt f {
               flag_left_justify. { log "flag: left justify"; }
               flag_left_zero_pad. { log "flag: left zero pad"; }
@@ -308,7 +308,7 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
     let n = 0u;
     let tmp_expr = make_new_str(cx, sp, "");
     let nargs = ivec::len[@ast::expr](args);
-    for pc: piece  in pieces {
+    for pc: piece in pieces {
         alt pc {
           piece_string(s) {
             let s_expr = make_new_str(cx, fmt_sp, s);
diff --git a/src/comp/syntax/ext/simplext.rs b/src/comp/syntax/ext/simplext.rs
index b57812cb1d23..543cd8b4644e 100644
--- a/src/comp/syntax/ext/simplext.rs
+++ b/src/comp/syntax/ext/simplext.rs
@@ -95,7 +95,7 @@ fn elts_to_ell(cx: &ext_ctxt, elts: &[@expr])
     -> {pre: [@expr], rep: option::t[@expr], post: [@expr]} {
     let idx: uint = 0u;
     let res = none;
-    for elt: @expr  in elts {
+    for elt: @expr in elts {
         alt elt.node {
           expr_mac(m) {
             alt m.node {
@@ -124,7 +124,7 @@ fn elts_to_ell(cx: &ext_ctxt, elts: &[@expr])
 fn option_flatten_map[T, U](f: &fn(&T) -> option::t[U] , v: &[T]) ->
    option::t[[U]] {
     let res = ~[];
-    for elem: T  in v {
+    for elem: T in v {
         alt f(elem) { none. { ret none; } some(fv) { res += ~[fv]; } }
     }
     ret some(res);
@@ -185,11 +185,11 @@ selectors. */
 fn use_selectors_to_bind(b: &binders, e: @expr) -> option::t[bindings] {
     let res = new_str_hash[arb_depth[matchable]]();
     //need to do this first, to check vec lengths.
-    for sel: selector  in b.literal_ast_matchers {
+    for sel: selector in b.literal_ast_matchers {
         alt sel(match_expr(e)) { none. { ret none; } _ { } }
     }
     let never_mind: bool = false;
-    for each pair: @{key: ident, val: selector}  in b.real_binders.items() {
+    for each pair: @{key: ident, val: selector} in b.real_binders.items() {
         alt pair.val(match_expr(e)) {
           none. { never_mind = true; }
           some(mtc) { res.insert(pair.key, mtc); }
@@ -233,7 +233,7 @@ fn transcribe(cx: &ext_ctxt, b: &bindings, body: @expr) -> @expr {
 fn follow(m: &arb_depth[matchable], idx_path: @mutable [uint]) ->
    arb_depth[matchable] {
     let res: arb_depth[matchable] = m;
-    for idx: uint  in *idx_path {
+    for idx: uint in *idx_path {
         alt res {
           leaf(_) { ret res;/* end of the line */ }
           seq(new_ms, _) { res = new_ms.(idx); }
@@ -276,7 +276,7 @@ iter free_vars(b: &bindings, e: @expr) -> ident {
     let f = make_fold(f_pre);
     f.fold_expr(e); // ignore result
     dummy_out(f);
-    for each id: ident  in idents.keys() { put id; }
+    for each id: ident in idents.keys() { put id; }
 }
 
 
@@ -293,7 +293,7 @@ fn transcribe_exprs(cx: &ext_ctxt, b: &bindings, idx_path: @mutable [uint],
             let repeat: option::t[{rep_count: uint, name: ident}] = none;
             /* we need to walk over all the free vars in lockstep, except for
             the leaves, which are just duplicated */
-            for each fv: ident  in free_vars(b, repeat_me) {
+            for each fv: ident in free_vars(b, repeat_me) {
                 let cur_pos = follow(b.get(fv), idx_path);
                 alt cur_pos {
                   leaf(_) { }
@@ -686,7 +686,7 @@ fn add_new_extension(cx: &ext_ctxt, sp: span, arg: @expr,
 
     let macro_name: option::t[str] = none;
     let clauses: [@clause] = ~[];
-    for arg: @expr  in args {
+    for arg: @expr in args {
         alt arg.node {
           expr_vec(elts, mut, seq_kind) {
             if ivec::len(elts) != 2u {
diff --git a/src/comp/syntax/fold.rs b/src/comp/syntax/fold.rs
index 806d72499aab..944915384ee5 100644
--- a/src/comp/syntax/fold.rs
+++ b/src/comp/syntax/fold.rs
@@ -283,7 +283,7 @@ fn noop_fold_pat(p: &pat_, fld: ast_fold) -> pat_ {
           }
           pat_rec(fields, etc) {
             let fs = ~[];
-            for f: ast::field_pat  in fields {
+            for f: ast::field_pat in fields {
                 fs += ~[{ident: f.ident, pat: fld.fold_pat(f.pat)}];
             }
             pat_rec(fs, etc)
diff --git a/src/comp/syntax/parse/eval.rs b/src/comp/syntax/parse/eval.rs
index 6dd06a97901a..fb52960517d0 100644
--- a/src/comp/syntax/parse/eval.rs
+++ b/src/comp/syntax/parse/eval.rs
@@ -29,7 +29,7 @@ fn eval_crate_directives(cx: ctx, cdirs: &[@ast::crate_directive],
                          prefix: str,
                          view_items: &mutable [@ast::view_item],
                          items: &mutable [@ast::item]) {
-    for sub_cdir: @ast::crate_directive  in cdirs {
+    for sub_cdir: @ast::crate_directive in cdirs {
         eval_crate_directive(cx, sub_cdir, prefix, view_items, items);
     }
 }
diff --git a/src/comp/syntax/parse/lexer.rs b/src/comp/syntax/parse/lexer.rs
index 4ceb5ba1df59..edeb6df407bc 100644
--- a/src/comp/syntax/parse/lexer.rs
+++ b/src/comp/syntax/parse/lexer.rs
@@ -166,7 +166,7 @@ fn consume_block_comment(rdr: &reader) {
 
 fn digits_to_string(s: str) -> int {
     let accum_int: int = 0;
-    for c: u8  in s {
+    for c: u8 in s {
         accum_int *= 10;
         accum_int += dec_digit_val(c as char);
     }
diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs
index 8b7621b9018a..93cdf617a636 100644
--- a/src/comp/syntax/parse/parser.rs
+++ b/src/comp/syntax/parse/parser.rs
@@ -355,7 +355,7 @@ fn parse_ty_field(p: &parser) -> ast::ty_field {
 // otherwise, fail
 fn ident_index(p: &parser, args: &[ast::arg], i: &ast::ident) -> uint {
     let j = 0u;
-    for a: ast::arg  in args { if a.ident == i { ret j; } j += 1u; }
+    for a: ast::arg in args { if a.ident == i { ret j; } j += 1u; }
     p.fatal("Unbound variable " + i + " in constraint arg");
 }
 
@@ -1219,7 +1219,7 @@ const ternary_prec: int = 0;
 fn parse_more_binops(p: &parser, lhs: @ast::expr, min_prec: int) ->
    @ast::expr {
     let peeked = p.peek();
-    for cur: op_spec  in *p.get_prec_table() {
+    for cur: op_spec in *p.get_prec_table() {
         if cur.prec > min_prec && cur.tok == peeked {
             p.bump();
             let rhs = parse_more_binops(p, parse_prefix_expr(p), cur.prec);
@@ -2123,7 +2123,7 @@ fn parse_item_tag(p: &parser, attrs: &[ast::attribute]) -> @ast::item {
                 let arg_tys =
                     parse_seq(token::LPAREN, token::RPAREN,
                               some(token::COMMA), bind parse_ty(_, false), p);
-                for ty: @ast::ty  in arg_tys.node {
+                for ty: @ast::ty in arg_tys.node {
                     args += ~[{ty: ty, id: p.get_id()}];
                 }
                 vhi = arg_tys.span.hi;
diff --git a/src/comp/syntax/print/pprust.rs b/src/comp/syntax/print/pprust.rs
index c9481a3fb23c..e0389c47874c 100644
--- a/src/comp/syntax/print/pprust.rs
+++ b/src/comp/syntax/print/pprust.rs
@@ -218,7 +218,7 @@ fn synth_comment(s: &ps, text: str) {
 fn commasep[IN](s: &ps, b: breaks, elts: &[IN], op: fn(&ps, &IN) ) {
     box(s, 0u, b);
     let first = true;
-    for elt: IN  in elts {
+    for elt: IN in elts {
         if first { first = false; } else { word_space(s, ","); }
         op(s, elt);
     }
@@ -231,7 +231,7 @@ fn commasep_cmnt[IN](s: &ps, b: breaks, elts: &[IN], op: fn(&ps, &IN) ,
     box(s, 0u, b);
     let len = ivec::len[IN](elts);
     let i = 0u;
-    for elt: IN  in elts {
+    for elt: IN in elts {
         maybe_print_comment(s, get_span(elt).hi);
         op(s, elt);
         i += 1u;
@@ -252,19 +252,19 @@ fn commasep_exprs(s: &ps, b: breaks, exprs: &[@ast::expr]) {
 
 fn print_mod(s: &ps, _mod: &ast::_mod, attrs: &[ast::attribute]) {
     print_inner_attributes(s, attrs);
-    for vitem: @ast::view_item  in _mod.view_items {
+    for vitem: @ast::view_item in _mod.view_items {
         print_view_item(s, vitem);
     }
-    for item: @ast::item  in _mod.items { print_item(s, item); }
+    for item: @ast::item in _mod.items { print_item(s, item); }
 }
 
 fn print_native_mod(s: &ps, nmod: &ast::native_mod,
                     attrs: &[ast::attribute]) {
     print_inner_attributes(s, attrs);
-    for vitem: @ast::view_item  in nmod.view_items {
+    for vitem: @ast::view_item in nmod.view_items {
         print_view_item(s, vitem);
     }
-    for item: @ast::native_item  in nmod.items { print_native_item(s, item); }
+    for item: @ast::native_item in nmod.items { print_native_item(s, item); }
 }
 
 fn print_type(s: &ps, ty: &@ast::ty) {
@@ -330,7 +330,7 @@ fn print_type(s: &ps, ty: &@ast::ty) {
       ast::ty_obj(methods) {
         head(s, "obj");
         bopen(s);
-        for m: ast::ty_method  in methods {
+        for m: ast::ty_method in methods {
             hardbreak_if_not_bol(s);
             cbox(s, indent_unit);
             maybe_print_comment(s, m.span.lo);
@@ -471,7 +471,7 @@ fn print_item(s: &ps, item: &@ast::item) {
             end(s);
         } else {
             bopen(s);
-            for v: ast::variant  in variants {
+            for v: ast::variant in variants {
                 space(s.s);
                 maybe_print_comment(s, v.span.lo);
                 word(s.s, v.node.name);
@@ -506,7 +506,7 @@ fn print_item(s: &ps, item: &@ast::item) {
         pclose(s);
         space(s.s);
         bopen(s);
-        for meth: @ast::method  in _obj.methods {
+        for meth: @ast::method in _obj.methods {
             let typarams: [ast::ty_param] = ~[];
             hardbreak_if_not_bol(s);
             maybe_print_comment(s, meth.span.lo);
@@ -534,7 +534,7 @@ fn print_item(s: &ps, item: &@ast::item) {
 
 fn print_outer_attributes(s: &ps, attrs: &[ast::attribute]) {
     let count = 0;
-    for attr: ast::attribute  in attrs {
+    for attr: ast::attribute in attrs {
         alt attr.node.style {
           ast::attr_outer. { print_attribute(s, attr); count += 1; }
           _ {/* fallthrough */ }
@@ -545,7 +545,7 @@ fn print_outer_attributes(s: &ps, attrs: &[ast::attribute]) {
 
 fn print_inner_attributes(s: &ps, attrs: &[ast::attribute]) {
     let count = 0;
-    for attr: ast::attribute  in attrs {
+    for attr: ast::attribute in attrs {
         alt attr.node.style {
           ast::attr_inner. {
             print_attribute(s, attr);
@@ -594,7 +594,7 @@ fn print_possibly_embedded_block(s: &ps, blk: &ast::blk, embedded: embed_type,
     }
 
     let last_stmt = option::none;
-    for st: @ast::stmt  in blk.node.stmts {
+    for st: @ast::stmt in blk.node.stmts {
         maybe_protect_unop(s, last_stmt, stmt_(st));
         print_stmt(s, *st);
         last_stmt = option::some(st);
@@ -856,12 +856,12 @@ fn print_expr(s: &ps, expr: &@ast::expr) {
         print_expr(s, expr);
         space(s.s);
         bopen(s);
-        for arm: ast::arm  in arms {
+        for arm: ast::arm in arms {
             space(s.s);
             cbox(s, alt_indent_unit);
             ibox(s, 0u);
             let first = true;
-            for p: @ast::pat  in arm.pats {
+            for p: @ast::pat in arm.pats {
                 if first {
                     first = false;
                 } else { space(s.s); word_space(s, "|"); }
@@ -1126,7 +1126,7 @@ fn print_path(s: &ps, path: &ast::path) {
     maybe_print_comment(s, path.span.lo);
     if path.node.global { word(s.s, "::"); }
     let first = true;
-    for id: str  in path.node.idents {
+    for id: str in path.node.idents {
         if first { first = false; } else { word(s.s, "::"); }
         word(s.s, id);
     }
@@ -1293,7 +1293,7 @@ fn print_view_item(s: &ps, item: &@ast::view_item) {
             word_space(s, "=");
         }
         let first = true;
-        for elt: str  in ids {
+        for elt: str in ids {
             if first { first = false; } else { word(s.s, "::"); }
             word(s.s, elt);
         }
@@ -1301,7 +1301,7 @@ fn print_view_item(s: &ps, item: &@ast::view_item) {
       ast::view_item_import_glob(ids, _) {
         head(s, "import");
         let first = true;
-        for elt: str  in ids {
+        for elt: str in ids {
             if first { first = false; } else { word(s.s, "::"); }
             word(s.s, elt);
         }
@@ -1320,7 +1320,7 @@ fn print_view_item(s: &ps, item: &@ast::view_item) {
 // FIXME: The fact that this builds up the table anew for every call is
 // not good. Eventually, table should be a const.
 fn operator_prec(op: ast::binop) -> int {
-    for spec: parse::parser::op_spec  in *parse::parser::prec_table() {
+    for spec: parse::parser::op_spec in *parse::parser::prec_table() {
         if spec.op == op { ret spec.prec; }
     }
     fail;
@@ -1497,7 +1497,7 @@ fn print_comment(s: &ps, cmnt: lexer::cmnt) {
       }
       lexer::isolated. {
         pprust::hardbreak_if_not_bol(s);
-        for line: str  in cmnt.lines { word(s.s, line); hardbreak(s.s); }
+        for line: str in cmnt.lines { word(s.s, line); hardbreak(s.s); }
       }
       lexer::trailing. {
         word(s.s, " ");
@@ -1506,7 +1506,7 @@ fn print_comment(s: &ps, cmnt: lexer::cmnt) {
             hardbreak(s.s);
         } else {
             ibox(s, 0u);
-            for line: str  in cmnt.lines { word(s.s, line); hardbreak(s.s); }
+            for line: str in cmnt.lines { word(s.s, line); hardbreak(s.s); }
             end(s);
         }
       }
@@ -1571,7 +1571,7 @@ fn constr_args_to_str[T](f: &fn(&T) -> str ,
                          args: &[@ast::sp_constr_arg[T]]) -> str {
     let comma = false;
     let s = "(";
-    for a: @ast::sp_constr_arg[T]  in args {
+    for a: @ast::sp_constr_arg[T] in args {
         if comma { s += ", "; } else { comma = true; }
         s += constr_arg_to_str[T](f, a.node);
     }
@@ -1602,7 +1602,7 @@ fn ast_ty_fn_constr_to_str(c: &@ast::constr) -> str {
 fn ast_ty_fn_constrs_str(constrs: &[@ast::constr]) -> str {
     let s = "";
     let colon = true;
-    for c: @ast::constr  in constrs {
+    for c: @ast::constr in constrs {
         if colon { s += " : "; colon = false; } else { s += ", "; }
         s += ast_ty_fn_constr_to_str(c);
     }
@@ -1624,7 +1624,7 @@ fn ast_fn_constrs_str(decl: &ast::fn_decl,
                       constrs: &[@ast::constr]) -> str {
     let s = "";
     let colon = true;
-    for c: @ast::constr  in constrs {
+    for c: @ast::constr in constrs {
         if colon { s += " : "; colon = false; } else { s += ", "; }
         s += ast_fn_constr_to_str(decl, c);
     }
@@ -1649,7 +1649,7 @@ fn ty_constr_to_str(c: &@ast::ty_constr) -> str {
 fn ast_ty_constrs_str(constrs: &[@ast::ty_constr]) -> str {
     let s = "";
     let colon = true;
-    for c: @ast::ty_constr  in constrs {
+    for c: @ast::ty_constr in constrs {
         if colon { s += " : "; colon = false; } else { s += ", "; }
         s += ty_constr_to_str(c);
     }
diff --git a/src/comp/syntax/visit.rs b/src/comp/syntax/visit.rs
index 2f366621c285..c4f6395c72f0 100644
--- a/src/comp/syntax/visit.rs
+++ b/src/comp/syntax/visit.rs
@@ -60,7 +60,7 @@ fn visit_crate_directive[E](cd: &@crate_directive, e: &E, v: &vt[E]) {
     alt cd.node {
       cdir_src_mod(_, _, _) { }
       cdir_dir_mod(_, _, cdirs, _) {
-        for cdir: @crate_directive  in cdirs {
+        for cdir: @crate_directive in cdirs {
             visit_crate_directive(cdir, e, v);
         }
       }
@@ -71,8 +71,8 @@ fn visit_crate_directive[E](cd: &@crate_directive, e: &E, v: &vt[E]) {
 }
 
 fn visit_mod[E](m: &_mod, sp: &span, e: &E, v: &vt[E]) {
-    for vi: @view_item  in m.view_items { v.visit_view_item(vi, e, v); }
-    for i: @item  in m.items { v.visit_item(i, e, v); }
+    for vi: @view_item in m.view_items { v.visit_view_item(vi, e, v); }
+    for i: @item in m.items { v.visit_item(i, e, v); }
 }
 
 fn visit_view_item[E](vi: &@view_item, e: &E, v: &vt[E]) { }
@@ -89,21 +89,21 @@ fn visit_item[E](i: &@item, e: &E, v: &vt[E]) {
       item_fn(f, tp) { v.visit_fn(f, tp, i.span, some(i.ident), i.id, e, v); }
       item_mod(m) { v.visit_mod(m, i.span, e, v); }
       item_native_mod(nm) {
-        for vi: @view_item  in nm.view_items { v.visit_view_item(vi, e, v); }
-        for ni: @native_item  in nm.items { v.visit_native_item(ni, e, v); }
+        for vi: @view_item in nm.view_items { v.visit_view_item(vi, e, v); }
+        for ni: @native_item in nm.items { v.visit_native_item(ni, e, v); }
       }
       item_ty(t, _) { v.visit_ty(t, e, v); }
       item_res(f, dtor_id, tps, _) {
         v.visit_fn(f, tps, i.span, some(i.ident), dtor_id, e, v);
       }
       item_tag(variants, _) {
-        for vr: variant  in variants {
-            for va: variant_arg  in vr.node.args { v.visit_ty(va.ty, e, v); }
+        for vr: variant in variants {
+            for va: variant_arg in vr.node.args { v.visit_ty(va.ty, e, v); }
         }
       }
       item_obj(ob, _, _) {
-        for f: obj_field  in ob.fields { v.visit_ty(f.ty, e, v); }
-        for m: @method  in ob.methods {
+        for f: obj_field in ob.fields { v.visit_ty(f.ty, e, v); }
+        for m: @method in ob.methods {
             v.visit_fn(m.node.meth, ~[], m.span, some(m.node.ident),
                        m.node.id, e, v);
         }
@@ -131,29 +131,29 @@ fn visit_ty[E](t: &@ty, e: &E, v: &vt[E]) {
       ty_chan(t) { v.visit_ty(t, e, v); }
       ty_task. {/* no-op */ }
       ty_rec(flds) {
-        for f: ty_field  in flds { v.visit_ty(f.node.mt.ty, e, v); }
+        for f: ty_field in flds { v.visit_ty(f.node.mt.ty, e, v); }
       }
       ty_tup(ts) {
         for tt in ts { v.visit_ty(tt, e, v); }
       }
       ty_fn(_, args, out, _, constrs) {
-        for a: ty_arg  in args { v.visit_ty(a.node.ty, e, v); }
-        for c: @constr  in constrs {
+        for a: ty_arg in args { v.visit_ty(a.node.ty, e, v); }
+        for c: @constr in constrs {
             v.visit_constr(c.node.path, c.span, c.node.id, e, v);
         }
         v.visit_ty(out, e, v);
       }
       ty_obj(tmeths) {
-        for m: ty_method  in tmeths {
-            for a: ty_arg  in m.node.inputs { v.visit_ty(a.node.ty, e, v); }
+        for m: ty_method in tmeths {
+            for a: ty_arg in m.node.inputs { v.visit_ty(a.node.ty, e, v); }
             v.visit_ty(m.node.output, e, v);
         }
       }
-      ty_path(p, _) { for tp: @ty  in p.node.types { v.visit_ty(tp, e, v); } }
+      ty_path(p, _) { for tp: @ty in p.node.types { v.visit_ty(tp, e, v); } }
       ty_type. {/* no-op */ }
       ty_constr(t, cs) {
         v.visit_ty(t, e, v);
-        for tc: @spanned[constr_general_[path, node_id]]  in cs {
+        for tc: @spanned[constr_general_[path, node_id]] in cs {
             v.visit_constr(tc.node.path, tc.span, tc.node.id, e, v);
         }
       }
@@ -169,11 +169,11 @@ fn visit_constr[E](operator: &path, sp: &span, id: node_id, e: &E,
 fn visit_pat[E](p: &@pat, e: &E, v: &vt[E]) {
     alt p.node {
       pat_tag(path, children) {
-        for tp: @ty  in path.node.types { v.visit_ty(tp, e, v); }
-        for child: @pat  in children { v.visit_pat(child, e, v); }
+        for tp: @ty in path.node.types { v.visit_ty(tp, e, v); }
+        for child: @pat in children { v.visit_pat(child, e, v); }
       }
       pat_rec(fields, _) {
-        for f: field_pat  in fields { v.visit_pat(f.pat, e, v); }
+        for f: field_pat in fields { v.visit_pat(f.pat, e, v); }
       }
       pat_tup(elts) {
         for elt in elts { v.visit_pat(elt, e, v); }
@@ -191,8 +191,8 @@ fn visit_native_item[E](ni: &@native_item, e: &E, v: &vt[E]) {
 }
 
 fn visit_fn_decl[E](fd: &fn_decl, e: &E, v: &vt[E]) {
-    for a: arg  in fd.inputs { v.visit_ty(a.ty, e, v); }
-    for c: @constr  in fd.constraints {
+    for a: arg in fd.inputs { v.visit_ty(a.ty, e, v); }
+    for c: @constr in fd.constraints {
         v.visit_constr(c.node.path, c.span, c.node.id, e, v);
     }
     v.visit_ty(fd.output, e, v);
@@ -205,7 +205,7 @@ fn visit_fn[E](f: &_fn, tp: &[ty_param], sp: &span, i: &fn_ident, id: node_id,
 }
 
 fn visit_block[E](b: &ast::blk, e: &E, v: &vt[E]) {
-    for s: @stmt  in b.node.stmts { v.visit_stmt(s, e, v); }
+    for s: @stmt in b.node.stmts { v.visit_stmt(s, e, v); }
     visit_expr_opt(b.node.expr, e, v);
 }
 
@@ -220,7 +220,7 @@ fn visit_stmt[E](s: &@stmt, e: &E, v: &vt[E]) {
 fn visit_decl[E](d: &@decl, e: &E, v: &vt[E]) {
     alt d.node {
       decl_local(locs) {
-        for loc: @ast::local  in locs { v.visit_local(loc, e, v); }
+        for loc: @ast::local in locs { v.visit_local(loc, e, v); }
       }
       decl_item(it) { v.visit_item(it, e, v); }
     }
@@ -231,7 +231,7 @@ fn visit_expr_opt[E](eo: option::t[@expr], e: &E, v: &vt[E]) {
 }
 
 fn visit_exprs[E](exprs: &[@expr], e: &E, v: &vt[E]) {
-    for ex: @expr  in exprs { v.visit_expr(ex, e, v); }
+    for ex: @expr in exprs { v.visit_expr(ex, e, v); }
 }
 
 fn visit_mac[E](m: mac, e: &E, v: &vt[E]) {
@@ -247,7 +247,7 @@ fn visit_expr[E](ex: &@expr, e: &E, v: &vt[E]) {
     alt ex.node {
       expr_vec(es, _, _) { visit_exprs(es, e, v); }
       expr_rec(flds, base) {
-        for f: field  in flds { v.visit_expr(f.node.expr, e, v); }
+        for f: field in flds { v.visit_expr(f.node.expr, e, v); }
         visit_expr_opt(base, e, v);
       }
       expr_tup(elts) {
@@ -260,7 +260,7 @@ fn visit_expr[E](ex: &@expr, e: &E, v: &vt[E]) {
       expr_self_method(_) { }
       expr_bind(callee, args) {
         v.visit_expr(callee, e, v);
-        for eo: option::t[@expr]  in args { visit_expr_opt(eo, e, v); }
+        for eo: option::t[@expr] in args { visit_expr_opt(eo, e, v); }
       }
       expr_spawn(_, _, callee, args) {
         v.visit_expr(callee, e, v);
@@ -294,7 +294,7 @@ fn visit_expr[E](ex: &@expr, e: &E, v: &vt[E]) {
       expr_do_while(b, x) { v.visit_block(b, e, v); v.visit_expr(x, e, v); }
       expr_alt(x, arms) {
         v.visit_expr(x, e, v);
-        for a: arm  in arms { v.visit_arm(a, e, v); }
+        for a: arm in arms { v.visit_arm(a, e, v); }
       }
       expr_fn(f) { v.visit_fn(f, ~[], ex.span, none, ex.id, e, v); }
       expr_block(b) { v.visit_block(b, e, v); }
@@ -310,7 +310,7 @@ fn visit_expr[E](ex: &@expr, e: &E, v: &vt[E]) {
       expr_recv(a, b) { v.visit_expr(a, e, v); v.visit_expr(b, e, v); }
       expr_field(x, _) { v.visit_expr(x, e, v); }
       expr_index(a, b) { v.visit_expr(a, e, v); v.visit_expr(b, e, v); }
-      expr_path(p) { for tp: @ty  in p.node.types { v.visit_ty(tp, e, v); } }
+      expr_path(p) { for tp: @ty in p.node.types { v.visit_ty(tp, e, v); } }
       expr_fail(eo) { visit_expr_opt(eo, e, v); }
       expr_break. { }
       expr_cont. { }
@@ -326,7 +326,7 @@ fn visit_expr[E](ex: &@expr, e: &E, v: &vt[E]) {
         alt anon_obj.fields {
           none. { }
           some(fields) {
-            for f: anon_obj_field  in fields {
+            for f: anon_obj_field in fields {
                 v.visit_ty(f.ty, e, v);
                 v.visit_expr(f.expr, e, v);
             }
@@ -336,7 +336,7 @@ fn visit_expr[E](ex: &@expr, e: &E, v: &vt[E]) {
           none. { }
           some(ex) { v.visit_expr(ex, e, v); }
         }
-        for m: @method  in anon_obj.methods {
+        for m: @method in anon_obj.methods {
             v.visit_fn(m.node.meth, ~[], m.span, some(m.node.ident),
                        m.node.id, e, v);
         }
@@ -347,7 +347,7 @@ fn visit_expr[E](ex: &@expr, e: &E, v: &vt[E]) {
 }
 
 fn visit_arm[E](a: &arm, e: &E, v: &vt[E]) {
-    for p: @pat  in a.pats { v.visit_pat(p, e, v); }
+    for p: @pat in a.pats { v.visit_pat(p, e, v); }
     v.visit_block(a.body, e, v);
 }
 
diff --git a/src/comp/util/common.rs b/src/comp/util/common.rs
index 30e77fa4a599..fe6fc00ae6f9 100644
--- a/src/comp/util/common.rs
+++ b/src/comp/util/common.rs
@@ -51,7 +51,7 @@ fn field_expr(f: &ast::field) -> @ast::expr { ret f.node.expr; }
 
 fn field_exprs(fields: &[ast::field]) -> [@ast::expr] {
     let es = ~[];
-    for f: ast::field  in fields { es += ~[f.node.expr]; }
+    for f: ast::field in fields { es += ~[f.node.expr]; }
     ret es;
 }
 
diff --git a/src/comp/util/ppaux.rs b/src/comp/util/ppaux.rs
index 50d2799d7f0f..faa9195b35bd 100644
--- a/src/comp/util/ppaux.rs
+++ b/src/comp/util/ppaux.rs
@@ -48,7 +48,7 @@ fn ty_to_str(cx: &ctxt, typ: &t) -> str {
         alt ident { some(i) { s += " "; s += i; } _ { } }
         s += "(";
         let strs = ~[];
-        for a: arg  in inputs { strs += ~[fn_input_to_str(cx, a)]; }
+        for a: arg in inputs { strs += ~[fn_input_to_str(cx, a)]; }
         s += str::connect(strs, ", ");
         s += ")";
         if struct(cx, output) != ty_nil {
@@ -100,7 +100,7 @@ fn ty_to_str(cx: &ctxt, typ: &t) -> str {
       ty_task. { s += "task"; }
       ty_rec(elems) {
         let strs: [str] = ~[];
-        for fld: field  in elems { strs += ~[field_to_str(cx, fld)]; }
+        for fld: field in elems { strs += ~[field_to_str(cx, fld)]; }
         s += "{" + str::connect(strs, ",") + "}";
       }
       ty_tup(elems) {
@@ -114,7 +114,7 @@ fn ty_to_str(cx: &ctxt, typ: &t) -> str {
         s += "<tag#" + int::str(id.crate) + ":" + int::str(id.node) + ">";
         if ivec::len[t](tps) > 0u {
             let strs: [str] = ~[];
-            for typ: t  in tps { strs += ~[ty_to_str(cx, typ)]; }
+            for typ: t in tps { strs += ~[ty_to_str(cx, typ)]; }
             s += "[" + str::connect(strs, ",") + "]";
         }
       }
@@ -128,7 +128,7 @@ fn ty_to_str(cx: &ctxt, typ: &t) -> str {
       }
       ty_obj(meths) {
         let strs = ~[];
-        for m: method  in meths { strs += ~[method_to_str(cx, m)]; }
+        for m: method in meths { strs += ~[method_to_str(cx, m)]; }
         s += "obj {\n\t" + str::connect(strs, "\n\t") + "\n}";
       }
       ty_res(id, _, _) {
@@ -158,7 +158,7 @@ fn constr_to_str(c: &@constr) -> str {
 fn constrs_str(constrs: &[@constr]) -> str {
     let s = "";
     let colon = true;
-    for c: @constr  in constrs {
+    for c: @constr in constrs {
         if colon { s += " : "; colon = false; } else { s += ", "; }
         s += constr_to_str(c);
     }
diff --git a/src/fuzzer/ivec_fuzz.rs b/src/fuzzer/ivec_fuzz.rs
index 8448ef1dadfb..e4140898b9df 100644
--- a/src/fuzzer/ivec_fuzz.rs
+++ b/src/fuzzer/ivec_fuzz.rs
@@ -65,17 +65,17 @@ fn vec_edits[T](v: &[T], xs: &[T]) -> [[T]] {
 
     }
 
-    for each i: uint  in ix(0u, 1u, Lv) { edits += ~[vec_omit(v, i)]; }
-    for each i: uint  in ix(0u, 1u, Lv) { edits += ~[vec_dup(v, i)]; }
-    for each i: uint  in ix(0u, 2u, Lv) { edits += ~[vec_swadj(v, i)]; }
-    for each i: uint  in ix(1u, 2u, Lv) { edits += ~[vec_prefix(v, i)]; }
-    for each i: uint  in ix(2u, 1u, Lv) { edits += ~[vec_suffix(v, i)]; }
+    for each i: uint in ix(0u, 1u, Lv) { edits += ~[vec_omit(v, i)]; }
+    for each i: uint in ix(0u, 1u, Lv) { edits += ~[vec_dup(v, i)]; }
+    for each i: uint in ix(0u, 2u, Lv) { edits += ~[vec_swadj(v, i)]; }
+    for each i: uint in ix(1u, 2u, Lv) { edits += ~[vec_prefix(v, i)]; }
+    for each i: uint in ix(2u, 1u, Lv) { edits += ~[vec_suffix(v, i)]; }
 
-    for each j: uint  in ix(0u, 1u, len(xs)) {
-        for each i: uint  in ix(0u, 1u, Lv) {
+    for each j: uint in ix(0u, 1u, len(xs)) {
+        for each i: uint in ix(0u, 1u, Lv) {
             edits += ~[vec_poke(v, i, xs.(j))];
         }
-        for each i: uint  in ix(0u, 0u, Lv) {
+        for each i: uint in ix(0u, 0u, Lv) {
             edits += ~[vec_insert(v, i, xs.(j))];
         }
     }
@@ -99,7 +99,7 @@ fn vec_to_str(v: &[int]) -> str {
 fn show_edits(a: &[int], xs: &[int]) {
     log_err "=== Edits of " + vec_to_str(a) + " ===";
     let b = vec_edits(a, xs);
-    for each i: uint  in ix(0u, 1u, len(b)) { log_err vec_to_str(b.(i)); }
+    for each i: uint in ix(0u, 1u, len(b)) { log_err vec_to_str(b.(i)); }
 }
 
 fn demo_edits() {
diff --git a/src/lib/bitv.rs b/src/lib/bitv.rs
index b241cce6b3d7..64932c17cc4c 100644
--- a/src/lib/bitv.rs
+++ b/src/lib/bitv.rs
@@ -41,7 +41,7 @@ fn process(op: &block(uint, uint) -> uint , v0: &t, v1: &t) -> bool {
     assert (ivec::len(v0.storage) == len);
     assert (v0.nbits == v1.nbits);
     let changed = false;
-    for each i: uint  in uint::range(0u, len) {
+    for each i: uint in uint::range(0u, len) {
         let w0 = v0.storage.(i);
         let w1 = v1.storage.(i);
         let w = op(w0, w1);
@@ -71,7 +71,7 @@ fn assign(v0: &t, v1: t) -> bool {
 fn clone(v: t) -> t {
     let storage = ivec::init_elt_mut[uint](0u, v.nbits / uint_bits() + 1u);
     let len = ivec::len(v.storage);
-    for each i: uint  in uint::range(0u, len) { storage.(i) = v.storage.(i); }
+    for each i: uint in uint::range(0u, len) { storage.(i) = v.storage.(i); }
     ret @{storage: storage, nbits: v.nbits};
 }
 
@@ -98,17 +98,17 @@ fn equal(v0: &t, v1: &t) -> bool {
 }
 
 fn clear(v: &t) {
-    for each i: uint  in uint::range(0u, ivec::len(v.storage)) {
+    for each i: uint in uint::range(0u, ivec::len(v.storage)) {
         v.storage.(i) = 0u;
     }
 }
 
 fn set_all(v: &t) {
-    for each i: uint  in uint::range(0u, v.nbits) { set(v, i, true); }
+    for each i: uint in uint::range(0u, v.nbits) { set(v, i, true); }
 }
 
 fn invert(v: &t) {
-    for each i: uint  in uint::range(0u, ivec::len(v.storage)) {
+    for each i: uint in uint::range(0u, ivec::len(v.storage)) {
         v.storage.(i) = !v.storage.(i);
     }
 }
@@ -135,14 +135,14 @@ fn set(v: &t, i: uint, x: bool) {
 
 /* true if all bits are 1 */
 fn is_true(v: &t) -> bool {
-    for i: uint  in to_ivec(v) { if i != 1u { ret false; } }
+    for i: uint in to_ivec(v) { if i != 1u { ret false; } }
     ret true;
 }
 
 
 /* true if all bits are non-1 */
 fn is_false(v: &t) -> bool {
-    for i: uint  in to_ivec(v) { if i == 1u { ret false; } }
+    for i: uint in to_ivec(v) { if i == 1u { ret false; } }
     ret true;
 }
 
@@ -155,7 +155,7 @@ fn to_ivec(v: &t) -> [uint] {
 
 fn to_str(v: &t) -> str {
     let rs = "";
-    for i: uint  in to_ivec(v) {
+    for i: uint in to_ivec(v) {
         if i == 1u { rs += "1"; } else { rs += "0"; }
     }
     ret rs;
diff --git a/src/lib/either.rs b/src/lib/either.rs
index 4c84e804185f..018eee24dc63 100644
--- a/src/lib/either.rs
+++ b/src/lib/either.rs
@@ -12,7 +12,7 @@ fn either[T, U, V](f_left: &block(&T) -> V, f_right: &block(&U) -> V,
 
 fn lefts[T, U](eithers: &[t[T, U]]) -> [T] {
     let result: [T] = ~[];
-    for elt: t[T, U]  in eithers {
+    for elt: t[T, U] in eithers {
         alt elt { left(l) { result += ~[l] } _ {/* fallthrough */ } }
     }
     ret result;
@@ -20,7 +20,7 @@ fn lefts[T, U](eithers: &[t[T, U]]) -> [T] {
 
 fn rights[T, U](eithers: &[t[T, U]]) -> [U] {
     let result: [U] = ~[];
-    for elt: t[T, U]  in eithers {
+    for elt: t[T, U] in eithers {
         alt elt { right(r) { result += ~[r] } _ {/* fallthrough */ } }
     }
     ret result;
@@ -29,7 +29,7 @@ fn rights[T, U](eithers: &[t[T, U]]) -> [U] {
 fn partition[T, U](eithers: &[t[T, U]]) -> {lefts: [T], rights: [U]} {
     let lefts: [T] = ~[];
     let rights: [U] = ~[];
-    for elt: t[T, U]  in eithers {
+    for elt: t[T, U] in eithers {
         alt elt { left(l) { lefts += ~[l] } right(r) { rights += ~[r] } }
     }
     ret {lefts: lefts, rights: rights};
diff --git a/src/lib/extfmt.rs b/src/lib/extfmt.rs
index 4ca7d873d1f1..13cfda6e1900 100644
--- a/src/lib/extfmt.rs
+++ b/src/lib/extfmt.rs
@@ -440,7 +440,7 @@ mod rt {
         ret padstr + s;
     }
     fn have_flag(flags: &[flag], f: flag) -> bool {
-        for candidate: flag  in flags { if candidate == f { ret true; } }
+        for candidate: flag in flags { if candidate == f { ret true; } }
         ret false;
     }
 }
diff --git a/src/lib/fs.rs b/src/lib/fs.rs
index 9f47b2d11f7f..e3eb47802b62 100644
--- a/src/lib/fs.rs
+++ b/src/lib/fs.rs
@@ -48,7 +48,7 @@ fn list_dir(p: path) -> [str] {
     let pl = str::byte_len(p);
     if pl == 0u || p.(pl - 1u) as char != os_fs::path_sep { p += path_sep(); }
     let full_paths: [str] = ~[];
-    for filename: str  in os_fs::list_dir(p) {
+    for filename: str in os_fs::list_dir(p) {
         if !str::eq(filename, ".") {
             if !str::eq(filename, "..") { full_paths += ~[p + filename]; }
         }
diff --git a/src/lib/getopts.rs b/src/lib/getopts.rs
index 57d680720ba5..68e1b40edc37 100644
--- a/src/lib/getopts.rs
+++ b/src/lib/getopts.rs
@@ -146,7 +146,7 @@ fn getopts(args: &[str], opts: &[opt]) -> result {
                 }
             }
             let name_pos = 0u;
-            for nm: name  in names {
+            for nm: name in names {
                 name_pos += 1u;
                 let optid;
                 alt find_opt(opts, nm) {
@@ -218,7 +218,7 @@ fn opt_str(m: &match, nm: str) -> str {
 
 fn opt_strs(m: &match, nm: str) -> [str] {
     let acc: [str] = ~[];
-    for v: optval  in opt_vals(m, nm) {
+    for v: optval in opt_vals(m, nm) {
         alt v { val(s) { acc += ~[s]; } _ { } }
     }
     ret acc;
diff --git a/src/lib/io.rs b/src/lib/io.rs
index 35969a3c8d7b..8349b67712eb 100644
--- a/src/lib/io.rs
+++ b/src/lib/io.rs
@@ -291,7 +291,7 @@ obj fd_buf_writer(fd: int, res: option::t[@fd_res]) {
 fn file_buf_writer(path: str, flags: &[fileflag]) -> buf_writer {
     let fflags: int =
         os::libc_constants::O_WRONLY() | os::libc_constants::O_BINARY();
-    for f: fileflag  in flags {
+    for f: fileflag in flags {
         alt f {
           append. { fflags |= os::libc_constants::O_APPEND(); }
           create. { fflags |= os::libc_constants::O_CREAT(); }
@@ -402,7 +402,7 @@ obj byte_buf_writer(buf: mutable_byte_buf) {
         // Fast path.
 
         if buf.pos == ivec::len(buf.buf) {
-            for b: u8  in v { buf.buf += ~[mutable b]; }
+            for b: u8 in v { buf.buf += ~[mutable b]; }
             buf.pos += ivec::len[u8](v);
             ret;
         }
diff --git a/src/lib/ivec.rs b/src/lib/ivec.rs
index 363eca6c0daa..d8285b74ad12 100644
--- a/src/lib/ivec.rs
+++ b/src/lib/ivec.rs
@@ -74,13 +74,13 @@ fn init_elt_mut[@T](t: &T, n_elts: uint) -> [mutable T] {
 
 fn to_mut[@T](v: &[T]) -> [mutable T] {
     let vres = ~[mutable];
-    for t: T  in v { vres += ~[mutable t]; }
+    for t: T in v { vres += ~[mutable t]; }
     ret vres;
 }
 
 fn from_mut[@T](v: &[mutable T]) -> [T] {
     let vres = ~[];
-    for t: T  in v { vres += ~[t]; }
+    for t: T in v { vres += ~[t]; }
     ret vres;
 }
 
@@ -193,7 +193,7 @@ fn grow_set[@T](v: &mutable [mutable T], index: uint, initval: &T, val: &T) {
 fn map[@T, @U](f: &block(&T) -> U , v: &[mutable? T]) -> [U] {
     let result = ~[];
     reserve(result, len(v));
-    for elem: T  in v {
+    for elem: T in v {
         let elem2 = elem; // satisfies alias checker
         result += ~[f(elem2)];
     }
@@ -213,7 +213,7 @@ fn map2[@T, @U, @V](f: &block(&T, &U) -> V, v0: &[T], v1: &[U])
 fn filter_map[@T, @U](f: &block(&T) -> option::t[U],
                       v: &[mutable? T]) -> [U] {
     let result = ~[];
-    for elem: T  in v {
+    for elem: T in v {
         let elem2 = elem; // satisfies alias checker
         alt f(elem2) {
           none. {/* no-op */ }
@@ -232,28 +232,28 @@ fn foldl[@T, @U](p: &block(&U, &T) -> U , z: &U, v: &[mutable? T]) -> U {
 }
 
 fn any[T](f: &block(&T) -> bool , v: &[T]) -> bool {
-    for elem: T  in v { if f(elem) { ret true; } }
+    for elem: T in v { if f(elem) { ret true; } }
     ret false;
 }
 
 fn all[T](f: &block(&T) -> bool , v: &[T]) -> bool {
-    for elem: T  in v { if !f(elem) { ret false; } }
+    for elem: T in v { if !f(elem) { ret false; } }
     ret true;
 }
 
 fn member[T](x: &T, v: &[T]) -> bool {
-    for elt: T  in v { if x == elt { ret true; } }
+    for elt: T in v { if x == elt { ret true; } }
     ret false;
 }
 
 fn count[T](x: &T, v: &[mutable? T]) -> uint {
     let cnt = 0u;
-    for elt: T  in v { if x == elt { cnt += 1u; } }
+    for elt: T in v { if x == elt { cnt += 1u; } }
     ret cnt;
 }
 
 fn find[@T](f: &block(&T) -> bool , v: &[T]) -> option::t[T] {
-    for elt: T  in v { if f(elt) { ret some(elt); } }
+    for elt: T in v { if f(elt) { ret some(elt); } }
     ret none;
 }
 
diff --git a/src/lib/list.rs b/src/lib/list.rs
index f096d5fd2e9f..1ef84ee79e70 100644
--- a/src/lib/list.rs
+++ b/src/lib/list.rs
@@ -9,7 +9,7 @@ fn from_vec[@T](v: &[T]) -> list[T] {
     // a reverse vector iterator. Unfortunately generic iterators seem not to
     // work yet.
 
-    for item: T  in ivec::reversed(v) { l = cons[T](item, @l); }
+    for item: T in ivec::reversed(v) { l = cons[T](item, @l); }
     ret l;
 }
 
diff --git a/src/lib/map.rs b/src/lib/map.rs
index 68aecc6cbe07..6431d4a4d420 100644
--- a/src/lib/map.rs
+++ b/src/lib/map.rs
@@ -100,7 +100,7 @@ fn mk_hashmap[@K, @V](hasher: &hashfn[K], eqer: &eqfn[K]) -> hashmap[K, V] {
     fn rehash[@K, @V](hasher: &hashfn[K], eqer: &eqfn[K],
                       oldbkts: &[mutable bucket[K, V]], noldbkts: uint,
                       newbkts: &[mutable bucket[K, V]], nnewbkts: uint) {
-        for b: bucket[K, V]  in oldbkts {
+        for b: bucket[K, V] in oldbkts {
             alt b {
               some(k_, v_) {
                 let k = k_;
@@ -177,12 +177,12 @@ fn mk_hashmap[@K, @V](hasher: &hashfn[K], eqer: &eqfn[K]) -> hashmap[K, V] {
             bkts = newbkts;
         }
         iter items() -> @{key: K, val: V} {
-            for b: bucket[K, V]  in bkts {
+            for b: bucket[K, V] in bkts {
                 alt b { some(k, v) { put @{key: k, val: v}; } _ { } }
             }
         }
         iter keys() -> K {
-            for b: bucket[K, V]  in bkts {
+            for b: bucket[K, V] in bkts {
                 alt b { some(k, _) { put k; } _ { } }
             }
         }
diff --git a/src/lib/run_program.rs b/src/lib/run_program.rs
index 72e34ac1970d..c2ee4d72cd0d 100644
--- a/src/lib/run_program.rs
+++ b/src/lib/run_program.rs
@@ -14,7 +14,7 @@ native "rust" mod rustrt {
 
 fn arg_vec(prog: str, args: &[str]) -> [sbuf] {
     let argptrs = ~[str::buf(prog)];
-    for arg: str  in args { argptrs += ~[str::buf(arg)]; }
+    for arg: str in args { argptrs += ~[str::buf(arg)]; }
     argptrs += ~[0 as sbuf];
     ret argptrs;
 }
diff --git a/src/lib/sha1.rs b/src/lib/sha1.rs
index 97076f8b5d0b..9b54ecdaea08 100644
--- a/src/lib/sha1.rs
+++ b/src/lib/sha1.rs
@@ -64,7 +64,7 @@ fn mk_sha1() -> sha1 {
         // FIXME: Should be typestate precondition
 
         assert (!st.computed);
-        for element: u8  in msg {
+        for element: u8 in msg {
             st.msg_block.(st.msg_block_idx) = element;
             st.msg_block_idx += 1u;
             st.len_low += 8u32;
@@ -165,7 +165,7 @@ fn mk_sha1() -> sha1 {
     fn mk_result(st: &sha1state) -> [u8] {
         if !st.computed { pad_msg(st); st.computed = true; }
         let rs: [u8] = ~[];
-        for hpart: u32  in st.h {
+        for hpart: u32 in st.h {
             let a = hpart >> 24u32 & 0xFFu32 as u8;
             let b = hpart >> 16u32 & 0xFFu32 as u8;
             let c = hpart >> 8u32 & 0xFFu32 as u8;
@@ -243,7 +243,7 @@ fn mk_sha1() -> sha1 {
         fn result_str() -> str {
             let r = mk_result(st);
             let s = "";
-            for b: u8  in r { s += uint::to_str(b as uint, 16u); }
+            for b: u8 in r { s += uint::to_str(b as uint, 16u); }
             ret s;
         }
     }
diff --git a/src/lib/str.rs b/src/lib/str.rs
index 3210e31e9e45..d229b7d25fae 100644
--- a/src/lib/str.rs
+++ b/src/lib/str.rs
@@ -100,7 +100,7 @@ fn hash(s: &str) -> uint {
     // FIXME: replace with murmur.
 
     let u: uint = 5381u;
-    for c: u8  in s { u *= 33u; u += c as uint; }
+    for c: u8 in s { u *= 33u; u += c as uint; }
     ret u;
 }
 
@@ -156,7 +156,7 @@ fn is_ascii(s: str) -> bool {
 fn alloc(n_bytes: uint) -> str { ret rustrt::str_alloc(n_bytes); }
 
 /// Returns true if the string has length 0
-pred is_empty(s: str) -> bool { for c: u8  in s { ret false; } ret true; }
+pred is_empty(s: str) -> bool { for c: u8 in s { ret false; } ret true; }
 
 /// Returns true if the string has length greater than 0
 pred is_not_empty(s: str) -> bool { !is_empty(s) }
@@ -240,7 +240,7 @@ fn from_char(ch: char) -> str {
 
 fn from_chars(chs: &[char]) -> str {
     let buf = "";
-    for ch: char  in chs { push_utf8_bytes(buf, ch); }
+    for ch: char in chs { push_utf8_bytes(buf, ch); }
     ret buf;
 }
 
@@ -337,7 +337,7 @@ fn refcount(s: str) -> uint {
 // Standard bits from the world of string libraries.
 fn index(s: str, c: u8) -> int {
     let i: int = 0;
-    for k: u8  in s { if k == c { ret i; } i += 1; }
+    for k: u8 in s { if k == c { ret i; } i += 1; }
     ret -1;
 }
 
@@ -353,7 +353,7 @@ fn find(haystack: str, needle: str) -> int {
     if needle_len == 0 { ret 0; }
     fn match_at(haystack: &str, needle: &str, i: int) -> bool {
         let j: int = i;
-        for c: u8  in needle { if haystack.(j) != c { ret false; } j += 1; }
+        for c: u8 in needle { if haystack.(j) != c { ret false; } j += 1; }
         ret true;
     }
     let i: int = 0;
@@ -436,7 +436,7 @@ fn split(s: str, sep: u8) -> [str] {
     let v: [str] = ~[];
     let accum: str = "";
     let ends_with_sep: bool = false;
-    for c: u8  in s {
+    for c: u8 in s {
         if c == sep {
             v += ~[accum];
             accum = "";
@@ -449,14 +449,14 @@ fn split(s: str, sep: u8) -> [str] {
 
 fn concat(v: &[str]) -> str {
     let s: str = "";
-    for ss: str  in v { s += ss; }
+    for ss: str in v { s += ss; }
     ret s;
 }
 
 fn connect(v: &[str], sep: str) -> str {
     let s: str = "";
     let first: bool = true;
-    for ss: str  in v {
+    for ss: str in v {
         if first { first = false; } else { s += sep; }
         s += ss;
     }
@@ -470,7 +470,7 @@ fn to_upper(s: str) -> str {
     let ascii_a = 'a' as u8;
     let ascii_z = 'z' as u8;
     let diff = 32u8;
-    for byte: u8  in s {
+    for byte: u8 in s {
         let next;
         if ascii_a <= byte && byte <= ascii_z {
             next = byte - diff;
diff --git a/src/lib/term.rs b/src/lib/term.rs
index 4d635e780b27..8891a9ddadd4 100644
--- a/src/lib/term.rs
+++ b/src/lib/term.rs
@@ -51,7 +51,7 @@ fn color_supported() -> bool {
     let supported_terms = ~["xterm-color", "xterm", "screen-bce"];
     ret alt generic_os::getenv("TERM") {
           option::some(env) {
-            for term: str  in supported_terms {
+            for term: str in supported_terms {
                 if str::eq(term, env) { ret true; }
             }
             false
diff --git a/src/lib/test.rs b/src/lib/test.rs
index abff663a8da4..d6b151dd18f3 100644
--- a/src/lib/test.rs
+++ b/src/lib/test.rs
@@ -50,7 +50,7 @@ type test_desc = {name: test_name, fn: test_fn, ignore: bool};
 // arguments and a vector of test_descs (generated at compile time).
 fn test_main(args: &vec[str], tests: &[test_desc]) {
     let ivec_args =
-        { let iargs = ~[]; for arg: str  in args { iargs += ~[arg] } iargs };
+        { let iargs = ~[]; for arg: str in args { iargs += ~[arg] } iargs };
     check (ivec::is_not_empty(ivec_args));
     let opts =
         alt parse_opts(ivec_args) {
diff --git a/src/test/bench/99bob-iter.rs b/src/test/bench/99bob-iter.rs
index 3807c893b0b3..cf1989ce2949 100644
--- a/src/test/bench/99bob-iter.rs
+++ b/src/test/bench/99bob-iter.rs
@@ -43,11 +43,11 @@ fn sub(t: str, n: int) -> str {
 iter ninetynine() -> int { let n: int = 100; while n > 1 { n -= 1; put n; } }
 
 fn main() {
-    for each n: int  in ninetynine() {
+    for each n: int in ninetynine() {
         log sub(b1(), n);
         log sub(b2(), n - 1);
         log "";
     }
     log b7();
     log b8();
-}
\ No newline at end of file
+}
diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs
index c7d50e5b3871..38f51fa65be3 100644
--- a/src/test/bench/shootout-fasta.rs
+++ b/src/test/bench/shootout-fasta.rs
@@ -26,7 +26,7 @@ type aminoacids = {ch: char, prob: u32};
 fn make_cumulative(aa: &[aminoacids]) -> [aminoacids] {
     let cp: u32 = 0u32;
     let ans: [aminoacids] = ~[];
-    for a: aminoacids  in aa { cp += a.prob; ans += ~[{ch: a.ch, prob: cp}]; }
+    for a: aminoacids in aa { cp += a.prob; ans += ~[{ch: a.ch, prob: cp}]; }
     ret ans;
 }
 
@@ -47,7 +47,7 @@ fn make_random_fasta(id: str, desc: str, genelist: &[aminoacids], n: int) {
     log ">" + id + " " + desc;
     let rng = myrandom(std::rand::mk_rng().next());
     let op: str = "";
-    for each i: uint  in uint::range(0u, n as uint) {
+    for each i: uint in uint::range(0u, n as uint) {
         str::push_byte(op, select_random(rng.next(100u32), genelist) as u8);
         if str::byte_len(op) >= LINE_LENGTH() { log op; op = ""; }
     }
@@ -58,7 +58,7 @@ fn make_repeat_fasta(id: str, desc: str, s: str, n: int) {
     log ">" + id + " " + desc;
     let op: str = "";
     let sl: uint = str::byte_len(s);
-    for each i: uint  in uint::range(0u, n as uint) {
+    for each i: uint in uint::range(0u, n as uint) {
         str::push_byte(op, s.(i % sl));
         if str::byte_len(op) >= LINE_LENGTH() { log op; op = ""; }
     }
@@ -91,4 +91,4 @@ fn main(args: vec[str]) {
     make_repeat_fasta("ONE", "Homo sapiens alu", alu, n * 2);
     make_random_fasta("TWO", "IUB ambiguity codes", iub, n * 3);
     make_random_fasta("THREE", "Homo sapiens frequency", homosapiens, n * 5);
-}
\ No newline at end of file
+}
diff --git a/src/test/bench/shootout-nbody.rs b/src/test/bench/shootout-nbody.rs
index 5be089671d9e..f248dff1cda9 100644
--- a/src/test/bench/shootout-nbody.rs
+++ b/src/test/bench/shootout-nbody.rs
@@ -17,7 +17,7 @@ fn main() {
     let bodies: [Body::props] = NBodySystem::MakeNBodySystem();
 
 
-    for n: int  in inputs {
+    for n: int in inputs {
         log NBodySystem::energy(bodies);
 
         let i: int = 0;
@@ -201,4 +201,4 @@ mod Body {
         props.vz = -pz / SOLAR_MASS;
     }
 
-}
\ No newline at end of file
+}
diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs
index 16ae17f1ee59..4c41c1f05b7c 100644
--- a/src/test/bench/shootout-pfib.rs
+++ b/src/test/bench/shootout-pfib.rs
@@ -73,7 +73,7 @@ fn stress_task(id: int) {
 
 fn stress(num_tasks: int) {
     let tasks = [];
-    for each i: int  in range(0, num_tasks) {
+    for each i: int in range(0, num_tasks) {
         tasks += [task::_spawn(bind stress_task(i))];
     }
     for t in tasks { task::join_id(t); }
@@ -99,8 +99,8 @@ fn main(argv: vec[str]) {
             let out = io::stdout();
 
 
-            for each n: int  in range(1, max + 1) {
-                for each i: int  in range(0, num_trials) {
+            for each n: int in range(1, max + 1) {
+                for each i: int in range(0, num_trials) {
                     let start = time::precise_time_ns();
                     let fibn = fib(n);
                     let stop = time::precise_time_ns();
@@ -113,4 +113,4 @@ fn main(argv: vec[str]) {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/bench/task-perf-word-count.rs b/src/test/bench/task-perf-word-count.rs
index 0b84271f59df..c67697f29d43 100644
--- a/src/test/bench/task-perf-word-count.rs
+++ b/src/test/bench/task-perf-word-count.rs
@@ -76,7 +76,7 @@ mod map_reduce {
 
     fn start_mappers(ctrl: _chan[ctrl_proto], inputs: &[str]) -> [task_id] {
         let tasks = ~[];
-        for i: str  in inputs {
+        for i: str in inputs {
             tasks += ~[task::_spawn(bind map_task(ctrl, i))];
         }
         ret tasks;
diff --git a/src/test/compile-fail/for-loop-decl.rs b/src/test/compile-fail/for-loop-decl.rs
index 5b7fa90a74de..b3c5c21d0ef0 100644
--- a/src/test/compile-fail/for-loop-decl.rs
+++ b/src/test/compile-fail/for-loop-decl.rs
@@ -10,10 +10,10 @@ fn bitv_to_str(enclosing: fn_info, v: bitv::t) -> str {
     let s = "";
 
     // error is that the value type in the hash map is var_info, not a box
-    for each p: @{key: uint, val: @uint}  in enclosing.vars.items() {
+    for each p: @{key: uint, val: @uint} in enclosing.vars.items() {
         if bitv::get(v, *p.val) { s += "foo"; }
     }
     ret s;
 }
 
-fn main() { log "OK"; }
\ No newline at end of file
+fn main() { log "OK"; }
diff --git a/src/test/compile-fail/shadow.rs b/src/test/compile-fail/shadow.rs
index 73cf4ac9655b..3576a1e4ded8 100644
--- a/src/test/compile-fail/shadow.rs
+++ b/src/test/compile-fail/shadow.rs
@@ -6,10 +6,10 @@ fn foo(c: [int]) {
 
 
     alt none[int] {
-      some[int](_) { for i: int  in c { log a; let a = 17; b += ~[a]; } }
+      some[int](_) { for i: int in c { log a; let a = 17; b += ~[a]; } }
     }
 }
 
 tag t[T] { none; some(T); }
 
-fn main() { foo(~[]); }
\ No newline at end of file
+fn main() { foo(~[]); }
diff --git a/src/test/compile-fail/unsafe-for.rs b/src/test/compile-fail/unsafe-for.rs
index 829dbd41c1b9..43e8b9cb7c24 100644
--- a/src/test/compile-fail/unsafe-for.rs
+++ b/src/test/compile-fail/unsafe-for.rs
@@ -2,5 +2,5 @@
 
 fn main() {
     let v: [mutable int] = ~[mutable 1, 2, 3];
-    for x: int  in v { v.(0) = 10; log x; }
-}
\ No newline at end of file
+    for x: int in v { v.(0) = 10; log x; }
+}
diff --git a/src/test/compiletest/compiletest.rs b/src/test/compiletest/compiletest.rs
index 910118184238..870999e7b04b 100644
--- a/src/test/compiletest/compiletest.rs
+++ b/src/test/compiletest/compiletest.rs
@@ -129,7 +129,7 @@ fn make_tests(cx: &cx) -> tests_and_conv_fn {
     log #fmt("making tests from %s", cx.config.src_base);
     let configport = mk_port[[u8]]();
     let tests = ~[];
-    for file: str  in fs::list_dir(cx.config.src_base) {
+    for file: str in fs::list_dir(cx.config.src_base) {
         log #fmt("inspecting file %s", file);
         if is_test(cx.config, file) {
             tests += ~[make_test(cx, file, configport)];
diff --git a/src/test/compiletest/header.rs b/src/test/compiletest/header.rs
index bd250073405b..4d8855680089 100644
--- a/src/test/compiletest/header.rs
+++ b/src/test/compiletest/header.rs
@@ -28,7 +28,7 @@ fn load_props(testfile: &str) -> test_props {
     let compile_flags = option::none;
     let pp_exact = option::none;
     let no_valgrind = false;
-    for each ln: str  in iter_header(testfile) {
+    for each ln: str in iter_header(testfile) {
         alt parse_error_pattern(ln) {
           option::some(ep) { error_patterns += ~[ep]; }
           option::none. { }
@@ -56,7 +56,7 @@ fn load_props(testfile: &str) -> test_props {
 
 fn is_test_ignored(config: &config, testfile: &str) -> bool {
     let found = false;
-    for each ln: str  in iter_header(testfile) {
+    for each ln: str in iter_header(testfile) {
         // FIXME: Can't return or break from iterator
         found = found
             || parse_name_directive(ln, "xfail-" + config.stage_id);
diff --git a/src/test/compiletest/runtest.rs b/src/test/compiletest/runtest.rs
index 15d010172d92..4aaeaa07b1ab 100644
--- a/src/test/compiletest/runtest.rs
+++ b/src/test/compiletest/runtest.rs
@@ -192,7 +192,7 @@ fn check_error_patterns(props: &test_props, testfile: &str,
 
     let next_err_idx = 0u;
     let next_err_pat = props.error_patterns.(next_err_idx);
-    for line: str  in str::split(procres.stdout, '\n' as u8) {
+    for line: str in str::split(procres.stdout, '\n' as u8) {
         if str::find(line, next_err_pat) > 0 {
             log #fmt("found error pattern %s", next_err_pat);
             next_err_idx += 1u;
@@ -211,7 +211,7 @@ fn check_error_patterns(props: &test_props, testfile: &str,
         fatal_procres(#fmt("error pattern '%s' not found!",
                            missing_patterns.(0)), procres);
     } else {
-        for pattern: str  in missing_patterns {
+        for pattern: str in missing_patterns {
             error(#fmt("error pattern '%s' not found!", pattern));
         }
         fatal_procres("multiple error patterns not found", procres);
diff --git a/src/test/run-fail/for-each-loop-fail.rs b/src/test/run-fail/for-each-loop-fail.rs
index efeb27ff3417..4128845ab093 100644
--- a/src/test/run-fail/for-each-loop-fail.rs
+++ b/src/test/run-fail/for-each-loop-fail.rs
@@ -1,4 +1,4 @@
 // error-pattern:moop
 use std;
 import std::uint;
-fn main() { for each i: uint  in uint::range(0u, 10u) { fail "moop"; } }
\ No newline at end of file
+fn main() { for each i: uint in uint::range(0u, 10u) { fail "moop"; } }
diff --git a/src/test/run-pass/alt-phi.rs b/src/test/run-pass/alt-phi.rs
index 07a4fe5fb811..a99e138fcebc 100644
--- a/src/test/run-pass/alt-phi.rs
+++ b/src/test/run-pass/alt-phi.rs
@@ -7,8 +7,8 @@ iter foo() -> int { put 10; }
 fn main() {
     let x = true;
     alt a {
-      a. { x = true; for each i: int  in foo() { } }
+      a. { x = true; for each i: int in foo() { } }
       b. { x = false; }
       c. { x = false; }
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/run-pass/argv.rs b/src/test/run-pass/argv.rs
index 0f2716ea2bef..c8b1222a2006 100644
--- a/src/test/run-pass/argv.rs
+++ b/src/test/run-pass/argv.rs
@@ -4,5 +4,5 @@ import std::ivec;
 fn main(args: vec[str]) {
     let vs: [str] = ~["hi", "there", "this", "is", "a", "vec"];
     let vvs: [[str]] = ~[ivec::from_vec(args), vs];
-    for vs: [str]  in vvs { for s: str  in vs { log s; } }
-}
\ No newline at end of file
+    for vs: [str] in vvs { for s: str in vs { log s; } }
+}
diff --git a/src/test/run-pass/auto-loop.rs b/src/test/run-pass/auto-loop.rs
index 238c16697831..b4ea2f5dedc7 100644
--- a/src/test/run-pass/auto-loop.rs
+++ b/src/test/run-pass/auto-loop.rs
@@ -1,5 +1,5 @@
 fn main() {
     let sum = 0;
-    for x  in ~[1, 2, 3, 4, 5] { sum += x; }
+    for x in ~[1, 2, 3, 4, 5] { sum += x; }
     assert (sum == 15);
-}
\ No newline at end of file
+}
diff --git a/src/test/run-pass/block-iter-1.rs b/src/test/run-pass/block-iter-1.rs
index eac1e19f0673..6f450f7c1251 100644
--- a/src/test/run-pass/block-iter-1.rs
+++ b/src/test/run-pass/block-iter-1.rs
@@ -1,4 +1,4 @@
-fn iter_vec[T](v: &[T], f: &block(&T) ) { for x: T  in v { f(x); } }
+fn iter_vec[T](v: &[T], f: &block(&T) ) { for x: T in v { f(x); } }
 
 fn main() {
     let v = ~[1, 2, 3, 4, 5, 6, 7];
diff --git a/src/test/run-pass/block-iter-2.rs b/src/test/run-pass/block-iter-2.rs
index 22ceefcaa938..fd22ac3d570c 100644
--- a/src/test/run-pass/block-iter-2.rs
+++ b/src/test/run-pass/block-iter-2.rs
@@ -1,4 +1,4 @@
-fn iter_vec[T](v: &[T], f: &block(&T) ) { for x: T  in v { f(x); } }
+fn iter_vec[T](v: &[T], f: &block(&T) ) { for x: T in v { f(x); } }
 
 fn main() {
     let v = ~[1, 2, 3, 4, 5];
diff --git a/src/test/run-pass/break.rs b/src/test/run-pass/break.rs
index 28b9a806c113..d53445ef5866 100644
--- a/src/test/run-pass/break.rs
+++ b/src/test/run-pass/break.rs
@@ -6,7 +6,7 @@ fn main() {
     assert (i == 10);
     do  { i += 1; if i == 20 { break; } } while i < 30
     assert (i == 20);
-    for x: int  in ~[1, 2, 3, 4, 5, 6] {
+    for x: int in ~[1, 2, 3, 4, 5, 6] {
         if x == 3 { break; }
         assert (x <= 3);
     }
@@ -14,8 +14,8 @@ fn main() {
     while i < 10 { i += 1; if i % 2 == 0 { cont; } assert (i % 2 != 0); }
     i = 0;
     do  { i += 1; if i % 2 == 0 { cont; } assert (i % 2 != 0); } while i < 10
-    for x: int  in ~[1, 2, 3, 4, 5, 6] {
+    for x: int in ~[1, 2, 3, 4, 5, 6] {
         if x % 2 == 0 { cont; }
         assert (x % 2 != 0);
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/run-pass/for-loop-fail.rs b/src/test/run-pass/for-loop-fail.rs
index 4a39d10590a9..2e52a5ae1f7a 100644
--- a/src/test/run-pass/for-loop-fail.rs
+++ b/src/test/run-pass/for-loop-fail.rs
@@ -1 +1 @@
-fn main() { let x: [int] = ~[]; for i: int  in x { fail "moop"; } }
\ No newline at end of file
+fn main() { let x: [int] = ~[]; for i: int in x { fail "moop"; } }
diff --git a/src/test/run-pass/foreach-box-drop.rs b/src/test/run-pass/foreach-box-drop.rs
index 3c025a07e7f6..cfb33289cf86 100644
--- a/src/test/run-pass/foreach-box-drop.rs
+++ b/src/test/run-pass/foreach-box-drop.rs
@@ -4,6 +4,6 @@ obj ob[K](k: K) {
     iter foo() -> @{a: K} { put @{a: k}; }
 }
 
-fn x(o: &ob[str]) { for each i: @{a: str}  in o.foo() { } }
+fn x(o: &ob[str]) { for each i: @{a: str} in o.foo() { } }
 
-fn main() { let o = ob[str]("hi" + "there"); x(o); }
\ No newline at end of file
+fn main() { let o = ob[str]("hi" + "there"); x(o); }
diff --git a/src/test/run-pass/foreach-nested-2.rs b/src/test/run-pass/foreach-nested-2.rs
index 26d1caca5ab6..ba42d7a6ac48 100644
--- a/src/test/run-pass/foreach-nested-2.rs
+++ b/src/test/run-pass/foreach-nested-2.rs
@@ -12,10 +12,10 @@ iter range(start: int, stop: int) -> int {
 fn main() {
     let a: [mutable int] = ~[mutable -1, -1, -1, -1, -1, -1, -1, -1];
     let p: int = 0;
-    for each i: int  in two() {
-        for each j: int  in range(0, 2) {
+    for each i: int in two() {
+        for each j: int in range(0, 2) {
             let tmp: int = 10 * i + j;
-            for each k: int  in range(0, 2) { a.(p) = 10 * tmp + k; p += 1; }
+            for each k: int in range(0, 2) { a.(p) = 10 * tmp + k; p += 1; }
         }
     }
     assert (a.(0) == 0);
@@ -26,4 +26,4 @@ fn main() {
     assert (a.(5) == 101);
     assert (a.(6) == 110);
     assert (a.(7) == 111);
-}
\ No newline at end of file
+}
diff --git a/src/test/run-pass/foreach-nested.rs b/src/test/run-pass/foreach-nested.rs
index ecf80b191dbf..4e90818621df 100644
--- a/src/test/run-pass/foreach-nested.rs
+++ b/src/test/run-pass/foreach-nested.rs
@@ -7,11 +7,11 @@ iter two() -> int { put 0; put 1; }
 fn main() {
     let a: [mutable int] = ~[mutable -1, -1, -1, -1];
     let p: int = 0;
-    for each i: int  in two() {
-        for each j: int  in two() { a.(p) = 10 * i + j; p += 1; }
+    for each i: int in two() {
+        for each j: int in two() { a.(p) = 10 * i + j; p += 1; }
     }
     assert (a.(0) == 0);
     assert (a.(1) == 1);
     assert (a.(2) == 10);
     assert (a.(3) == 11);
-}
\ No newline at end of file
+}
diff --git a/src/test/run-pass/foreach-put-structured.rs b/src/test/run-pass/foreach-put-structured.rs
index 2384a3849749..229e1e87c109 100644
--- a/src/test/run-pass/foreach-put-structured.rs
+++ b/src/test/run-pass/foreach-put-structured.rs
@@ -9,7 +9,7 @@ iter pairs() -> {_0: int, _1: int} {
 fn main() {
     let i: int = 10;
     let j: int = 0;
-    for each p: {_0: int, _1: int}  in pairs() {
+    for each p: {_0: int, _1: int} in pairs() {
         log p._0;
         log p._1;
         assert (p._0 + 10 == i);
@@ -17,4 +17,4 @@ fn main() {
         j = p._1;
     }
     assert (j == 45);
-}
\ No newline at end of file
+}
diff --git a/src/test/run-pass/foreach-simple-outer-slot.rs b/src/test/run-pass/foreach-simple-outer-slot.rs
index e2a01d292e26..11e61d4b2d86 100644
--- a/src/test/run-pass/foreach-simple-outer-slot.rs
+++ b/src/test/run-pass/foreach-simple-outer-slot.rs
@@ -4,7 +4,7 @@
 // -*- rust -*-
 fn main() {
     let sum: int = 0;
-    for each i: int  in first_ten() { log "main"; log i; sum = sum + i; }
+    for each i: int in first_ten() { log "main"; log i; sum = sum + i; }
     log "sum";
     log sum;
     assert (sum == 45);
@@ -13,4 +13,4 @@ fn main() {
 iter first_ten() -> int {
     let i: int = 0;
     while i < 10 { log "first_ten"; put i; i = i + 1; }
-}
\ No newline at end of file
+}
diff --git a/src/test/run-pass/foreach-simple.rs b/src/test/run-pass/foreach-simple.rs
index 94ae11b89320..7e43703a9b25 100644
--- a/src/test/run-pass/foreach-simple.rs
+++ b/src/test/run-pass/foreach-simple.rs
@@ -2,9 +2,9 @@
 
 
 // -*- rust -*-
-fn main() { for each i: int  in first_ten() { log "main"; } }
+fn main() { for each i: int in first_ten() { log "main"; } }
 
 iter first_ten() -> int {
     let i: int = 90;
     while i < 100 { log "first_ten"; log i; put i; i = i + 1; }
-}
\ No newline at end of file
+}
diff --git a/src/test/run-pass/generic-iter-frame.rs b/src/test/run-pass/generic-iter-frame.rs
index 36b7aa5a4754..e4f8609e59b8 100644
--- a/src/test/run-pass/generic-iter-frame.rs
+++ b/src/test/run-pass/generic-iter-frame.rs
@@ -4,6 +4,6 @@
 // Contrived example? No. It showed up in rustc's resolve pass.
 iter i() { put (); }
 
-fn foo[T](t: &T) { let x: int = 10; for each j: ()  in i() { log x; } }
+fn foo[T](t: &T) { let x: int = 10; for each j: () in i() { log x; } }
 
-fn main() { foo(0xdeadbeef_u); }
\ No newline at end of file
+fn main() { foo(0xdeadbeef_u); }
diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs
index 8077219b0f0b..d4ac50339fdf 100644
--- a/src/test/run-pass/hashmap-memory.rs
+++ b/src/test/run-pass/hashmap-memory.rs
@@ -33,7 +33,7 @@ mod map_reduce {
     tag ctrl_proto { find_reducer([u8], _chan[int]); mapper_done; }
 
     fn start_mappers(ctrl: _chan[ctrl_proto], inputs: &[str]) {
-        for i: str  in inputs { task::_spawn(bind map_task(ctrl, i)); }
+        for i: str in inputs { task::_spawn(bind map_task(ctrl, i)); }
     }
 
     fn map_task(ctrl: _chan[ctrl_proto], input: str) {
@@ -93,4 +93,4 @@ mod map_reduce {
 
 fn main() {
     map_reduce::map_reduce(~["../src/test/run-pass/hashmap-memory.rs"]);
-}
\ No newline at end of file
+}
diff --git a/src/test/run-pass/iter-range.rs b/src/test/run-pass/iter-range.rs
index 8b22a436c94a..d5cab50916e1 100644
--- a/src/test/run-pass/iter-range.rs
+++ b/src/test/run-pass/iter-range.rs
@@ -8,6 +8,6 @@ iter range(a: int, b: int) -> int {
 
 fn main() {
     let sum: int = 0;
-    for each x: int  in range(0, 100) { sum += x; }
+    for each x: int in range(0, 100) { sum += x; }
     log sum;
-}
\ No newline at end of file
+}
diff --git a/src/test/run-pass/iter-ret.rs b/src/test/run-pass/iter-ret.rs
index ff68fc608147..77edc2c0ec79 100644
--- a/src/test/run-pass/iter-ret.rs
+++ b/src/test/run-pass/iter-ret.rs
@@ -2,6 +2,6 @@
 
 iter x() -> int { }
 
-fn f() -> bool { for each i: int  in x() { ret true; } ret false; }
+fn f() -> bool { for each i: int in x() { ret true; } ret false; }
 
-fn main(args: vec[str]) { f(); }
\ No newline at end of file
+fn main(args: vec[str]) { f(); }
diff --git a/src/test/run-pass/linear-for-loop.rs b/src/test/run-pass/linear-for-loop.rs
index 119ee8c76bc3..a36848106f66 100644
--- a/src/test/run-pass/linear-for-loop.rs
+++ b/src/test/run-pass/linear-for-loop.rs
@@ -3,12 +3,12 @@
 fn main() {
     let x = ~[1, 2, 3];
     let y = 0;
-    for i: int  in x { log i; y += i; }
+    for i: int in x { log i; y += i; }
     log y;
     assert (y == 6);
     let s = "hello there";
     let i: int = 0;
-    for c: u8  in s {
+    for c: u8 in s {
         if i == 0 { assert (c == 'h' as u8); }
         if i == 1 { assert (c == 'e' as u8); }
         if i == 2 { assert (c == 'l' as u8); }
@@ -21,4 +21,4 @@ fn main() {
         log c;
     }
     assert (i == 11);
-}
\ No newline at end of file
+}
diff --git a/src/test/run-pass/loop-scope.rs b/src/test/run-pass/loop-scope.rs
index 1c61a8570e9e..fc5618d823df 100644
--- a/src/test/run-pass/loop-scope.rs
+++ b/src/test/run-pass/loop-scope.rs
@@ -1,6 +1,6 @@
 fn main() {
     let x = ~[10, 20, 30];
     let sum = 0;
-    for x  in x { sum += x; }
+    for x in x { sum += x; }
     assert (sum == 60);
-}
\ No newline at end of file
+}
diff --git a/src/test/run-pass/maybe-mutable.rs b/src/test/run-pass/maybe-mutable.rs
index 563fa5e62723..5c941e7c4777 100644
--- a/src/test/run-pass/maybe-mutable.rs
+++ b/src/test/run-pass/maybe-mutable.rs
@@ -4,7 +4,7 @@
 // -*- rust -*-
 fn len(v: [mutable? int]) -> uint {
     let i = 0u;
-    for x: int  in v { i += 1u; }
+    for x: int in v { i += 1u; }
     ret i;
 }
 
@@ -13,4 +13,4 @@ fn main() {
     log len(v0);
     let v1 = ~[mutable 1, 2, 3, 4, 5];
     log len(v1);
-}
\ No newline at end of file
+}
diff --git a/src/test/run-pass/move-3.rs b/src/test/run-pass/move-3.rs
index 97d1bd722d0d..9ce0eb3bf5c1 100644
--- a/src/test/run-pass/move-3.rs
+++ b/src/test/run-pass/move-3.rs
@@ -10,8 +10,8 @@ fn test(x: bool, foo: @{x: int, y: int, z: int}) -> int {
 
 fn main() {
     let x = @{x: 1, y: 2, z: 3};
-    for each i: uint  in uint::range(0u, 10000u) {
+    for each i: uint in uint::range(0u, 10000u) {
         assert (test(true, x) == 2);
     }
     assert (test(false, x) == 5);
-}
\ No newline at end of file
+}
diff --git a/src/test/run-pass/pattern-bound-var-in-for-each.rs b/src/test/run-pass/pattern-bound-var-in-for-each.rs
index c9ac288ef154..3ee92b32d0b3 100644
--- a/src/test/run-pass/pattern-bound-var-in-for-each.rs
+++ b/src/test/run-pass/pattern-bound-var-in-for-each.rs
@@ -10,7 +10,7 @@ fn foo(src: uint) {
 
     alt some(src) {
       some(src_id) {
-        for each i: uint  in uint::range(0u, 10u) {
+        for each i: uint in uint::range(0u, 10u) {
             let yyy = src_id;
             assert (yyy == 0u);
         }
@@ -19,4 +19,4 @@ fn foo(src: uint) {
     }
 }
 
-fn main() { foo(0u); }
\ No newline at end of file
+fn main() { foo(0u); }
diff --git a/src/test/run-pass/rt-circular-buffer.rs b/src/test/run-pass/rt-circular-buffer.rs
index a468b1d144d8..2490b4a45ecc 100644
--- a/src/test/run-pass/rt-circular-buffer.rs
+++ b/src/test/run-pass/rt-circular-buffer.rs
@@ -31,7 +31,7 @@ fn test_grow() {
     let myport: port[record] = port();
     let mychan = chan(myport);
     let val: record = {val1: 0u32, val2: 0u32, val3: 0u32};
-    for each i: uint  in uint::range(0u, 100u) { mychan <| val; }
+    for each i: uint in uint::range(0u, 100u) { mychan <| val; }
 }
 
 
@@ -48,8 +48,8 @@ fn test_shrink2() {
     let myport: port[record] = port();
     let mychan = chan(myport);
     let val: record = {val1: 0u32, val2: 0u32, val3: 0u32};
-    for each i: uint  in uint::range(0u, 100u) { mychan <| val; }
-    for each i: uint  in uint::range(0u, 100u) { let x; myport |> x; }
+    for each i: uint in uint::range(0u, 100u) { mychan <| val; }
+    for each i: uint in uint::range(0u, 100u) { let x; myport |> x; }
 }
 
 
@@ -57,7 +57,7 @@ fn test_shrink2() {
 fn test_rotate() {
     let myport: port[record] = port();
     let mychan = chan(myport);
-    for each i: uint  in uint::range(0u, 100u) {
+    for each i: uint in uint::range(0u, 100u) {
         let val = {val1: i as u32, val2: i as u32, val3: i as u32};
         mychan <| val;
         let x;
@@ -74,13 +74,13 @@ fn test_rotate() {
 fn test_rotate_grow() {
     let myport: port[record] = port();
     let mychan = chan(myport);
-    for each j: uint  in uint::range(0u, 10u) {
-        for each i: uint  in uint::range(0u, 10u) {
+    for each j: uint in uint::range(0u, 10u) {
+        for each i: uint in uint::range(0u, 10u) {
             let val: record =
                 {val1: i as u32, val2: i as u32, val3: i as u32};
             mychan <| val;
         }
-        for each i: uint  in uint::range(0u, 10u) {
+        for each i: uint in uint::range(0u, 10u) {
             let x;
             myport |> x;
             assert (x.val1 == i as u32);
diff --git a/src/test/run-pass/task-comm.rs b/src/test/run-pass/task-comm.rs
index 40b6e8c92937..580be0ed9a81 100644
--- a/src/test/run-pass/task-comm.rs
+++ b/src/test/run-pass/task-comm.rs
@@ -49,7 +49,7 @@ fn test00() {
         }
     }
 
-    for t: task_id  in tasks { task::join_id(t); }
+    for t: task_id in tasks { task::join_id(t); }
 
     log "Completed: Final number is: ";
     assert (sum ==
@@ -137,7 +137,7 @@ fn test06() {
         i = i + 1; tasks += [task::_spawn(bind test06_start(i))]; }
 
 
-    for t: task_id  in tasks { task::join_id(t); }
+    for t: task_id in tasks { task::join_id(t); }
 }
 
 
diff --git a/src/test/run-pass/type-params-in-for-each.rs b/src/test/run-pass/type-params-in-for-each.rs
index 76ab695634a3..a75a1010895b 100644
--- a/src/test/run-pass/type-params-in-for-each.rs
+++ b/src/test/run-pass/type-params-in-for-each.rs
@@ -6,7 +6,7 @@ iter range(lo: uint, hi: uint) -> uint {
 }
 
 fn create_index[T](index: &[{a: T, b: uint}], hash_fn: fn(&T) -> uint ) {
-    for each i: uint  in range(0u, 256u) { let bucket: [T] = ~[]; }
+    for each i: uint in range(0u, 256u) { let bucket: [T] = ~[]; }
 }
 
-fn main() { }
\ No newline at end of file
+fn main() { }
diff --git a/src/test/run-pass/utf8.rs b/src/test/run-pass/utf8.rs
index 62f25c50baa4..e7dc27806122 100644
--- a/src/test/run-pass/utf8.rs
+++ b/src/test/run-pass/utf8.rs
@@ -31,7 +31,7 @@ fn main() {
 
     fn check_str_eq(a: str, b: str) {
         let i: int = 0;
-        for ab: u8  in a {
+        for ab: u8 in a {
             log i;
             log ab;
             let bb: u8 = b.(i);
@@ -45,4 +45,4 @@ fn main() {
     check_str_eq(japan, japan_e);
     check_str_eq(uzbekistan, uzbekistan_e);
     check_str_eq(austria, austria_e);
-}
\ No newline at end of file
+}
diff --git a/src/test/stdtest/qsort.rs b/src/test/stdtest/qsort.rs
index 0799f505e3cb..1a249de4919e 100644
--- a/src/test/stdtest/qsort.rs
+++ b/src/test/stdtest/qsort.rs
@@ -50,7 +50,7 @@ fn test_simple() {
     sort::quick_sort(lteq, names);
 
     let pairs = ivec::zip(expected, ivec::from_mut(names));
-    for p: {_0: int, _1: int}  in pairs {
+    for p: {_0: int, _1: int} in pairs {
         log #fmt("%d %d", p._0, p._1);
         assert (p._0 == p._1);
     }
diff --git a/src/test/stdtest/sha1.rs b/src/test/stdtest/sha1.rs
index 7afd5e5bfab4..5cbdb25d195c 100644
--- a/src/test/stdtest/sha1.rs
+++ b/src/test/stdtest/sha1.rs
@@ -74,7 +74,7 @@ fn test() {
     // Test that it works when accepting the message all at once
 
     let sh = sha1::mk_sha1();
-    for t: test  in tests {
+    for t: test in tests {
         sh.input_str(t.input);
         let out = sh.result();
         check_vec_eq(t.output, out);
@@ -83,7 +83,7 @@ fn test() {
 
 
     // Test that it works when accepting the message in pieces
-    for t: test  in tests {
+    for t: test in tests {
         let len = str::byte_len(t.input);
         let left = len;
         while left > 0u {
diff --git a/src/test/stdtest/str.rs b/src/test/stdtest/str.rs
index 04e75155b0c1..8124e565f6a4 100644
--- a/src/test/stdtest/str.rs
+++ b/src/test/stdtest/str.rs
@@ -29,7 +29,7 @@ fn test_split() {
         log i;
         let v = str::split(s, c as u8);
         log "split to: ";
-        for z: str  in v { log z; }
+        for z: str in v { log z; }
         log "comparing: " + v.(i) + " vs. " + k;
         assert (str::eq(v.(i), k));
     }
diff --git a/src/test/stdtest/test.rs b/src/test/stdtest/test.rs
index 6526ee6531ba..7d587e235219 100644
--- a/src/test/stdtest/test.rs
+++ b/src/test/stdtest/test.rs
@@ -71,7 +71,7 @@ fn sort_tests() {
         {
             let testfn = fn () { };
             let tests = ~[];
-            for name: str  in names {
+            for name: str in names {
                 let test = {name: name, fn: testfn, ignore: false};
                 tests += ~[test];
             }
@@ -89,7 +89,7 @@ fn sort_tests() {
     let pairs = ivec::zip(expected, filtered);
 
 
-    for p: {_0: str, _1: test::test_desc}  in pairs {
+    for p: {_0: str, _1: test::test_desc} in pairs {
         assert (p._0 == p._1.name);
     }
 }