Demode extfmt

Needs a snapshot before this can be completed, because I changed
the mode for conv_poly.

4 files changed, 57 insertions, 50 deletions

diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs
index 1c12397568d..7f208a3a710 100644
--- a/src/libsyntax/diagnostic.rs
+++ b/src/libsyntax/diagnostic.rs
@@ -10,30 +10,30 @@ export ice_msg;
 export expect;
 
 type emitter = fn@(cmsp: Option<(codemap::codemap, span)>,
-                   msg: ~str, lvl: level);
+                   msg: &str, lvl: level);
 
 
 trait span_handler {
-    fn span_fatal(sp: span, msg: ~str) -> !;
-    fn span_err(sp: span, msg: ~str);
-    fn span_warn(sp: span, msg: ~str);
-    fn span_note(sp: span, msg: ~str);
-    fn span_bug(sp: span, msg: ~str) -> !;
-    fn span_unimpl(sp: span, msg: ~str) -> !;
+    fn span_fatal(sp: span, msg: &str) -> !;
+    fn span_err(sp: span, msg: &str);
+    fn span_warn(sp: span, msg: &str);
+    fn span_note(sp: span, msg: &str);
+    fn span_bug(sp: span, msg: &str) -> !;
+    fn span_unimpl(sp: span, msg: &str) -> !;
     fn handler() -> handler;
 }
 
 trait handler {
-    fn fatal(msg: ~str) -> !;
-    fn err(msg: ~str);
+    fn fatal(msg: &str) -> !;
+    fn err(msg: &str);
     fn bump_err_count();
     fn has_errors() -> bool;
     fn abort_if_errors();
-    fn warn(msg: ~str);
-    fn note(msg: ~str);
-    fn bug(msg: ~str) -> !;
-    fn unimpl(msg: ~str) -> !;
-    fn emit(cmsp: Option<(codemap::codemap, span)>, msg: ~str, lvl: level);
+    fn warn(msg: &str);
+    fn note(msg: &str);
+    fn bug(msg: &str) -> !;
+    fn unimpl(msg: &str) -> !;
+    fn emit(cmsp: Option<(codemap::codemap, span)>, msg: &str, lvl: level);
 }
 
 type handler_t = @{
@@ -47,24 +47,24 @@ type codemap_t = @{
 };
 
 impl codemap_t: span_handler {
-    fn span_fatal(sp: span, msg: ~str) -> ! {
+    fn span_fatal(sp: span, msg: &str) -> ! {
         self.handler.emit(Some((self.cm, sp)), msg, fatal);
         fail;
     }
-    fn span_err(sp: span, msg: ~str) {
+    fn span_err(sp: span, msg: &str) {
         self.handler.emit(Some((self.cm, sp)), msg, error);
         self.handler.bump_err_count();
     }
-    fn span_warn(sp: span, msg: ~str) {
+    fn span_warn(sp: span, msg: &str) {
         self.handler.emit(Some((self.cm, sp)), msg, warning);
     }
-    fn span_note(sp: span, msg: ~str) {
+    fn span_note(sp: span, msg: &str) {
         self.handler.emit(Some((self.cm, sp)), msg, note);
     }
-    fn span_bug(sp: span, msg: ~str) -> ! {
+    fn span_bug(sp: span, msg: &str) -> ! {
         self.span_fatal(sp, ice_msg(msg));
     }
-    fn span_unimpl(sp: span, msg: ~str) -> ! {
+    fn span_unimpl(sp: span, msg: &str) -> ! {
         self.span_bug(sp, ~"unimplemented " + msg);
     }
     fn handler() -> handler {
@@ -73,11 +73,11 @@ impl codemap_t: span_handler {
 }
 
 impl handler_t: handler {
-    fn fatal(msg: ~str) -> ! {
+    fn fatal(msg: &str) -> ! {
         self.emit(None, msg, fatal);
         fail;
     }
-    fn err(msg: ~str) {
+    fn err(msg: &str) {
         self.emit(None, msg, error);
         self.bump_err_count();
     }
@@ -97,22 +97,22 @@ impl handler_t: handler {
         }
         self.fatal(s);
     }
-    fn warn(msg: ~str) {
+    fn warn(msg: &str) {
         self.emit(None, msg, warning);
     }
-    fn note(msg: ~str) {
+    fn note(msg: &str) {
         self.emit(None, msg, note);
     }
-    fn bug(msg: ~str) -> ! {
+    fn bug(msg: &str) -> ! {
         self.fatal(ice_msg(msg));
     }
-    fn unimpl(msg: ~str) -> ! { self.bug(~"unimplemented " + msg); }
-    fn emit(cmsp: Option<(codemap::codemap, span)>, msg: ~str, lvl: level) {
+    fn unimpl(msg: &str) -> ! { self.bug(~"unimplemented " + msg); }
+    fn emit(cmsp: Option<(codemap::codemap, span)>, msg: &str, lvl: level) {
         self.emit(cmsp, msg, lvl);
     }
 }
 
-fn ice_msg(msg: ~str) -> ~str {
+fn ice_msg(msg: &str) -> ~str {
     fmt!("internal compiler error: %s", msg)
 }
 
@@ -126,17 +126,19 @@ fn mk_handler(emitter: Option<emitter>) -> handler {
       Some(e) => e,
       None => {
         let f = fn@(cmsp: Option<(codemap::codemap, span)>,
-            msg: ~str, t: level) {
+            msg: &str, t: level) {
             emit(cmsp, msg, t);
         };
         f
       }
     };
 
-    @{
-        mut err_count: 0u,
+    let x: handler_t = @{
+        mut err_count: 0,
         emit: emit
-    } as handler
+    };
+
+    x as handler
 }
 
 enum level {
@@ -171,7 +173,7 @@ fn diagnosticcolor(lvl: level) -> u8 {
     }
 }
 
-fn print_diagnostic(topic: ~str, lvl: level, msg: ~str) {
+fn print_diagnostic(topic: ~str, lvl: level, msg: &str) {
     let use_color = term::color_supported() &&
         io::stderr().get_type() == io::Screen;
     if str::is_not_empty(topic) {
@@ -188,7 +190,7 @@ fn print_diagnostic(topic: ~str, lvl: level, msg: ~str) {
 }
 
 fn emit(cmsp: Option<(codemap::codemap, span)>,
-        msg: ~str, lvl: level) {
+        msg: &str, lvl: level) {
     match cmsp {
       Some((cm, sp)) => {
         let sp = codemap::adjust_span(cm,sp);
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index 5f4d86b9860..6c71fd8fcbc 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -133,12 +133,12 @@ trait ext_ctxt {
     fn mod_path() -> ~[ast::ident];
     fn bt_push(ei: codemap::expn_info_);
     fn bt_pop();
-    fn span_fatal(sp: span, msg: ~str) -> !;
-    fn span_err(sp: span, msg: ~str);
-    fn span_warn(sp: span, msg: ~str);
-    fn span_unimpl(sp: span, msg: ~str) -> !;
-    fn span_bug(sp: span, msg: ~str) -> !;
-    fn bug(msg: ~str) -> !;
+    fn span_fatal(sp: span, msg: &str) -> !;
+    fn span_err(sp: span, msg: &str);
+    fn span_warn(sp: span, msg: &str);
+    fn span_unimpl(sp: span, msg: &str) -> !;
+    fn span_bug(sp: span, msg: &str) -> !;
+    fn bug(msg: &str) -> !;
     fn next_id() -> ast::node_id;
     pure fn trace_macros() -> bool;
     fn set_trace_macros(x: bool);
@@ -182,27 +182,27 @@ fn mk_ctxt(parse_sess: parse::parse_sess,
               _ => self.bug(~"tried to pop without a push")
             }
         }
-        fn span_fatal(sp: span, msg: ~str) -> ! {
+        fn span_fatal(sp: span, msg: &str) -> ! {
             self.print_backtrace();
             self.parse_sess.span_diagnostic.span_fatal(sp, msg);
         }
-        fn span_err(sp: span, msg: ~str) {
+        fn span_err(sp: span, msg: &str) {
             self.print_backtrace();
             self.parse_sess.span_diagnostic.span_err(sp, msg);
         }
-        fn span_warn(sp: span, msg: ~str) {
+        fn span_warn(sp: span, msg: &str) {
             self.print_backtrace();
             self.parse_sess.span_diagnostic.span_warn(sp, msg);
         }
-        fn span_unimpl(sp: span, msg: ~str) -> ! {
+        fn span_unimpl(sp: span, msg: &str) -> ! {
             self.print_backtrace();
             self.parse_sess.span_diagnostic.span_unimpl(sp, msg);
         }
-        fn span_bug(sp: span, msg: ~str) -> ! {
+        fn span_bug(sp: span, msg: &str) -> ! {
             self.print_backtrace();
             self.parse_sess.span_diagnostic.span_bug(sp, msg);
         }
-        fn bug(msg: ~str) -> ! {
+        fn bug(msg: &str) -> ! {
             self.print_backtrace();
             self.parse_sess.span_diagnostic.handler().bug(msg);
         }
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index 8ce426f0357..a43b0cb69f4 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -50,6 +50,10 @@ fn mk_access(cx: ext_ctxt, sp: span, p: ~[ast::ident], m: ast::ident)
     let pathexpr = mk_path(cx, sp, p);
     return mk_access_(cx, sp, pathexpr, m);
 }
+fn mk_addr_of(cx: ext_ctxt, sp: span, e: @ast::expr) -> @ast::expr {
+    return mk_expr(cx, sp, ast::expr_addr_of(ast::m_imm, e));
+}
+
 fn mk_call_(cx: ext_ctxt, sp: span, fn_expr: @ast::expr,
             args: ~[@ast::expr]) -> @ast::expr {
     mk_expr(cx, sp, ast::expr_call(fn_expr, args, false))
diff --git a/src/libsyntax/ext/fmt.rs b/src/libsyntax/ext/fmt.rs
index e4f197801c2..8b94620f9b6 100644
--- a/src/libsyntax/ext/fmt.rs
+++ b/src/libsyntax/ext/fmt.rs
@@ -20,10 +20,10 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
     let fmtspan = args[0].span;
     debug!("Format string:");
     log(debug, fmt);
-    fn parse_fmt_err_(cx: ext_ctxt, sp: span, msg: ~str) -> ! {
+    fn parse_fmt_err_(cx: ext_ctxt, sp: span, msg: &str) -> ! {
         cx.span_fatal(sp, msg);
     }
-    let parse_fmt_err = fn@(s: ~str) -> ! {
+    let parse_fmt_err = fn@(s: &str) -> ! {
         parse_fmt_err_(cx, fmtspan, s)
     };
     let pieces = parse_fmt_string(fmt, parse_fmt_err);
@@ -39,7 +39,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
    -> @ast::expr {
     fn make_path_vec(_cx: ext_ctxt, ident: @~str) -> ~[ast::ident] {
         let intr = _cx.parse_sess().interner;
-        return ~[intr.intern(@~"extfmt"), intr.intern(@~"rt"),
+        return ~[intr.intern(@~"extfmt"), intr.intern(@~"rt2"),
                  intr.intern(ident)];
     }
     fn make_rt_path_expr(cx: ext_ctxt, sp: span, nm: @~str) -> @ast::expr {
@@ -187,7 +187,8 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
           TyFloat => {
             return make_conv_call(cx, arg.span, ~"float", cnv, arg);
           }
-          TyPoly => return make_conv_call(cx, arg.span, ~"poly", cnv, arg)
+          TyPoly => return make_conv_call(cx, arg.span, ~"poly", cnv,
+                                          mk_addr_of(cx, sp, arg))
         }
     }
     fn log_conv(c: Conv) {