Reformat

This changes the indexing syntax from .() to [], the vector syntax from ~[] to
[] and the extension syntax from #fmt() to #fmt[]

Author: brson

src/comp/back/link.rs

@@ -137,10 +137,9 @@ mod write {
                                                                    False);
 
             if threshold != 0u {
-                llvm::LLVMPassManagerBuilderUseInlinerWithThreshold(MPMB,
-                                                                   threshold);
+                llvm::LLVMPassManagerBuilderUseInlinerWithThreshold(
+                    MPMB, threshold);
             }
-
             llvm::LLVMPassManagerBuilderPopulateModulePassManager(MPMB,
                                                                   pm.llpm);
 
@@ -293,21 +292,21 @@ fn build_link_meta(sess: &session::session, c: &ast::crate, output: &str,
        provided_metas {
         let name: option::t<str> = none;
         let vers: option::t<str> = none;
-        let cmh_items: [@ast::meta_item] = ~[];
+        let cmh_items: [@ast::meta_item] = [];
         let linkage_metas = attr::find_linkage_metas(c.node.attrs);
         attr::require_unique_names(sess, linkage_metas);
         for meta: @ast::meta_item in linkage_metas {
             if attr::get_meta_item_name(meta) == "name" {
                 alt attr::get_meta_item_value_str(meta) {
                   some(v) { name = some(v); }
-                  none. { cmh_items += ~[meta]; }
+                  none. { cmh_items += [meta]; }
                 }
-            } else if (attr::get_meta_item_name(meta) == "vers") {
+            } else if attr::get_meta_item_name(meta) == "vers" {
                 alt attr::get_meta_item_value_str(meta) {
                   some(v) { vers = some(v); }
-                  none. { cmh_items += ~[meta]; }
+                  none. { cmh_items += [meta]; }
                 }
-            } else { cmh_items += ~[meta]; }
+            } else { cmh_items += [meta]; }
         }
         ret {name: name, vers: vers, cmh_items: cmh_items};
     }
