Prohibit trailing whitespace under 'tidy' script. Clean up all caught cases.

Makefile.in

@@ -257,6 +257,7 @@ include $(CFG_SRC_DIR)/mk/docs.mk
 ifneq ($(strip $(findstring dist,$(MAKECMDGOALS))   \
                $(findstring check,$(MAKECMDGOALS))  \
                $(findstring test,$(MAKECMDGOALS))   \
+               $(findstring tidy,$(MAKECMDGOALS))   \
                $(findstring clean,$(MAKECMDGOALS))),)
   CFG_INFO := $(info cfg: including dist rules)
   include $(CFG_SRC_DIR)/mk/dist.mk

src/comp/back/link.rs

@@ -325,7 +325,7 @@ fn build_link_meta(&session::session sess, &ast::crate c,
         fn len_and_str_lit(&ast::lit l) -> str {
             ret len_and_str(pprust::lit_to_str(@l));
         }
-    
+
         auto cmh_items = attr::sort_meta_items(metas.cmh_items);
 
         sha.reset();

src/comp/front/attr.rs

@@ -199,7 +199,7 @@ fn require_unique_names(&session::session sess, &(@ast::meta_item)[] metas) {
     for (@ast::meta_item meta in metas) {
         auto name = get_meta_item_name(meta);
         if (map.contains_key(name)) {
-            sess.span_fatal(meta.span, 
+            sess.span_fatal(meta.span,
                             #fmt("duplicate meta item `%s`", name));
         }
         map.insert(name, ());

src/comp/front/test.rs

@@ -98,7 +98,7 @@ fn fold_item(&test_ctxt cx, &@ast::item i,
 }
 
 fn is_test_fn(&@ast::item i) -> bool {
-    auto has_test_attr = 
+    auto has_test_attr =
         ivec::len(attr::find_attrs_by_name(i.attrs, "test")) > 0u;
 
     fn has_test_signature(&@ast::item i) -> bool {
@@ -173,7 +173,7 @@ fn mk_tests(&test_ctxt cx) -> @ast::item {
                                 cf = ast::return,
                                 constraints = ~[]);
     auto proto = ast::proto_fn;
-    
+
     // The vector of test_descs for this crate
     auto test_descs = mk_test_desc_vec(cx);
 
@@ -352,7 +352,7 @@ fn mk_test_main_call(&test_ctxt cx) -> @ast::expr {
                                             node = test_main_path_expr_,
                                             span = rec(lo=0u, hi=0u));
 
-    let ast::expr_ test_main_call_expr_ 
+    let ast::expr_ test_main_call_expr_
         = ast::expr_call(@test_main_path_expr, ~[@args_path_expr,
                                                  @test_call_expr]);
 

src/comp/lib/llvm.rs

@@ -889,7 +889,7 @@ native mod llvm = "rustllvm" {
  * BuilderRef B into place.  A BuilderRef is a cursor-like LLVM value that
  * inserts instructions for a particular BasicBlockRef at a particular
  * position; for our purposes, it always inserts at the end of the basic block
- * it's attached to.  
+ * it's attached to.
  */
 
 // FIXME: Do we want to support mutable object fields?
@@ -1524,9 +1524,9 @@ fn type_to_str_inner(type_names names, &TypeRef[] outer0, TypeRef ty) -> str {
             ret s;
         }
 
-        case (10) { 
+        case (10) {
             auto el_ty = llvm::LLVMGetElementType(ty);
-            ret "[" + type_to_str_inner(names, outer, el_ty) + "]"; 
+            ret "[" + type_to_str_inner(names, outer, el_ty) + "]";
         }
 
         case (11) {

src/comp/metadata/tyencode.rs

@@ -236,7 +236,7 @@ fn enc_constr(&io::writer w, &@ctxt cx, &@ty::constr_def c) {
         if (semi) { w.write_char(';'); } else { semi = true; }
         alt (a.node) {
             case (carg_base) { w.write_char('*'); }
-            case (carg_ident(?i)) { 
+            case (carg_ident(?i)) {
                 w.write_uint(i);
             }
             case (carg_lit(?l)) { w.write_str(lit_to_str(l)); }

src/comp/middle/resolve.rs

@@ -156,7 +156,7 @@ fn map_crate(&@env e, &@ast::crate c) {
              with *visit::default_visitor[scopes]());
     visit::visit_crate(*c, cons(scope_crate, @nil),
                        visit::mk_vt(v_map_mod));
-    // Register the top-level mod 
+    // Register the top-level mod
 
     e.mod_map.insert(-1,
                      @rec(m=some(c.node.module),
@@ -342,7 +342,7 @@ fn visit_fn_with_scope(&@env e, &ast::_fn f, &ast::ty_param[] tp, &span sp,
     // for f's constrs in the table.
 
     for (@ast::constr c in f.decl.constraints) {
-        resolve_constr(e, id, c, sc, v); 
+        resolve_constr(e, id, c, sc, v);
     }
     visit::visit_fn(f, tp, sp, name, id,
                     cons(scope_fn(f.decl, tp), @sc), v);
@@ -1294,7 +1294,7 @@ fn check_arm(@env e, &ast::arm a, &() x, &vt[()] v) {
                     // Fight the alias checker
                     auto name_ = name;
                     e.sess.span_err
-                        (a.pats.(i).span, "binding " + name_ + 
+                        (a.pats.(i).span, "binding " + name_ +
                          " does not occur in first pattern");
                 }
             }

src/comp/middle/trans.rs

@@ -2726,7 +2726,7 @@ fn iter_structural_ty_full(&@block_ctxt cx, ValueRef av, ValueRef bv,
         }
         ret rslt(cx, C_nil());
     }
-    
+
     let result r = rslt(cx, C_nil());
     alt (ty::struct(cx.fcx.lcx.ccx.tcx, t)) {
         case (ty::ty_tup(?args)) {
@@ -4481,7 +4481,7 @@ fn collect_upvars(&@block_ctxt cx, &ast::block bloc,
 
 // Given a block context and a list of upvars, construct a closure that
 // contains pointers to all of the upvars and all of the tydescs in
-// scope. Return the ValueRef and TypeRef corresponding to the closure. 
+// scope. Return the ValueRef and TypeRef corresponding to the closure.
 fn build_environment(&@block_ctxt cx, &ast::node_id[] upvars) ->
     tup(ValueRef, TypeRef) {
     auto upvar_count = std::ivec::len(upvars);
@@ -5149,8 +5149,8 @@ fn trans_cast(&@block_ctxt cx, &@ast::expr e, ast::node_id id) -> result {
                     int_cast(e_res.bcx, lldsttype, llsrctype, e_res.val,
                              ty::type_is_signed(cx.fcx.lcx.ccx.tcx, t)));
         }
-    } 
-    else { 
+    }
+    else {
         if (ty::type_is_integral(cx.fcx.lcx.ccx.tcx,
                                  ty::expr_ty(cx.fcx.lcx.ccx.tcx, e))) {
             if (ty::type_is_signed(cx.fcx.lcx.ccx.tcx,
@@ -5748,7 +5748,7 @@ fn trans_call(&@block_ctxt cx, &@ast::expr f, &option::t[ValueRef] lliterbody,
     auto llretslot = args_res._2;
     /*
     log "calling: " + val_str(cx.fcx.lcx.ccx.tn, faddr);
-    
+
     for (ValueRef arg in llargs) {
         log "arg: " + val_str(cx.fcx.lcx.ccx.tn, arg);
     }
@@ -6181,7 +6181,7 @@ fn trans_expr_out(&@block_ctxt cx, &@ast::expr e, out_method output) ->
                check the value of that variable, doing nothing
                if it's set to false and acting like a check
                otherwise. */
-            auto c = get_extern_const(cx.fcx.lcx.ccx.externs, 
+            auto c = get_extern_const(cx.fcx.lcx.ccx.externs,
                                       cx.fcx.lcx.ccx.llmod,
                                       "check_claims", T_bool());
             auto cond = cx.build.Load(c);
@@ -6215,7 +6215,7 @@ fn trans_expr_out(&@block_ctxt cx, &@ast::expr e, out_method output) ->
         }
         case (_) {
             // The expression is an lvalue. Fall through.
-            assert (ty::is_lval(e)); // make sure it really is and that we 
+            assert (ty::is_lval(e)); // make sure it really is and that we
                                // didn't forget to add a case for a new expr!
         }
     }
@@ -6396,7 +6396,7 @@ fn trans_fail_expr(&@block_ctxt cx, &option::t[span] sp_opt,
         }
     }
 }
- 
+
 fn trans_fail(&@block_ctxt cx, &option::t[span] sp_opt, &str fail_str)
    -> result {
     auto V_fail_str = C_cstr(cx.fcx.lcx.ccx, fail_str);
@@ -6607,7 +6607,7 @@ fn trans_spawn(&@block_ctxt cx, &ast::spawn_dom dom, &option::t[str] name,
     // order, so that they match the expected stack layout for the spawnee)
     //
     // 3. Fill the tuple with the arguments we evaluated.
-    // 
+    //
     // 3.5. Generate a wrapper function that takes the tuple and unpacks it to
     // call the real task.
     //
@@ -6648,12 +6648,12 @@ fn trans_spawn(&@block_ctxt cx, &ast::spawn_dom dom, &option::t[str] name,
     auto llargs = alloc_ty(bcx, args_ty);
     auto i = 0u;
     for (ValueRef v in arg_vals) {
-        // log_err #fmt("ty(llargs) = %s", 
+        // log_err #fmt("ty(llargs) = %s",
         //              val_str(bcx.fcx.lcx.ccx.tn, llargs.val));
 
         auto target = bcx.build.GEP(llargs.val, ~[C_int(0), C_int(i as int)]);
         // log_err #fmt("ty(v) = %s", val_str(bcx.fcx.lcx.ccx.tn, v));
-        // log_err #fmt("ty(target) = %s", 
+        // log_err #fmt("ty(target) = %s",
         //              val_str(bcx.fcx.lcx.ccx.tn, target));
 
         bcx.build.Store(v, target);
@@ -6728,8 +6728,8 @@ fn mk_spawn_wrapper(&@block_ctxt cx, &@ast::expr func, &ty::t args_ty) ->
 // tasks, and for sending things through channels. There are probably some
 // uniqueness optimizations and things we can do here for tasks in the same
 // domain.
-fn deep_copy(&@block_ctxt bcx, ValueRef v, ty::t t, ValueRef target_task) 
-    -> result 
+fn deep_copy(&@block_ctxt bcx, ValueRef v, ty::t t, ValueRef target_task)
+    -> result
 {
     // TODO: make sure all paths add any reference counting that they need to.
 
@@ -6747,17 +6747,17 @@ fn deep_copy(&@block_ctxt bcx, ValueRef v, ty::t t, ValueRef target_task)
     else if(ty::type_is_chan(tcx, t)) {
         // If this is a channel, we need to clone it.
         auto chan_ptr = bcx.build.PointerCast(v, T_opaque_chan_ptr());
-      
-        auto chan_raw_val = 
+
+        auto chan_raw_val =
             bcx.build.Call(bcx.fcx.lcx.ccx.upcalls.clone_chan,
                            ~[bcx.fcx.lltaskptr, target_task, chan_ptr]);
 
         // Cast back to the type the context was expecting.
-        auto chan_val = bcx.build.PointerCast(chan_raw_val, 
+        auto chan_val = bcx.build.PointerCast(chan_raw_val,
                                               val_ty(v));
 
         ret rslt(bcx, chan_val);
-    } 
+    }
     else if(ty::type_is_structural(tcx, t)) {
         fn inner_deep_copy(&@block_ctxt bcx, ValueRef v, ty::t t) -> result {
             log_err "Unimplemented type for deep_copy.";
@@ -6865,7 +6865,7 @@ fn recv_val(&@block_ctxt cx, ValueRef to, &@ast::expr from, &ty::t unit_ty,
 // function and putting it in the generated code as an object item, we are
 // instead "inlining" the construction of the object and returning the object
 // itself.
-fn trans_anon_obj(@block_ctxt bcx, &span sp, &ast::anon_obj anon_obj, 
+fn trans_anon_obj(@block_ctxt bcx, &span sp, &ast::anon_obj anon_obj,
                   &ast::ty_param[] ty_params, ast::node_id id) -> result {
 
     // Right now, we're assuming that anon objs don't take ty params, even
@@ -6903,12 +6903,12 @@ fn trans_anon_obj(@block_ctxt bcx, &span sp, &ast::anon_obj anon_obj,
 
     // create_vtbl() wants an ast::_obj and all we have is an ast::anon_obj,
     // so we need to roll our own.
-    fn anon_obj_field_to_obj_field(&ast::anon_obj_field f) 
+    fn anon_obj_field_to_obj_field(&ast::anon_obj_field f)
         -> ast::obj_field {
         ret rec(mut=f.mut, ty=f.ty, ident=f.ident, id=f.id);
     }
     let ast::_obj wrapper_obj = rec(
-        fields = std::ivec::map(anon_obj_field_to_obj_field, 
+        fields = std::ivec::map(anon_obj_field_to_obj_field,
                                 additional_fields),
         methods = anon_obj.methods,
         dtor = none[@ast::method]);
@@ -6916,7 +6916,7 @@ fn trans_anon_obj(@block_ctxt bcx, &span sp, &ast::anon_obj anon_obj,
     let ty::t with_obj_ty;
     auto vtbl;
     alt (anon_obj.with_obj) {
-        case (none) { 
+        case (none) {
             // If there's no with_obj -- that is, if we're just adding new
             // fields rather than extending an existing object -- then we just
             // pass the outer object to create_vtbl().  Our vtable won't need
@@ -6949,16 +6949,16 @@ fn trans_anon_obj(@block_ctxt bcx, &span sp, &ast::anon_obj anon_obj,
             // create a forwarding slot.  And, of course, we need to create a
             // normal vtable entry for every method being added.
             vtbl = create_vtbl(bcx.fcx.lcx, sp, llouter_obj_ty, outer_obj_ty,
-                               wrapper_obj, ty_params, 
+                               wrapper_obj, ty_params,
                                some(with_obj_ty),
                                additional_field_tys);
         }
     }
-    
+
     // Allocate the object that we're going to return.  It's a two-word pair
     // containing a vtable pointer and a body pointer.
-    auto pair = 
-        alloca(bcx, 
+    auto pair =
+        alloca(bcx,
                T_struct(~[val_ty(vtbl),
                           T_obj_ptr(ccx.tn, std::ivec::len(ty_params))]));
 
@@ -7003,7 +7003,7 @@ fn trans_anon_obj(@block_ctxt bcx, &span sp, &ast::anon_obj anon_obj,
         // Synthesize a tuple type for typarams: [typaram, ...]
         let ty::t typarams_ty = ty::mk_imm_tup(ccx.tcx, tps);
 
-        // Tuple type for body: 
+        // Tuple type for body:
         // [tydesc_ty, [typaram, ...], [field, ...], with_obj]
         let ty::t body_ty =
             ty::mk_imm_tup(ccx.tcx, ~[tydesc_ty, typarams_ty,
@@ -7068,7 +7068,7 @@ fn trans_anon_obj(@block_ctxt bcx, &span sp, &ast::anon_obj anon_obj,
             auto capture =
                 GEP_tup_like(bcx, typarams_ty, body_typarams.val, ~[0, i]);
             bcx = capture.bcx;
-            bcx = copy_val(bcx, INIT, capture.val, typaram, 
+            bcx = copy_val(bcx, INIT, capture.val, typaram,
                            tydesc_ty).bcx;
             i += 1;
         }
@@ -7091,7 +7091,7 @@ fn trans_anon_obj(@block_ctxt bcx, &span sp, &ast::anon_obj anon_obj,
                 GEP_tup_like(bcx, fields_ty, body_fields.val, ~[0, i]);
             bcx = field.bcx;
             bcx = copy_val(bcx, INIT, field.val,
-                           additional_field_vals.(i).val, 
+                           additional_field_vals.(i).val,
                            additional_field_tys.(i)).bcx;
             i += 1;
         }
@@ -7258,7 +7258,7 @@ fn new_raw_block_ctxt(&@fn_ctxt fcx, BasicBlockRef llbb) -> @block_ctxt {
 
 
 // trans_block_cleanups: Go through all the cleanups attached to this
-// block_ctxt and execute them.  
+// block_ctxt and execute them.
 //
 // When translating a block that introdces new variables during its scope, we
 // need to make sure those variables go out of scope when the block ends.  We
@@ -7685,7 +7685,7 @@ fn trans_fn(@local_ctxt cx, &span sp, &ast::_fn f, ValueRef llfndecl,
     // Set up arguments to the function.
     auto fcx = new_fn_ctxt(cx, sp, llfndecl);
     create_llargs_for_fn_args(fcx, f.proto, ty_self,
-                              ty::ret_ty_of_fn(cx.ccx.tcx, id), 
+                              ty::ret_ty_of_fn(cx.ccx.tcx, id),
                               f.decl.inputs, ty_params);
     copy_any_self_to_alloca(fcx, ty_self);
     alt ({ fcx.llself }) {
@@ -7782,13 +7782,13 @@ fn process_fwding_mthd(@local_ctxt cx, &span sp, @ty::method m,
     // method's return type, if necessary.
     auto llretptr = fcx.llretptr;
     if (ty::type_has_dynamic_size(cx.ccx.tcx, m.output)) {
-        llretptr = bcx.build.PointerCast(llretptr, 
+        llretptr = bcx.build.PointerCast(llretptr,
                                          T_typaram_ptr(cx.ccx.tn));
     }
 
     // Now, we have to get the the with_obj's vtbl out of the self_obj.  This
     // is a multi-step process:
-    
+
     // First, grab the box out of the self_obj.  It contains a refcount and a
     // body.
     auto llself_obj_box =
@@ -7821,7 +7821,7 @@ fn process_fwding_mthd(@local_ctxt cx, &span sp, @ty::method m,
     // Synthesize a tuple type for typarams: [typaram, ...]
     let ty::t typarams_ty = ty::mk_imm_tup(cx.ccx.tcx, tps);
 
-    // Tuple type for body: 
+    // Tuple type for body:
     // [tydesc_ty, [typaram, ...], [field, ...], with_obj]
     let ty::t body_ty =
         ty::mk_imm_tup(cx.ccx.tcx, ~[tydesc_ty, typarams_ty,
@@ -7864,7 +7864,7 @@ fn process_fwding_mthd(@local_ctxt cx, &span sp, @ty::method m,
 
     // Pick out the original method from the vtable.  The +1 is because slot
     // #0 contains the destructor.
-    auto llorig_mthd = bcx.build.GEP(llwith_obj_vtbl, 
+    auto llorig_mthd = bcx.build.GEP(llwith_obj_vtbl,
                                      ~[C_int(0), C_int(ix + 1u as int)]);
 
     // Set up the original method to be called.
@@ -7876,7 +7876,7 @@ fn process_fwding_mthd(@local_ctxt cx, &span sp, @ty::method m,
                         m.inputs,
                         m.output,
                         std::ivec::len[ast::ty_param](ty_params));
-    llorig_mthd = bcx.build.PointerCast(llorig_mthd, 
+    llorig_mthd = bcx.build.PointerCast(llorig_mthd,
                                         T_ptr(T_ptr(llorig_mthd_ty)));
     llorig_mthd = bcx.build.Load(llorig_mthd);
 
@@ -7886,13 +7886,13 @@ fn process_fwding_mthd(@local_ctxt cx, &span sp, @ty::method m,
 
     // Copy the explicit arguments that are being passed into the forwarding
     // function (they're in fcx.llargs) to llorig_mthd_args.
-    
+
     let uint a = 3u; // retptr, task ptr, env come first
     let ValueRef passed_arg = llvm::LLVMGetParam(llforwarding_fn, a);
     for (ty::arg arg in m.inputs) {
         if (arg.mode == ty::mo_val) {
             passed_arg = load_if_immediate(bcx, passed_arg, arg.ty);
-        } 
+        }
         llorig_mthd_args += ~[passed_arg];
         a += 1u;
     }
@@ -7908,8 +7908,8 @@ fn process_fwding_mthd(@local_ctxt cx, &span sp, @ty::method m,
 
 // process_normal_mthd: Create the contents of a normal vtable slot.  A helper
 // function for create_vtbl.
-fn process_normal_mthd(@local_ctxt cx, @ast::method m, TypeRef llself_ty, 
-                       ty::t self_ty, &ast::ty_param[] ty_params) 
+fn process_normal_mthd(@local_ctxt cx, @ast::method m, TypeRef llself_ty,
+                       ty::t self_ty, &ast::ty_param[] ty_params)
     -> ValueRef {
 
     auto llfnty = T_nil();
@@ -7917,7 +7917,7 @@ fn process_normal_mthd(@local_ctxt cx, @ast::method m, TypeRef llself_ty,
         case (ty::ty_fn(?proto, ?inputs, ?output, _, _)) {
             llfnty =
                 type_of_fn_full(
-                    cx.ccx, m.span, proto, 
+                    cx.ccx, m.span, proto,
                     some[TypeRef](llself_ty), inputs, output,
                     std::ivec::len[ast::ty_param](ty_params));
         }
@@ -7927,14 +7927,14 @@ fn process_normal_mthd(@local_ctxt cx, @ast::method m, TypeRef llself_ty,
     let str s = mangle_internal_name_by_path(mcx.ccx, mcx.path);
     let ValueRef llfn =
         decl_internal_fastcall_fn(cx.ccx.llmod, s, llfnty);
- 
+
     // Every method on an object gets its node_id inserted into the
     // crate-wide item_ids map, together with the ValueRef that points to
     // where that method's definition will be in the executable.
     cx.ccx.item_ids.insert(m.node.id, llfn);
     cx.ccx.item_symbols.insert(m.node.id, s);
     trans_fn(mcx, m.span, m.node.meth, llfn,
-             some[ty_self_pair](tup(llself_ty, self_ty)), 
+             some[ty_self_pair](tup(llself_ty, self_ty)),
              ty_params, m.node.id);
 
     ret llfn;
@@ -7996,7 +7996,7 @@ fn create_vtbl(@local_ctxt cx, &span sp, TypeRef llself_ty, ty::t self_ty,
                 case (ty::ty_obj(?with_obj_methods)) {
                     for (ty::method m in with_obj_methods) {
                         meths += ~[fwding_mthd(@m)];
-                    } 
+                    }
                 }
                 case (_) {
                     // Shouldn't happen.
@@ -8008,7 +8008,7 @@ fn create_vtbl(@local_ctxt cx, &span sp, TypeRef llself_ty, ty::t self_ty,
             // Now, filter out any methods that we don't need forwarding slots
             // for, because they're being replaced.
             fn filtering_fn(@local_ctxt cx, &vtbl_mthd m,
-                            (@ast::method)[] addtl_meths) 
+                            (@ast::method)[] addtl_meths)
                 -> option::t[vtbl_mthd] {
 
                 alt (m) {
@@ -8040,15 +8040,15 @@ fn create_vtbl(@local_ctxt cx, &span sp, TypeRef llself_ty, ty::t self_ty,
             }
             auto f = bind filtering_fn(cx, _, ob.methods);
             meths = std::ivec::filter_map[vtbl_mthd, vtbl_mthd](f, meths);
-            
+
             // And now add the additional ones (both replacements and entirely
             // new ones).  These'll just be normal methods.
             for (@ast::method m in ob.methods) {
                 meths += ~[normal_mthd(m)];
             }
         }
-    } 
-    
+    }
+
     // Sort all the methods.
     fn vtbl_mthd_lteq(&vtbl_mthd a, &vtbl_mthd b) -> bool {
         alt (a) {
@@ -8107,7 +8107,7 @@ fn create_vtbl(@local_ctxt cx, &span sp, TypeRef llself_ty, ty::t self_ty,
             }
         }
     }
-    
+
     auto vtbl = C_struct(llmethods);
     auto vtbl_name = mangle_internal_name_by_path(cx.ccx,
                                                   cx.path + ~["vtbl"]);
@@ -8197,7 +8197,7 @@ fn trans_obj(@local_ctxt cx, &span sp, &ast::_obj ob, ast::node_id ctor_id,
     // It will be located in the read-only memory of the executable we're
     // creating and will contain ValueRefs for all of this object's methods.
     // create_vtbl returns a pointer to the vtable, which we store.
-    auto vtbl = create_vtbl(cx, sp, llself_ty, self_ty, ob, ty_params, none, 
+    auto vtbl = create_vtbl(cx, sp, llself_ty, self_ty, ob, ty_params, none,
                             ~[]);
 
     bcx.build.Store(vtbl, pair_vtbl);
@@ -8344,7 +8344,7 @@ fn trans_res_ctor(@local_ctxt cx, &span sp, &ast::_fn dtor,
     auto llctor_decl;
     alt (cx.ccx.item_ids.find(ctor_id)) {
         case (some(?x)) { llctor_decl = x; }
-        case (_) { 
+        case (_) {
             cx.ccx.sess.span_fatal(sp, "unbound ctor_id in trans_res_ctor");
         }
     }

src/comp/middle/trans_alt.rs

@@ -180,7 +180,7 @@ fn get_options(&@crate_ctxt ccx, &match m, uint col) -> opt[] {
     for (match_branch br in m) {
         alt (br.pats.(col).node) {
             ast::pat_lit(?l) { add_to_set(found, lit(l)); }
-            ast::pat_tag(_, _) { 
+            ast::pat_tag(_, _) {
                 add_to_set(found, variant_opt(ccx, br.pats.(col).id));
             }
             _ {}
@@ -323,7 +323,7 @@ fn compile_submatch(@block_ctxt bcx, &match m, ValueRef[] vals, &mk_fail f,
                 }
             }
             lit(?l) {
-                test_val = bcx.build.Load(val); 
+                test_val = bcx.build.Load(val);
                 kind = alt (l.node) {
                     ast::lit_str(_, _) { compare }
                     _ { switch }
@@ -386,7 +386,7 @@ fn make_phi_bindings(&@block_ctxt bcx, &exit_node[] map,
         }
         fail;
     }
-    
+
     auto our_block = bcx.llbb as uint;
     for each (@tup(ast::ident, ast::node_id) item in ids.items()) {
         auto llbbs = ~[];

src/comp/middle/tstate/ann.rs

@@ -3,7 +3,7 @@ import tritv::*;
 
 type precond = t;
 
-/* 2 means "this constraint may or may not be true after execution" 
+/* 2 means "this constraint may or may not be true after execution"
    1 means "this constraint is definitely true after execution"
    0 means "this constraint is definitely false after execution" */
 type postcond = t;
@@ -23,7 +23,7 @@ type poststate = t;
   0 means "don't know whether this variable is
   initialized" */
 
-/* 
+/*
    This says: this expression requires the constraints whose value is 1 in
    <pre> to be true, and given the precondition, it guarantees that the
    constraints in <post> whose values are 1 are true, and that the constraints

src/comp/middle/tstate/auxiliary.rs

@@ -93,7 +93,7 @@ fn tritv_to_str(fn_ctxt fcx, &tritv::t v) -> str {
             case (?t) {
                 s +=
                     if (comma) { ", " } else { comma = true; "" } +
-                    if (t == tfalse) { "!" } else { "" } +                  
+                    if (t == tfalse) { "!" } else { "" } +
                     constraint_to_str(fcx.ccx.tcx, p.c);
             }
         }
@@ -119,7 +119,7 @@ fn log_tritv_err(fn_ctxt fcx, tritv::t v) { log_err tritv_to_str(fcx, v); }
 
 fn tos(&uint[] v) -> str {
     auto rslt = "";
-    for (uint i in v) { if (i == 0u) { rslt += "0"; } 
+    for (uint i in v) { if (i == 0u) { rslt += "0"; }
         else if (i == 1u) { rslt += "1"; }
         else { rslt += "?"; } }
     ret rslt;
@@ -190,7 +190,7 @@ once.
 norm_constraint, in contrast, gets used when handling an instance
 of a constraint rather than a definition of a constraint. It can
 also be init or pred (ninit or npred), but the npred case just has
-a single argument list. 
+a single argument list.
 
 The representation of constraints, where multiple instances of the
 same predicate are collapsed into one entry in the table, makes it
@@ -209,7 +209,7 @@ type pred_desc_ = rec((@constr_arg_use)[] args, uint bit_num);
 type pred_desc = spanned[pred_desc_];
 
 // FIXME: Should be node_id, since we can only talk
-// about locals. 
+// about locals.
 type constr_arg_use = constr_arg_general[tup(ident, def_id)];
 
 tag constraint {
@@ -559,7 +559,7 @@ fn expr_to_constr_arg(ty::ctxt tcx, &@expr e) -> @constr_arg_use {
                 case (_) {
                     tcx.sess.bug("exprs_to_constr_args: non-local variable " +
                                  "as pred arg");
-                        
+
                 }
             }
         }
@@ -694,7 +694,7 @@ type subst = tup(inst, inst)[];
 
 fn find_instances(&fn_ctxt fcx, &subst subst, &constraint c)
         -> (tup(uint, uint))[] {
-   
+
     let (tup(uint, uint))[] rslt = ~[];
     if (ivec::len(subst) == 0u) {
         ret rslt;
@@ -765,7 +765,7 @@ fn replace(subst subst, pred_desc d) -> (constr_arg_general_[inst])[] {
             }
          }
     }
-    
+
     /*
     for (constr_arg_general_[tup(ident, def_id)] p in rslt) {
         alt (p) {
@@ -787,12 +787,12 @@ fn path_to_ident(&ty::ctxt cx, &path p) -> ident {
     }
 }
 
-tag if_ty { 
+tag if_ty {
     if_check;
     plain_if;
 }
 
-fn local_node_id_to_def_id_strict(&fn_ctxt fcx, &span sp, &node_id i) 
+fn local_node_id_to_def_id_strict(&fn_ctxt fcx, &span sp, &node_id i)
     -> def_id {
     alt (local_node_id_to_def(fcx, i)) {
         case (some(def_local(?d_id))) {
@@ -819,7 +819,7 @@ fn local_node_id_to_def(&fn_ctxt fcx, &node_id i) -> option::t[def]
 fn local_node_id_to_def_id(&fn_ctxt fcx, &node_id i) -> option::t[def_id] {
     alt (local_node_id_to_def(fcx, i)) {
         case (some(def_local(?d_id))) { some(d_id) }
-        case (some (def_arg(?a_id)))  { some(a_id) } 
+        case (some (def_arg(?a_id)))  { some(a_id) }
         case (_)                      { none }
     }
 }
@@ -865,7 +865,7 @@ fn copy_in_poststate_two(&fn_ctxt fcx, &poststate src_post,
         // dest def_id
         auto instances = find_instances(fcx, subst, p._1);
 
-        for (tup(uint,uint) p in instances) { 
+        for (tup(uint,uint) p in instances) {
             if (promises_(p._0, src_post)) {
                 set_in_poststate_(p._1, target_post);
             }

src/comp/middle/tstate/bitvectors.rs

@@ -138,7 +138,7 @@ fn seq_preconds(&fn_ctxt fcx, &pre_and_post[] pps) -> precond {
             auto next_first = clone(first.precondition);
             union(next_first, second_pre);
             auto next_first_post = clone(first.postcondition);
-            seq_tritv(next_first_post, second.postcondition); 
+            seq_tritv(next_first_post, second.postcondition);
             ret seq_preconds_go(fcx, ivec::slice(pps, 1u, sz),
                                 @rec(precondition=next_first,
                                      postcondition=next_first_post));
@@ -189,7 +189,7 @@ fn relax_precond_stmt(&fn_ctxt fcx, node_id i, &@stmt s) {
 fn relax_precond_block(&fn_ctxt fcx, node_id i, &block b) {
     relax_precond_block_non_recursive(fcx, i, b);
     // FIXME: should use visit instead
-    // could at least generalize this pattern 
+    // could at least generalize this pattern
     // (also seen in ck::check_states_against_conditions)
     let @mutable bool keepgoing = @mutable true;
 
@@ -238,7 +238,7 @@ fn clear_in_poststate_expr(&fn_ctxt fcx, &@expr e, &poststate t) {
                                                             c=ninit(i))), t);
                         }
                         case (some(_)) { /* ignore args (for now...) */ }
-                        case (_) { 
+                        case (_) {
                             fcx.ccx.tcx.sess.bug("clear_in_poststate_expr: \
                                    unbound var"); }
                         }

src/comp/middle/tstate/ck.rs

@@ -187,7 +187,7 @@ fn fn_states(&_fn f, &ast::ty_param[] tps,
              &visit::vt[crate_ctxt] v) {
     visit::visit_fn(f, tps, sp, i, id, ccx, v);
     /* Look up the var-to-bit-num map for this function */
-    
+
     assert (ccx.fm.contains_key(id));
     auto f_info = ccx.fm.get(id);
     auto name = option::from_maybe("anon", i);

src/comp/middle/tstate/collect_locals.rs

@@ -47,7 +47,7 @@ fn collect_pred(&@expr e, &ctxt cx, &visit::vt[ctxt] v) {
     // visit subexpressions
     visit::visit_expr(e, cx, v);
 }
- 
+
 fn find_locals(&ty::ctxt tcx, &_fn f, &ty_param[] tps, &span sp, &fn_ident i,
                node_id id) -> ctxt {
     let ctxt cx = rec(cs=@mutable ~[], tcx=tcx);

src/comp/middle/tstate/pre_post_conditions.rs

@@ -112,7 +112,7 @@ fn find_pre_post_item(&crate_ctxt ccx, &item i) {
 
 /* Finds the pre and postcondition for each expr in <args>;
    sets the precondition in a to be the result of combining
-   the preconditions for <args>, and the postcondition in a to 
+   the preconditions for <args>, and the postcondition in a to
    be the union of all postconditions for <args> */
 fn find_pre_post_exprs(&fn_ctxt fcx, &(@expr)[] args, node_id id) {
     if (ivec::len[@expr](args) > 0u) {
@@ -137,7 +137,7 @@ fn find_pre_post_loop(&fn_ctxt fcx, &@local l, &@expr index, &block body,
     find_pre_post_block(fcx, body);
     auto v_init = rec(id=l.node.id, c=ninit(l.node.ident));
     relax_precond_block(fcx, bit_num(fcx, v_init) as node_id, body);
-    
+
     // Hack: for-loop index variables are frequently ignored,
     // so we pretend they're used
     use_var(fcx, l.node.id);
@@ -149,7 +149,7 @@ fn find_pre_post_loop(&fn_ctxt fcx, &@local l, &@expr index, &block body,
     copy_pre_post_(fcx.ccx, id, loop_precond, loop_postcond);
 }
 
-// Generates a pre/post assuming that a is the 
+// Generates a pre/post assuming that a is the
 // annotation for an if-expression with consequent conseq
 // and alternative maybe_alt
 fn join_then_else(&fn_ctxt fcx, &@expr antec, &block conseq,
@@ -236,7 +236,7 @@ fn handle_update(&fn_ctxt fcx, &@expr parent,
         case (expr_path(?p)) {
             auto post = expr_postcond(fcx.ccx, parent);
             auto tmp = tritv_clone(post);
-            
+
             alt (ty) {
                 case (oper_move) {
                     if (is_path(rhs)) {
@@ -255,7 +255,7 @@ fn handle_update(&fn_ctxt fcx, &@expr parent,
                     auto df = node_id_to_def_strict(fcx.ccx.tcx, lhs.id);
                     alt (df) {
                         case (def_local(?d_id)) {
-                            auto i = 
+                            auto i =
                                 bit_num(fcx,
                                  rec(id=d_id._1,
                                      c=ninit(path_to_ident(fcx.ccx.tcx, p))));
@@ -293,7 +293,7 @@ fn handle_update(&fn_ctxt fcx, &@expr parent,
                 case (_) { /* do nothing */ }
             }
         }
-        case (_) { 
+        case (_) {
             find_pre_post_expr(fcx, lhs);
         }
     }
@@ -597,7 +597,7 @@ fn find_pre_post_stmt(&fn_ctxt fcx, &stmt s) {
                              whether or not this is a move */
 
                             find_pre_post_expr(fcx, an_init.expr);
-                            copy_pre_post(fcx.ccx, alocal.node.id, 
+                            copy_pre_post(fcx.ccx, alocal.node.id,
                                           an_init.expr);
                             /* Inherit ann from initializer, and add var being
                                initialized to the postcondition */
@@ -617,7 +617,7 @@ fn find_pre_post_stmt(&fn_ctxt fcx, &stmt s) {
                             }
 
                             gen(fcx, id,
-                                rec(id=alocal.node.id, 
+                                rec(id=alocal.node.id,
                                     c=ninit(alocal.node.ident)));
 
                             if (an_init.op == init_move &&
@@ -650,7 +650,7 @@ fn find_pre_post_stmt(&fn_ctxt fcx, &stmt s) {
 fn find_pre_post_block(&fn_ctxt fcx, block b) {
     /* Want to say that if there is a break or cont in this
      block, then that invalidates the poststate upheld by
-    any of the stmts after it. 
+    any of the stmts after it.
     Given that the typechecker has run, we know any break will be in
     a block that forms a loop body. So that's ok. There'll never be an
     expr_break outside a loop body, therefore, no expr_break outside a block.
@@ -661,7 +661,7 @@ fn find_pre_post_block(&fn_ctxt fcx, block b) {
      This will mean that:
      x = 0;
      break;
-    
+
      won't have a postcondition that says x is initialized, but that's ok.
      */
 

src/comp/middle/tstate/states.rs

@@ -98,7 +98,7 @@ fn find_pre_post_state_two(&fn_ctxt fcx, &prestate pres, &@expr lhs,
             // tmp remembers "old" constraints we'd otherwise forget,
             // for substitution purposes
             auto tmp = tritv_clone(post);
-            
+
             alt (ty) {
                 case (oper_move) {
                     if (is_path(rhs)) {
@@ -166,7 +166,7 @@ fn find_pre_post_state_exprs(&fn_ctxt fcx, &prestate pres, node_id id,
             changed |= set_poststate_ann
                 (fcx.ccx, id, false_postcond(num_constraints(fcx.enclosing)));
         }
-        case (_) { 
+        case (_) {
             changed |= set_poststate_ann(fcx.ccx, id, rs._1);
         }
     }
@@ -188,7 +188,7 @@ fn find_pre_post_state_loop(&fn_ctxt fcx, prestate pres, &@local l,
 
     changed |= find_pre_post_state_block(fcx, index_post, body);
 
-    if (has_nonlocal_exits(body)) { 
+    if (has_nonlocal_exits(body)) {
         // See [Break-unsound]
         ret (changed | set_poststate_ann(fcx.ccx, id, pres));
     }
@@ -201,7 +201,7 @@ fn find_pre_post_state_loop(&fn_ctxt fcx, prestate pres, &@local l,
 
 fn gen_if_local(&fn_ctxt fcx, &poststate p, &@expr e) -> bool {
     alt (e.node) {
-        case (expr_path(?pth)) { 
+        case (expr_path(?pth)) {
             alt (node_id_to_def(fcx.ccx, e.id)) {
                 case (some(def_local(?loc))) {
                     ret set_in_poststate_ident(fcx, loc._1,
@@ -219,7 +219,7 @@ fn join_then_else(&fn_ctxt fcx, &@expr antec, &block conseq,
                   &prestate pres) -> bool {
     auto changed = set_prestate_ann(fcx.ccx, id, pres) |
         find_pre_post_state_expr(fcx, pres, antec);
-    
+
     /*
     log_err("join_then_else:");
     log_expr_err(*antec);
@@ -259,7 +259,7 @@ fn join_then_else(&fn_ctxt fcx, &@expr antec, &block conseq,
 
             changed |=
                 find_pre_post_state_block(fcx, conseq_prestate, conseq);
-   
+
             auto poststate_res =
                 intersect_states(block_poststate(fcx.ccx, conseq),
                                     expr_poststate(fcx.ccx, altern));
@@ -271,7 +271,7 @@ fn join_then_else(&fn_ctxt fcx, &@expr antec, &block conseq,
                 aux::tritv_to_str(fcx, expr_poststate(fcx.ccx, altern)));
             fcx.ccx.tcx.sess.span_note(antec.span,
             "conseq poststate = " + aux::tritv_to_str(fcx,
-               block_poststate(fcx.ccx, conseq))); 
+               block_poststate(fcx.ccx, conseq)));
             */
 
             changed |= set_poststate_ann(fcx.ccx, id, poststate_res);
@@ -373,7 +373,7 @@ fn find_pre_post_state_expr(&fn_ctxt fcx, &prestate pres, @expr e) -> bool {
                 (fcx, expr_poststate(fcx.ccx, lhs), rhs);
             auto post = tritv_clone(expr_poststate(fcx.ccx, rhs));
             forget_in_poststate_still_init(fcx, post, rhs.id);
-            gen_if_local(fcx, post, rhs); 
+            gen_if_local(fcx, post, rhs);
             ret changed | set_poststate_ann(fcx.ccx, e.id, post);
         }
         case (expr_ret(?maybe_ret_val)) {
@@ -452,7 +452,7 @@ fn find_pre_post_state_expr(&fn_ctxt fcx, &prestate pres, @expr e) -> bool {
             /* conservative approximation: if a loop contains a break
                or cont, we assume nothing about the poststate */
             /* which is still unsound -- see [Break-unsound] */
-            if (has_nonlocal_exits(body)) { 
+            if (has_nonlocal_exits(body)) {
                 ret changed | set_poststate_ann(fcx.ccx, e.id, pres);
             }
             else {
@@ -580,7 +580,7 @@ fn find_pre_post_state_expr(&fn_ctxt fcx, &prestate pres, @expr e) -> bool {
 fn find_pre_post_state_stmt(&fn_ctxt fcx, &prestate pres, @stmt s) -> bool {
     auto stmt_ann = stmt_to_ann(fcx.ccx, *s);
 
-    /*    
+    /*
     log_err "*At beginning: stmt = ";
     log_stmt_err(*s);
     log_err "*prestate = ";
@@ -613,7 +613,7 @@ fn find_pre_post_state_stmt(&fn_ctxt fcx, &prestate pres, @stmt s) -> bool {
                                                           an_init.expr.id);
                                     alt (rhs_d) {
                                         case (some(?rhsid)) {
-                                            auto instrhs = 
+                                            auto instrhs =
                                                 tup(path_to_ident(fcx.ccx.tcx,
                                                                   p), rhsid);
                                             copy_in_poststate(fcx, post,

src/comp/middle/tstate/tritv.rs

@@ -19,7 +19,7 @@ export tritv_clear;
 export tritv_doesntcare;
 export to_str;
 
-/* for a fixed index: 
+/* for a fixed index:
    10 = "this constraint may or may not be true after execution"
    01 = "this constraint is definitely true"
    00 = "this constraint is definitely false"
@@ -165,7 +165,7 @@ fn tritv_get(&t v, uint i) -> trit {
   else if (b2) { ttrue }
   else         { tfalse}
 }
- 
+
 fn tritv_set(uint i, &t v, trit t) -> bool {
   auto old = tritv_get(v, i);
   alt (t) {

src/comp/middle/ty.rs

@@ -2328,7 +2328,7 @@ mod unify {
                     }
                     case (_) { ret ures_err(terr_mismatch); }
                 }
-            }       
+            }
             case (ty::ty_param(_)) { ret struct_cmp(cx, expected, actual); }
             case (ty::ty_tag(?expected_id, ?expected_tps)) {
                 alt (struct(cx.tcx, actual)) {

src/comp/middle/typeck.rs

@@ -95,7 +95,7 @@ fn ty_param_count_and_ty_for_def(&@fn_ctxt fcx, &span sp, &ast::def defn) ->
     alt (defn) {
         case (ast::def_arg(?id)) {
             assert (fcx.locals.contains_key(id._1));
-            auto typ = ty::mk_var(fcx.ccx.tcx, 
+            auto typ = ty::mk_var(fcx.ccx.tcx,
                                   lookup_local(fcx, sp, id._1));
             ret tup(0u, typ);
         }
@@ -1616,7 +1616,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
         check_expr(fcx, e);
         demand::simple(fcx, e.span, ty::mk_bool(fcx.ccx.tcx),
                        expr_ty(fcx.ccx.tcx, e));
-        
+
         /* e must be a call expr where all arguments are either
            literals or slots */
             alt (e.node) {
@@ -1625,7 +1625,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
                         case (ast::expr_path(?oper_name)) {
                             alt (fcx.ccx.tcx.def_map.find(operator.id)) {
                                 case (some(ast::def_fn(?_d_id,
-                                                       ast::pure_fn))) { 
+                                                       ast::pure_fn))) {
                                     // do nothing
                                 }
                                 case (_) {
@@ -1678,7 +1678,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
         write::ty_only_fixup(fcx, id, if_t);
     }
 
-    // Checks the compatibility 
+    // Checks the compatibility
     fn check_binop_type_compat(&@fn_ctxt fcx, span span,
                                ty::t ty, ast::binop binop) {
         auto resolved_t = resolve_type_vars_if_possible(fcx, ty);
@@ -1745,7 +1745,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
                         case (ty::ty_ptr(?inner)) { oper_t = inner.ty; }
                         case (_) {
                             fcx.ccx.tcx.sess.span_fatal
-                                (expr.span, "dereferencing non-" + 
+                                (expr.span, "dereferencing non-" +
                                  "dereferenceable type: " +
                                  ty_to_str(fcx.ccx.tcx, oper_t));
                         }
@@ -2191,7 +2191,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
             alt (base) {
                 case (none) {
                     fn get_node(&spanned[field] f) -> field { f.node }
-                    auto typ = ty::mk_rec(fcx.ccx.tcx, 
+                    auto typ = ty::mk_rec(fcx.ccx.tcx,
                                           ivec::map(get_node, fields_t));
                     write::ty_only_fixup(fcx, id, typ);
                 }
@@ -2313,8 +2313,8 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
             auto t = next_ty_var(fcx);
             alt(typ) {
                 case (some(?_t)) {
-                    demand::simple(fcx, expr.span, 
-                                   ast_ty_to_ty_crate(fcx.ccx, _t), 
+                    demand::simple(fcx, expr.span,
+                                   ast_ty_to_ty_crate(fcx.ccx, _t),
                                    t);
                 }
                 case (none) {}
@@ -2352,7 +2352,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
 
             // FIXME: this is duplicated between here and trans -- it should
             // appear in one place
-            fn anon_obj_field_to_obj_field(&ast::anon_obj_field f) 
+            fn anon_obj_field_to_obj_field(&ast::anon_obj_field f)
                 -> ast::obj_field {
                 ret rec(mut=f.mut, ty=f.ty, ident=f.ident, id=f.id);
             }
@@ -2417,7 +2417,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
                                 // The user is trying to extend a non-object.
                                 fcx.ccx.tcx.sess.span_fatal(
                                     e.span,
-                                    syntax::print::pprust::expr_to_str(e) + 
+                                    syntax::print::pprust::expr_to_str(e) +
                                     " does not have object type");
                             }
                         }

src/comp/syntax/ast.rs

@@ -620,7 +620,7 @@ fn is_exported(ident i, _mod m) -> bool {
             case (_) {/* fall through */ }
         }
     }
-    // If there are no declared exports then 
+    // If there are no declared exports then
     // everything not imported is exported
 
     ret count == 0u && !nonlocal;

src/comp/syntax/ext/base.rs

@@ -6,7 +6,7 @@ import codemap::span;
 import std::map::new_str_hash;
 import codemap;
 
-type syntax_expander = 
+type syntax_expander =
     fn(&ext_ctxt, span, &(@ast::expr)[], option::t[str]) -> @ast::expr;
 type macro_definer = fn(&ext_ctxt, span, &(@ast::expr)[],
                         option::t[str]) -> tup(str, syntax_extension);
@@ -22,7 +22,7 @@ fn syntax_expander_table() -> hashmap[str, syntax_extension] {
     auto syntax_expanders = new_str_hash[syntax_extension]();
     syntax_expanders.insert("fmt", normal(ext::fmt::expand_syntax_ext));
     syntax_expanders.insert("env", normal(ext::env::expand_syntax_ext));
-    syntax_expanders.insert("macro",    
+    syntax_expanders.insert("macro",
                             macro_defining(ext::simplext::add_new_extension));
     ret syntax_expanders;
 }
@@ -85,7 +85,7 @@ fn expr_to_str(&ext_ctxt cx, @ast::expr expr, str error) -> str {
 fn expr_to_ident(&ext_ctxt cx, @ast::expr expr, str error) -> ast::ident {
     alt(expr.node) {
         case (ast::expr_path(?p)) {
-            if (ivec::len(p.node.types) > 0u 
+            if (ivec::len(p.node.types) > 0u
                     || ivec::len(p.node.idents) != 1u) {
                 cx.span_fatal(expr.span, error);
             } else {

src/comp/syntax/ext/expand.rs

@@ -13,8 +13,8 @@ import std::option::some;
 import std::map::hashmap;
 import std::ivec;
 
-fn expand_expr(&hashmap[str, base::syntax_extension] exts, 
-               &session::session sess, &expr_ e, ast_fold fld, 
+fn expand_expr(&hashmap[str, base::syntax_extension] exts,
+               &session::session sess, &expr_ e, ast_fold fld,
                &fn(&ast::expr_, ast_fold) -> expr_ orig) -> expr_ {
     ret alt(e) {
         case (expr_mac(?mac)) {
@@ -25,18 +25,18 @@ fn expand_expr(&hashmap[str, base::syntax_extension] exts,
                     auto ext_cx = base::mk_ctxt(sess);
                     alt (exts.find(extname)) {
                         case (none) {
-                            emit_error(some(pth.span), 
+                            emit_error(some(pth.span),
                                        "unknown syntax expander: '"
                                        + extname + "'", sess.get_codemap());
                             fail
                         }
                         case (some(base::normal(?ext))) {
                             //keep going, outside-in
-                            fld.fold_expr(ext(ext_cx, pth.span, 
+                            fld.fold_expr(ext(ext_cx, pth.span,
                                               args, body)).node
                         }
                         case (some(base::macro_defining(?ext))) {
-                            auto named_extension 
+                            auto named_extension
                                 = ext(ext_cx, pth.span, args, body);
                             exts.insert(named_extension._0,
                                         named_extension._1);
@@ -65,7 +65,7 @@ fn expand_crate(&session::session sess, &@crate c) -> @crate {
     auto res = @f.fold_crate(*c);
     dummy_out(f); //temporary: kill circular reference
     ret res;
-    
+
 }
 
 // Local Variables:

src/comp/syntax/ext/simplext.rs

@@ -61,8 +61,8 @@ fn subst_path(&ext_ctxt cx, &(invk_binding)[] ibs, &path_ p, ast_fold fld)
     // Don't substitute into qualified names.
     if (ivec::len(p.types) > 0u || ivec::len(p.idents) != 1u) { ret p; }
     ret alt (lookup(ibs, p.idents.(0))) {
-        case (some(ident_binding(_, ?id))) { 
-            rec(global=false, idents=~[id.node], types=~[]) 
+        case (some(ident_binding(_, ?id))) {
+            rec(global=false, idents=~[id.node], types=~[])
         }
         case (some(path_binding(_, ?a_pth))) { a_pth.node }
         case (some(expr_binding(_, ?expr))) {
@@ -74,18 +74,18 @@ fn subst_path(&ext_ctxt cx, &(invk_binding)[] ibs, &path_ p, ast_fold fld)
 }
 
 
-fn subst_expr(&ext_ctxt cx, &(invk_binding)[] ibs, &ast::expr_ e, 
-              ast_fold fld, fn(&ast::expr_, ast_fold) -> ast::expr_ orig) 
+fn subst_expr(&ext_ctxt cx, &(invk_binding)[] ibs, &ast::expr_ e,
+              ast_fold fld, fn(&ast::expr_, ast_fold) -> ast::expr_ orig)
     -> ast::expr_ {
     ret alt(e) {
         case (expr_path(?p)){
             // Don't substitute into qualified names.
-            if (ivec::len(p.node.types) > 0u || 
+            if (ivec::len(p.node.types) > 0u ||
                 ivec::len(p.node.idents) != 1u) { e }
             alt (lookup(ibs, p.node.idents.(0))) {
-                case (some(ident_binding(_, ?id))) { 
-                    expr_path(respan(id.span, 
-                                     rec(global=false, 
+                case (some(ident_binding(_, ?id))) {
+                    expr_path(respan(id.span,
+                                     rec(global=false,
                                          idents=~[id.node],types=~[])))
                 }
                 case (some(path_binding(_, ?a_pth))) { expr_path(*a_pth) }
@@ -107,7 +107,7 @@ tag invk_binding {
 }
 
 fn path_to_ident(&path pth) -> option::t[ident] {
-    if (ivec::len(pth.node.idents) == 1u 
+    if (ivec::len(pth.node.idents) == 1u
         && ivec::len(pth.node.types) == 0u) {
         ret some(pth.node.idents.(0u));
     }
@@ -115,7 +115,7 @@ fn path_to_ident(&path pth) -> option::t[ident] {
 }
 
 fn process_clause(&ext_ctxt cx, &mutable vec[pat_ext] pes,
-                  &mutable option::t[str] macro_name, &path pth, 
+                  &mutable option::t[str] macro_name, &path pth,
                   &(@ast::expr)[] invoc_args, @ast::expr body) {
     let str clause_name = alt(path_to_ident(pth)) {
         case (some(?id)) { id }
@@ -139,10 +139,10 @@ fn add_new_extension(&ext_ctxt cx, span sp, &(@ast::expr)[] args,
     for (@ast::expr arg in args) {
         alt(arg.node) {
             case(expr_vec(?elts, ?mut, ?seq_kind)) {
-                
+
                 if (ivec::len(elts) != 2u) {
-                    cx.span_fatal((*arg).span, 
-                                  "extension clause must consist of [" + 
+                    cx.span_fatal((*arg).span,
+                                  "extension clause must consist of [" +
                                   "macro invocation, expansion body]");
                 }
                 alt(elts.(0u).node) {
@@ -168,10 +168,10 @@ fn add_new_extension(&ext_ctxt cx, span sp, &(@ast::expr)[] args,
     }
 
     auto ext = bind generic_extension(_,_,_,_,@pat_exts);
-    
+
     ret tup(alt (macro_name) {
                 case (some(?id)) { id }
-                case (none) { 
+                case (none) {
                     cx.span_fatal(sp, "macro definition must have "
                                   + "at least one clause")
                 }
@@ -192,7 +192,7 @@ fn add_new_extension(&ext_ctxt cx, span sp, &(@ast::expr)[] args,
                 case (expr_vec(?p_elts, _, _)) {
                     alt (arg) {
                         case (expr_vec(?a_elts, _, _)) {
-                            if (ivec::len(p_elts) != ivec::len(a_elts)) { 
+                            if (ivec::len(p_elts) != ivec::len(a_elts)) {
                                 none[vec[invk_binding]]
                             }
                             let uint i = 0u;
@@ -218,12 +218,12 @@ fn add_new_extension(&ext_ctxt cx, span sp, &(@ast::expr)[] args,
                                     alt (path_to_ident(a_pth)) {
                                         case (some(?a_id)) {
                                             some(~[ident_binding
-                                                   (p_id, 
+                                                   (p_id,
                                                     respan(argument.span,
                                                                  a_id))])
                                         }
                                         case (none) {
-                                            some(~[path_binding(p_id, 
+                                            some(~[path_binding(p_id,
                                                                 @a_pth)])
                                         }
                                     }

src/comp/syntax/fold.rs

@@ -18,9 +18,9 @@ type ast_fold = @mutable a_f;
 
 // We may eventually want to be able to fold over type parameters, too
 
-type ast_fold_precursor = 
+type ast_fold_precursor =
     rec(fn (&crate_ c, ast_fold) -> crate_                fold_crate,
-        fn (&crate_directive_ cd, ast_fold) -> crate_directive_ 
+        fn (&crate_directive_ cd, ast_fold) -> crate_directive_
                                                  fold_crate_directive,
         fn (&view_item_ i, ast_fold) -> view_item_        fold_view_item,
         fn (&@native_item i, ast_fold) -> @native_item    fold_native_item,
@@ -72,27 +72,27 @@ type a_f =
 
 //fn nf_dummy[T](&T node) -> T { fail; }
 fn nf_crate_dummy(&crate c) -> crate { fail; }
-fn nf_crate_directive_dummy(&@crate_directive c) 
+fn nf_crate_directive_dummy(&@crate_directive c)
     -> @crate_directive { fail; }
-fn nf_view_item_dummy(&@view_item v) -> @view_item { fail; } 
-fn nf_native_item_dummy(&@native_item n) -> @native_item { fail; } 
-fn nf_item_dummy(&@item i) -> @item { fail; } 
-fn nf_item_underscore_dummy(&item_ i) -> item_ { fail; } 
-fn nf_method_dummy(&@method m) -> @method { fail; } 
-fn nf_block_dummy(&block b) -> block { fail; } 
-fn nf_stmt_dummy(&@stmt s) -> @stmt { fail; } 
-fn nf_arm_dummy(&arm a) -> arm { fail; } 
-fn nf_pat_dummy(&@pat p) -> @pat { fail; } 
-fn nf_decl_dummy(&@decl d) -> @decl { fail; } 
-fn nf_expr_dummy(&@expr e) -> @expr { fail; } 
-fn nf_ty_dummy(&@ty t) -> @ty { fail; } 
-fn nf_constr_dummy(&@constr c) -> @constr { fail; } 
-fn nf_fn_dummy(&_fn f) -> _fn { fail; } 
-fn nf_mod_dummy(&_mod m) -> _mod { fail; } 
-fn nf_native_mod_dummy(&native_mod n) -> native_mod { fail; } 
-fn nf_variant_dummy(&variant v) -> variant { fail; } 
-fn nf_ident_dummy(&ident i) -> ident { fail; } 
-fn nf_path_dummy(&path p) -> path { fail; } 
+fn nf_view_item_dummy(&@view_item v) -> @view_item { fail; }
+fn nf_native_item_dummy(&@native_item n) -> @native_item { fail; }
+fn nf_item_dummy(&@item i) -> @item { fail; }
+fn nf_item_underscore_dummy(&item_ i) -> item_ { fail; }
+fn nf_method_dummy(&@method m) -> @method { fail; }
+fn nf_block_dummy(&block b) -> block { fail; }
+fn nf_stmt_dummy(&@stmt s) -> @stmt { fail; }
+fn nf_arm_dummy(&arm a) -> arm { fail; }
+fn nf_pat_dummy(&@pat p) -> @pat { fail; }
+fn nf_decl_dummy(&@decl d) -> @decl { fail; }
+fn nf_expr_dummy(&@expr e) -> @expr { fail; }
+fn nf_ty_dummy(&@ty t) -> @ty { fail; }
+fn nf_constr_dummy(&@constr c) -> @constr { fail; }
+fn nf_fn_dummy(&_fn f) -> _fn { fail; }
+fn nf_mod_dummy(&_mod m) -> _mod { fail; }
+fn nf_native_mod_dummy(&native_mod n) -> native_mod { fail; }
+fn nf_variant_dummy(&variant v) -> variant { fail; }
+fn nf_ident_dummy(&ident i) -> ident { fail; }
+fn nf_path_dummy(&path p) -> path { fail; }
 fn nf_obj_field_dummy(&obj_field o) -> obj_field { fail; }
 fn nf_local_dummy(&@local o) -> @local { fail; }
 
@@ -114,7 +114,7 @@ fn fold_meta_item_(&@meta_item mi, ast_fold fld) -> @meta_item {
              span=mi.span);
 }
 //used in noop_fold_item and noop_fold_crate
-fn fold_attribute_(&attribute at, fn(&@meta_item) -> @meta_item fmi) 
+fn fold_attribute_(&attribute at, fn(&@meta_item) -> @meta_item fmi)
     -> attribute {
     ret rec(node=rec(style=at.node.style,
                      value=*fmi(@at.node.value)),
@@ -122,7 +122,7 @@ fn fold_attribute_(&attribute at, fn(&@meta_item) -> @meta_item fmi)
 }
 //used in noop_fold_native_item and noop_fold_fn
 fn fold_arg_(&arg a, ast_fold fld) -> arg {
-    ret rec(mode=a.mode, ty=fld.fold_ty(a.ty), 
+    ret rec(mode=a.mode, ty=fld.fold_ty(a.ty),
             ident=fld.fold_ident(a.ident), id=a.id);
 }
 //used in noop_fold_expr, and possibly elsewhere in the future
@@ -130,10 +130,10 @@ fn fold_mac_(&mac m, ast_fold fld) -> mac {
     ret rec(node=
             alt(m.node) {
                 case (mac_invoc(?pth,?args,?body)) {
-                    mac_invoc(fld.fold_path(pth), 
+                    mac_invoc(fld.fold_path(pth),
                               ivec::map(fld.fold_expr, args), body)
                 }
-                case (mac_embed_type(?ty)) { 
+                case (mac_embed_type(?ty)) {
                     mac_embed_type(fld.fold_ty(ty))
                 }
                 case (mac_embed_block(?block)) {
@@ -158,17 +158,17 @@ fn noop_fold_crate(&crate_ c, ast_fold fld) -> crate_ {
             config=ivec::map(fold_meta_item, c.config));
 }
 
-fn noop_fold_crate_directive(&crate_directive_ cd, ast_fold fld) 
+fn noop_fold_crate_directive(&crate_directive_ cd, ast_fold fld)
     -> crate_directive_ {
     ret alt(cd) {
-        case(cdir_src_mod(?id,?fname,?attrs)) { 
+        case(cdir_src_mod(?id,?fname,?attrs)) {
             cdir_src_mod(fld.fold_ident(id), fname, attrs)
                 }
         case(cdir_dir_mod(?id,?fname,?cds,?attrs)) {
             cdir_dir_mod(fld.fold_ident(id),fname,
                          ivec::map(fld.fold_crate_directive, cds), attrs)
                 }
-        case(cdir_view_item(?vi)) { 
+        case(cdir_view_item(?vi)) {
             cdir_view_item(fld.fold_view_item(vi))
                 }
         case(cdir_syntax(_)) { cd }
@@ -191,7 +191,7 @@ fn noop_fold_native_item(&@native_item ni, ast_fold fld) -> @native_item {
              node=alt (ni.node) {
                  case (native_item_ty) { native_item_ty }
                  case (native_item_fn(?st, ?fdec, ?typms)) {
-                     native_item_fn(st, 
+                     native_item_fn(st,
                                     rec(inputs=ivec::map(fold_arg,
                                                          fdec.inputs),
                                         output=fld.fold_ty(fdec.output),
@@ -217,7 +217,7 @@ fn noop_fold_item(&@item i, ast_fold fld) -> @item {
 
 fn noop_fold_item_underscore(&item_ i, ast_fold fld) -> item_ {
     fn fold_obj_field_(&obj_field of, ast_fold fld) -> obj_field {
-        ret rec(mut=of.mut, ty=fld.fold_ty(of.ty), 
+        ret rec(mut=of.mut, ty=fld.fold_ty(of.ty),
                 ident=fld.fold_ident(of.ident), id=of.id);
     }
     auto fold_obj_field = bind fold_obj_field_(_,fld);
@@ -253,7 +253,7 @@ fn noop_fold_item_underscore(&item_ i, ast_fold fld) -> item_ {
 
 fn noop_fold_method(&method_ m, ast_fold fld) -> method_ {
     ret rec(ident=fld.fold_ident(m.ident),
-            meth=fld.fold_fn(m.meth), id=m.id); 
+            meth=fld.fold_fn(m.meth), id=m.id);
 }
 
 
@@ -319,9 +319,9 @@ fn noop_fold_expr(&expr_ e, ast_fold fld) -> expr_ {
     }
     auto fold_field = bind fold_field_(_,fld);
     fn fold_anon_obj_(&anon_obj ao, ast_fold fld) -> anon_obj {
-        fn fold_anon_obj_field_(&anon_obj_field aof, ast_fold fld) 
+        fn fold_anon_obj_field_(&anon_obj_field aof, ast_fold fld)
             -> anon_obj_field {
-            ret rec(mut=aof.mut, ty=fld.fold_ty(aof.ty), 
+            ret rec(mut=aof.mut, ty=fld.fold_ty(aof.ty),
                     expr=fld.fold_expr(aof.expr),
                     ident=fld.fold_ident(aof.ident), id=aof.id);
         }
@@ -337,7 +337,7 @@ fn noop_fold_expr(&expr_ e, ast_fold fld) -> expr_ {
                 with_obj=option::map(fld.fold_expr, ao.with_obj))
     }
     auto fold_anon_obj = bind fold_anon_obj_(_,fld);
-    
+
     auto fold_mac = bind fold_mac_(_,fld);
 
     ret alt (e) {
@@ -362,7 +362,7 @@ fn noop_fold_expr(&expr_ e, ast_fold fld) -> expr_ {
             expr_bind(fld.fold_expr(f), ivec::map(opt_map_se, args))
                 }
         case (expr_spawn(?spawn_dom, ?name, ?f, ?args)) {
-            expr_spawn(spawn_dom, name, fld.fold_expr(f), 
+            expr_spawn(spawn_dom, name, fld.fold_expr(f),
                        ivec::map(fld.fold_expr, args))
                 }
         case (expr_binary(?binop, ?lhs, ?rhs)) {
@@ -376,7 +376,7 @@ fn noop_fold_expr(&expr_ e, ast_fold fld) -> expr_ {
             expr_cast(fld.fold_expr(expr), ty)
         }
         case (expr_if(?cond, ?tr, ?fl)) {
-            expr_if(fld.fold_expr(cond), fld.fold_block(tr), 
+            expr_if(fld.fold_expr(cond), fld.fold_block(tr),
                     option::map(fld.fold_expr, fl))
                 }
         case (expr_ternary(?cond, ?tr, ?fl)) {
@@ -388,11 +388,11 @@ fn noop_fold_expr(&expr_ e, ast_fold fld) -> expr_ {
             expr_while(fld.fold_expr(cond), fld.fold_block(body))
                 }
         case (expr_for(?decl, ?expr, ?block)) {
-            expr_for(fld.fold_local(decl), fld.fold_expr(expr), 
+            expr_for(fld.fold_local(decl), fld.fold_expr(expr),
                      fld.fold_block(block))
                 }
         case (expr_for_each(?decl, ?expr, ?block)) {
-            expr_for_each(fld.fold_local(decl), fld.fold_expr(expr), 
+            expr_for_each(fld.fold_local(decl), fld.fold_expr(expr),
                           fld.fold_block(block))
                 }
         case (expr_do_while(?block, ?expr)) {
@@ -437,10 +437,10 @@ fn noop_fold_expr(&expr_ e, ast_fold fld) -> expr_ {
         case (expr_fail(?e)) { expr_fail(option::map(fld.fold_expr, e)) }
         case (expr_break()) { e }
         case (expr_cont()) { e }
-        case (expr_ret(?e)) { 
+        case (expr_ret(?e)) {
             expr_ret(option::map(fld.fold_expr, e))
                 }
-        case (expr_put(?e)) { 
+        case (expr_put(?e)) {
             expr_put(option::map(fld.fold_expr, e))
                 }
         case (expr_be(?e)) { expr_be(fld.fold_expr(e)) }
@@ -448,10 +448,10 @@ fn noop_fold_expr(&expr_ e, ast_fold fld) -> expr_ {
         case (expr_assert(?e)) { expr_assert(fld.fold_expr(e)) }
         case (expr_check(?m, ?e)) { expr_check(m, fld.fold_expr(e)) }
         case (expr_if_check(?cond, ?tr, ?fl)) {
-            expr_if_check(fld.fold_expr(cond), fld.fold_block(tr), 
+            expr_if_check(fld.fold_expr(cond), fld.fold_block(tr),
                           option::map(fld.fold_expr, fl))
                 }
-        case (expr_port(?ot)) { 
+        case (expr_port(?ot)) {
             expr_port(alt(ot) {
                     case (option::some(?t)) { option::some(fld.fold_ty(t)) }
                     case (option::none) { option::none }
@@ -531,7 +531,7 @@ fn noop_fold_local(&local_ l, ast_fold fld) -> local_ {
                 case (option::none[initializer]) { l.init }
                 case (option::some[initializer](?init)) {
                     option::some[initializer]
-                    (rec(op=init.op, 
+                    (rec(op=init.op,
                          expr=fld.fold_expr(init.expr)))
                 }
             },
@@ -591,7 +591,7 @@ fn dummy_out(ast_fold a) {
 
 
 fn make_fold(&ast_fold_precursor afp) -> ast_fold {
-    let ast_fold result = 
+    let ast_fold result =
         @mutable rec(fold_crate = nf_crate_dummy,
                      fold_crate_directive = nf_crate_directive_dummy,
                      fold_view_item = nf_view_item_dummy,
@@ -620,7 +620,7 @@ fn make_fold(&ast_fold_precursor afp) -> ast_fold {
         ret rec(node=afp.fold_crate(c.node, f),
                 span=c.span);
     }
-    fn f_crate_directive(&ast_fold_precursor afp, ast_fold f, 
+    fn f_crate_directive(&ast_fold_precursor afp, ast_fold f,
                          &@crate_directive c) -> @crate_directive {
         ret @rec(node=afp.fold_crate_directive(c.node, f),
                  span=c.span);
@@ -669,14 +669,14 @@ fn make_fold(&ast_fold_precursor afp) -> ast_fold {
     }
     fn f_fn(&ast_fold_precursor afp, ast_fold f, &_fn x) -> _fn {
         ret afp.fold_fn(x, f);
-    }    
+    }
     fn f_mod(&ast_fold_precursor afp, ast_fold f, &_mod x) -> _mod {
         ret afp.fold_mod(x, f);
     }
-    fn f_native_mod(&ast_fold_precursor afp, ast_fold f, &native_mod x) -> 
+    fn f_native_mod(&ast_fold_precursor afp, ast_fold f, &native_mod x) ->
         native_mod {
         ret afp.fold_native_mod(x, f);
-    }    
+    }
     fn f_variant(&ast_fold_precursor afp, ast_fold f, &variant x)
         -> variant {
         ret rec(node=afp.fold_variant(x.node, f), span=x.span);

src/comp/syntax/parse/lexer.rs

@@ -370,8 +370,8 @@ fn next_token(&reader rdr) -> token::token {
         case ('?') { rdr.bump(); ret token::QUES; }
         case (';') { rdr.bump(); ret token::SEMI; }
         case (',') { rdr.bump(); ret token::COMMA; }
-        case ('.') { 
-            rdr.bump(); 
+        case ('.') {
+            rdr.bump();
             if (rdr.curr() == '.' && rdr.next() == '.') {
                 rdr.bump();
                 rdr.bump();
@@ -386,8 +386,8 @@ fn next_token(&reader rdr) -> token::token {
         case ('[') { rdr.bump(); ret token::LBRACKET; }
         case (']') { rdr.bump(); ret token::RBRACKET; }
         case ('@') { rdr.bump(); ret token::AT; }
-        case ('#') { 
-            rdr.bump(); 
+        case ('#') {
+            rdr.bump();
             if (rdr.curr() == '<') {
                 rdr.bump();
                 ret token::POUND_LT;

src/comp/syntax/parse/parser.rs

@@ -361,7 +361,7 @@ fn parse_ty_constr(&ast::arg[] fn_args, &parser p) -> @ast::constr {
 }
 
 
-// Use the args list to translate each bound variable 
+// Use the args list to translate each bound variable
 // mentioned in a constraint to an arg index.
 // Seems weird to do this in the parser, but I'm not sure how else to.
 fn parse_constrs(&ast::arg[] args, &parser p)
@@ -932,7 +932,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr {
         ex = ast::expr_assert(e);
         hi = e.span.hi;
     } else if (eat_word(p, "check")) {
-        /* Should be a predicate (pure boolean function) applied to 
+        /* Should be a predicate (pure boolean function) applied to
            arguments that are all either slot variables or literals.
            but the typechecker enforces that. */
 
@@ -943,7 +943,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr {
         /* Same rules as check, except that if check-claims
          is enabled (a command-line flag), then the parser turns
         claims into check */
-        
+
         auto e = parse_expr(p);
         hi = e.span.hi;
         ex = ast::expr_check(ast::unchecked, e);
@@ -1310,7 +1310,7 @@ fn parse_else_expr(&parser p) -> @ast::expr {
 fn parse_head_local(&parser p) -> @ast::local {
     if (is_word(p, "auto")) {
         ret parse_auto_local(p);
-    } else { 
+    } else {
         ret parse_typed_local(p);
     }
 }
@@ -1709,7 +1709,7 @@ fn parse_block(&parser p) -> ast::block {
     be parse_block_tail(p);
 }
 
-// some blocks start with "#{"... 
+// some blocks start with "#{"...
 fn parse_block_tail(&parser p) -> ast::block {
     auto lo = p.get_lo_pos();
     let (@ast::stmt)[] stmts = ~[];
@@ -1865,7 +1865,7 @@ fn parse_dtor(&parser p) -> @ast::method {
             purity=ast::impure_fn,
             cf=ast::return,
 
-            // I guess dtors can't have constraints? 
+            // I guess dtors can't have constraints?
             constraints=~[]);
     let ast::_fn f = rec(decl=d, proto=ast::proto_fn, body=b);
     let ast::method_ m =
@@ -2432,7 +2432,7 @@ fn parse_crate_from_source_str(&str name, &str source, &ast::crate_cfg cfg,
 }
 
 // Parses a source module as a crate
-fn parse_crate_mod(&parser p, &ast::crate_cfg cfg, parse_sess sess) 
+fn parse_crate_mod(&parser p, &ast::crate_cfg cfg, parse_sess sess)
     -> @ast::crate {
     auto lo = p.get_lo_pos();
     auto crate_attrs = parse_inner_attrs_and_next(p);

src/comp/syntax/print/pprust.rs

@@ -574,7 +574,7 @@ fn print_stmt(&ps s, &ast::stmt st) {
 
 fn print_block(&ps s, &ast::block blk) {
     print_possibly_embedded_block(s, blk, false);
-} 
+}
 
 fn print_possibly_embedded_block(&ps s, &ast::block blk, bool embedded) {
     maybe_print_comment(s, blk.span.lo);
@@ -1003,13 +1003,13 @@ fn print_expr(&ps s, &@ast::expr expr) {
                 print_expr(s, field.expr);
                 end(s);
             }
-            fn get_span(&ast::anon_obj_field f) -> codemap::span { 
-                ret f.ty.span; 
+            fn get_span(&ast::anon_obj_field f) -> codemap::span {
+                ret f.ty.span;
             }
             alt (anon_obj.fields) {
                 case (none) { }
                 case (some(?fields)) {
-                    commasep_cmnt(s, consistent, fields, print_field, 
+                    commasep_cmnt(s, consistent, fields, print_field,
                                        get_span);
                 }
             }

src/comp/syntax/walk.rs

@@ -394,7 +394,7 @@ fn walk_expr(&ast_visitor v, @ast::expr e) {
             alt (anon_obj.fields) {
                 case (none) { }
                 case (some(?fields)) {
-                    for (ast::anon_obj_field f in fields) { 
+                    for (ast::anon_obj_field f in fields) {
                         walk_ty(v, f.ty);
                         walk_expr(v, f.expr);
                     }

src/etc/tidy.py

@@ -25,6 +25,9 @@ for line in fileinput.input(openhook=fileinput.hook_encoded("utf-8")):
     if not autocrlf and line.find('\r') != -1:
         report_err("CR character")
 
+    if line.endswith(" \n") or line.endswith("\t\n"):
+        report_err("trailing whitespace")
+
     line_len = len(line)-2 if autocrlf else len(line)-1
     if line_len > cols:
         report_err("line longer than %d chars" % cols)

src/lib/u64.rs

@@ -2,7 +2,7 @@ fn to_str(u64 n, uint radix) -> str {
     assert(0u < radix && radix <= 16u);
 
     auto r64 = radix as u64;
-    
+
     fn digit(u64 n) -> str {
         ret alt (n) {
             case (0u64) { "0" }

src/lib/vec.rs

@@ -300,13 +300,13 @@ fn or(&vec[bool] v) -> bool {
 
 fn any[T](&fn(&T) -> bool f, &vec[T] v) -> bool {
     for (T t in v) {
-        if (f(t)) { ret true; } 
+        if (f(t)) { ret true; }
     }
     ret false;
 }
 fn all[T](&fn(&T) -> bool f, &vec[T] v) -> bool {
     for (T t in v) {
-        if (!f(t)) { ret false; } 
+        if (!f(t)) { ret false; }
     }
     ret true;
 }

src/lib/win32_fs.rs

@@ -11,7 +11,7 @@ fn list_dir(str path) -> str[] {
 }
 
 fn path_is_absolute(str p) -> bool {
-    ret str::char_at(p, 0u) == '/' 
+    ret str::char_at(p, 0u) == '/'
         || (str::char_at(p, 1u) == ':' && str::char_at(p, 2u) == '\\');
 }
 

src/rt/arch/i386/context.cpp

@@ -5,7 +5,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-extern "C" uint32_t CDECL swap_registers(registers_t *oregs, 
+extern "C" uint32_t CDECL swap_registers(registers_t *oregs,
                                          registers_t *regs)
   asm ("swap_registers");
 

src/rt/arch/i386/context.h

@@ -22,7 +22,7 @@ class context {
 
 public:
   context();
-  
+
   context *next;
 
   void swap(context &out);

src/rt/globals.h

@@ -45,6 +45,6 @@ extern "C" {
                     __FILE__, __LINE__, res, strerror(res));        \
             abort();                                                \
         }                                                           \
-    }                                                               
+    }
 
 #endif /* GLOBALS_H */

src/rt/isaac/randport.cpp

@@ -76,7 +76,7 @@ void randinit(randctx *ctx, word flag)
      mix(a,b,c,d,e,f,g,h);
    }
 
-   if (flag) 
+   if (flag)
    {
      /* initialize using the contents of r[] as the seed */
      for (i=0; i<RANDSIZ; i+=8)

src/rt/memory_region.cpp

@@ -67,7 +67,7 @@ memory_region::realloc(void *mem, size_t size) {
     void *newMem = _srv->realloc(mem, size);
 #ifdef TRACK_ALLOCATIONS
     if (_allocation_list[index] != mem) {
-        printf("at index %d, found %p, expected %p\n", 
+        printf("at index %d, found %p, expected %p\n",
                index, _allocation_list[index], mem);
         printf("realloc: ptr 0x%" PRIxPTR " is not in allocation_list\n",
             (uintptr_t) mem);
@@ -76,7 +76,7 @@ memory_region::realloc(void *mem, size_t size) {
     else {
         _allocation_list[index] = newMem;
         (*(int*)newMem) = index;
-        // printf("realloc: stored %p at index %d, replacing %p\n", 
+        // printf("realloc: stored %p at index %d, replacing %p\n",
         //        newMem, index, mem);
     }
 #endif
@@ -101,7 +101,7 @@ memory_region::malloc(size_t size) {
     *p = index;
     // printf("malloc: stored %p at index %d\n", mem, index);
 #endif
-    // printf("malloc: ptr 0x%" PRIxPTR " region=%p\n", 
+    // printf("malloc: ptr 0x%" PRIxPTR " region=%p\n",
     //        (uintptr_t) mem, this);
     if (_synchronized) { _lock.unlock(); }
 #ifdef TRACK_ALLOCATIONS

src/rt/rust.cpp

@@ -105,7 +105,7 @@ rust_start(uintptr_t main_fn, int argc, char **argv, void* crate_map) {
     rust_kernel *kernel = new rust_kernel(srv);
     kernel->start();
     rust_scheduler *sched = kernel->get_scheduler();
-    command_line_args *args 
+    command_line_args *args
         = new (kernel) command_line_args(sched->root_task, argc, argv);
 
     DLOG(sched, dom, "startup: %d args in 0x%" PRIxPTR,

src/rt/rust_builtin.cpp

@@ -83,7 +83,7 @@ rust_getcwd(rust_task *task) {
     rust_str *st;
     st = new (mem) rust_str(sched, alloc, fill, (const uint8_t *)cbuf);
 
-    return st;    
+    return st;
 }
 
 extern "C" CDECL

src/rt/rust_chan.cpp

@@ -6,7 +6,7 @@
  */
 rust_chan::rust_chan(rust_task *task,
                      maybe_proxy<rust_port> *port,
-                     size_t unit_sz) 
+                     size_t unit_sz)
     : ref_count(1),
       kernel(task->kernel),
       task(task),

src/rt/rust_kernel.cpp

@@ -11,7 +11,7 @@ rust_kernel::rust_kernel(rust_srv *srv) :
     _region(&srv->local_region),
     _log(srv, NULL),
     _srv(srv),
-    _interrupt_kernel_loop(FALSE) 
+    _interrupt_kernel_loop(FALSE)
 {
     sched = create_scheduler("main");
 }
@@ -245,14 +245,14 @@ rust_kernel::signal_kernel_lock() {
 int rust_kernel::start_task_threads(int num_threads)
 {
     rust_task_thread *thread = NULL;
-    
+
     // -1, because this thread will also be a thread.
     for(int i = 0; i < num_threads - 1; ++i) {
         thread = new rust_task_thread(i + 1, this);
         thread->start();
         threads.push(thread);
     }
-    
+
     sched->start_main_loop(0);
 
     while(threads.pop(&thread)) {

src/rt/rust_kernel.h

@@ -126,10 +126,10 @@ public:
 class rust_task_thread : public rust_thread {
     int id;
     rust_kernel *owner;
-    
+
 public:
     rust_task_thread(int id, rust_kernel *owner);
-    
+
     virtual void run();
 };
 

src/rt/rust_message.cpp

@@ -106,7 +106,7 @@ void data_message::kernel_process() {
 
 }
 
-rust_message_queue::rust_message_queue(rust_srv *srv, rust_kernel *kernel) 
+rust_message_queue::rust_message_queue(rust_srv *srv, rust_kernel *kernel)
     : region(srv, true),
       kernel(kernel),
       sched_handle(NULL) {

src/rt/rust_port.cpp

@@ -1,7 +1,7 @@
 #include "rust_internal.h"
 #include "rust_port.h"
 
-rust_port::rust_port(rust_task *task, size_t unit_sz) 
+rust_port::rust_port(rust_task *task, size_t unit_sz)
     : maybe_proxy<rust_port>(this), kernel(task->kernel), task(task),
       unit_sz(unit_sz), writers(task), chans(task) {
 

src/rt/rust_task.cpp

@@ -127,7 +127,7 @@ void task_start_wrapper(spawn_args *a)
     a->f(&rval, task, a->a3, a->a4);
 
     LOG(task, task, "task exited with value %d", rval);
-    
+
 
     LOG(task, task, "task ref_count: %d", task->ref_count);
     A(task->sched, task->ref_count >= 0,
@@ -147,7 +147,7 @@ rust_task::start(uintptr_t spawnee_fn,
     LOGPTR(sched, "from spawnee", spawnee_fn);
 
     I(sched, stk->data != NULL);
-    
+
     char *sp = (char *)rust_sp;
 
     sp -= sizeof(spawn_args);
@@ -481,7 +481,7 @@ rust_task::get_handle() {
 
 bool rust_task::can_schedule(int id)
 {
-    return yield_timer.has_timed_out() && 
+    return yield_timer.has_timed_out() &&
         running_on == -1 &&
         (pinned_on == -1 || pinned_on == id);
 }

src/rt/rust_task.h

@@ -74,7 +74,7 @@ rust_task : public maybe_proxy<rust_task>,
     rust_handle<rust_task> *handle;
 
     context ctx;
-    
+
     // This flag indicates that a worker is either currently running the task
     // or is about to run this task.
     int running_on;

src/rt/rust_timer.cpp

@@ -71,7 +71,7 @@ rust_timer::~rust_timer() {
     exit_flag = 1;
 #if defined(__WIN32__)
     sched->kernel->win32_require("WaitForSingleObject",
-                               WaitForSingleObject(thread, INFINITE) == 
+                               WaitForSingleObject(thread, INFINITE) ==
                                WAIT_OBJECT_0);
 #else
     pthread_join(thread, NULL);

src/rt/rust_upcall.cpp

@@ -192,20 +192,20 @@ upcall_recv(rust_task *task, uintptr_t *dptr, rust_port *port) {
     {
         scoped_lock with(port->lock);
         LOG_UPCALL_ENTRY(task);
-    
+
         LOG(task, comm, "port: 0x%" PRIxPTR ", dptr: 0x%" PRIxPTR
             ", size: 0x%" PRIxPTR ", chan_no: %d",
             (uintptr_t) port, (uintptr_t) dptr, port->unit_sz,
             port->chans.length());
-    
+
         if (port->receive(dptr)) {
             return;
         }
-    
+
         // No data was buffered on any incoming channel, so block this task on
         // the port. Remember the rendezvous location so that any sender task
         // can write to it before waking up this task.
-    
+
         LOG(task, comm, "<=== waiting for rendezvous data ===");
         task->rendezvous_ptr = dptr;
         task->block(port, "waiting for rendezvous data");
@@ -351,7 +351,6 @@ rust_str *make_str(rust_task *task, char const *s, size_t fill) {
 extern "C" CDECL rust_str *
 upcall_new_str(rust_task *task, char const *s, size_t fill) {
     LOG_UPCALL_ENTRY(task);
-    
     return make_str(task, s, fill);
 }
 
@@ -537,7 +536,7 @@ upcall_start_task(rust_task *spawner,
     rust_scheduler *sched = spawner->sched;
     DLOG(sched, task,
          "upcall start_task(task %s @0x%" PRIxPTR
-         ", spawnee 0x%" PRIxPTR ")", 
+         ", spawnee 0x%" PRIxPTR ")",
          task->name, task,
          spawnee_fn);
 

src/rt/rust_util.h

@@ -157,7 +157,7 @@ isaac_init(rust_scheduler *sched, randctx *rctx)
         } else {
             int fd = open("/dev/urandom", O_RDONLY);
             I(sched, fd > 0);
-            I(sched, 
+            I(sched,
               read(fd, (void*) &rctx->randrsl, sizeof(rctx->randrsl))
               == sizeof(rctx->randrsl));
             I(sched, close(fd) == 0);
@@ -175,8 +175,8 @@ rust_vec : public rc_base<rust_vec>
     size_t fill;
     size_t pad; // Pad to align data[0] to 16 bytes.
     uint8_t data[];
-    rust_vec(rust_scheduler *sched, size_t alloc, size_t fill, 
-             uint8_t const *d) 
+    rust_vec(rust_scheduler *sched, size_t alloc, size_t fill,
+             uint8_t const *d)
         : alloc(alloc),
           fill(fill)
     {

src/rt/sync/lock_and_signal.cpp

@@ -21,7 +21,7 @@ lock_and_signal::lock_and_signal() {
 }
 
 #else
-lock_and_signal::lock_and_signal() 
+lock_and_signal::lock_and_signal()
     : _locked(false)
 {
     CHECKED(pthread_cond_init(&_cond, NULL));

src/rt/sync/lock_and_signal.h

@@ -30,7 +30,7 @@ public:
 
 class scoped_lock {
   lock_and_signal &lock;
-  
+
 public:
   scoped_lock(lock_and_signal &lock);
   ~scoped_lock();

src/rt/sync/sync.h

@@ -11,7 +11,7 @@ public:
         T oldValue, T newValue) {
         return __sync_bool_compare_and_swap(address, oldValue, newValue);
     }
-    
+
     template <class T>
     static T increment(T *address) {
         return __sync_add_and_fetch(address, 1);
@@ -20,7 +20,7 @@ public:
     template <class T>
     static T decrement(T *address) {
         return __sync_sub_and_fetch(address, 1);
-    }    
+    }
 
     template <class T>
     static T increment(T &address) {
@@ -30,7 +30,7 @@ public:
     template <class T>
     static T decrement(T &address) {
         return __sync_sub_and_fetch(&address, 1);
-    }    
+    }
 };
 
 /**

src/snapshots.txt

@@ -58,7 +58,7 @@ S 2011-06-15 02018fe
   macos-i386 4942eeb8897d75cbdb8cf15bef3b9bc941bc9f34
   winnt-i386 b8cf72007bf751062de0802984e7e5a68b66ae61
 
-S 2011-06-15 92bd350 
+S 2011-06-15 92bd350
   linux-i386 145b68488a780623cc31c5e043c6770007273f80
   macos-i386 d3149431f12603927bb211f53f8572fc188eb7d2
   winnt-i386 8ee37c22195ce180961db1fad013a0743cf97cdd

src/test/bench/99-bottles/99bob-iter.rs

@@ -1,6 +1,6 @@
 
 
-/* -*- mode::rust;indent-tabs-mode::nil -*- 
+/* -*- mode::rust;indent-tabs-mode::nil -*-
  * Implementation of 99 Bottles of Beer
  * http://99-bottles-of-beer.net/
  */

src/test/bench/99-bottles/99bob-pattern.rs

@@ -1,6 +1,6 @@
 
 
-/* -*- mode::rust;indent-tabs-mode::nil -*- 
+/* -*- mode::rust;indent-tabs-mode::nil -*-
  * Implementation of 99 Bottles of Beer
  * http://99-bottles-of-beer.net/
  */

src/test/bench/99-bottles/99bob-simple.rs

@@ -1,6 +1,6 @@
 
 
-/* -*- mode::rust;indent-tabs-mode::nil -*- 
+/* -*- mode::rust;indent-tabs-mode::nil -*-
  * Implementation of 99 Bottles of Beer
  * http://99-bottles-of-beer.net/
  */

src/test/bench/99-bottles/99bob-tail.rs

@@ -1,4 +1,4 @@
-/* -*- mode::rust;indent-tabs-mode::nil -*- 
+/* -*- mode::rust;indent-tabs-mode::nil -*-
  * Implementation of 99 Bottles of Beer
  * http://99-bottles-of-beer.net/
  */

src/test/bench/shootout/nbody.rs

@@ -40,10 +40,10 @@ mod NBodySystem {
     fn MakeNBodySystem() -> vec[Body::props] {
         let vec[Body::props] bodies = [
             // these each return a Body::props
-            Body::sun(), 
-            Body::jupiter(), 
-            Body::saturn(), 
-            Body::uranus(), 
+            Body::sun(),
+            Body::jupiter(),
+            Body::saturn(),
+            Body::uranus(),
             Body::neptune()];
 
         let float px = 0.0;
@@ -132,7 +132,7 @@ mod NBodySystem {
 
                 distance = llvm::sqrt(dx*dx + dy*dy + dz*dz);
                 e -= (bodies.(i).mass * bodies.(j).mass) / distance;
-                
+
                 j += 1;
             }
 
@@ -149,12 +149,12 @@ mod Body {
     const float SOLAR_MASS = 39.478417604357432; // was 4 * PI * PI originally
     const float DAYS_PER_YEAR = 365.24;
 
-    type props = rec(mutable float x, 
-                     mutable float y, 
-                     mutable float z, 
-                     mutable float vx, 
+    type props = rec(mutable float x,
+                     mutable float y,
+                     mutable float z,
+                     mutable float vx,
                      mutable float vy,
-                     mutable float vz, 
+                     mutable float vz,
                      float mass);
 
     fn jupiter() -> Body::props {
@@ -218,8 +218,8 @@ mod Body {
    }
 
    fn offsetMomentum(&Body::props props,
-                            float px, 
-                            float py, 
+                            float px,
+                            float py,
                             float pz) -> () {
        props.vx = -px / SOLAR_MASS;
        props.vy = -py / SOLAR_MASS;

src/test/bench/shootout/pfib.rs

@@ -27,7 +27,7 @@ fn fib(int n) -> int {
         }
         else {
             let port[int] p = port();
-      
+
             auto t1 = spawn pfib(chan(p), n - 1);
             auto t2 = spawn pfib(chan(p), n - 2);
 
@@ -58,12 +58,12 @@ fn main(vec[str] argv) {
         assert(stop >= start);
 
         auto elapsed = stop - start;
-        auto us_task = elapsed / (fibn as u64) / (1000 as u64); 
+        auto us_task = elapsed / (fibn as u64) / (1000 as u64);
 
         log_err #fmt("Determined that fib(%d) = %d in %d%d ns (%d us / task)",
-                     n, fibn, 
-                     (elapsed / (1000000 as u64)) as int, 
-                     (elapsed % (1000000 as u64)) as int, 
+                     n, fibn,
+                     (elapsed / (1000000 as u64)) as int,
+                     (elapsed % (1000000 as u64)) as int,
                      us_task as int);
     }
 }

src/test/bench/task-perf/pfib.rs

@@ -37,7 +37,7 @@ fn fib(int n) -> int {
         }
         else {
             auto p = port();
-      
+
             auto t1 = spawn pfib(chan(p), n - 1);
             auto t2 = spawn pfib(chan(p), n - 2);
 
@@ -84,7 +84,7 @@ fn stress(int num_tasks) {
     }
     for each(int i in range(0, num_tasks)) {
         task::join(tasks.(i));
-    }    
+    }
 }
 
 fn main(vec[str] argv) {
@@ -107,7 +107,7 @@ fn main(vec[str] argv) {
             auto num_trials = 10;
 
             auto out = io::stdout();
-            
+
             for each(int n in range(1, max + 1)) {
                 for each(int i in range(0, num_trials)) {
                     auto start = time::precise_time_ns();
@@ -115,8 +115,8 @@ fn main(vec[str] argv) {
                     auto stop = time::precise_time_ns();
 
                     auto elapsed = stop - start;
-            
-                    out.write_line(#fmt("%d\t%d\t%s", n, fibn, 
+
+                    out.write_line(#fmt("%d\t%d\t%s", n, fibn,
                                         u64::str(elapsed)));
                 }
             }

src/test/bench/task-perf/word-count.rs

@@ -30,10 +30,10 @@ mod map_reduce {
     type mapper = fn(str, putter);
 
     type getter = fn() -> option[str];
-    
+
     type reducer = fn(str, getter);
 
-    
+
     fn map_reduce (vec[str] inputs,
                    mapper f,
                    reducer reduce) {
@@ -48,7 +48,7 @@ mod map_reduce {
                 }
                 case (none) { }
             }
-            
+
             im.insert(key, old + [val]);
         }
 
@@ -86,7 +86,7 @@ fn main(vec[str] argv) {
 
         while(true) {
             alt(read_word(f)) {
-                case (some(?w)) { 
+                case (some(?w)) {
                     emit(w, "1");
                 }
                 case (none) {
@@ -98,7 +98,7 @@ fn main(vec[str] argv) {
 
     fn reduce(str word, map_reduce::getter get) {
         auto count = 0;
-        
+
         while(true) {
             alt(get()) {
                 case(some(_)) { count += 1 }

src/test/compile-fail/bind-parameterized-args.rs

@@ -3,7 +3,7 @@
 fn main() {
   fn echo[T](int c, vec[T] x) {
   }
-  
+
   let fn(vec[int]) -> () y = bind echo(42, _);
 
   y([1]);

src/test/compile-fail/if-check-precond-fail.rs

@@ -17,7 +17,7 @@ fn print_even(uint x) : even(x) {
 }
 
 fn foo(uint x) -> () {
-  if check(even(x)) { 
+  if check(even(x)) {
       fail;
     }
   else {

src/test/compile-fail/impure-pred.rs

@@ -3,7 +3,7 @@
 
 fn g() -> () {}
 
-pred f(int q) -> bool { 
+pred f(int q) -> bool {
   g();
   ret true;
 }
@@ -11,5 +11,5 @@ pred f(int q) -> bool {
 fn main() {
   auto x = 0;
 
-  check f(x); 
+  check f(x);
 }

src/test/compile-fail/macro-2.rs

@@ -1,6 +1,6 @@
 //error-pattern:expanded as an identifier
 fn main() {
   #macro([#mylambda(x, body), {fn f(int x) -> int {ret body}; f}]);
-  
+
   assert(#mylambda(y*1, y*2)(8) == 16);
 }

src/test/compile-fail/macro.rs

@@ -2,6 +2,6 @@
 
 fn main() {
   #macro([#trivial(), 1*2*4*2*1]);
-  
+
   assert(#trivial(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16) == 16);
 }

src/test/compile-fail/no-constraint-prop.rs

@@ -17,5 +17,5 @@ fn main() {
   // the next statement, since it's not true in the
   // prestate.
   auto d <- a;
-  log (safe_slice("kitties", b, d)); 
+  log (safe_slice("kitties", b, d));
 }

src/test/compile-fail/not-a-pred-check.rs

@@ -6,5 +6,5 @@ fn f(int q) -> bool { ret true; }
 fn main() {
   auto x = 0;
 
-  check f(x); 
+  check f(x);
 }

src/test/compile-fail/not-pred-args.rs

@@ -6,5 +6,5 @@ pred f(int q) -> bool { ret true; }
 
 fn main() {
 // should fail to typecheck, as pred args must be slot variables or literals
-  check f(42 * 17); 
+  check f(42 * 17);
 }

src/test/compile-fail/self-missing-method.rs

@@ -6,7 +6,7 @@ fn main() {
           self();
       }
   }
-  
+
   auto a = foo;
   a.m();
 }

src/test/run-fail/fail-arg.rs

@@ -4,6 +4,6 @@ fn f(int a) {
   log a;
 }
 
-fn main() { 
+fn main() {
   f(fail "woe");
-} 
+}

src/test/run-fail/if-check-fail.rs

@@ -13,7 +13,7 @@ pred even(uint x) -> bool {
 }
 
 fn foo(uint x) -> () {
-  if check(even(x)) { 
+  if check(even(x)) {
       log x;
     }
   else {

src/test/run-fail/task-comm-14.rs

@@ -12,9 +12,9 @@ io fn main() {
         i = i - 1;
     }
 
-    // Spawned tasks are likely killed before they get a chance to send 
+    // Spawned tasks are likely killed before they get a chance to send
     // anything back, so we deadlock here.
-    
+
     i = 10;
     let int value = 0;
     while (i > 0) {
@@ -22,7 +22,7 @@ io fn main() {
         po |> value;
         i = i - 1;
     }
-  
+
     log "main thread exiting";
 }
 

src/test/run-pass/alt-join.rs

@@ -8,7 +8,7 @@ import std::option::some;
 fn foo[T](&option::t[T] y) {
     let int x;
     let vec[int] rs = [];
-    /* tests that x doesn't get put in the precondition for the 
+    /* tests that x doesn't get put in the precondition for the
        entire if expression */
 
     if (true) {

src/test/run-pass/constraint-prop-expr-move.rs

@@ -9,5 +9,5 @@ fn main() {
   let uint c = 17u;
   check le(a, b);
   c <- a;
-  log (safe_slice("kitties", c, b)); 
+  log (safe_slice("kitties", c, b));
 }

src/test/run-pass/constraint-prop-move.rs

@@ -8,5 +8,5 @@ fn main() {
   let uint b = 4u;
   check le(a, b);
   auto c <- a;
-  log (safe_slice("kitties", c, b)); 
+  log (safe_slice("kitties", c, b));
 }

src/test/run-pass/constraint-prop-swap.rs

@@ -8,5 +8,5 @@ fn main() {
   let uint b = 1u;
   check le(b, a);
   b <-> a;
-  log (safe_slice("kitties", a, b)); 
+  log (safe_slice("kitties", a, b));
 }

src/test/run-pass/constraint-prop.rs

@@ -8,5 +8,5 @@ fn main() {
   let uint b = 4u;
   check le(a, b);
   auto c = b;
-  log (safe_slice("kitties", a, c)); 
+  log (safe_slice("kitties", a, c));
 }

src/test/run-pass/fn-constraint.rs

@@ -6,5 +6,5 @@ fn main() {
   let uint a = 1u;
   let uint b = 4u;
   check le(a, b);
-  log (safe_slice("kitties", a, b)); 
+  log (safe_slice("kitties", a, b));
 }

src/test/run-pass/if-check-precond.rs

@@ -16,7 +16,7 @@ fn print_even(uint x) : even(x) {
 }
 
 fn foo(uint x) -> () {
-  if check(even(x)) { 
+  if check(even(x)) {
       print_even(x);
     }
   else {

src/test/run-pass/if-check.rs

@@ -12,7 +12,7 @@ pred even(uint x) -> bool {
 }
 
 fn foo(uint x) -> () {
-  if check(even(x)) { 
+  if check(even(x)) {
       log x;
     }
   else {

src/test/run-pass/import-glob-1.rs

@@ -1,8 +1,8 @@
 import a1::b1::word_traveler;
 
-mod a1 {                    // 
-  mod b1 {                  // 
-    import a2::b1::*;       //         <-\ 
+mod a1 {                    //
+  mod b1 {                  //
+    import a2::b1::*;       //         <-\
     export word_traveler;   //           |
   }                         //           |
   mod b2 {                  //           |

src/test/run-pass/import-glob-circular.rs

@@ -48,7 +48,7 @@ mod test2 {
     //assert(f1() == 1u);
     assert(f2() == 2u);
     assert(f2() == 2u);
-    assert(common() == 2u);    
+    assert(common() == 2u);
     assert(common() == 2u);
   }
 }

src/test/run-pass/issue-507.rs

@@ -1,5 +1,5 @@
 
-/* 
+/*
    This is a test case for Issue 507.
 
    https://github.com/graydon/rust/issues/507
@@ -22,7 +22,7 @@ fn main() {
   let port[int] p = port();
 
   auto _child = spawn child(chan(p));
-  
+
   let int x;
   p |> x;
 

src/test/run-pass/lib-deque.rs

@@ -190,7 +190,7 @@ fn main() {
                               two(17, 42));
     /*
      * FIXME: Segfault.  Also appears to be caused only after upcall_grow_task
-    
+
     log "*** test parameterized: taggypar[int]";
     let eqfn[taggypar[int]] eq4 = taggypareq[int];
     test_parameterized[taggypar[int]](eq4,
@@ -199,7 +199,7 @@ fn main() {
                                       threepar[int](1, 2, 3),
                                       twopar[int](17, 42));
     log "*** end test parameterized: taggypar[int]";
-    
+
      */
 
     log "*** test parameterized: reccy";

src/test/run-pass/lib-map.rs

@@ -194,7 +194,7 @@ fn test_removal() {
         /**
          * FIXME (issue #150): we want to check the removed value as in the
          * following:
-        
+
         let util.option[uint] v = hm.remove(i);
         alt (v) {
           case (util.some[uint](u)) {
@@ -202,7 +202,7 @@ fn test_removal() {
           }
           case (util.none[uint]()) { fail; }
         }
-        
+
          * but we util.option is a tag type so util.some and util.none are
          * off limits until we parse the dwarf for tag types.
          */

src/test/run-pass/macro-2.rs

@@ -1,5 +1,5 @@
 fn main() {
   #macro([#mylambda(x,body), {fn f(int x) -> int { ret body }; f}]);
-  
+
   assert(#mylambda(y,y*2)(8) == 16);
 }

src/test/run-pass/macro-3.rs

@@ -1,5 +1,5 @@
 fn main() {
   #macro([#trivial(), 1*2*4*2*1]);
-  
+
   assert(#trivial() == 16);
 }

src/test/run-pass/macro.rs

@@ -1,4 +1,4 @@
 fn main() {
   #macro([#m1(a), a*4]);
-  assert (#m1(2) == 8);  
+  assert (#m1(2) == 8);
 }

src/test/run-pass/simple-anon-objs.rs

@@ -7,8 +7,8 @@ fn main() {
     auto my_normal_obj = normal();
 
     // Extending an object with a new method
-    auto my_anon_obj = obj { 
-        fn bar() -> int { 
+    auto my_anon_obj = obj {
+        fn bar() -> int {
             ret 3;
         }
         with my_normal_obj

src/test/run-pass/spawn2.rs

@@ -13,7 +13,7 @@ fn child(int i1,
          int i6,
          int i7,
          int i8,
-         int i9) 
+         int i9)
 {
   log_err i1;
   log_err i2;

src/test/run-pass/syntax-extension-fmt.rs

@@ -14,7 +14,7 @@ fn main() {
 
     test(#fmt("test"), "test");
 
-    // a quadratic optimization in LLVM (jump-threading) makes this test a 
+    // a quadratic optimization in LLVM (jump-threading) makes this test a
     // bit slow to compile unless we break it up
     part1();
     part2();
@@ -133,10 +133,10 @@ fn part4() {
     // conversions support precision - it's not standard printf so we
     // can do whatever. For now I'm making it behave the same as string
     // conversions.
-    
+
     test(#fmt("%.b", true), "");
     test(#fmt("%.0b", true), "");
-    test(#fmt("%.1b", true), "t");  
+    test(#fmt("%.1b", true), "t");
 }
 
 fn part5() {

src/test/run-pass/task-comm-1.rs

@@ -5,7 +5,7 @@ use std;
 import std::task::join;
 
 fn main() -> () {
-   test00(); 
+   test00();
 }
 
 fn start() {

src/test/run-pass/task-comm-12.rs

@@ -10,16 +10,16 @@ fn main() -> () {
 fn start(int task_number) {
     log "Started / Finished task.";
 }
-    
-fn test00() {    
+
+fn test00() {
     let int i = 0;
     let task t = spawn start(i);
-    
+
     // Sleep long enough for the task to finish.
     task::sleep(10000u);
-    
+
     // Try joining tasks that have already finished.
     task::join(t);
-    
+
     log "Joined task.";
 }

src/test/run-pass/task-comm-13.rs

@@ -8,7 +8,7 @@ fn start(chan[int] c, int start, int number_of_messages) {
     while (i < number_of_messages) {
         c <| start + i;
         i += 1;
-    }    
+    }
 }
 
 fn main() -> () {

src/test/run-pass/task-comm-2.rs

@@ -4,7 +4,7 @@ use std;
 
 import std::task;
 
-fn main() -> () {    
+fn main() -> () {
     log "===== SPAWNING and JOINING THREAD TASKS =====";
     test00();
 }
@@ -17,20 +17,20 @@ fn start(int task_number) {
     }
     log "Finished task.";
 }
-    
+
 fn test00() {
     let int number_of_tasks = 8;
-    
+
     let int i = 0;
     let vec[task] tasks = [];
     while (i < number_of_tasks) {
         i = i + 1;
         tasks += [spawn start(i)];
     }
-    
+
     for (task t in tasks) {
         task::join(t);
     }
-    
+
     log "Joined all task.";
 }

src/test/run-pass/task-comm-3.rs

@@ -22,21 +22,21 @@ fn test00_start(chan[int] ch, int message, int count) {
 fn test00() {
     let int number_of_tasks = 16;
     let int number_of_messages = 4;
-    
+
     log "Creating tasks";
-    
+
     let port[int] po = port();
     let chan[int] ch = chan(po);
-    
+
     let int i = 0;
-    
+
     // Create and spawn tasks...
     let vec[task] tasks = [];
     while (i < number_of_tasks) {
         tasks += [spawn test00_start(ch, i, number_of_messages)];
         i = i + 1;
     }
-    
+
     // Read from spawned tasks...
     let int sum = 0;
     for (task t in tasks) {
@@ -52,9 +52,9 @@ fn test00() {
     for (task t in tasks) {
         task::join(t);
     }
-    
+
     log "Completed: Final number is: ";
-    // assert (sum == (((number_of_tasks * (number_of_tasks - 1)) / 2) * 
+    // assert (sum == (((number_of_tasks * (number_of_tasks - 1)) / 2) *
     //       number_of_messages));
     assert (sum == 480);
 }

src/test/run-pass/task-comm-6.rs

@@ -32,7 +32,7 @@ fn test00() {
         i += 1;
     }
     assert (sum == 1998000);
-    // assert (sum == 4 * ((number_of_messages * 
+    // assert (sum == 4 * ((number_of_messages *
     //                   (number_of_messages - 1)) / 2));
 
 }

src/test/run-pass/task-comm-7.rs

@@ -12,24 +12,24 @@ fn test00_start(chan[int] c, int start, int number_of_messages) {
     while (i < number_of_messages) {
         c <| start + i;
         i += 1;
-    }    
+    }
 }
 
 fn test00() {
-    let int r = 0;    
+    let int r = 0;
     let int sum = 0;
     let port[int] p = port();
     let int number_of_messages = 10;
-        
-    let task t0 = spawn test00_start(chan(p), 
+
+    let task t0 = spawn test00_start(chan(p),
                         number_of_messages * 0, number_of_messages);
-    let task t1 = spawn test00_start(chan(p), 
+    let task t1 = spawn test00_start(chan(p),
                         number_of_messages * 1, number_of_messages);
-    let task t2 = spawn test00_start(chan(p), 
+    let task t2 = spawn test00_start(chan(p),
                         number_of_messages * 2, number_of_messages);
-    let task t3 = spawn test00_start(chan(p), 
+    let task t3 = spawn test00_start(chan(p),
                         number_of_messages * 3, number_of_messages);
-    
+
     let int i = 0;
     while (i < number_of_messages) {
         p |> r; sum += r;
@@ -38,12 +38,12 @@ fn test00() {
         p |> r; sum += r;
         i += 1;
     }
-            
+
     task::join(t0);
     task::join(t1);
     task::join(t2);
     task::join(t3);
-    
-    assert (sum == (((number_of_messages * 4) * 
+
+    assert (sum == (((number_of_messages * 4) *
                    ((number_of_messages * 4) - 1)) / 2));
 }

src/test/run-pass/task-comm-8.rs

@@ -12,24 +12,24 @@ fn test00_start(chan[int] c, int start, int number_of_messages) {
     while (i < number_of_messages) {
         c <| start + i;
         i += 1;
-    }    
+    }
 }
 
 fn test00() {
-    let int r = 0;    
+    let int r = 0;
     let int sum = 0;
     let port[int] p = port();
     let int number_of_messages = 10;
-        
-    let task t0 = spawn test00_start(chan(p), 
+
+    let task t0 = spawn test00_start(chan(p),
                         number_of_messages * 0, number_of_messages);
-    let task t1 = spawn test00_start(chan(p), 
+    let task t1 = spawn test00_start(chan(p),
                         number_of_messages * 1, number_of_messages);
-    let task t2 = spawn test00_start(chan(p), 
+    let task t2 = spawn test00_start(chan(p),
                         number_of_messages * 2, number_of_messages);
-    let task t3 = spawn test00_start(chan(p), 
+    let task t3 = spawn test00_start(chan(p),
                         number_of_messages * 3, number_of_messages);
-    
+
     let int i = 0;
     while (i < number_of_messages) {
         p |> r; sum += r;
@@ -38,12 +38,12 @@ fn test00() {
         p |> r; sum += r;
         i += 1;
     }
-            
+
     task::join(t0);
     task::join(t1);
     task::join(t2);
     task::join(t3);
-    
-    assert (sum == (((number_of_messages * 4) * 
+
+    assert (sum == (((number_of_messages * 4) *
                    ((number_of_messages * 4) - 1)) / 2));
 }