Fix damage done by the pretty-printer

Author: marijnh

src/comp/back/link.rs

@@ -340,10 +340,8 @@ fn build_link_meta(sess: &session::session, c: &ast::crate, output: &str,
         ret alt metas.name {
               some(v) { v }
               none. {
-                let 
-                    // FIXME: Remove this vec->ivec conversion.
-
-                    name =
+                // FIXME: Remove this vec->ivec conversion.
+                let name =
                     {
                         let os_vec =
                             str::split(fs::basename(output), '.' as u8);

src/comp/driver/rustc.rs

@@ -65,9 +65,8 @@ fn build_configuration(sess: session::session, argv0: str, input: str) ->
     // some default and generated configuration items
     let default_cfg = default_configuration(sess, argv0, input);
     let user_cfg = sess.get_opts().cfg;
-    let 
-        // If the user wants a test runner, then add the test cfg
-        gen_cfg =
+    // If the user wants a test runner, then add the test cfg
+    let gen_cfg =
         {
             if sess.get_opts().test && !attr::contains_name(user_cfg, "test")
                {

src/comp/front/config.rs

@@ -101,9 +101,7 @@ fn in_cfg(cfg: &ast::crate_cfg, attrs: &ast::attribute[]) -> bool {
     // Pull the inner meta_items from the #[cfg(meta_item, ...)]  attributes,
     // so we can match against them. This is the list of configurations for
     // which the item is valid
-    let 
-
-        item_cfg_metas =
+    let item_cfg_metas =
         {
             fn extract_metas(inner_items: &(@ast::meta_item)[],
                              cfg_item: &@ast::meta_item) ->

src/comp/lib/llvm.rs

@@ -1395,11 +1395,10 @@ obj builder(B: BuilderRef, terminated: @mutable bool) {
 
     fn is_terminated() -> bool {
         ret *terminated;
-    }drop 
-
-          {
+    }
+    drop {
          llvm::LLVMDisposeBuilder(B);
-     }
+    }
 }
 
 /* Memory-managed object interface to type handles. */

src/comp/metadata/creader.rs

@@ -122,22 +122,20 @@ fn find_library_crate(sess: &session::session, ident: &ast::ident,
 
     attr::require_unique_names(sess, metas);
 
-    let 
-        // FIXME: Probably want a warning here since the user
-        // is using the wrong type of meta item
-        crate_name =
-        {
-            let name_items = attr::find_meta_items_by_name(metas, "name");
-            alt ivec::last(name_items) {
-              some(i) {
-                alt attr::get_meta_item_value_str(i) {
-                  some(n) { n }
-                  _ { ident }
-                }
-              }
-              none. { ident }
+    // FIXME: Probably want a warning here since the user
+    // is using the wrong type of meta item
+    let crate_name = {
+        let name_items = attr::find_meta_items_by_name(metas, "name");
+        alt ivec::last(name_items) {
+          some(i) {
+            alt attr::get_meta_item_value_str(i) {
+              some(n) { n }
+              _ { ident }
             }
-        };
+          }
+          none. { ident }
+        }
+    };
 
     let nn = default_native_lib_naming(sess, sess.get_opts().static);
     let x =

src/comp/metadata/decoder.rs

@@ -164,9 +164,8 @@ fn lookup_def(cnum: ast::crate_num, data: @u8[], did_: &ast::def_id) ->
     let item = lookup_item(did_.node, data);
     let kind_ch = item_kind(item);
     let did = {crate: cnum, node: did_.node};
-    let 
-        // We treat references to tags as references to types.
-        def =
+    // We treat references to tags as references to types.
+    let def =
         alt kind_ch as char {
           'c' { ast::def_const(did) }
           'f' { ast::def_fn(did, ast::impure_fn) }

src/comp/middle/alias.rs

@@ -39,10 +39,9 @@ tag local_info { arg(ast::mode); objfield(ast::mutability); }
 type ctx = {tcx: ty::ctxt, local_map: std::map::hashmap[node_id, local_info]};
 
 fn check_crate(tcx: ty::ctxt, crate: &@ast::crate) {
-    let 
-        // Stores information about object fields and function
-        // arguments that's otherwise not easily available.
-        cx =
+    // Stores information about object fields and function
+    // arguments that's otherwise not easily available.
+    let cx =
         @{tcx: tcx, local_map: std::map::new_int_hash()};
     let v =
         @{visit_fn: bind visit_fn(cx, _, _, _, _, _, _, _),

src/comp/middle/freevars.rs

@@ -73,12 +73,12 @@ fn collect_freevars(def_map: &resolve::def_map, sess: &session::session,
 
     let e: env =
         @{mutable refs: ~[], decls: decls, def_map: def_map, sess: sess};
-    walker(visit::mk_simple_visitor(@{visit_local: bind walk_local(e, _),
-                                      visit_pat: bind walk_pat(e, _),
-                                      visit_expr: bind walk_expr(e, _),
-                                      visit_fn: bind walk_fn(e, _, _, _, _, _)
-                                         with
-                                             *visit::default_simple_visitor()}));
+    walker(visit::mk_simple_visitor
+           (@{visit_local: bind walk_local(e, _),
+              visit_pat: bind walk_pat(e, _),
+              visit_expr: bind walk_expr(e, _),
+              visit_fn: bind walk_fn(e, _, _, _, _, _)
+              with *visit::default_simple_visitor()}));
 
     // Calculate (refs - decls). This is the set of captured upvars.
     // We build a vec of the node ids of the uses and a set of the

src/comp/middle/trans.rs

@@ -830,10 +830,9 @@ fn trans_malloc_boxed(cx: &@block_ctxt, t: ty::t) -> result {
     // size of; box_ptr is the type that's converted to a TypeRef and used as
     // the pointer cast target in trans_raw_malloc.
 
-    let 
-        // The mk_int here is the space being
-        // reserved for the refcount.
-        boxed_body =
+    // The mk_int here is the space being
+    // reserved for the refcount.
+    let boxed_body =
         ty::mk_imm_tup(bcx_tcx(cx), ~[ty::mk_int(bcx_tcx(cx)), t]);
     let box_ptr = ty::mk_imm_box(bcx_tcx(cx), t);
     let sz = size_of(cx, boxed_body);
@@ -1243,21 +1242,20 @@ fn incr_refcnt_of_boxed(cx: &@block_ctxt, box_ptr: ValueRef) -> result {
 fn make_free_glue(cx: &@block_ctxt, v0: ValueRef, t: &ty::t) {
     // NB: v is an *alias* of type t here, not a direct value.
 
-    let 
-        // FIXME: switch gc/non-gc on layer of the type.
-        // FIXME: switch gc/non-gc on layer of the type.
-        // TODO: call upcall_kill
+    // FIXME: switch gc/non-gc on layer of the type.
+    // FIXME: switch gc/non-gc on layer of the type.
+    // TODO: call upcall_kill
 
 
-        // Call through the obj's own fields-drop glue first.
+    // Call through the obj's own fields-drop glue first.
 
-        // Then free the body.
-        // FIXME: switch gc/non-gc on layer of the type.
-        // Call through the closure's own fields-drop glue first.
+    // Then free the body.
+    // FIXME: switch gc/non-gc on layer of the type.
+    // Call through the closure's own fields-drop glue first.
 
-        // Then free the body.
-        // FIXME: switch gc/non-gc on layer of the type.
-        rs =
+    // Then free the body.
+    // FIXME: switch gc/non-gc on layer of the type.
+    let rs =
         alt ty::struct(bcx_tcx(cx), t) {
           ty::ty_str. { let v = cx.build.Load(v0); trans_non_gc_free(cx, v) }
           ty::ty_vec(_) {
@@ -1361,9 +1359,7 @@ fn maybe_free_ivec_heap_part(cx: &@block_ctxt, v0: ValueRef, unit_ty: ty::t)
 fn make_drop_glue(cx: &@block_ctxt, v0: ValueRef, t: &ty::t) {
     // NB: v0 is an *alias* of type t here, not a direct value.
     let ccx = bcx_ccx(cx);
-    let 
-
-        rs =
+    let rs =
         alt ty::struct(ccx.tcx, t) {
           ty::ty_str. { decr_refcnt_maybe_free(cx, v0, v0, t) }
           ty::ty_vec(_) { decr_refcnt_maybe_free(cx, v0, v0, t) }
@@ -1453,7 +1449,9 @@ fn trans_res_drop(cx: @block_ctxt, rs: ValueRef, did: &ast::def_id,
     // value here, but the dtor expects a type that still has opaque pointers
     // for type variables.
     let val_llty =
-        lib::llvm::fn_ty_param_tys(llvm::LLVMGetElementType(llvm::LLVMTypeOf(dtor_addr))).(std::ivec::len(args));
+        lib::llvm::fn_ty_param_tys(llvm::LLVMGetElementType
+                                   (llvm::LLVMTypeOf(dtor_addr)))
+                                    .(std::ivec::len(args));
     let val_cast = cx.build.BitCast(val.val, val_llty);
     cx.build.FastCall(dtor_addr, args + ~[val_cast]);
 
@@ -3345,9 +3343,8 @@ mod ivec {
             maybe_on_heap_cx.build.PointerCast(vptr,
                                                T_ptr(T_ivec_heap(llunitty)));
         let heap_ptr_ptr =
-            maybe_on_heap_cx.build.InBoundsGEP(stub_ptr,
-                                               ~[C_int(0),
-                                                 C_uint(abi::ivec_heap_stub_elt_ptr)]);
+            maybe_on_heap_cx.build.InBoundsGEP
+            (stub_ptr, ~[C_int(0), C_uint(abi::ivec_heap_stub_elt_ptr)]);
         let heap_ptr = maybe_on_heap_cx.build.Load(heap_ptr_ptr);
         let heap_ptr_is_nonnull =
             maybe_on_heap_cx.build.ICmp(lib::llvm::LLVMIntNE, heap_ptr,
@@ -3358,9 +3355,8 @@ mod ivec {
 
         // Ok, the vector is on the heap. Copy the heap part.
         let alen_ptr =
-            on_heap_cx.build.InBoundsGEP(stub_ptr,
-                                         ~[C_int(0),
-                                           C_uint(abi::ivec_heap_stub_elt_alen)]);
+            on_heap_cx.build.InBoundsGEP
+            (stub_ptr, ~[C_int(0), C_uint(abi::ivec_heap_stub_elt_alen)]);
         let alen = on_heap_cx.build.Load(alen_ptr);
 
         let heap_part_sz =
@@ -3598,17 +3594,15 @@ fn trans_if(cx: &@block_ctxt, cond: &@ast::expr, thn: &ast::blk,
     let then_cx = new_scope_block_ctxt(cx, "then");
     let then_res = trans_block(then_cx, thn, output);
     let else_cx = new_scope_block_ctxt(cx, "else");
-    let 
-        // Synthesize a block here to act as the else block
-        // containing an if expression. Needed in order for the
-        // else scope to behave like a normal block scope. A tad
-        // ugly.
-        // Calling trans_block directly instead of trans_expr
-        // because trans_expr will create another scope block
-        // context for the block, but we've already got the
-        // 'else' context
-
-        else_res =
+    // Synthesize a block here to act as the else block
+    // containing an if expression. Needed in order for the
+    // else scope to behave like a normal block scope. A tad
+    // ugly.
+    // Calling trans_block directly instead of trans_expr
+    // because trans_expr will create another scope block
+    // context for the block, but we've already got the
+    // 'else' context
+    let else_res =
         alt els {
           some(elexpr) {
             alt elexpr.node {
@@ -4908,7 +4902,7 @@ fn trans_call(cx: &@block_ctxt, f: &@ast::expr,
     let llretslot = args_res.retslot;
     /*
     log "calling: " + val_str(bcx_ccx(cx).tn, faddr);
-    
+
     for (ValueRef arg in llargs) {
         log "arg: " + val_str(bcx_ccx(cx).tn, arg);
     }
@@ -5334,9 +5328,9 @@ fn trans_expr_out(cx: &@block_ctxt, e: &@ast::expr, output: out_method) ->
       }
       _ {
         // The expression is an lvalue. Fall through.
-        assert (ty::is_lval(e)); // make sure it really is and that we
-                                 // didn't forget to add a case for a new expr!
-
+        assert (ty::is_lval(e));
+        // make sure it really is and that we
+        // didn't forget to add a case for a new expr!
       }
     }
     // lval cases fall through to trans_lval and then
@@ -6352,8 +6346,8 @@ fn copy_args_to_allocas(fcx: @fn_ctxt, args: &ast::arg[],
             alt bcx.fcx.llargs.find(aarg.id) {
               some(x) { argval = x; }
               _ {
-                bcx_ccx(bcx).sess.span_fatal(aarg.ty.span,
-                                             "unbound arg ID in copy_args_to_allocas");
+                bcx_ccx(bcx).sess.span_fatal
+                    (aarg.ty.span, "unbound arg ID in copy_args_to_allocas");
               }
             }
             bcx.build.Store(argval, a);
@@ -6374,8 +6368,8 @@ fn add_cleanups_for_args(bcx: &@block_ctxt, args: &ast::arg[],
             alt bcx.fcx.llargs.find(aarg.id) {
               some(x) { argval = x; }
               _ {
-                bcx_ccx(bcx).sess.span_fatal(aarg.ty.span,
-                                             "unbound arg ID in copy_args_to_allocas");
+                bcx_ccx(bcx).sess.span_fatal
+                    (aarg.ty.span, "unbound arg ID in copy_args_to_allocas");
               }
             }
             add_clean(bcx, argval, arg_tys.(arg_n).ty);
@@ -7227,9 +7221,8 @@ fn trans_tag_variant(cx: @local_ctxt, tag_id: ast::node_id,
     let bcx = new_top_block_ctxt(fcx);
     let lltop = bcx.llbb;
 
-    let 
-        // Cast the tag to a type we can GEP into.
-        llblobptr =
+    // Cast the tag to a type we can GEP into.
+    let llblobptr =
         if is_degen {
             fcx.llretptr
         } else {

src/comp/middle/trans_alt.rs

@@ -294,9 +294,8 @@ fn compile_submatch(bcx: @block_ctxt, m: &match, vals: ValueRef[],
             if ivec::len(ty::tag_variants(ccx.tcx, vdef.tg)) == 1u {
                 kind = single;
             } else {
-                let tagptr =
-                    bcx.build.PointerCast(val,
-                                          trans_common::T_opaque_tag_ptr(ccx.tn));
+                let tagptr = bcx.build.PointerCast
+                    (val, trans_common::T_opaque_tag_ptr(ccx.tn));
                 let discrimptr = bcx.build.GEP(tagptr, ~[C_int(0), C_int(0)]);
                 test_val = bcx.build.Load(discrimptr);
                 kind = switch;

src/comp/middle/tstate/bitvectors.rs

@@ -159,9 +159,7 @@ fn relax_precond_block(fcx: &fn_ctxt, i: node_id, b: &blk) {
     fn quit(keepgoing: @mutable bool, i: &@item) { *keepgoing = false; }
     fn kg(keepgoing: @mutable bool) -> bool { ret *keepgoing; }
 
-    let 
-
-        v =
+    let v =
         {visit_block_pre: bind relax_precond_block_non_recursive(fcx, i, _),
          visit_expr_pre: bind relax_precond_expr(fcx, i, _),
          visit_stmt_pre: bind relax_precond_stmt(fcx, i, _),

src/comp/middle/tstate/pre_post_conditions.rs

@@ -641,7 +641,7 @@ fn find_pre_post_block(fcx: &fn_ctxt, b: blk) {
      This will mean that:
      x = 0;
      break;
-    
+
      won't have a postcondition that says x is initialized, but that's ok.
      */
 

src/comp/middle/ty.rs

@@ -1987,8 +1987,9 @@ mod unify {
 
             let result_mode;
             if expected_input.mode != actual_input.mode {
-                ret fn_common_res_err(ures_err(terr_mode_mismatch(expected_input.mode,
-                                                                  actual_input.mode)));
+                ret fn_common_res_err
+                    (ures_err(terr_mode_mismatch(expected_input.mode,
+                                                 actual_input.mode)));
             } else { result_mode = expected_input.mode; }
             let result = unify_step(cx, expected_input.ty, actual_input.ty);
             alt result {
@@ -2817,10 +2818,10 @@ fn ast_constr_to_constr[T](tcx: ty::ctxt, c: &@ast::constr_general[T]) ->
                     {path: c.node.path, args: c.node.args, id: pred_id});
       }
       _ {
-        tcx.sess.span_fatal(c.span,
-                            "Predicate " + path_to_str(c.node.path) +
-                                " is unbound or bound to a non-function or an \
-                        impure function");
+        tcx.sess.span_fatal
+            (c.span, "Predicate " + path_to_str(c.node.path) +
+             " is unbound or bound to a non-function or an \
+              impure function");
       }
     }
 }