Change syntax extension syntax: `#m[...]` -> `m!{...}`.

18 files changed, 368 insertions, 368 deletions

diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs
index 610dd43835c..f71f991c9f8 100644
--- a/src/libstd/deque.rs
+++ b/src/libstd/deque.rs
@@ -278,37 +278,37 @@ mod tests {
         fn reccyeq(a: reccy, b: reccy) -> bool {
             ret a.x == b.x && a.y == b.y && taggyeq(a.t, b.t);
         }
-        #debug("*** test boxes");
+        debug!{"*** test boxes"};
         test_boxes(@5, @72, @64, @175);
-        #debug("*** end test boxes");
-        #debug("test parameterized: int");
+        debug!{"*** end test boxes"};
+        debug!{"test parameterized: int"};
         let eq1: eqfn<int> = inteq;
         test_parameterized::<int>(eq1, 5, 72, 64, 175);
-        #debug("*** test parameterized: @int");
+        debug!{"*** test parameterized: @int"};
         let eq2: eqfn<@int> = intboxeq;
         test_parameterized::<@int>(eq2, @5, @72, @64, @175);
-        #debug("*** end test parameterized @int");
-        #debug("test parameterized: taggy");
+        debug!{"*** end test parameterized @int"};
+        debug!{"test parameterized: taggy"};
         let eq3: eqfn<taggy> = taggyeq;
         test_parameterized::<taggy>(eq3, one(1), two(1, 2), three(1, 2, 3),
                                     two(17, 42));
 
-        #debug("*** test parameterized: taggypar<int>");
+        debug!{"*** test parameterized: taggypar<int>"};
         let eq4: eqfn<taggypar<int>> = |x,y| taggypareq::<int>(x, y);
         test_parameterized::<taggypar<int>>(eq4, onepar::<int>(1),
                                             twopar::<int>(1, 2),
                                             threepar::<int>(1, 2, 3),
                                             twopar::<int>(17, 42));
-        #debug("*** end test parameterized: taggypar::<int>");
+        debug!{"*** end test parameterized: taggypar::<int>"};
 
-        #debug("*** test parameterized: reccy");
+        debug!{"*** test parameterized: reccy"};
         let reccy1: reccy = {x: 1, y: 2, t: one(1)};
         let reccy2: reccy = {x: 345, y: 2, t: two(1, 2)};
         let reccy3: reccy = {x: 1, y: 777, t: three(1, 2, 3)};
         let reccy4: reccy = {x: 19, y: 252, t: two(17, 42)};
         let eq5: eqfn<reccy> = reccyeq;
         test_parameterized::<reccy>(eq5, reccy1, reccy2, reccy3, reccy4);
-        #debug("*** end test parameterized: reccy");
-        #debug("*** done");
+        debug!{"*** end test parameterized: reccy"};
+        debug!{"*** done"};
     }
 }
diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs
index 8dbb39d1831..d5d1e70bc7b 100644
--- a/src/libstd/ebml.rs
+++ b/src/libstd/ebml.rs
@@ -80,7 +80,7 @@ fn vuint_at(data: &[u8], start: uint) -> {val: uint, next: uint} {
                  (data[start + 2u] as uint) << 8u |
                  (data[start + 3u] as uint),
              next: start + 4u};
-    } else { #error("vint too big"); fail; }
+    } else { error!{"vint too big"}; fail; }
 }
 
 fn doc(data: @~[u8]) -> doc {
@@ -112,7 +112,7 @@ fn get_doc(d: doc, tg: uint) -> doc {
     alt maybe_get_doc(d, tg) {
       some(d) { ret d; }
       none {
-        #error("failed to find block with tag %u", tg);
+        error!{"failed to find block with tag %u", tg};
         fail;
       }
     }
@@ -200,7 +200,7 @@ fn write_sized_vuint(w: io::writer, n: uint, size: uint) {
         w.write(&[0x10u8 | ((n >> 24_u) as u8), (n >> 16_u) as u8,
                  (n >> 8_u) as u8, n as u8]);
       }
-      _ { fail #fmt("vint to write too big: %?", n); }
+      _ { fail fmt!{"vint to write too big: %?", n}; }
     };
 }
 
@@ -209,7 +209,7 @@ fn write_vuint(w: io::writer, n: uint) {
     if n < 0x4000_u { write_sized_vuint(w, n, 2u); ret; }
     if n < 0x200000_u { write_sized_vuint(w, n, 3u); ret; }
     if n < 0x10000000_u { write_sized_vuint(w, n, 4u); ret; }
-    fail #fmt("vint to write too big: %?", n);
+    fail fmt!{"vint to write too big: %?", n};
 }
 
 fn writer(w: io::writer) -> writer {
@@ -220,7 +220,7 @@ fn writer(w: io::writer) -> writer {
 // FIXME (#2741): Provide a function to write the standard ebml header.
 impl writer for writer {
     fn start_tag(tag_id: uint) {
-        #debug["Start tag %u", tag_id];
+        debug!{"Start tag %u", tag_id};
 
         // Write the enum ID:
         write_vuint(self.writer, tag_id);
@@ -239,7 +239,7 @@ impl writer for writer {
         write_sized_vuint(self.writer, size, 4u);
         self.writer.seek(cur_pos as int, io::seek_set);
 
-        #debug["End tag (size = %u)", size];
+        debug!{"End tag (size = %u)", size};
     }
 
     fn wr_tag(tag_id: uint, blk: fn()) {
@@ -309,12 +309,12 @@ impl writer for writer {
     }
 
     fn wr_bytes(b: &[u8]) {
-        #debug["Write %u bytes", vec::len(b)];
+        debug!{"Write %u bytes", vec::len(b)};
         self.writer.write(b);
     }
 
     fn wr_str(s: ~str) {
-        #debug["Write str: %?", s];
+        debug!{"Write str: %?", s};
         self.writer.write(str::bytes(s));
     }
 }
@@ -437,29 +437,29 @@ impl deserializer_priv for ebml_deserializer {
                 self.pos = r_doc.end;
                 let str = ebml::doc_as_str(r_doc);
                 if lbl != str {
-                    fail #fmt["Expected label %s but found %s", lbl, str];
+                    fail fmt!{"Expected label %s but found %s", lbl, str};
                 }
             }
         }
     }
 
     fn next_doc(exp_tag: ebml_serializer_tag) -> ebml::doc {
-        #debug[". next_doc(exp_tag=%?)", exp_tag];
+        debug!{". next_doc(exp_tag=%?)", exp_tag};
         if self.pos >= self.parent.end {
             fail ~"no more documents in current node!";
         }
         let {tag: r_tag, doc: r_doc} =
             ebml::doc_at(self.parent.data, self.pos);
-        #debug["self.parent=%?-%? self.pos=%? r_tag=%? r_doc=%?-%?",
+        debug!{"self.parent=%?-%? self.pos=%? r_tag=%? r_doc=%?-%?",
                copy self.parent.start, copy self.parent.end,
-               copy self.pos, r_tag, r_doc.start, r_doc.end];
+               copy self.pos, r_tag, r_doc.start, r_doc.end};
         if r_tag != (exp_tag as uint) {
-            fail #fmt["expected EMBL doc with tag %? but found tag %?",
-                      exp_tag, r_tag];
+            fail fmt!{"expected EMBL doc with tag %? but found tag %?",
+                      exp_tag, r_tag};
         }
         if r_doc.end > self.parent.end {
-            fail #fmt["invalid EBML, child extends to 0x%x, parent to 0x%x",
-                      r_doc.end, self.parent.end];
+            fail fmt!{"invalid EBML, child extends to 0x%x, parent to 0x%x",
+                      r_doc.end, self.parent.end};
         }
         self.pos = r_doc.end;
         ret r_doc;
@@ -478,7 +478,7 @@ impl deserializer_priv for ebml_deserializer {
 
     fn _next_uint(exp_tag: ebml_serializer_tag) -> uint {
         let r = ebml::doc_as_u32(self.next_doc(exp_tag));
-        #debug["_next_uint exp_tag=%? result=%?", exp_tag, r];
+        debug!{"_next_uint exp_tag=%? result=%?", exp_tag, r};
         ret r as uint;
     }
 }
@@ -493,7 +493,7 @@ impl deserializer of serialization::deserializer for ebml_deserializer {
     fn read_uint() -> uint {
         let v = ebml::doc_as_u64(self.next_doc(es_uint));
         if v > (core::uint::max_value as u64) {
-            fail #fmt["uint %? too large for this architecture", v];
+            fail fmt!{"uint %? too large for this architecture", v};
         }
         ret v as uint;
     }
@@ -505,7 +505,7 @@ impl deserializer of serialization::deserializer for ebml_deserializer {
     fn read_int() -> int {
         let v = ebml::doc_as_u64(self.next_doc(es_int)) as i64;
         if v > (int::max_value as i64) || v < (int::min_value as i64) {
-            fail #fmt["int %? out of range for this architecture", v];
+            fail fmt!{"int %? out of range for this architecture", v};
         }
         ret v as int;
     }
@@ -520,67 +520,67 @@ impl deserializer of serialization::deserializer for ebml_deserializer {
 
     // Compound types:
     fn read_enum<T:copy>(name: ~str, f: fn() -> T) -> T {
-        #debug["read_enum(%s)", name];
+        debug!{"read_enum(%s)", name};
         self._check_label(name);
         self.push_doc(self.next_doc(es_enum), f)
     }
 
     fn read_enum_variant<T:copy>(f: fn(uint) -> T) -> T {
-        #debug["read_enum_variant()"];
+        debug!{"read_enum_variant()"};
         let idx = self._next_uint(es_enum_vid);
-        #debug["  idx=%u", idx];
+        debug!{"  idx=%u", idx};
         do self.push_doc(self.next_doc(es_enum_body)) {
             f(idx)
         }
     }
 
     fn read_enum_variant_arg<T:copy>(idx: uint, f: fn() -> T) -> T {
-        #debug["read_enum_variant_arg(idx=%u)", idx];
+        debug!{"read_enum_variant_arg(idx=%u)", idx};
         f()
     }
 
     fn read_vec<T:copy>(f: fn(uint) -> T) -> T {
-        #debug["read_vec()"];
+        debug!{"read_vec()"};
         do self.push_doc(self.next_doc(es_vec)) {
             let len = self._next_uint(es_vec_len);
-            #debug["  len=%u", len];
+            debug!{"  len=%u", len};
             f(len)
         }
     }
 
     fn read_vec_elt<T:copy>(idx: uint, f: fn() -> T) -> T {
-        #debug["read_vec_elt(idx=%u)", idx];
+        debug!{"read_vec_elt(idx=%u)", idx};
         self.push_doc(self.next_doc(es_vec_elt), f)
     }
 
     fn read_box<T:copy>(f: fn() -> T) -> T {
-        #debug["read_box()"];
+        debug!{"read_box()"};
         f()
     }
 
     fn read_uniq<T:copy>(f: fn() -> T) -> T {
-        #debug["read_uniq()"];
+        debug!{"read_uniq()"};
         f()
     }
 
     fn read_rec<T:copy>(f: fn() -> T) -> T {
-        #debug["read_rec()"];
+        debug!{"read_rec()"};
         f()
     }
 
     fn read_rec_field<T:copy>(f_name: ~str, f_idx: uint, f: fn() -> T) -> T {
-        #debug["read_rec_field(%s, idx=%u)", f_name, f_idx];
+        debug!{"read_rec_field(%s, idx=%u)", f_name, f_idx};
         self._check_label(f_name);
         f()
     }
 
     fn read_tup<T:copy>(sz: uint, f: fn() -> T) -> T {
-        #debug["read_tup(sz=%u)", sz];
+        debug!{"read_tup(sz=%u)", sz};
         f()
     }
 
     fn read_tup_elt<T:copy>(idx: uint, f: fn() -> T) -> T {
-        #debug["read_tup_elt(idx=%u)", idx];
+        debug!{"read_tup_elt(idx=%u)", idx};
         f()
     }
 }
@@ -631,14 +631,14 @@ fn test_option_int() {
     }
 
     fn test_v(v: option<int>) {
-        #debug["v == %?", v];
+        debug!{"v == %?", v};
         let mbuf = io::mem_buffer();
         let ebml_w = ebml::writer(io::mem_buffer_writer(mbuf));
         serialize_0(ebml_w, v);
         let ebml_doc = ebml::doc(@io::mem_buffer_buf(mbuf));
         let deser = ebml_deserializer(ebml_doc);
         let v1 = deserialize_0(deser);
-        #debug["v1 == %?", v1];
+        debug!{"v1 == %?", v1};
         assert v == v1;
     }
 
diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs
index 8ba2dc16b76..3cafc118525 100644
--- a/src/libstd/getopts.rs
+++ b/src/libstd/getopts.rs
@@ -314,7 +314,7 @@ fn getopts(args: ~[~str], opts: ~[opt]) -> result unsafe {
 fn opt_vals(m: match, nm: ~str) -> ~[optval] {
     ret alt find_opt(m.opts, mkname(nm)) {
           some(id) { m.vals[id] }
-          none { #error("No option '%s' defined", nm); fail }
+          none { error!{"No option '%s' defined", nm}; fail }
         };
 }
 
diff --git a/src/libstd/json.rs b/src/libstd/json.rs
index 74707e36a51..ee265269872 100644
--- a/src/libstd/json.rs
+++ b/src/libstd/json.rs
@@ -632,7 +632,7 @@ impl of to_str::to_str for json {
 
 impl of to_str::to_str for error {
     fn to_str() -> ~str {
-        #fmt("%u:%u: %s", self.line, self.col, *self.msg)
+        fmt!{"%u:%u: %s", self.line, self.col, *self.msg}
     }
 }
 
diff --git a/src/libstd/map.rs b/src/libstd/map.rs
index 2522c9d5876..c660adc527f 100644
--- a/src/libstd/map.rs
+++ b/src/libstd/map.rs
@@ -122,16 +122,16 @@ mod chained {
             loop {
                 alt copy e0.next {
                   absent {
-                    #debug("search_tbl: absent, comp %u, hash %u, idx %u",
-                           comp, h, idx);
+                    debug!{"search_tbl: absent, comp %u, hash %u, idx %u",
+                           comp, h, idx};
                     ret not_found;
                   }
                   present(e1) {
                     comp += 1u;
                     if e1.hash == h && self.eqer(e1.key, k) {
-                        #debug("search_tbl: present, comp %u, \
+                        debug!{"search_tbl: present, comp %u, \
                                 hash %u, idx %u",
-                               comp, h, idx);
+                               comp, h, idx};
                         ret found_after(e0, e1);
                     } else {
                         e0 = e1;
@@ -145,14 +145,14 @@ mod chained {
             let idx = h % vec::len(self.chains);
             alt copy self.chains[idx] {
               absent {
-                #debug("search_tbl: absent, comp %u, hash %u, idx %u",
-                       0u, h, idx);
+                debug!{"search_tbl: absent, comp %u, hash %u, idx %u",
+                       0u, h, idx};
                 ret not_found;
               }
               present(e) {
                 if e.hash == h && self.eqer(e.key, k) {
-                    #debug("search_tbl: present, comp %u, hash %u, idx %u",
-                           1u, h, idx);
+                    debug!{"search_tbl: present, comp %u, hash %u, idx %u",
+                           1u, h, idx};
                     ret found_first(idx, e);
                 } else {
                     ret self.search_rem(k, h, idx, e);
@@ -248,7 +248,7 @@ mod chained {
         fn get(k: K) -> V {
             alt self.find(k) {
               some(v) => {v}
-              none => {fail #fmt["Key not found in table: %?", k]}
+              none => {fail fmt!{"Key not found in table: %?", k}}
             }
         }
 
@@ -427,14 +427,14 @@ mod tests {
 
     #[test]
     fn test_simple() {
-        #debug("*** starting test_simple");
+        debug!{"*** starting test_simple"};
         fn eq_uint(&&x: uint, &&y: uint) -> bool { ret x == y; }
         fn uint_id(&&x: uint) -> uint { x }
         let hasher_uint: map::hashfn<uint> = uint_id;
         let eqer_uint: map::eqfn<uint> = eq_uint;
         let hasher_str: map::hashfn<~str> = str::hash;
         let eqer_str: map::eqfn<~str> = str::eq;
-        #debug("uint -> uint");
+        debug!{"uint -> uint"};
         let hm_uu: map::hashmap<uint, uint> =
             map::hashmap::<uint, uint>(hasher_uint, eqer_uint);
         assert (hm_uu.insert(10u, 12u));
@@ -450,7 +450,7 @@ mod tests {
         let ten: ~str = ~"ten";
         let eleven: ~str = ~"eleven";
         let twelve: ~str = ~"twelve";
-        #debug("str -> uint");
+        debug!{"str -> uint"};
         let hm_su: map::hashmap<~str, uint> =
             map::hashmap::<~str, uint>(hasher_str, eqer_str);
         assert (hm_su.insert(~"ten", 12u));
@@ -464,7 +464,7 @@ mod tests {
         assert (hm_su.get(~"twelve") == 14u);
         assert (!hm_su.insert(~"twelve", 12u));
         assert (hm_su.get(~"twelve") == 12u);
-        #debug("uint -> str");
+        debug!{"uint -> str"};
         let hm_us: map::hashmap<uint, ~str> =
             map::hashmap::<uint, ~str>(hasher_uint, eqer_uint);
         assert (hm_us.insert(10u, ~"twelve"));
@@ -477,7 +477,7 @@ mod tests {
         assert (str::eq(hm_us.get(12u), ~"fourteen"));
         assert (!hm_us.insert(12u, ~"twelve"));
         assert (str::eq(hm_us.get(12u), ~"twelve"));
-        #debug("str -> str");
+        debug!{"str -> str"};
         let hm_ss: map::hashmap<~str, ~str> =
             map::hashmap::<~str, ~str>(hasher_str, eqer_str);
         assert (hm_ss.insert(ten, ~"twelve"));
@@ -490,7 +490,7 @@ mod tests {
         assert (str::eq(hm_ss.get(~"twelve"), ~"fourteen"));
         assert (!hm_ss.insert(~"twelve", ~"twelve"));
         assert (str::eq(hm_ss.get(~"twelve"), ~"twelve"));
-        #debug("*** finished test_simple");
+        debug!{"*** finished test_simple"};
     }
 
 
@@ -499,11 +499,11 @@ mod tests {
     */
     #[test]
     fn test_growth() {
-        #debug("*** starting test_growth");
+        debug!{"*** starting test_growth"};
         let num_to_insert: uint = 64u;
         fn eq_uint(&&x: uint, &&y: uint) -> bool { ret x == y; }
         fn uint_id(&&x: uint) -> uint { x }
-        #debug("uint -> uint");
+        debug!{"uint -> uint"};
         let hasher_uint: map::hashfn<uint> = uint_id;
         let eqer_uint: map::eqfn<uint> = eq_uint;
         let hm_uu: map::hashmap<uint, uint> =
@@ -511,26 +511,26 @@ mod tests {
         let mut i: uint = 0u;
         while i < num_to_insert {
             assert (hm_uu.insert(i, i * i));
-            #debug("inserting %u -> %u", i, i*i);
+            debug!{"inserting %u -> %u", i, i*i};
             i += 1u;
         }
-        #debug("-----");
+        debug!{"-----"};
         i = 0u;
         while i < num_to_insert {
-            #debug("get(%u) = %u", i, hm_uu.get(i));
+            debug!{"get(%u) = %u", i, hm_uu.get(i)};
             assert (hm_uu.get(i) == i * i);
             i += 1u;
         }
         assert (hm_uu.insert(num_to_insert, 17u));
         assert (hm_uu.get(num_to_insert) == 17u);
-        #debug("-----");
+        debug!{"-----"};
         i = 0u;
         while i < num_to_insert {
-            #debug("get(%u) = %u", i, hm_uu.get(i));
+            debug!{"get(%u) = %u", i, hm_uu.get(i)};
             assert (hm_uu.get(i) == i * i);
             i += 1u;
         }
-        #debug("str -> str");
+        debug!{"str -> str"};
         let hasher_str: map::hashfn<~str> = str::hash;
         let eqer_str: map::eqfn<~str> = str::eq;
         let hm_ss: map::hashmap<~str, ~str> =
@@ -538,17 +538,17 @@ mod tests {
         i = 0u;
         while i < num_to_insert {
             assert hm_ss.insert(uint::to_str(i, 2u), uint::to_str(i * i, 2u));
-            #debug("inserting \"%s\" -> \"%s\"",
+            debug!{"inserting \"%s\" -> \"%s\"",
                    uint::to_str(i, 2u),
-                   uint::to_str(i*i, 2u));
+                   uint::to_str(i*i, 2u)};
             i += 1u;
         }
-        #debug("-----");
+        debug!{"-----"};
         i = 0u;
         while i < num_to_insert {
-            #debug("get(\"%s\") = \"%s\"",
+            debug!{"get(\"%s\") = \"%s\"",
                    uint::to_str(i, 2u),
-                   hm_ss.get(uint::to_str(i, 2u)));
+                   hm_ss.get(uint::to_str(i, 2u))};
             assert (str::eq(hm_ss.get(uint::to_str(i, 2u)),
                             uint::to_str(i * i, 2u)));
             i += 1u;
@@ -557,22 +557,22 @@ mod tests {
                              uint::to_str(17u, 2u)));
         assert (str::eq(hm_ss.get(uint::to_str(num_to_insert, 2u)),
                         uint::to_str(17u, 2u)));
-        #debug("-----");
+        debug!{"-----"};
         i = 0u;
         while i < num_to_insert {
-            #debug("get(\"%s\") = \"%s\"",
+            debug!{"get(\"%s\") = \"%s\"",
                    uint::to_str(i, 2u),
-                   hm_ss.get(uint::to_str(i, 2u)));
+                   hm_ss.get(uint::to_str(i, 2u))};
             assert (str::eq(hm_ss.get(uint::to_str(i, 2u)),
                             uint::to_str(i * i, 2u)));
             i += 1u;
         }
-        #debug("*** finished test_growth");
+        debug!{"*** finished test_growth"};
     }
 
     #[test]
     fn test_removal() {
-        #debug("*** starting test_removal");
+        debug!{"*** starting test_removal"};
         let num_to_insert: uint = 64u;
         fn eq(&&x: uint, &&y: uint) -> bool { ret x == y; }
         fn hash(&&u: uint) -> uint {
@@ -591,12 +591,12 @@ mod tests {
         let mut i: uint = 0u;
         while i < num_to_insert {
             assert (hm.insert(i, i * i));
-            #debug("inserting %u -> %u", i, i*i);
+            debug!{"inserting %u -> %u", i, i*i};
             i += 1u;
         }
         assert (hm.size() == num_to_insert);
-        #debug("-----");
-        #debug("removing evens");
+        debug!{"-----"};
+        debug!{"removing evens"};
         i = 0u;
         while i < num_to_insert {
             let v = hm.remove(i);
@@ -607,44 +607,44 @@ mod tests {
             i += 2u;
         }
         assert (hm.size() == num_to_insert / 2u);
-        #debug("-----");
+        debug!{"-----"};
         i = 1u;
         while i < num_to_insert {
-            #debug("get(%u) = %u", i, hm.get(i));
+            debug!{"get(%u) = %u", i, hm.get(i)};
             assert (hm.get(i) == i * i);
             i += 2u;
         }
-        #debug("-----");
+        debug!{"-----"};
         i = 1u;
         while i < num_to_insert {
-            #debug("get(%u) = %u", i, hm.get(i));
+            debug!{"get(%u) = %u", i, hm.get(i)};
             assert (hm.get(i) == i * i);
             i += 2u;
         }
-        #debug("-----");
+        debug!{"-----"};
         i = 0u;
         while i < num_to_insert {
             assert (hm.insert(i, i * i));
-            #debug("inserting %u -> %u", i, i*i);
+            debug!{"inserting %u -> %u", i, i*i};
             i += 2u;
         }
         assert (hm.size() == num_to_insert);
-        #debug("-----");
+        debug!{"-----"};
         i = 0u;
         while i < num_to_insert {
-            #debug("get(%u) = %u", i, hm.get(i));
+            debug!{"get(%u) = %u", i, hm.get(i)};
             assert (hm.get(i) == i * i);
             i += 1u;
         }
-        #debug("-----");
+        debug!{"-----"};
         assert (hm.size() == num_to_insert);
         i = 0u;
         while i < num_to_insert {
-            #debug("get(%u) = %u", i, hm.get(i));
+            debug!{"get(%u) = %u", i, hm.get(i)};
             assert (hm.get(i) == i * i);
             i += 1u;
         }
-        #debug("*** finished test_removal");
+        debug!{"*** finished test_removal"};
     }
 
     #[test]
diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs
index 6fb4b3c1b33..38b6d6194eb 100644
--- a/src/libstd/net_ip.rs
+++ b/src/libstd/net_ip.rs
@@ -92,7 +92,7 @@ fn get_addr(++node: ~str, iotask: iotask)
         -> result::result<~[ip_addr], ip_get_addr_err> unsafe {
     do comm::listen |output_ch| {
         do str::as_buf(node) |node_ptr, len| {
-            log(debug, #fmt("slice len %?", len));
+            log(debug, fmt!{"slice len %?", len});
             let handle = create_uv_getaddrinfo_t();
             let handle_ptr = ptr::addr_of(handle);
             let handle_data: get_addr_data = {
@@ -167,10 +167,10 @@ mod v4 {
             }
         });
         if vec::len(parts) != 4u {
-                result::err(#fmt("'%s' doesn't have 4 parts", ip))
+                result::err(fmt!{"'%s' doesn't have 4 parts", ip})
                 }
         else if vec::contains(parts, 256u) {
-                result::err(#fmt("invalid octal in addr '%s'", ip))
+                result::err(fmt!{"invalid octal in addr '%s'", ip})
                 }
         else {
             result::ok({a: parts[0] as u8, b: parts[1] as u8,
@@ -191,8 +191,8 @@ mod v4 {
 
             let new_addr = uv_ip4_addr(ip, 22);
             let reformatted_name = uv_ip4_name(&new_addr);
-            log(debug, #fmt("try_parse_addr: input ip: %s reparsed ip: %s",
-                            ip, reformatted_name));
+            log(debug, fmt!{"try_parse_addr: input ip: %s reparsed ip: %s",
+                            ip, reformatted_name});
             let ref_ip_rep_result = parse_to_ipv4_rep(reformatted_name);
             if result::is_err(ref_ip_rep_result) {
                 let err_str = result::get_err(ref_ip_rep_result);
@@ -238,13 +238,13 @@ mod v6 {
             // need to figure out how to establish a parse failure..
             let new_addr = uv_ip6_addr(ip, 22);
             let reparsed_name = uv_ip6_name(&new_addr);
-            log(debug, #fmt("v6::try_parse_addr ip: '%s' reparsed '%s'",
-                            ip, reparsed_name));
+            log(debug, fmt!{"v6::try_parse_addr ip: '%s' reparsed '%s'",
+                            ip, reparsed_name});
             // '::' appears to be uv_ip6_name() returns for bogus
             // parses..
             if  ip != ~"::" && reparsed_name == ~"::" {
-                result::err({err_msg:#fmt("failed to parse '%s'",
-                                           ip)})
+                result::err({err_msg:fmt!{"failed to parse '%s'",
+                                           ip}})
             }
             else {
                 result::ok(ipv6(new_addr))
@@ -265,7 +265,7 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
     if status == 0i32 {
         if res != (ptr::null::<addrinfo>()) {
             let mut out_vec = ~[];
-            log(debug, #fmt("initial addrinfo: %?", res));
+            log(debug, fmt!{"initial addrinfo: %?", res});
             let mut curr_addr = res;
             loop {
                 let new_ip_addr = if ll::is_ipv4_addrinfo(curr_addr) {
@@ -292,11 +292,11 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
                 }
                 else {
                     curr_addr = next_addr;
-                    log(debug, #fmt("next_addr addrinfo: %?", curr_addr));
+                    log(debug, fmt!{"next_addr addrinfo: %?", curr_addr});
                 }
             }
-            log(debug, #fmt("successful process addrinfo result, len: %?",
-                            vec::len(out_vec)));
+            log(debug, fmt!{"successful process addrinfo result, len: %?",
+                            vec::len(out_vec)});
             (*handle_data).output_ch.send(result::ok(out_vec));
         }
         else {
@@ -328,19 +328,19 @@ mod test {
     fn test_ip_ipv6_parse_and_format_ip() {
         let localhost_str = ~"::1";
         let format_result = format_addr(v6::parse_addr(localhost_str));
-        log(debug, #fmt("results: expected: '%s' actual: '%s'",
-            localhost_str, format_result));
+        log(debug, fmt!{"results: expected: '%s' actual: '%s'",
+            localhost_str, format_result});
         assert format_result == localhost_str;
     }
     #[test]
     fn test_ip_ipv4_bad_parse() {
         alt v4::try_parse_addr(~"b4df00d") {
           result::err(err_info) {
-            log(debug, #fmt("got error as expected %?", err_info));
+            log(debug, fmt!{"got error as expected %?", err_info});
             assert true;
           }
           result::ok(addr) {
-            fail #fmt("Expected failure, but got addr %?", addr);
+            fail fmt!{"Expected failure, but got addr %?", addr};
           }
         }
     }
@@ -349,11 +349,11 @@ mod test {
     fn test_ip_ipv6_bad_parse() {
         alt v6::try_parse_addr(~"::,~2234k;") {
           result::err(err_info) {
-            log(debug, #fmt("got error as expected %?", err_info));
+            log(debug, fmt!{"got error as expected %?", err_info});
             assert true;
           }
           result::ok(addr) {
-            fail #fmt("Expected failure, but got addr %?", addr);
+            fail fmt!{"Expected failure, but got addr %?", addr};
           }
         }
     }
@@ -369,8 +369,8 @@ mod test {
         // note really sure how to realiably test/assert
         // this.. mostly just wanting to see it work, atm.
         let results = result::unwrap(ga_result);
-        log(debug, #fmt("test_get_addr: Number of results for %s: %?",
-                        localhost_name, vec::len(results)));
+        log(debug, fmt!{"test_get_addr: Number of results for %s: %?",
+                        localhost_name, vec::len(results)});
         for vec::each(results) |r| {
             let ipv_prefix = alt r {
               ipv4(_) {
@@ -380,8 +380,8 @@ mod test {
                 ~"IPv6"
               }
             };
-            log(debug, #fmt("test_get_addr: result %s: '%s'",
-                            ipv_prefix, format_addr(r)));
+            log(debug, fmt!{"test_get_addr: result %s: '%s'",
+                            ipv_prefix, format_addr(r)});
         }
         // at least one result.. this is going to vary from system
         // to system, based on stuff like the contents of /etc/hosts
diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs
index 66f57757560..d70d9b40de8 100644
--- a/src/libstd/net_tcp.rs
+++ b/src/libstd/net_tcp.rs
@@ -142,15 +142,15 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
         iotask: iotask
     };
     let socket_data_ptr = ptr::addr_of(*socket_data);
-    log(debug, #fmt("tcp_connect result_ch %?", conn_data.result_ch));
+    log(debug, fmt!{"tcp_connect result_ch %?", conn_data.result_ch});
     // get an unsafe representation of our stream_handle_ptr that
     // we can send into the interact cb to be handled in libuv..
-    log(debug, #fmt("stream_handle_ptr outside interact %?",
-        stream_handle_ptr));
+    log(debug, fmt!{"stream_handle_ptr outside interact %?",
+        stream_handle_ptr});
     do iotask::interact(iotask) |loop_ptr| {
         log(debug, ~"in interact cb for tcp client connect..");
-        log(debug, #fmt("stream_handle_ptr in interact %?",
-            stream_handle_ptr));
+        log(debug, fmt!{"stream_handle_ptr in interact %?",
+            stream_handle_ptr});
         alt uv::ll::tcp_init( loop_ptr, stream_handle_ptr) {
           0i32 {
             log(debug, ~"tcp_init successful");
@@ -167,7 +167,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
                     // info.. should probably add an additional
                     // rust type that actually is closer to
                     // what the libuv API expects (ip str + port num)
-                    log(debug, #fmt("addr: %?", addr));
+                    log(debug, fmt!{"addr: %?", addr});
                     let in_addr = uv::ll::ip4_addr(addr_str, port as int);
                     uv::ll::tcp_connect(
                         connect_req_ptr,
@@ -176,7 +176,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
                         tcp_connect_on_connect_cb)
                   }
                   ip::ipv6(addr) {
-                    log(debug, #fmt("addr: %?", addr));
+                    log(debug, fmt!{"addr: %?", addr});
                     let in_addr = uv::ll::ip6_addr(addr_str, port as int);
                     uv::ll::tcp_connect6(
                         connect_req_ptr,
@@ -334,7 +334,7 @@ fn read_start(sock: tcp_socket)
 fn read_stop(sock: tcp_socket,
              -read_port: comm::port<result::result<~[u8], tcp_err_data>>) ->
     result::result<(), tcp_err_data> unsafe {
-    log(debug, #fmt("taking the read_port out of commission %?", read_port));
+    log(debug, fmt!{"taking the read_port out of commission %?", read_port});
     let socket_data = ptr::addr_of(*sock.socket_data);
     read_stop_common_impl(socket_data)
 }
@@ -622,13 +622,13 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
                 let addr_str = ip::format_addr(loc_ip);
                 let bind_result = alt loc_ip {
                   ip::ipv4(addr) {
-                    log(debug, #fmt("addr: %?", addr));
+                    log(debug, fmt!{"addr: %?", addr});
                     let in_addr = uv::ll::ip4_addr(addr_str, port as int);
                     uv::ll::tcp_bind(server_stream_ptr,
                                      ptr::addr_of(in_addr))
                   }
                   ip::ipv6(addr) {
-                    log(debug, #fmt("addr: %?", addr));
+                    log(debug, fmt!{"addr: %?", addr});
                     let in_addr = uv::ll::ip6_addr(addr_str, port as int);
                     uv::ll::tcp_bind6(server_stream_ptr,
                                      ptr::addr_of(in_addr))
@@ -668,8 +668,8 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
     alt setup_result {
       some(err_data) {
         do iotask::interact(iotask) |loop_ptr| {
-            log(debug, #fmt("tcp::listen post-kill recv hl interact %?",
-                            loop_ptr));
+            log(debug, fmt!{"tcp::listen post-kill recv hl interact %?",
+                            loop_ptr});
             (*server_data_ptr).active = false;
             uv::ll::close(server_stream_ptr, tcp_lfc_close_cb);
         };
@@ -684,8 +684,8 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
             result::err(address_in_use)
           }
           _ {
-            log(debug, #fmt("Got '%s' '%s' libuv error",
-                            err_data.err_name, err_data.err_msg));
+            log(debug, fmt!{"Got '%s' '%s' libuv error",
+                            err_data.err_name, err_data.err_msg});
             result::err(
                 generic_listen_err(err_data.err_name, err_data.err_msg))
           }
@@ -695,8 +695,8 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
         on_establish_cb(kill_ch);
         let kill_result = comm::recv(kill_po);
         do iotask::interact(iotask) |loop_ptr| {
-            log(debug, #fmt("tcp::listen post-kill recv hl interact %?",
-                            loop_ptr));
+            log(debug, fmt!{"tcp::listen post-kill recv hl interact %?",
+                            loop_ptr});
             (*server_data_ptr).active = false;
             uv::ll::close(server_stream_ptr, tcp_lfc_close_cb);
         };
@@ -776,8 +776,8 @@ impl tcp_socket_buf of io::reader for @tcp_socket_buf {
                 if err_data.err_name == ~"EOF" {
                     break;
                 } else {
-                    #debug("ERROR sock_buf as io::reader.read err %? %?",
-                           err_data.err_name, err_data.err_msg);
+                    debug!{"ERROR sock_buf as io::reader.read err %? %?",
+                           err_data.err_name, err_data.err_msg};
 
                     ret 0;
                 }
@@ -809,7 +809,7 @@ impl tcp_socket_buf of io::reader for @tcp_socket_buf {
         false // noop
     }
     fn seek(dist: int, seek: io::seek_style) {
-        log(debug, #fmt("tcp_socket_buf seek stub %? %?", dist, seek));
+        log(debug, fmt!{"tcp_socket_buf seek stub %? %?", dist, seek});
         // noop
     }
     fn tell() -> uint {
@@ -826,12 +826,12 @@ impl tcp_socket_buf of io::writer for @tcp_socket_buf {
                                         vec::slice(data, 0, vec::len(data)));
         if w_result.is_err() {
             let err_data = w_result.get_err();
-            log(debug, #fmt("ERROR sock_buf as io::writer.writer err: %? %?",
-                             err_data.err_name, err_data.err_msg));
+            log(debug, fmt!{"ERROR sock_buf as io::writer.writer err: %? %?",
+                             err_data.err_name, err_data.err_msg});
         }
     }
     fn seek(dist: int, seek: io::seek_style) {
-      log(debug, #fmt("tcp_socket_buf seek stub %? %?", dist, seek));
+      log(debug, fmt!{"tcp_socket_buf seek stub %? %?", dist, seek});
         // noop
     }
     fn tell() -> uint {
@@ -856,14 +856,14 @@ fn tear_down_socket_data(socket_data: @tcp_socket_data) unsafe {
     let close_data_ptr = ptr::addr_of(close_data);
     let stream_handle_ptr = (*socket_data).stream_handle_ptr;
     do iotask::interact((*socket_data).iotask) |loop_ptr| {
-        log(debug, #fmt("interact dtor for tcp_socket stream %? loop %?",
-            stream_handle_ptr, loop_ptr));
+        log(debug, fmt!{"interact dtor for tcp_socket stream %? loop %?",
+            stream_handle_ptr, loop_ptr});
         uv::ll::set_data_for_uv_handle(stream_handle_ptr,
                                        close_data_ptr);
         uv::ll::close(stream_handle_ptr, tcp_socket_dtor_close_cb);
     };
     comm::recv(closed_po);
-    log(debug, #fmt("about to free socket_data at %?", socket_data));
+    log(debug, fmt!{"about to free socket_data at %?", socket_data});
     rustrt::rust_uv_current_kernel_free(stream_handle_ptr
                                        as *libc::c_void);
     log(debug, ~"exiting dtor for tcp_socket");
@@ -946,7 +946,7 @@ fn read_start_common_impl(socket_data: *tcp_socket_data)
     let start_ch = comm::chan(start_po);
     log(debug, ~"in tcp::read_start before interact loop");
     do iotask::interact((*socket_data).iotask) |loop_ptr| {
-        log(debug, #fmt("in tcp::read_start interact cb %?", loop_ptr));
+        log(debug, fmt!{"in tcp::read_start interact cb %?", loop_ptr});
         alt uv::ll::read_start(stream_handle_ptr as *uv::ll::uv_stream_t,
                                on_alloc_cb,
                                on_tcp_read_cb) {
@@ -990,7 +990,7 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data,
     };
     let write_data_ptr = ptr::addr_of(write_data);
     do iotask::interact((*socket_data_ptr).iotask) |loop_ptr| {
-        log(debug, #fmt("in interact cb for tcp::write %?", loop_ptr));
+        log(debug, fmt!{"in interact cb for tcp::write %?", loop_ptr});
         alt uv::ll::write(write_req_ptr,
                           stream_handle_ptr,
                           write_buf_vec_ptr,
@@ -1096,8 +1096,8 @@ impl of to_tcp_err_iface for uv::ll::uv_err_data {
 extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t,
                     nread: libc::ssize_t,
                     ++buf: uv::ll::uv_buf_t) unsafe {
-    log(debug, #fmt("entering on_tcp_read_cb stream: %? nread: %?",
-                    stream, nread));
+    log(debug, fmt!{"entering on_tcp_read_cb stream: %? nread: %?",
+                    stream, nread});
     let loop_ptr = uv::ll::get_loop_for_uv_handle(stream);
     let socket_data_ptr = uv::ll::get_data_for_uv_handle(stream)
         as *tcp_socket_data;
@@ -1105,8 +1105,8 @@ extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t,
       // incoming err.. probably eof
       -1 {
         let err_data = uv::ll::get_last_err_data(loop_ptr).to_tcp_err();
-        log(debug, #fmt("on_tcp_read_cb: incoming err.. name %? msg %?",
-                        err_data.err_name, err_data.err_msg));
+        log(debug, fmt!{"on_tcp_read_cb: incoming err.. name %? msg %?",
+                        err_data.err_name, err_data.err_msg});
         let reader_ch = (*socket_data_ptr).reader_ch;
         comm::send(reader_ch, result::err(err_data));
       }
@@ -1115,7 +1115,7 @@ extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t,
       // have data
       _ {
         // we have data
-        log(debug, #fmt("tcp on_read_cb nread: %d", nread as int));
+        log(debug, fmt!{"tcp on_read_cb nread: %d", nread as int});
         let reader_ch = (*socket_data_ptr).reader_ch;
         let buf_base = uv::ll::get_base_from_buf(buf);
         let new_bytes = vec::unsafe::from_buf(buf_base, nread as uint);
@@ -1131,10 +1131,10 @@ extern fn on_alloc_cb(handle: *libc::c_void,
     -> uv::ll::uv_buf_t unsafe {
     log(debug, ~"tcp read on_alloc_cb!");
     let char_ptr = uv::ll::malloc_buf_base_of(suggested_size);
-    log(debug, #fmt("tcp read on_alloc_cb h: %? char_ptr: %u sugsize: %u",
+    log(debug, fmt!{"tcp read on_alloc_cb h: %? char_ptr: %u sugsize: %u",
                      handle,
                      char_ptr as uint,
-                     suggested_size as uint));
+                     suggested_size as uint});
     uv::ll::buf_init(char_ptr, suggested_size as uint)
 }
 
@@ -1180,11 +1180,11 @@ extern fn stream_error_close_cb(handle: *uv::ll::uv_tcp_t) unsafe {
     let data = uv::ll::get_data_for_uv_handle(handle) as
         *connect_req_data;
     comm::send((*data).closed_signal_ch, ());
-    log(debug, #fmt("exiting steam_error_close_cb for %?", handle));
+    log(debug, fmt!{"exiting steam_error_close_cb for %?", handle});
 }
 
 extern fn tcp_connect_close_cb(handle: *uv::ll::uv_tcp_t) unsafe {
-    log(debug, #fmt("closed client tcp handle %?", handle));
+    log(debug, fmt!{"closed client tcp handle %?", handle});
 }
 
 extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t,
@@ -1192,7 +1192,7 @@ extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t,
     let conn_data_ptr = (uv::ll::get_data_for_req(connect_req_ptr)
                       as *connect_req_data);
     let result_ch = (*conn_data_ptr).result_ch;
-    log(debug, #fmt("tcp_connect result_ch %?", result_ch));
+    log(debug, fmt!{"tcp_connect result_ch %?", result_ch});
     let tcp_stream_ptr =
         uv::ll::get_stream_handle_from_connect_req(connect_req_ptr);
     alt status {
@@ -1204,8 +1204,8 @@ extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t,
         log(debug, ~"error in tcp_connect_on_connect_cb");
         let loop_ptr = uv::ll::get_loop_for_uv_handle(tcp_stream_ptr);
         let err_data = uv::ll::get_last_err_data(loop_ptr);
-        log(debug, #fmt("err_data %? %?", err_data.err_name,
-                        err_data.err_msg));
+        log(debug, fmt!{"err_data %? %?", err_data.err_name,
+                        err_data.err_msg});
         comm::send(result_ch, conn_failure(err_data));
         uv::ll::set_data_for_uv_handle(tcp_stream_ptr,
                                        conn_data_ptr);
@@ -1334,10 +1334,10 @@ mod test {
         assert actual_resp_result.is_ok();
         let actual_resp = actual_resp_result.get();
         let actual_req = comm::recv(server_result_po);
-        log(debug, #fmt("REQ: expected: '%s' actual: '%s'",
-                       expected_req, actual_req));
-        log(debug, #fmt("RESP: expected: '%s' actual: '%s'",
-                       expected_resp, actual_resp));
+        log(debug, fmt!{"REQ: expected: '%s' actual: '%s'",
+                       expected_req, actual_req});
+        log(debug, fmt!{"RESP: expected: '%s' actual: '%s'",
+                       expected_resp, actual_resp});
         assert str::contains(actual_req, expected_req);
         assert str::contains(actual_resp, expected_resp);
     }
@@ -1476,27 +1476,27 @@ mod test {
         };
 
         let actual_req = comm::recv(server_result_po);
-        log(debug, #fmt("REQ: expected: '%s' actual: '%s'",
-                       expected_req, actual_req));
-        log(debug, #fmt("RESP: expected: '%s' actual: '%s'",
-                       expected_resp, actual_resp));
+        log(debug, fmt!{"REQ: expected: '%s' actual: '%s'",
+                       expected_req, actual_req});
+        log(debug, fmt!{"RESP: expected: '%s' actual: '%s'",
+                       expected_resp, actual_resp});
         assert str::contains(actual_req, expected_req);
         assert str::contains(actual_resp, expected_resp);
     }
 
     fn buf_write(+w: io::writer, val: ~str) {
-        log(debug, #fmt("BUF_WRITE: val len %?", str::len(val)));
+        log(debug, fmt!{"BUF_WRITE: val len %?", str::len(val)});
         do str::byte_slice(val) |b_slice| {
-            log(debug, #fmt("BUF_WRITE: b_slice len %?",
-                            vec::len(b_slice)));
+            log(debug, fmt!{"BUF_WRITE: b_slice len %?",
+                            vec::len(b_slice)});
             w.write(b_slice)
         }
     }
 
     fn buf_read(+r: io::reader, len: uint) -> ~str {
         let new_bytes = r.read_bytes(len);
-        log(debug, #fmt("in buf_read.. new_bytes len: %?",
-                        vec::len(new_bytes)));
+        log(debug, fmt!{"in buf_read.. new_bytes len: %?",
+                        vec::len(new_bytes)});
         str::from_bytes(new_bytes)
     }
 
@@ -1508,8 +1508,8 @@ mod test {
         let listen_result = listen(server_ip_addr, server_port, 128u, iotask,
             // on_establish_cb -- called when listener is set up
             |kill_ch| {
-                log(debug, #fmt("establish_cb %?",
-                    kill_ch));
+                log(debug, fmt!{"establish_cb %?",
+                    kill_ch});
                 comm::send(cont_ch, ());
             },
             // risky to run this on the loop, but some users
@@ -1541,8 +1541,8 @@ mod test {
                         alt received_req_bytes {
                           result::ok(data) {
                             log(debug, ~"SERVER: got REQ str::from_bytes..");
-                            log(debug, #fmt("SERVER: REQ data len: %?",
-                                            vec::len(data)));
+                            log(debug, fmt!{"SERVER: REQ data len: %?",
+                                            vec::len(data)});
                             server_ch.send(
                                 str::from_bytes(data));
                             log(debug, ~"SERVER: before write");
@@ -1551,8 +1551,8 @@ mod test {
                             comm::send(kill_ch, none);
                           }
                           result::err(err_data) {
-                            log(debug, #fmt("SERVER: error recvd: %s %s",
-                                err_data.err_name, err_data.err_msg));
+                            log(debug, fmt!{"SERVER: error recvd: %s %s",
+                                err_data.err_name, err_data.err_msg});
                             comm::send(kill_ch, some(err_data));
                             server_ch.send(~"");
                           }
@@ -1569,8 +1569,8 @@ mod test {
         if result::is_err(listen_result) {
             alt result::get_err(listen_result) {
               generic_listen_err(name, msg) {
-                fail #fmt("SERVER: exited abnormally name %s msg %s",
-                                name, msg);
+                fail fmt!{"SERVER: exited abnormally name %s msg %s",
+                                name, msg};
               }
               access_denied {
                 fail ~"SERVER: exited abnormally, got access denied..";
@@ -1581,7 +1581,7 @@ mod test {
             }
         }
         let ret_val = server_ch.recv();
-        log(debug, #fmt("SERVER: exited and got ret val: '%s'", ret_val));
+        log(debug, fmt!{"SERVER: exited and got ret val: '%s'", ret_val});
         ret_val
     }
 
@@ -1591,12 +1591,12 @@ mod test {
         let listen_result = listen(server_ip_addr, server_port, 128u, iotask,
             // on_establish_cb -- called when listener is set up
             |kill_ch| {
-                log(debug, #fmt("establish_cb %?",
-                    kill_ch));
+                log(debug, fmt!{"establish_cb %?",
+                    kill_ch});
             },
             |new_conn, kill_ch| {
-                fail #fmt("SERVER: shouldn't be called.. %? %?",
-                           new_conn, kill_ch);
+                fail fmt!{"SERVER: shouldn't be called.. %? %?",
+                           new_conn, kill_ch};
         });
         // err check on listen_result
         if result::is_err(listen_result) {
@@ -1632,8 +1632,8 @@ mod test {
             else {
                 client_ch.send(str::from_bytes(read_result.get()));
                 let ret_val = client_ch.recv();
-                log(debug, #fmt("CLIENT: after client_ch recv ret: '%s'",
-                   ret_val));
+                log(debug, fmt!{"CLIENT: after client_ch recv ret: '%s'",
+                   ret_val});
                 ok(ret_val)
             }
         }
@@ -1645,8 +1645,8 @@ mod test {
         if result::is_err(write_result) {
             log(debug, ~"tcp_write_single: write failed!");
             let err_data = result::get_err(write_result);
-            log(debug, #fmt("tcp_write_single err name: %s msg: %s",
-                err_data.err_name, err_data.err_msg));
+            log(debug, fmt!{"tcp_write_single err name: %s msg: %s",
+                err_data.err_name, err_data.err_msg});
             // meh. torn on what to do here.
             fail ~"tcp_write_single failed";
         }
diff --git a/src/libstd/net_url.rs b/src/libstd/net_url.rs
index 3a3aae1ef6d..928f8bc9399 100644
--- a/src/libstd/net_url.rs
+++ b/src/libstd/net_url.rs
@@ -72,7 +72,7 @@ fn query_to_str(query: query) -> ~str {
     let mut strvec = ~[];
     for query.each |kv| {
         let (k, v) = kv;
-        strvec += ~[#fmt("%s=%s", k, v)];
+        strvec += ~[fmt!{"%s=%s", k, v}];
     };
     ret str::connect(strvec, ~"&");
 }
diff --git a/src/libstd/par.rs b/src/libstd/par.rs
index 3c05a0b5574..65aa077ef87 100644
--- a/src/libstd/par.rs
+++ b/src/libstd/par.rs
@@ -53,11 +53,11 @@ fn map_slices<A: copy send, B: copy send>(
                         let len = end - base;
                         let slice = (ptr::offset(p, base),
                                      len * sys::size_of::<A>());
-                        log(info, #fmt("pre-slice: %?", (base, slice)));
+                        log(info, fmt!{"pre-slice: %?", (base, slice)});
                         let slice : &[A] =
                             unsafe::reinterpret_cast(slice);
-                        log(info, #fmt("slice: %?",
-                                       (base, vec::len(slice), end - base)));
+                        log(info, fmt!{"slice: %?",
+                                       (base, vec::len(slice), end - base)});
                         assert(vec::len(slice) == end - base);
                         f(base, slice)
                     }
@@ -68,7 +68,7 @@ fn map_slices<A: copy send, B: copy send>(
         }
         log(info, ~"tasks spawned");
 
-        log(info, #fmt("num_tasks: %?", (num_tasks, futures.len())));
+        log(info, fmt!{"num_tasks: %?", (num_tasks, futures.len())});
         assert(num_tasks == futures.len());
 
         let r = do futures.map() |ys| {
diff --git a/src/libstd/prettyprint.rs b/src/libstd/prettyprint.rs
index dbeb5ab6381..6122474c06d 100644
--- a/src/libstd/prettyprint.rs
+++ b/src/libstd/prettyprint.rs
@@ -8,63 +8,63 @@ impl of serializer for writer {
     }
 
     fn emit_uint(v: uint) {
-        self.write_str(#fmt["%?u", v]);
+        self.write_str(fmt!{"%?u", v});
     }
 
     fn emit_u64(v: u64) {
-        self.write_str(#fmt["%?_u64", v]);
+        self.write_str(fmt!{"%?_u64", v});
     }
 
     fn emit_u32(v: u32) {
-        self.write_str(#fmt["%?_u32", v]);
+        self.write_str(fmt!{"%?_u32", v});
     }
 
     fn emit_u16(v: u16) {
-        self.write_str(#fmt["%?_u16", v]);
+        self.write_str(fmt!{"%?_u16", v});
     }
 
     fn emit_u8(v: u8) {
-        self.write_str(#fmt["%?_u8", v]);
+        self.write_str(fmt!{"%?_u8", v});
     }
 
     fn emit_int(v: int) {
-        self.write_str(#fmt["%?", v]);
+        self.write_str(fmt!{"%?", v});
     }
 
     fn emit_i64(v: i64) {
-        self.write_str(#fmt["%?_i64", v]);
+        self.write_str(fmt!{"%?_i64", v});
     }
 
     fn emit_i32(v: i32) {
-        self.write_str(#fmt["%?_i32", v]);
+        self.write_str(fmt!{"%?_i32", v});
     }
 
     fn emit_i16(v: i16) {
-        self.write_str(#fmt["%?_i16", v]);
+        self.write_str(fmt!{"%?_i16", v});
     }
 
     fn emit_i8(v: i8) {
-        self.write_str(#fmt["%?_i8", v]);
+        self.write_str(fmt!{"%?_i8", v});
     }
 
     fn emit_bool(v: bool) {
-        self.write_str(#fmt["%b", v]);
+        self.write_str(fmt!{"%b", v});
     }
 
     fn emit_float(v: float) {
-        self.write_str(#fmt["%?_f", v]);
+        self.write_str(fmt!{"%?_f", v});
     }
 
     fn emit_f64(v: f64) {
-        self.write_str(#fmt["%?_f64", v]);
+        self.write_str(fmt!{"%?_f64", v});
     }
 
     fn emit_f32(v: f32) {
-        self.write_str(#fmt["%?_f32", v]);
+        self.write_str(fmt!{"%?_f32", v});
     }
 
     fn emit_str(v: ~str) {
-        self.write_str(#fmt["%?", v]);
+        self.write_str(fmt!{"%?", v});
     }
 
     fn emit_enum(_name: ~str, f: fn()) {
diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs
index 0325ef3ac2e..37f829396ab 100644
--- a/src/libstd/smallintmap.rs
+++ b/src/libstd/smallintmap.rs
@@ -27,7 +27,7 @@ fn mk<T: copy>() -> smallintmap<T> {
  */
 #[inline(always)]
 fn insert<T: copy>(self: smallintmap<T>, key: uint, val: T) {
-    //io::println(#fmt("%?", key));
+    //io::println(fmt!{"%?", key});
     self.v.grow_set_elt(key, none, some(val));
 }
 
@@ -49,7 +49,7 @@ pure fn find<T: copy>(self: smallintmap<T>, key: uint) -> option<T> {
  */
 pure fn get<T: copy>(self: smallintmap<T>, key: uint) -> T {
     alt find(self, key) {
-      none { #error("smallintmap::get(): key not present"); fail; }
+      none { error!{"smallintmap::get(): key not present"}; fail; }
       some(v) { ret v; }
     }
 }
diff --git a/src/libstd/sort.rs b/src/libstd/sort.rs
index 6558e14c84d..95dbf5f97dc 100644
--- a/src/libstd/sort.rs
+++ b/src/libstd/sort.rs
@@ -253,7 +253,7 @@ mod test_qsort {
         let pairs = vec::zip(expected, immut_names);
         for vec::each(pairs) |p| {
             let (a, b) = p;
-            #debug("%d %d", a, b);
+            debug!{"%d %d", a, b};
             assert (a == b);
         }
     }
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index 218c32a1980..f9e4f94ed80 100644
--- a/src/libstd/test.rs
+++ b/src/libstd/test.rs
@@ -109,9 +109,9 @@ fn run_tests_console(opts: test_opts,
           te_filtered(filtered_tests) {
             st.total = vec::len(filtered_tests);
             let noun = if st.total != 1u { ~"tests" } else { ~"test" };
-            st.out.write_line(#fmt["\nrunning %u %s", st.total, noun]);
+            st.out.write_line(fmt!{"\nrunning %u %s", st.total, noun});
           }
-          te_wait(test) { st.out.write_str(#fmt["test %s ... ", test.name]); }
+          te_wait(test) { st.out.write_str(fmt!{"test %s ... ", test.name}); }
           te_result(test, result) {
             alt st.log_out {
                 some(f) {
@@ -146,7 +146,7 @@ fn run_tests_console(opts: test_opts,
             alt io::file_writer(path, ~[io::create, io::truncate]) {
                 result::ok(w) { some(w) }
                 result::err(s) {
-                    fail(#fmt("can't open output file: %s", s))
+                    fail(fmt!{"can't open output file: %s", s})
                 }
             }
         }
@@ -172,23 +172,23 @@ fn run_tests_console(opts: test_opts,
         print_failures(st);
     }
 
-    st.out.write_str(#fmt["\nresult: "]);
+    st.out.write_str(fmt!{"\nresult: "});
     if success {
         // There's no parallelism at this point so it's safe to use color
         write_ok(st.out, true);
     } else { write_failed(st.out, true); }
-    st.out.write_str(#fmt[". %u passed; %u failed; %u ignored\n\n", st.passed,
-                          st.failed, st.ignored]);
+    st.out.write_str(fmt!{". %u passed; %u failed; %u ignored\n\n", st.passed,
+                          st.failed, st.ignored});
 
     ret success;
 
     fn write_log(out: io::writer, result: test_result, test: test_desc) {
-        out.write_line(#fmt("%s %s",
+        out.write_line(fmt!{"%s %s",
                     alt result {
                         tr_ok { ~"ok" }
                         tr_failed { ~"failed" }
                         tr_ignored { ~"ignored" }
-                    }, test.name));
+                    }, test.name});
     }
 
     fn write_ok(out: io::writer, use_color: bool) {
@@ -220,7 +220,7 @@ fn print_failures(st: console_test_state) {
     let failures = vec::map(failures, |test| test.name);
     let failures = sort::merge_sort(str::le, failures);
     for vec::each(failures) |name| {
-        st.out.write_line(#fmt["    %s", name]);
+        st.out.write_line(fmt!{"    %s", name});
     }
 }
 
@@ -281,7 +281,7 @@ fn run_tests(opts: test_opts, tests: ~[test_desc],
     // It's tempting to just spawn all the tests at once, but since we have
     // many tests that run in other processes we would be making a big mess.
     let concurrency = get_concurrency();
-    #debug("using %u test tasks", concurrency);
+    debug!{"using %u test tasks", concurrency};
 
     let total = vec::len(filtered_tests);
     let mut run_idx = 0u;
diff --git a/src/libstd/time.rs b/src/libstd/time.rs
index 8680719c9b9..7cbf16f2ec0 100644
--- a/src/libstd/time.rs
+++ b/src/libstd/time.rs
@@ -200,9 +200,9 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
         if c == ch {
             ok(next)
         } else {
-            err(#fmt("Expected %?, found %?",
+            err(fmt!{"Expected %?, found %?",
                 str::from_char(c),
-                str::from_char(ch)))
+                str::from_char(ch)})
         }
     }
 
@@ -525,7 +525,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
           }
           '%' { parse_char(s, pos, '%') }
           ch {
-            err(#fmt("unknown formatting type: %?", str::from_char(ch)))
+            err(fmt!{"unknown formatting type: %?", str::from_char(ch)})
           }
         }
     }
@@ -643,70 +643,70 @@ fn strftime(format: ~str, tm: tm) -> ~str {
               11 { ~"Dec" }
             }
           }
-          'C' { #fmt("%02d", (tm.tm_year as int + 1900) / 100) }
+          'C' { fmt!{"%02d", (tm.tm_year as int + 1900) / 100} }
           'c' {
-            #fmt("%s %s %s %s %s",
+            fmt!{"%s %s %s %s %s",
                 parse_type('a', tm),
                 parse_type('b', tm),
                 parse_type('e', tm),
                 parse_type('T', tm),
-                parse_type('Y', tm))
+                parse_type('Y', tm)}
           }
           'D' | 'x' {
-            #fmt("%s/%s/%s",
+            fmt!{"%s/%s/%s",
                 parse_type('m', tm),
                 parse_type('d', tm),
-                parse_type('y', tm))
+                parse_type('y', tm)}
           }
-          'd' { #fmt("%02d", tm.tm_mday as int) }
-          'e' { #fmt("%2d", tm.tm_mday as int) }
+          'd' { fmt!{"%02d", tm.tm_mday as int} }
+          'e' { fmt!{"%2d", tm.tm_mday as int} }
           'F' {
-            #fmt("%s-%s-%s",
+            fmt!{"%s-%s-%s",
                 parse_type('Y', tm),
                 parse_type('m', tm),
-                parse_type('d', tm))
+                parse_type('d', tm)}
           }
           //'G' {}
           //'g' {}
-          'H' { #fmt("%02d", tm.tm_hour as int) }
+          'H' { fmt!{"%02d", tm.tm_hour as int} }
           'I' {
             let mut h = tm.tm_hour as int;
             if h == 0 { h = 12 }
             if h > 12 { h -= 12 }
-            #fmt("%02d", h)
+            fmt!{"%02d", h}
           }
-          'j' { #fmt("%03d", tm.tm_yday as int + 1) }
-          'k' { #fmt("%2d", tm.tm_hour as int) }
+          'j' { fmt!{"%03d", tm.tm_yday as int + 1} }
+          'k' { fmt!{"%2d", tm.tm_hour as int} }
           'l' {
             let mut h = tm.tm_hour as int;
             if h == 0 { h = 12 }
             if h > 12 { h -= 12 }
-            #fmt("%2d", h)
+            fmt!{"%2d", h}
           }
-          'M' { #fmt("%02d", tm.tm_min as int) }
-          'm' { #fmt("%02d", tm.tm_mon as int + 1) }
+          'M' { fmt!{"%02d", tm.tm_min as int} }
+          'm' { fmt!{"%02d", tm.tm_mon as int + 1} }
           'n' { ~"\n" }
           'P' { if tm.tm_hour as int < 12 { ~"am" } else { ~"pm" } }
           'p' { if tm.tm_hour as int < 12 { ~"AM" } else { ~"PM" } }
           'R' {
-            #fmt("%s:%s",
+            fmt!{"%s:%s",
                 parse_type('H', tm),
-                parse_type('M', tm))
+                parse_type('M', tm)}
           }
           'r' {
-            #fmt("%s:%s:%s %s",
+            fmt!{"%s:%s:%s %s",
                 parse_type('I', tm),
                 parse_type('M', tm),
                 parse_type('S', tm),
-                parse_type('p', tm))
+                parse_type('p', tm)}
           }
-          'S' { #fmt("%02d", tm.tm_sec as int) }
-          's' { #fmt("%d", tm.to_timespec().sec as int) }
+          'S' { fmt!{"%02d", tm.tm_sec as int} }
+          's' { fmt!{"%d", tm.to_timespec().sec as int} }
           'T' | 'X' {
-            #fmt("%s:%s:%s",
+            fmt!{"%s:%s:%s",
                 parse_type('H', tm),
                 parse_type('M', tm),
-                parse_type('S', tm))
+                parse_type('S', tm)}
           }
           't' { ~"\t" }
           //'U' {}
@@ -716,24 +716,24 @@ fn strftime(format: ~str, tm: tm) -> ~str {
           }
           //'V' {}
           'v' {
-            #fmt("%s-%s-%s",
+            fmt!{"%s-%s-%s",
                 parse_type('e', tm),
                 parse_type('b', tm),
-                parse_type('Y', tm))
+                parse_type('Y', tm)}
           }
           //'W' {}
           'w' { int::str(tm.tm_wday as int) }
           //'X' {}
           //'x' {}
           'Y' { int::str(tm.tm_year as int + 1900) }
-          'y' { #fmt("%02d", (tm.tm_year as int + 1900) % 100) }
+          'y' { fmt!{"%02d", (tm.tm_year as int + 1900) % 100} }
           'Z' { tm.tm_zone }
           'z' {
             let sign = if tm.tm_gmtoff > 0_i32 { '+' } else { '-' };
             let mut m = i32::abs(tm.tm_gmtoff) / 60_i32;
             let h = m / 60_i32;
             m -= h * 60_i32;
-            #fmt("%c%02d%02d", sign, h as int, m as int)
+            fmt!{"%c%02d%02d", sign, h as int, m as int}
           }
           //'+' {}
           '%' { ~"%" }
@@ -824,7 +824,7 @@ impl tm for tm {
             let mut m = i32::abs(self.tm_gmtoff) / 60_i32;
             let h = m / 60_i32;
             m -= h * 60_i32;
-            s + #fmt("%c%02d:%02d", sign, h as int, m as int)
+            s + fmt!{"%c%02d:%02d", sign, h as int, m as int}
         }
     }
 }
@@ -905,7 +905,7 @@ mod tests {
         let time = { sec: 1234567890_i64, nsec: 54321_i32 };
         let local = at(time);
 
-        #error("time_at: %?", local);
+        error!{"time_at: %?", local};
 
         assert local.tm_sec == 30_i32;
         assert local.tm_min == 31_i32;
@@ -1111,7 +1111,7 @@ mod tests {
         let utc   = at_utc(time);
         let local = at(time);
 
-        #error("test_ctime: %? %?", utc.ctime(), local.ctime());
+        error!{"test_ctime: %? %?", utc.ctime(), local.ctime()};
 
         assert utc.ctime()   == ~"Fri Feb 13 23:31:30 2009";
         assert local.ctime() == ~"Fri Feb 13 15:31:30 2009";
diff --git a/src/libstd/timer.rs b/src/libstd/timer.rs
index b72e2c47539..6b0b4eb2f17 100644
--- a/src/libstd/timer.rs
+++ b/src/libstd/timer.rs
@@ -106,8 +106,8 @@ fn recv_timeout<T: copy send>(iotask: iotask,
     // FIXME: This could be written clearer (#2618)
     either::either(
         |left_val| {
-            log(debug, #fmt("recv_time .. left_val %?",
-                           left_val));
+            log(debug, fmt!{"recv_time .. left_val %?",
+                           left_val});
             none
         }, |right_val| {
             some(right_val)
@@ -118,7 +118,7 @@ fn recv_timeout<T: copy send>(iotask: iotask,
 // INTERNAL API
 extern fn delayed_send_cb(handle: *uv::ll::uv_timer_t,
                                 status: libc::c_int) unsafe {
-    log(debug, #fmt("delayed_send_cb handle %? status %?", handle, status));
+    log(debug, fmt!{"delayed_send_cb handle %? status %?", handle, status});
     let timer_done_ch =
         *(uv::ll::get_data_for_uv_handle(handle) as *comm::chan<()>);
     let stop_result = uv::ll::timer_stop(handle);
@@ -134,7 +134,7 @@ extern fn delayed_send_cb(handle: *uv::ll::uv_timer_t,
 }
 
 extern fn delayed_send_close_cb(handle: *uv::ll::uv_timer_t) unsafe {
-    log(debug, #fmt("delayed_send_close_cb handle %?", handle));
+    log(debug, fmt!{"delayed_send_close_cb handle %?", handle});
     let timer_done_ch =
         *(uv::ll::get_data_for_uv_handle(handle) as *comm::chan<()>);
     comm::send(timer_done_ch, ());
diff --git a/src/libstd/uv_global_loop.rs b/src/libstd/uv_global_loop.rs
index 08096135952..d3b9795b85b 100644
--- a/src/libstd/uv_global_loop.rs
+++ b/src/libstd/uv_global_loop.rs
@@ -36,43 +36,43 @@ fn get_monitor_task_gl() -> iotask unsafe {
 
     let monitor_loop_chan_ptr = rustrt::rust_uv_get_kernel_global_chan_ptr();
 
-    #debug("ENTERING global_loop::get() loop chan: %?",
-           monitor_loop_chan_ptr);
+    debug!{"ENTERING global_loop::get() loop chan: %?",
+           monitor_loop_chan_ptr};
 
     let builder_fn = || {
         task::task().sched_mode(task::single_threaded).unlinked()
     };
 
-    #debug("before priv::chan_from_global_ptr");
+    debug!{"before priv::chan_from_global_ptr"};
     type monchan = chan<iotask>;
 
     let monitor_ch = do chan_from_global_ptr::<monchan>(monitor_loop_chan_ptr,
                                                         builder_fn) |msg_po| {
-        #debug("global monitor task starting");
+        debug!{"global monitor task starting"};
 
         // As a weak task the runtime will notify us when to exit
         do weaken_task() |weak_exit_po| {
-            #debug("global monitor task is now weak");
+            debug!{"global monitor task is now weak"};
             let hl_loop = spawn_loop();
             loop {
-                #debug("in outer_loop...");
+                debug!{"in outer_loop..."};
                 alt select2(weak_exit_po, msg_po) {
                   left(weak_exit) {
                     // all normal tasks have ended, tell the
                     // libuv loop to tear_down, then exit
-                    #debug("weak_exit_po recv'd msg: %?", weak_exit);
+                    debug!{"weak_exit_po recv'd msg: %?", weak_exit};
                     iotask::exit(hl_loop);
                     break;
                   }
                   right(fetch_ch) {
-                    #debug("hl_loop req recv'd: %?", fetch_ch);
+                    debug!{"hl_loop req recv'd: %?", fetch_ch};
                     fetch_ch.send(hl_loop);
                   }
                 }
             }
-            #debug("global monitor task is leaving weakend state");
+            debug!{"global monitor task is leaving weakend state"};
         };
-        #debug("global monitor task exiting");
+        debug!{"global monitor task exiting"};
     };
 
     // once we have a chan to the monitor loop, we ask it for
@@ -89,14 +89,14 @@ fn spawn_loop() -> iotask unsafe {
             // The I/O loop task also needs to be weak so it doesn't keep
             // the runtime alive
             do weaken_task |weak_exit_po| {
-                #debug("global libuv task is now weak %?", weak_exit_po);
+                debug!{"global libuv task is now weak %?", weak_exit_po};
                 task_body();
 
                 // We don't wait for the exit message on weak_exit_po
                 // because the monitor task will tell the uv loop when to
                 // exit
 
-                #debug("global libuv task is leaving weakened state");
+                debug!{"global libuv task is leaving weakened state"};
             }
         }
     };
@@ -110,8 +110,8 @@ mod test {
             timer_ptr as *libc::c_void) as *comm::chan<bool>;
         let exit_ch = *exit_ch_ptr;
         comm::send(exit_ch, true);
-        log(debug, #fmt("EXIT_CH_PTR simple_timer_close_cb exit_ch_ptr: %?",
-                       exit_ch_ptr));
+        log(debug, fmt!{"EXIT_CH_PTR simple_timer_close_cb exit_ch_ptr: %?",
+                       exit_ch_ptr});
     }
     extern fn simple_timer_cb(timer_ptr: *ll::uv_timer_t,
                              _status: libc::c_int) unsafe {
@@ -131,8 +131,8 @@ mod test {
         let exit_po = comm::port::<bool>();
         let exit_ch = comm::chan(exit_po);
         let exit_ch_ptr = ptr::addr_of(exit_ch);
-        log(debug, #fmt("EXIT_CH_PTR newly created exit_ch_ptr: %?",
-                       exit_ch_ptr));
+        log(debug, fmt!{"EXIT_CH_PTR newly created exit_ch_ptr: %?",
+                       exit_ch_ptr});
         let timer_handle = ll::timer_t();
         let timer_ptr = ptr::addr_of(timer_handle);
         do iotask::interact(iotask) |loop_ptr| {
diff --git a/src/libstd/uv_iotask.rs b/src/libstd/uv_iotask.rs
index 5566c0c8f0f..bc9878ccc40 100644
--- a/src/libstd/uv_iotask.rs
+++ b/src/libstd/uv_iotask.rs
@@ -29,9 +29,9 @@ fn spawn_iotask(-task: task::task_builder) -> iotask {
     do listen |iotask_ch| {
 
         do task.sched_mode(task::single_threaded).spawn {
-            #debug("entering libuv task");
+            debug!{"entering libuv task"};
             run_loop(iotask_ch);
-            #debug("libuv task exiting");
+            debug!{"libuv task exiting"};
         };
 
         iotask_ch.recv()
@@ -136,8 +136,8 @@ fn send_msg(iotask: iotask,
 extern fn wake_up_cb(async_handle: *ll::uv_async_t,
                     status: int) unsafe {
 
-    log(debug, #fmt("wake_up_cb extern.. handle: %? status: %?",
-                     async_handle, status));
+    log(debug, fmt!{"wake_up_cb extern.. handle: %? status: %?",
+                     async_handle, status});
 
     let loop_ptr = ll::get_loop_for_uv_handle(async_handle);
     let data = ll::get_data_for_uv_handle(async_handle) as *iotask_loop_data;
@@ -164,22 +164,22 @@ fn begin_teardown(data: *iotask_loop_data) unsafe {
 extern fn tear_down_close_cb(handle: *ll::uv_async_t) unsafe {
     let loop_ptr = ll::get_loop_for_uv_handle(handle);
     let loop_refs = ll::loop_refcount(loop_ptr);
-    log(debug, #fmt("tear_down_close_cb called, closing handle at %? refs %?",
-                    handle, loop_refs));
+    log(debug, fmt!{"tear_down_close_cb called, closing handle at %? refs %?",
+                    handle, loop_refs});
     assert loop_refs == 1i32;
 }
 
 #[cfg(test)]
 mod test {
     extern fn async_close_cb(handle: *ll::uv_async_t) unsafe {
-        log(debug, #fmt("async_close_cb handle %?", handle));
+        log(debug, fmt!{"async_close_cb handle %?", handle});
         let exit_ch = (*(ll::get_data_for_uv_handle(handle)
                         as *ah_data)).exit_ch;
         comm::send(exit_ch, ());
     }
     extern fn async_handle_cb(handle: *ll::uv_async_t, status: libc::c_int)
         unsafe {
-        log(debug, #fmt("async_handle_cb handle %? status %?",handle,status));
+        log(debug, fmt!{"async_handle_cb handle %? status %?",handle,status});
         ll::close(handle, async_close_cb);
     }
     type ah_data = {
@@ -217,13 +217,13 @@ mod test {
     }
 
     extern fn lifetime_handle_close(handle: *libc::c_void) unsafe {
-        log(debug, #fmt("lifetime_handle_close ptr %?", handle));
+        log(debug, fmt!{"lifetime_handle_close ptr %?", handle});
     }
 
     extern fn lifetime_async_callback(handle: *libc::c_void,
                                      status: libc::c_int) {
-        log(debug, #fmt("lifetime_handle_close ptr %? status %?",
-                        handle, status));
+        log(debug, fmt!{"lifetime_handle_close ptr %? status %?",
+                        handle, status});
     }
 
     #[test]
diff --git a/src/libstd/uv_ll.rs b/src/libstd/uv_ll.rs
index cb1f5321f78..96c3b5b1609 100644
--- a/src/libstd/uv_ll.rs
+++ b/src/libstd/uv_ll.rs
@@ -705,8 +705,8 @@ unsafe fn tcp_connect(connect_ptr: *uv_connect_t,
                       addr_ptr: *sockaddr_in,
                       ++after_connect_cb: *u8)
 -> libc::c_int {
-    log(debug, #fmt("b4 foreign tcp_connect--addr port: %u cb: %u",
-                    (*addr_ptr).sin_port as uint, after_connect_cb as uint));
+    log(debug, fmt!{"b4 foreign tcp_connect--addr port: %u cb: %u",
+                    (*addr_ptr).sin_port as uint, after_connect_cb as uint});
     ret rustrt::rust_uv_tcp_connect(connect_ptr, tcp_handle_ptr,
                                     after_connect_cb, addr_ptr);
 }
@@ -786,10 +786,10 @@ unsafe fn async_send(async_handle: *uv_async_t) {
 unsafe fn buf_init(++input: *u8, len: uint) -> uv_buf_t {
     let out_buf = { base: ptr::null(), len: 0 as libc::size_t };
     let out_buf_ptr = ptr::addr_of(out_buf);
-    log(debug, #fmt("buf_init - input %u len %u out_buf: %u",
+    log(debug, fmt!{"buf_init - input %u len %u out_buf: %u",
                      input as uint,
                      len as uint,
-                     out_buf_ptr as uint));
+                     out_buf_ptr as uint});
     // yuck :/
     rustrt::rust_uv_buf_init(out_buf_ptr, input, len as size_t);
     //let result = rustrt::rust_uv_buf_init_2(input, len as size_t);
@@ -797,9 +797,9 @@ unsafe fn buf_init(++input: *u8, len: uint) -> uv_buf_t {
     let res_base = get_base_from_buf(out_buf);
     let res_len = get_len_from_buf(out_buf);
     //let res_base = get_base_from_buf(result);
-    log(debug, #fmt("buf_init - result %u len %u",
+    log(debug, fmt!{"buf_init - result %u len %u",
                      res_base as uint,
-                     res_len as uint));
+                     res_len as uint});
     ret out_buf;
     //ret result;
 }
@@ -843,8 +843,8 @@ unsafe fn ip6_name(src: &sockaddr_in6) -> ~str {
                        0u8,0u8,0u8,0u8,0u8,0u8];
     do vec::as_buf(dst) |dst_buf, size| {
         let src_unsafe_ptr = src as *sockaddr_in6;
-        log(debug, #fmt("val of src *sockaddr_in6: %? sockaddr_in6: %?",
-                        src_unsafe_ptr, src));
+        log(debug, fmt!{"val of src *sockaddr_in6: %? sockaddr_in6: %?",
+                        src_unsafe_ptr, src});
         let result = rustrt::rust_uv_ip6_name(src_unsafe_ptr,
                                               dst_buf, size as libc::size_t);
         alt result {
@@ -964,8 +964,8 @@ unsafe fn get_last_err_info(uv_loop: *libc::c_void) -> ~str {
     let err_ptr = ptr::addr_of(err);
     let err_name = str::unsafe::from_c_str(err_name(err_ptr));
     let err_msg = str::unsafe::from_c_str(strerror(err_ptr));
-    ret #fmt("LIBUV ERROR: name: %s msg: %s",
-                    err_name, err_msg);
+    ret fmt!{"LIBUV ERROR: name: %s msg: %s",
+                    err_name, err_msg};
 }
 
 unsafe fn get_last_err_data(uv_loop: *libc::c_void) -> uv_err_data {
@@ -1015,8 +1015,8 @@ mod test {
     };
 
     extern fn after_close_cb(handle: *libc::c_void) {
-        log(debug, #fmt("after uv_close! handle ptr: %?",
-                        handle));
+        log(debug, fmt!{"after uv_close! handle ptr: %?",
+                        handle});
     }
 
     extern fn on_alloc_cb(handle: *libc::c_void,
@@ -1024,10 +1024,10 @@ mod test {
         -> uv_buf_t unsafe {
         log(debug, ~"on_alloc_cb!");
         let char_ptr = malloc_buf_base_of(suggested_size);
-        log(debug, #fmt("on_alloc_cb h: %? char_ptr: %u sugsize: %u",
+        log(debug, fmt!{"on_alloc_cb h: %? char_ptr: %u sugsize: %u",
                          handle,
                          char_ptr as uint,
-                         suggested_size as uint));
+                         suggested_size as uint});
         ret buf_init(char_ptr, suggested_size as uint);
     }
 
@@ -1035,11 +1035,11 @@ mod test {
                         nread: libc::ssize_t,
                         ++buf: uv_buf_t) unsafe {
         let nread = nread as int;
-        log(debug, #fmt("CLIENT entering on_read_cb nred: %d",
-                        nread));
+        log(debug, fmt!{"CLIENT entering on_read_cb nred: %d",
+                        nread});
         if (nread > 0) {
             // we have data
-            log(debug, #fmt("CLIENT read: data! nread: %d", nread));
+            log(debug, fmt!{"CLIENT read: data! nread: %d", nread});
             read_stop(stream);
             let client_data =
                 get_data_for_uv_handle(stream as *libc::c_void)
@@ -1067,20 +1067,20 @@ mod test {
 
     extern fn on_write_complete_cb(write_req: *uv_write_t,
                                   status: libc::c_int) unsafe {
-        log(debug, #fmt("CLIENT beginning on_write_complete_cb status: %d",
-                         status as int));
+        log(debug, fmt!{"CLIENT beginning on_write_complete_cb status: %d",
+                         status as int});
         let stream = get_stream_handle_from_write_req(write_req);
-        log(debug, #fmt("CLIENT on_write_complete_cb: tcp:%d write_handle:%d",
-            stream as int, write_req as int));
+        log(debug, fmt!{"CLIENT on_write_complete_cb: tcp:%d write_handle:%d",
+            stream as int, write_req as int});
         let result = read_start(stream, on_alloc_cb, on_read_cb);
-        log(debug, #fmt("CLIENT ending on_write_complete_cb .. status: %d",
-                         result as int));
+        log(debug, fmt!{"CLIENT ending on_write_complete_cb .. status: %d",
+                         result as int});
     }
 
     extern fn on_connect_cb(connect_req_ptr: *uv_connect_t,
                                  status: libc::c_int) unsafe {
-        log(debug, #fmt("beginning on_connect_cb .. status: %d",
-                         status as int));
+        log(debug, fmt!{"beginning on_connect_cb .. status: %d",
+                         status as int});
         let stream =
             get_stream_handle_from_connect_req(connect_req_ptr);
         if (status == 0i32) {
@@ -1089,14 +1089,14 @@ mod test {
                 connect_req_ptr as *libc::c_void)
                 as *request_wrapper;
             let write_handle = (*client_data).write_req;
-            log(debug, #fmt("on_connect_cb: tcp: %d write_hdl: %d",
-                            stream as int, write_handle as int));
+            log(debug, fmt!{"on_connect_cb: tcp: %d write_hdl: %d",
+                            stream as int, write_handle as int});
             let write_result = write(write_handle,
                               stream as *libc::c_void,
                               (*client_data).req_buf,
                               on_write_complete_cb);
-            log(debug, #fmt("on_connect_cb: write() status: %d",
-                             write_result as int));
+            log(debug, fmt!{"on_connect_cb: write() status: %d",
+                             write_result as int});
         }
         else {
             let test_loop = get_loop_for_uv_handle(
@@ -1123,7 +1123,7 @@ mod test {
         // data field in our uv_connect_t struct
         let req_str_bytes = str::bytes(req_str);
         let req_msg_ptr: *u8 = vec::unsafe::to_ptr(req_str_bytes);
-        log(debug, #fmt("req_msg ptr: %u", req_msg_ptr as uint));
+        log(debug, fmt!{"req_msg ptr: %u", req_msg_ptr as uint});
         let req_msg = ~[
             buf_init(req_msg_ptr, vec::len(req_str_bytes))
         ];
@@ -1131,9 +1131,9 @@ mod test {
         // this to C..
         let write_handle = write_t();
         let write_handle_ptr = ptr::addr_of(write_handle);
-        log(debug, #fmt("tcp req: tcp stream: %d write_handle: %d",
+        log(debug, fmt!{"tcp req: tcp stream: %d write_handle: %d",
                          tcp_handle_ptr as int,
-                         write_handle_ptr as int));
+                         write_handle_ptr as int});
         let client_data = { writer_handle: write_handle_ptr,
                     req_buf: ptr::addr_of(req_msg),
                     read_chan: client_chan };
@@ -1147,12 +1147,12 @@ mod test {
             let addr = ip4_addr(ip, port);
             // FIXME ref #2064
             let addr_ptr = ptr::addr_of(addr);
-            log(debug, #fmt("after build addr in rust. port: %u",
-                             addr.sin_port as uint));
+            log(debug, fmt!{"after build addr in rust. port: %u",
+                             addr.sin_port as uint});
 
             // this should set up the connection request..
-            log(debug, #fmt("b4 call tcp_connect connect cb: %u ",
-                            on_connect_cb as uint));
+            log(debug, fmt!{"b4 call tcp_connect connect cb: %u ",
+                            on_connect_cb as uint});
             let tcp_connect_result = tcp_connect(
                 connect_req_ptr, tcp_handle_ptr,
                 addr_ptr, on_connect_cb);
@@ -1183,8 +1183,8 @@ mod test {
     }
 
     extern fn server_after_close_cb(handle: *libc::c_void) unsafe {
-        log(debug, #fmt("SERVER server stream closed, should exit.. h: %?",
-                   handle));
+        log(debug, fmt!{"SERVER server stream closed, should exit.. h: %?",
+                   handle});
     }
 
     extern fn client_stream_after_close_cb(handle: *libc::c_void)
@@ -1212,15 +1212,15 @@ mod test {
         let nread = nread as int;
         if (nread > 0) {
             // we have data
-            log(debug, #fmt("SERVER read: data! nread: %d", nread));
+            log(debug, fmt!{"SERVER read: data! nread: %d", nread});
 
             // pull out the contents of the write from the client
             let buf_base = get_base_from_buf(buf);
             let buf_len = get_len_from_buf(buf) as uint;
-            log(debug, #fmt("SERVER buf base: %u, len: %u, nread: %d",
+            log(debug, fmt!{"SERVER buf base: %u, len: %u, nread: %d",
                             buf_base as uint,
                             buf_len as uint,
-                            nread));
+                            nread});
             let bytes = vec::unsafe::from_buf(buf_base, buf_len);
             let request_str = str::from_bytes(bytes);
 
@@ -1240,8 +1240,8 @@ mod test {
                     client_stream_ptr as *libc::c_void,
                     (*client_data).server_resp_buf,
                     after_server_resp_write);
-                log(debug, #fmt("SERVER: resp write result: %d",
-                            write_result as int));
+                log(debug, fmt!{"SERVER: resp write result: %d",
+                            write_result as int});
                 if (write_result != 0i32) {
                     log(debug, ~"bad result for server resp write()");
                     log(debug, get_last_err_info(
@@ -1275,8 +1275,8 @@ mod test {
                                server_stream_ptr as *libc::c_void);
         if status != 0i32 {
             let err_msg = get_last_err_info(test_loop);
-            log(debug, #fmt("server_connect_cb: non-zero status: %?",
-                         err_msg));
+            log(debug, fmt!{"server_connect_cb: non-zero status: %?",
+                         err_msg});
             ret;
         }
         let server_data = get_data_for_uv_handle(
@@ -1303,20 +1303,20 @@ mod test {
                     log(debug, ~"successful server read start");
                 }
                 else {
-                    log(debug, #fmt("server_connection_cb: bad read:%d",
-                                    read_result as int));
+                    log(debug, fmt!{"server_connection_cb: bad read:%d",
+                                    read_result as int});
                     assert false;
                 }
             }
             else {
-                log(debug, #fmt("server_connection_cb: bad accept: %d",
-                            accept_result as int));
+                log(debug, fmt!{"server_connection_cb: bad accept: %d",
+                            accept_result as int});
                 assert false;
             }
         }
         else {
-            log(debug, #fmt("server_connection_cb: bad client init: %d",
-                        client_init_result as int));
+            log(debug, fmt!{"server_connection_cb: bad client init: %d",
+                        client_init_result as int});
             assert false;
         }
     }
@@ -1335,8 +1335,8 @@ mod test {
     };
 
     extern fn async_close_cb(handle: *libc::c_void) {
-        log(debug, #fmt("SERVER: closing async cb... h: %?",
-                   handle));
+        log(debug, fmt!{"SERVER: closing async cb... h: %?",
+                   handle});
     }
 
     extern fn continue_async_cb(async_handle: *uv_async_t,
@@ -1371,7 +1371,7 @@ mod test {
 
         let resp_str_bytes = str::bytes(server_resp_msg);
         let resp_msg_ptr: *u8 = vec::unsafe::to_ptr(resp_str_bytes);
-        log(debug, #fmt("resp_msg ptr: %u", resp_msg_ptr as uint));
+        log(debug, fmt!{"resp_msg ptr: %u", resp_msg_ptr as uint});
         let resp_msg = ~[
             buf_init(resp_msg_ptr, vec::len(resp_str_bytes))
         ];
@@ -1430,26 +1430,26 @@ mod test {
                         log(debug, ~"server uv::run() has returned");
                     }
                     else {
-                        log(debug, #fmt("uv_async_init failure: %d",
-                                async_result as int));
+                        log(debug, fmt!{"uv_async_init failure: %d",
+                                async_result as int});
                         assert false;
                     }
                 }
                 else {
-                    log(debug, #fmt("non-zero result on uv_listen: %d",
-                                listen_result as int));
+                    log(debug, fmt!{"non-zero result on uv_listen: %d",
+                                listen_result as int});
                     assert false;
                 }
             }
             else {
-                log(debug, #fmt("non-zero result on uv_tcp_bind: %d",
-                            bind_result as int));
+                log(debug, fmt!{"non-zero result on uv_tcp_bind: %d",
+                            bind_result as int});
                 assert false;
             }
         }
         else {
-            log(debug, #fmt("non-zero result on uv_tcp_init: %d",
-                        tcp_init_result as int));
+            log(debug, fmt!{"non-zero result on uv_tcp_init: %d",
+                        tcp_init_result as int});
             assert false;
         }
         loop_delete(test_loop);
@@ -1526,8 +1526,8 @@ mod test {
     fn test_uv_ll_struct_size_uv_tcp_t() {
         let foreign_handle_size = rustrt::rust_uv_helper_uv_tcp_t_size();
         let rust_handle_size = sys::size_of::<uv_tcp_t>();
-        let output = #fmt("uv_tcp_t -- foreign: %u rust: %u",
-                          foreign_handle_size as uint, rust_handle_size);
+        let output = fmt!{"uv_tcp_t -- foreign: %u rust: %u",
+                          foreign_handle_size as uint, rust_handle_size};
         log(debug, output);
         assert foreign_handle_size as uint == rust_handle_size;
     }
@@ -1537,8 +1537,8 @@ mod test {
         let foreign_handle_size =
             rustrt::rust_uv_helper_uv_connect_t_size();
         let rust_handle_size = sys::size_of::<uv_connect_t>();
-        let output = #fmt("uv_connect_t -- foreign: %u rust: %u",
-                          foreign_handle_size as uint, rust_handle_size);
+        let output = fmt!{"uv_connect_t -- foreign: %u rust: %u",
+                          foreign_handle_size as uint, rust_handle_size};
         log(debug, output);
         assert foreign_handle_size as uint == rust_handle_size;
     }
@@ -1548,8 +1548,8 @@ mod test {
         let foreign_handle_size =
             rustrt::rust_uv_helper_uv_buf_t_size();
         let rust_handle_size = sys::size_of::<uv_buf_t>();
-        let output = #fmt("uv_buf_t -- foreign: %u rust: %u",
-                          foreign_handle_size as uint, rust_handle_size);
+        let output = fmt!{"uv_buf_t -- foreign: %u rust: %u",
+                          foreign_handle_size as uint, rust_handle_size};
         log(debug, output);
         assert foreign_handle_size as uint == rust_handle_size;
     }
@@ -1559,8 +1559,8 @@ mod test {
         let foreign_handle_size =
             rustrt::rust_uv_helper_uv_write_t_size();
         let rust_handle_size = sys::size_of::<uv_write_t>();
-        let output = #fmt("uv_write_t -- foreign: %u rust: %u",
-                          foreign_handle_size as uint, rust_handle_size);
+        let output = fmt!{"uv_write_t -- foreign: %u rust: %u",
+                          foreign_handle_size as uint, rust_handle_size};
         log(debug, output);
         assert foreign_handle_size as uint == rust_handle_size;
     }
@@ -1571,8 +1571,8 @@ mod test {
         let foreign_handle_size =
             rustrt::rust_uv_helper_sockaddr_in_size();
         let rust_handle_size = sys::size_of::<sockaddr_in>();
-        let output = #fmt("sockaddr_in -- foreign: %u rust: %u",
-                          foreign_handle_size as uint, rust_handle_size);
+        let output = fmt!{"sockaddr_in -- foreign: %u rust: %u",
+                          foreign_handle_size as uint, rust_handle_size};
         log(debug, output);
         assert foreign_handle_size as uint == rust_handle_size;
     }
@@ -1582,8 +1582,8 @@ mod test {
         let foreign_handle_size =
             rustrt::rust_uv_helper_sockaddr_in6_size();
         let rust_handle_size = sys::size_of::<sockaddr_in6>();
-        let output = #fmt("sockaddr_in6 -- foreign: %u rust: %u",
-                          foreign_handle_size as uint, rust_handle_size);
+        let output = fmt!{"sockaddr_in6 -- foreign: %u rust: %u",
+                          foreign_handle_size as uint, rust_handle_size};
         log(debug, output);
         // FIXME #1645 .. rust appears to pad structs to the nearest byte..?
         // .. can't get the uv::ll::sockaddr_in6 to == 28 :/
@@ -1597,8 +1597,8 @@ mod test {
         let foreign_handle_size =
             rustrt::rust_uv_helper_addr_in_size();
         let rust_handle_size = sys::size_of::<addr_in>();
-        let output = #fmt("addr_in -- foreign: %u rust: %u",
-                          foreign_handle_size as uint, rust_handle_size);
+        let output = fmt!{"addr_in -- foreign: %u rust: %u",
+                          foreign_handle_size as uint, rust_handle_size};
         log(debug, output);
         // FIXME #1645 .. see note above about struct padding
         assert (4u+foreign_handle_size as uint) == rust_handle_size;
@@ -1610,8 +1610,8 @@ mod test {
         let foreign_handle_size =
             rustrt::rust_uv_helper_uv_async_t_size();
         let rust_handle_size = sys::size_of::<uv_async_t>();
-        let output = #fmt("uv_async_t -- foreign: %u rust: %u",
-                          foreign_handle_size as uint, rust_handle_size);
+        let output = fmt!{"uv_async_t -- foreign: %u rust: %u",
+                          foreign_handle_size as uint, rust_handle_size};
         log(debug, output);
         assert foreign_handle_size as uint == rust_handle_size;
     }
@@ -1622,8 +1622,8 @@ mod test {
         let foreign_handle_size =
             rustrt::rust_uv_helper_uv_timer_t_size();
         let rust_handle_size = sys::size_of::<uv_timer_t>();
-        let output = #fmt("uv_timer_t -- foreign: %u rust: %u",
-                          foreign_handle_size as uint, rust_handle_size);
+        let output = fmt!{"uv_timer_t -- foreign: %u rust: %u",
+                          foreign_handle_size as uint, rust_handle_size};
         log(debug, output);
         assert foreign_handle_size as uint == rust_handle_size;
     }
@@ -1635,8 +1635,8 @@ mod test {
         let foreign_handle_size =
             rustrt::rust_uv_helper_uv_getaddrinfo_t_size();
         let rust_handle_size = sys::size_of::<uv_getaddrinfo_t>();
-        let output = #fmt("uv_getaddrinfo_t -- foreign: %u rust: %u",
-                          foreign_handle_size as uint, rust_handle_size);
+        let output = fmt!{"uv_getaddrinfo_t -- foreign: %u rust: %u",
+                          foreign_handle_size as uint, rust_handle_size};
         log(debug, output);
         assert foreign_handle_size as uint == rust_handle_size;
     }
@@ -1648,8 +1648,8 @@ mod test {
         let foreign_handle_size =
             rustrt::rust_uv_helper_addrinfo_size();
         let rust_handle_size = sys::size_of::<addrinfo>();
-        let output = #fmt("addrinfo -- foreign: %u rust: %u",
-                          foreign_handle_size as uint, rust_handle_size);
+        let output = fmt!{"addrinfo -- foreign: %u rust: %u",
+                          foreign_handle_size as uint, rust_handle_size};
         log(debug, output);
         assert foreign_handle_size as uint == rust_handle_size;
     }