@@ -316,7 +315,7 @@ fn build_link_meta(sess: &session::session, c: &ast::crate, output: &str,
     fn crate_meta_extras_hash(sha: sha1, _crate: &ast::crate,
                               metas: &provided_metas) -> str {
         fn len_and_str(s: &str) -> str {
-            ret #fmt("%u_%s", str::byte_len(s), s);
+            ret #fmt["%u_%s", str::byte_len(s), s];
         }
 
         fn len_and_str_lit(l: &ast::lit) -> str {
@@ -345,8 +344,8 @@ fn build_link_meta(sess: &session::session, c: &ast::crate, output: &str,
 
     fn warn_missing(sess: &session::session, name: str, default: str) {
         if !sess.get_opts().library { ret; }
-        sess.warn(#fmt("missing crate link meta '%s', using '%s' as default",
-                       name, default));
+        sess.warn(#fmt["missing crate link meta '%s', using '%s' as default",
+                       name, default]);
     }
 
     fn crate_meta_name(sess: &session::session, _crate: &ast::crate,
@@ -356,8 +355,7 @@ fn build_link_meta(sess: &session::session, c: &ast::crate, output: &str,
               none. {
                 let name =
                     {
-                        let os =
-                            str::split(fs::basename(output), '.' as u8);
+                        let os = str::split(fs::basename(output), '.' as u8);
                         assert (vec::len(os) >= 2u);
                         vec::pop(os);
                         str::connect(os, ".")
@@ -429,7 +427,7 @@ fn mangle(ss: &[str]) -> str {
 
     let n = "_ZN"; // Begin name-sequence.
 
-    for s: str in ss { n += #fmt("%u%s", str::byte_len(s), s); }
+    for s: str in ss { n += #fmt["%u%s", str::byte_len(s), s]; }
     n += "E"; // End name-sequence.
 
     ret n;
@@ -438,7 +436,7 @@ fn mangle(ss: &[str]) -> str {
 fn exported_name(path: &[str], hash: &str, _vers: &str) -> str {
     // FIXME: versioning isn't working yet
 
-    ret mangle(path + ~[hash]); //  + "@" + vers;
+    ret mangle(path + [hash]); //  + "@" + vers;
 
 }
 
@@ -451,12 +449,12 @@ fn mangle_internal_name_by_type_only(ccx: &@crate_ctxt, t: &ty::t, name: &str)
    -> str {
     let s = util::ppaux::ty_to_short_str(ccx.tcx, t);
     let hash = get_symbol_hash(ccx, t);
-    ret mangle(~[name, s, hash]);
+    ret mangle([name, s, hash]);
 }
 
 fn mangle_internal_name_by_path_and_seq(ccx: &@crate_ctxt, path: &[str],
                                         flav: &str) -> str {
-    ret mangle(path + ~[ccx.names.next(flav)]);
+    ret mangle(path + [ccx.names.next(flav)]);
 }
 
 fn mangle_internal_name_by_path(_ccx: &@crate_ctxt, path: &[str]) -> str {

src/comp/back/upcall.rs

@@ -51,72 +51,68 @@ type upcalls =
 
 fn declare_upcalls(_tn: type_names, tydesc_type: TypeRef,
                    taskptr_type: TypeRef, llmod: ModuleRef) -> @upcalls {
-    fn decl(llmod: ModuleRef, name: str, tys: [TypeRef],
-          rv: TypeRef) -> ValueRef {
-        let arg_tys: [TypeRef] = ~[];
-        for t: TypeRef in tys { arg_tys += ~[t]; }
+    fn decl(llmod: ModuleRef, name: str, tys: [TypeRef], rv: TypeRef) ->
+       ValueRef {
+        let arg_tys: [TypeRef] = [];
+        for t: TypeRef in tys { arg_tys += [t]; }
         let fn_ty = T_fn(arg_tys, rv);
         ret trans::decl_cdecl_fn(llmod, "upcall_" + name, fn_ty);
     }
-    fn decl_with_taskptr(taskptr_type: TypeRef,
-                         llmod: ModuleRef, name: str, tys: [TypeRef],
-                         rv: TypeRef) -> ValueRef {
-        ret decl(llmod, name, ~[taskptr_type] + tys, rv);
+    fn decl_with_taskptr(taskptr_type: TypeRef, llmod: ModuleRef, name: str,
+                         tys: [TypeRef], rv: TypeRef) -> ValueRef {
+        ret decl(llmod, name, [taskptr_type] + tys, rv);
     }
     let dv = bind decl_with_taskptr(taskptr_type, llmod, _, _, T_void());
     let d = bind decl_with_taskptr(taskptr_type, llmod, _, _, _);
     let dr = bind decl(llmod, _, _, _);
 
-    let empty_vec: [TypeRef] = ~[];
-    ret @{grow_task: dv("grow_task", ~[T_size_t()]),
+    let empty_vec: [TypeRef] = [];
+    ret @{grow_task: dv("grow_task", [T_size_t()]),
           _yield: dv("yield", empty_vec),
-          sleep: dv("sleep", ~[T_size_t()]),
-          _fail: dv("fail", ~[T_ptr(T_i8()), T_ptr(T_i8()), T_size_t()]),
-          kill: dv("kill", ~[taskptr_type]),
+          sleep: dv("sleep", [T_size_t()]),
+          _fail: dv("fail", [T_ptr(T_i8()), T_ptr(T_i8()), T_size_t()]),
+          kill: dv("kill", [taskptr_type]),
           exit: dv("exit", empty_vec),
           malloc:
-              d("malloc", ~[T_size_t(), T_ptr(tydesc_type)], T_ptr(T_i8())),
-          free: dv("free", ~[T_ptr(T_i8()), T_int()]),
+              d("malloc", [T_size_t(), T_ptr(tydesc_type)], T_ptr(T_i8())),
+          free: dv("free", [T_ptr(T_i8()), T_int()]),
           shared_malloc:
-              d("shared_malloc", ~[T_size_t(), T_ptr(tydesc_type)],
+              d("shared_malloc", [T_size_t(), T_ptr(tydesc_type)],
                 T_ptr(T_i8())),
-          shared_free: dv("shared_free", ~[T_ptr(T_i8())]),
-          mark: d("mark", ~[T_ptr(T_i8())], T_int()),
-          new_str: d("new_str", ~[T_ptr(T_i8()), T_size_t()], T_ptr(T_str())),
+          shared_free: dv("shared_free", [T_ptr(T_i8())]),
+          mark: d("mark", [T_ptr(T_i8())], T_int()),
+          new_str: d("new_str", [T_ptr(T_i8()), T_size_t()], T_ptr(T_str())),
           evec_append:
               d("evec_append",
-                ~[T_ptr(tydesc_type), T_ptr(tydesc_type),
-                  T_ptr(T_opaque_vec_ptr()), T_opaque_vec_ptr(), T_bool()],
+                [T_ptr(tydesc_type), T_ptr(tydesc_type),
+                 T_ptr(T_opaque_vec_ptr()), T_opaque_vec_ptr(), T_bool()],
                 T_void()),
           get_type_desc:
               d("get_type_desc",
-                ~[T_ptr(T_nil()), T_size_t(), T_size_t(), T_size_t(),
-                  T_ptr(T_ptr(tydesc_type))], T_ptr(tydesc_type)),
+                [T_ptr(T_nil()), T_size_t(), T_size_t(), T_size_t(),
+                 T_ptr(T_ptr(tydesc_type))], T_ptr(tydesc_type)),
           ivec_resize:
-              d("ivec_resize", ~[T_ptr(T_opaque_ivec()), T_int()], T_void()),
+              d("ivec_resize", [T_ptr(T_opaque_ivec()), T_int()], T_void()),
           ivec_spill:
-              d("ivec_spill", ~[T_ptr(T_opaque_ivec()), T_int()], T_void()),
+              d("ivec_spill", [T_ptr(T_opaque_ivec()), T_int()], T_void()),
           ivec_resize_shared:
-              d("ivec_resize_shared", ~[T_ptr(T_opaque_ivec()), T_int()],
+              d("ivec_resize_shared", [T_ptr(T_opaque_ivec()), T_int()],
                 T_void()),
           ivec_spill_shared:
-              d("ivec_spill_shared", ~[T_ptr(T_opaque_ivec()), T_int()],
+              d("ivec_spill_shared", [T_ptr(T_opaque_ivec()), T_int()],
                 T_void()),
           cmp_type:
-              dr("cmp_type", ~[T_ptr(T_i1()), taskptr_type,
-                 T_ptr(tydesc_type), T_ptr(T_ptr(tydesc_type)),
-                 T_ptr(T_i8()), T_ptr(T_i8()), T_i8()],
-                 T_void()),
+              dr("cmp_type",
+                 [T_ptr(T_i1()), taskptr_type, T_ptr(tydesc_type),
+                  T_ptr(T_ptr(tydesc_type)), T_ptr(T_i8()), T_ptr(T_i8()),
+                  T_i8()], T_void()),
           log_type:
-              dr("log_type", ~[taskptr_type, T_ptr(tydesc_type),
-                 T_ptr(T_i8()), T_i32()],
+              dr("log_type",
+                 [taskptr_type, T_ptr(tydesc_type), T_ptr(T_i8()), T_i32()],
                  T_void()),
-          dynastack_mark:
-              d("dynastack_mark", ~[], T_ptr(T_i8())),
-          dynastack_alloc:
-              d("dynastack_alloc", ~[T_size_t()], T_ptr(T_i8())),
-          dynastack_free:
-              d("dynastack_free", ~[T_ptr(T_i8())], T_void())};
+          dynastack_mark: d("dynastack_mark", [], T_ptr(T_i8())),
+          dynastack_alloc: d("dynastack_alloc", [T_size_t()], T_ptr(T_i8())),
+          dynastack_free: d("dynastack_free", [T_ptr(T_i8())], T_void())};
 }
 //
 // Local Variables: