Convert rustc::syntax::ext::base to istrs. Issue #855

brson · brson · commit 7efbfea8d08c · 2011-08-27T16:55:48.000-07:00
diff --git a/src/comp/syntax/ext/base.rs b/src/comp/syntax/ext/base.rs
@@ -9,7 +9,7 @@ import codemap;
 
 type syntax_expander =
     fn(&ext_ctxt, span, @ast::expr, &option::t<istr>) -> @ast::expr;
-type macro_def = {ident: str, ext: syntax_extension};
+type macro_def = {ident: istr, ext: syntax_extension};
 type macro_definer =
     fn(&ext_ctxt, span, @ast::expr, &option::t<istr>) -> macro_def;
 
@@ -36,9 +36,9 @@ fn syntax_expander_table() -> hashmap<istr, syntax_extension> {
 }
 
 obj ext_ctxt(sess: @session,
-             crate_file_name_hack: str,
+             crate_file_name_hack: istr,
              mutable backtrace: codemap::opt_span) {
-    fn crate_file_name() -> str { ret crate_file_name_hack; }
+    fn crate_file_name() -> istr { ret crate_file_name_hack; }
 
     fn session() -> @session { ret sess; }
 
@@ -58,29 +58,29 @@ obj ext_ctxt(sess: @session,
             let tmp = pre;
             backtrace = tmp;
           }
-          _ { self.bug("tried to pop without a push"); }
+          _ { self.bug(~"tried to pop without a push"); }
         }
     }
 
-    fn span_fatal(sp: span, msg: str) -> ! {
+    fn span_fatal(sp: span, msg: istr) -> ! {
         self.print_backtrace();
-        sess.span_fatal(sp, istr::from_estr(msg));
+        sess.span_fatal(sp, msg);
     }
-    fn span_err(sp: span, msg: str) {
+    fn span_err(sp: span, msg: istr) {
         self.print_backtrace();
-        sess.span_err(sp, istr::from_estr(msg));
+        sess.span_err(sp, msg);
     }
-    fn span_unimpl(sp: span, msg: str) -> ! {
+    fn span_unimpl(sp: span, msg: istr) -> ! {
         self.print_backtrace();
-        sess.span_unimpl(sp, istr::from_estr(msg));
+        sess.span_unimpl(sp, msg);
     }
-    fn span_bug(sp: span, msg: str) -> ! {
+    fn span_bug(sp: span, msg: istr) -> ! {
         self.print_backtrace();
-        sess.span_bug(sp, istr::from_estr(msg));
+        sess.span_bug(sp, msg);
     }
-    fn bug(msg: str) -> ! {
+    fn bug(msg: istr) -> ! {
         self.print_backtrace();
-        sess.bug(istr::from_estr(msg));
+        sess.bug(msg);
     }
     fn next_id() -> ast::node_id { ret sess.next_node_id(); }
 
@@ -96,23 +96,24 @@ fn mk_ctxt(sess: &session) -> ext_ctxt {
     // super-ugly and needs a better solution.
     let crate_file_name_hack = sess.get_codemap().files[0].name;
 
-    ret ext_ctxt(@sess, istr::to_estr(crate_file_name_hack),
+    ret ext_ctxt(@sess, crate_file_name_hack,
                  codemap::os_none);
 }
 
-fn expr_to_str(cx: &ext_ctxt, expr: @ast::expr, error: str) -> str {
+fn expr_to_str(cx: &ext_ctxt, expr: @ast::expr, error: &istr) -> istr {
     alt expr.node {
       ast::expr_lit(l) {
         alt l.node {
-          ast::lit_str(s, _) { ret istr::to_estr(s); }
+          ast::lit_str(s, _) { ret s; }
           _ { cx.span_fatal(l.span, error); }
         }
       }
       _ { cx.span_fatal(expr.span, error); }
     }
 }
 
-fn expr_to_ident(cx: &ext_ctxt, expr: @ast::expr, error: str) -> ast::ident {
+fn expr_to_ident(cx: &ext_ctxt, expr: @ast::expr,
+                 error: &istr) -> ast::ident {
     alt expr.node {
       ast::expr_path(p) {
         if vec::len(p.node.types) > 0u || vec::len(p.node.idents) != 1u {
diff --git a/src/comp/syntax/ext/concat_idents.rs b/src/comp/syntax/ext/concat_idents.rs
@@ -8,12 +8,12 @@ fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, arg: @ast::expr,
         alt arg.node {
           ast::expr_vec(elts, _) { elts }
           _ {
-            cx.span_fatal(sp, "#concat_idents requires a vector argument .")
+            cx.span_fatal(sp, ~"#concat_idents requires a vector argument .")
           }
         };
     let res: ast::ident = ~"";
     for e: @ast::expr in args {
-        res += expr_to_ident(cx, e, "expected an ident");
+        res += expr_to_ident(cx, e, ~"expected an ident");
     }
 
     ret @{id: cx.next_id(),
diff --git a/src/comp/syntax/ext/env.rs b/src/comp/syntax/ext/env.rs
@@ -17,17 +17,17 @@ fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, arg: @ast::expr,
         alt arg.node {
           ast::expr_vec(elts, _) { elts }
           _ {
-            cx.span_fatal(sp, "#env requires arguments of the form `[...]`.")
+            cx.span_fatal(sp, ~"#env requires arguments of the form `[...]`.")
           }
         };
     if vec::len::<@ast::expr>(args) != 1u {
-        cx.span_fatal(sp, "malformed #env call");
+        cx.span_fatal(sp, ~"malformed #env call");
     }
     // FIXME: if this was more thorough it would manufacture an
     // option::t<str> rather than just an maybe-empty string.
 
-    let var = expr_to_str(cx, args[0], "#env requires a string");
-    alt generic_os::getenv(istr::from_estr(var)) {
+    let var = expr_to_str(cx, args[0], ~"#env requires a string");
+    alt generic_os::getenv(var) {
       option::none. { ret make_new_str(cx, sp, ""); }
       option::some(s) {
         ret make_new_str(cx, sp, istr::to_estr(s));
diff --git a/src/comp/syntax/ext/expand.rs b/src/comp/syntax/ext/expand.rs
@@ -26,9 +26,9 @@ fn expand_expr(exts: &hashmap<istr, syntax_extension>, cx: &ext_ctxt,
                 let extname = pth.node.idents[0];
                 alt exts.find(extname) {
                   none. {
-                    cx.span_fatal(pth.span,
+                    cx.span_fatal(pth.span, istr::from_estr(
                                   #fmt["macro undefined: '%s'",
-                                       istr::to_estr(extname)])
+                                       istr::to_estr(extname)]))
                   }
                   some(normal(ext)) {
                     let expanded = ext(cx, pth.span, args, body);
@@ -43,13 +43,13 @@ fn expand_expr(exts: &hashmap<istr, syntax_extension>, cx: &ext_ctxt,
                   some(macro_defining(ext)) {
                     let named_extension = ext(cx, pth.span, args, body);
                     exts.insert(
-                        istr::from_estr(named_extension.ident),
+                        named_extension.ident,
                         named_extension.ext);
                     ast::expr_rec([], none)
                   }
                 }
               }
-              _ { cx.span_bug(mac.span, "naked syntactic bit") }
+              _ { cx.span_bug(mac.span, ~"naked syntactic bit") }
             }
           }
           _ { orig(e, fld) }
diff --git a/src/comp/syntax/ext/fmt.rs b/src/comp/syntax/ext/fmt.rs
@@ -22,23 +22,24 @@ fn expand_syntax_ext(cx: &ext_ctxt, sp: span, arg: @ast::expr,
         alt arg.node {
           ast::expr_vec(elts, _) { elts }
           _ {
-            cx.span_fatal(sp, "#fmt requires arguments of the form `[...]`.")
+            cx.span_fatal(sp, ~"#fmt requires arguments of the form `[...]`.")
           }
         };
     if vec::len::<@ast::expr>(args) == 0u {
-        cx.span_fatal(sp, "#fmt requires a format string");
+        cx.span_fatal(sp, ~"#fmt requires a format string");
     }
     let fmt =
         expr_to_str(cx, args[0],
-                    "first argument to #fmt must be a " + "string literal.");
+                    ~"first argument to #fmt must be a "
+                    + ~"string literal.");
     let fmtspan = args[0].span;
     log "Format string:";
     log fmt;
     fn parse_fmt_err_(cx: &ext_ctxt, sp: span, msg: str) -> ! {
-        cx.span_fatal(sp, msg);
+        cx.span_fatal(sp, istr::from_estr(msg));
     }
     let parse_fmt_err = bind parse_fmt_err_(cx, fmtspan, _);
-    let pieces = parse_fmt_string(fmt, parse_fmt_err);
+    let pieces = parse_fmt_string(istr::to_estr(fmt), parse_fmt_err);
     ret pieces_to_expr(cx, sp, pieces, args);
 }
 
@@ -102,7 +103,7 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
     }
     fn make_path_vec(cx: &ext_ctxt, ident: &ast::ident) -> [ast::ident] {
         fn compiling_std(cx: &ext_ctxt) -> bool {
-            ret str::find(cx.crate_file_name(), "std.rc") >= 0;
+            ret istr::find(cx.crate_file_name(), ~"std.rc") >= 0;
         }
         if compiling_std(cx) {
             ret [~"extfmt", ~"rt", ident];
@@ -149,7 +150,7 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
                 let count_is_args = [count_lit];
                 ret make_call(cx, sp, count_is_path, count_is_args);
               }
-              _ { cx.span_unimpl(sp, "unimplemented #fmt conversion"); }
+              _ { cx.span_unimpl(sp, ~"unimplemented #fmt conversion"); }
             }
         }
         fn make_ty(cx: &ext_ctxt, sp: span, t: &ty) -> @ast::expr {
@@ -203,7 +204,7 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
               _ { ret false; }
             }
         }
-        let unsupported = "conversion not supported in #fmt string";
+        let unsupported = ~"conversion not supported in #fmt string";
         alt cnv.param {
           option::none. { }
           _ { cx.span_unimpl(sp, unsupported); }
@@ -214,15 +215,15 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
               flag_sign_always. {
                 if !is_signed_type(cnv) {
                     cx.span_fatal(sp,
-                                  "+ flag only valid in " +
-                                      "signed #fmt conversion");
+                                  ~"+ flag only valid in " +
+                                      ~"signed #fmt conversion");
                 }
               }
               flag_space_for_sign. {
                 if !is_signed_type(cnv) {
                     cx.span_fatal(sp,
-                                  "space flag only valid in " +
-                                      "signed #fmt conversions");
+                                  ~"space flag only valid in " +
+                                      ~"signed #fmt conversions");
                 }
               }
               flag_left_zero_pad. { }
@@ -330,8 +331,8 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
             n += 1u;
             if n >= nargs {
                 cx.span_fatal(sp,
-                              "not enough arguments to #fmt " +
-                                  "for the given format string");
+                              ~"not enough arguments to #fmt " +
+                                  ~"for the given format string");
             }
             log "Building conversion:";
             log_conv(conv);
@@ -345,9 +346,9 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
 
     if expected_nargs < nargs {
         cx.span_fatal(
-            sp,
+            sp, istr::from_estr(
             #fmt["too many arguments to #fmt. found %u, expected %u",
-                 nargs, expected_nargs]);
+                 nargs, expected_nargs]));
     }
     ret tmp_expr;
 }
diff --git a/src/comp/syntax/ext/ident_to_str.rs b/src/comp/syntax/ext/ident_to_str.rs
@@ -10,16 +10,16 @@ fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, arg: @ast::expr,
         alt arg.node {
           ast::expr_vec(elts, _) { elts }
           _ {
-            cx.span_fatal(sp, "#ident_to_str requires a vector argument .")
+            cx.span_fatal(sp, ~"#ident_to_str requires a vector argument .")
           }
         };
     if vec::len::<@ast::expr>(args) != 1u {
-        cx.span_fatal(sp, "malformed #ident_to_str call");
+        cx.span_fatal(sp, ~"malformed #ident_to_str call");
     }
 
     ret make_new_lit(cx, sp,
                      ast::lit_str(expr_to_ident(cx, args[0u],
-                                                "expected an ident"),
+                                                ~"expected an ident"),
                                   ast::sk_rc));
 
 }
diff --git a/src/comp/syntax/ext/simplext.rs b/src/comp/syntax/ext/simplext.rs

Original file line number	Diff line number	Diff line change
`@@ -8,12 +8,12 @@ fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, arg: @ast::expr,`
`8`	`8`	`alt arg.node {`
`9`	`9`	`ast::expr_vec(elts, _) { elts }`
`10`	`10`	`_ {`
`11`		`- cx.span_fatal(sp, "#concat_idents requires a vector argument .")`
	`11`	`+ cx.span_fatal(sp, ~"#concat_idents requires a vector argument .")`
`12`	`12`	`}`
`13`	`13`	`};`
`14`	`14`	`let res: ast::ident = ~"";`
`15`	`15`	`for e: @ast::expr in args {`
`16`		`- res += expr_to_ident(cx, e, "expected an ident");`
	`16`	`+ res += expr_to_ident(cx, e, ~"expected an ident");`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`ret @{id: cx.next_id(),`
Original file line number	Diff line number	Diff line change
`@@ -26,9 +26,9 @@ fn expand_expr(exts: &hashmap<istr, syntax_extension>, cx: &ext_ctxt,`
`26`	`26`	`let extname = pth.node.idents[0];`
`27`	`27`	`alt exts.find(extname) {`
`28`	`28`	`none. {`
`29`		`- cx.span_fatal(pth.span,`
	`29`	`+ cx.span_fatal(pth.span, istr::from_estr(`
`30`	`30`	`#fmt["macro undefined: '%s'",`
`31`		`- istr::to_estr(extname)])`
	`31`	`+ istr::to_estr(extname)]))`
`32`	`32`	`}`
`33`	`33`	`some(normal(ext)) {`
`34`	`34`	`let expanded = ext(cx, pth.span, args, body);`
`@@ -43,13 +43,13 @@ fn expand_expr(exts: &hashmap<istr, syntax_extension>, cx: &ext_ctxt,`
`43`	`43`	`some(macro_defining(ext)) {`
`44`	`44`	`let named_extension = ext(cx, pth.span, args, body);`
`45`	`45`	`exts.insert(`
`46`		`- istr::from_estr(named_extension.ident),`
	`46`	`+ named_extension.ident,`
`47`	`47`	`named_extension.ext);`
`48`	`48`	`ast::expr_rec([], none)`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`	`}`
`52`		`- _ { cx.span_bug(mac.span, "naked syntactic bit") }`
	`52`	`+ _ { cx.span_bug(mac.span, ~"naked syntactic bit") }`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`	`_ { orig(e, fld) }`
Original file line number	Diff line number	Diff line change
`@@ -22,23 +22,24 @@ fn expand_syntax_ext(cx: &ext_ctxt, sp: span, arg: @ast::expr,`
`22`	`22`	`alt arg.node {`
`23`	`23`	`ast::expr_vec(elts, _) { elts }`
`24`	`24`	`_ {`
`25`		- cx.span_fatal(sp, "#fmt requires arguments of the form `[...]`.")
	`25`	+ cx.span_fatal(sp, ~"#fmt requires arguments of the form `[...]`.")
`26`	`26`	`}`
`27`	`27`	`};`
`28`	`28`	`if vec::len::<@ast::expr>(args) == 0u {`
`29`		`- cx.span_fatal(sp, "#fmt requires a format string");`
	`29`	`+ cx.span_fatal(sp, ~"#fmt requires a format string");`
`30`	`30`	`}`
`31`	`31`	`let fmt =`
`32`	`32`	`expr_to_str(cx, args[0],`
`33`		`- "first argument to #fmt must be a " + "string literal.");`
	`33`	`+ ~"first argument to #fmt must be a "`
	`34`	`+ + ~"string literal.");`
`34`	`35`	`let fmtspan = args[0].span;`
`35`	`36`	`log "Format string:";`
`36`	`37`	`log fmt;`
`37`	`38`	`fn parse_fmt_err_(cx: &ext_ctxt, sp: span, msg: str) -> ! {`
`38`		`- cx.span_fatal(sp, msg);`
	`39`	`+ cx.span_fatal(sp, istr::from_estr(msg));`
`39`	`40`	`}`
`40`	`41`	`let parse_fmt_err = bind parse_fmt_err_(cx, fmtspan, _);`
`41`		`- let pieces = parse_fmt_string(fmt, parse_fmt_err);`
	`42`	`+ let pieces = parse_fmt_string(istr::to_estr(fmt), parse_fmt_err);`
`42`	`43`	`ret pieces_to_expr(cx, sp, pieces, args);`
`43`	`44`	`}`
`44`	`45`
`@@ -102,7 +103,7 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],`
`102`	`103`	`}`
`103`	`104`	`fn make_path_vec(cx: &ext_ctxt, ident: &ast::ident) -> [ast::ident] {`
`104`	`105`	`fn compiling_std(cx: &ext_ctxt) -> bool {`
`105`		`- ret str::find(cx.crate_file_name(), "std.rc") >= 0;`
	`106`	`+ ret istr::find(cx.crate_file_name(), ~"std.rc") >= 0;`
`106`	`107`	`}`
`107`	`108`	`if compiling_std(cx) {`
`108`	`109`	`ret [~"extfmt", ~"rt", ident];`
`@@ -149,7 +150,7 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],`
`149`	`150`	`let count_is_args = [count_lit];`
`150`	`151`	`ret make_call(cx, sp, count_is_path, count_is_args);`
`151`	`152`	`}`
`152`		`- _ { cx.span_unimpl(sp, "unimplemented #fmt conversion"); }`
	`153`	`+ _ { cx.span_unimpl(sp, ~"unimplemented #fmt conversion"); }`
`153`	`154`	`}`
`154`	`155`	`}`
`155`	`156`	`fn make_ty(cx: &ext_ctxt, sp: span, t: &ty) -> @ast::expr {`
`@@ -203,7 +204,7 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],`
`203`	`204`	`_ { ret false; }`
`204`	`205`	`}`
`205`	`206`	`}`
`206`		`- let unsupported = "conversion not supported in #fmt string";`
	`207`	`+ let unsupported = ~"conversion not supported in #fmt string";`
`207`	`208`	`alt cnv.param {`
`208`	`209`	`option::none. { }`
`209`	`210`	`_ { cx.span_unimpl(sp, unsupported); }`
`@@ -214,15 +215,15 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],`
`214`	`215`	`flag_sign_always. {`
`215`	`216`	`if !is_signed_type(cnv) {`
`216`	`217`	`cx.span_fatal(sp,`
`217`		`- "+ flag only valid in " +`
`218`		`- "signed #fmt conversion");`
	`218`	`+ ~"+ flag only valid in " +`
	`219`	`+ ~"signed #fmt conversion");`
`219`	`220`	`}`
`220`	`221`	`}`
`221`	`222`	`flag_space_for_sign. {`
`222`	`223`	`if !is_signed_type(cnv) {`
`223`	`224`	`cx.span_fatal(sp,`
`224`		`- "space flag only valid in " +`
`225`		`- "signed #fmt conversions");`
	`225`	`+ ~"space flag only valid in " +`
	`226`	`+ ~"signed #fmt conversions");`
`226`	`227`	`}`
`227`	`228`	`}`
`228`	`229`	`flag_left_zero_pad. { }`
`@@ -330,8 +331,8 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],`
`330`	`331`	`n += 1u;`
`331`	`332`	`if n >= nargs {`
`332`	`333`	`cx.span_fatal(sp,`
`333`		`- "not enough arguments to #fmt " +`
`334`		`- "for the given format string");`
	`334`	`+ ~"not enough arguments to #fmt " +`
	`335`	`+ ~"for the given format string");`
`335`	`336`	`}`
`336`	`337`	`log "Building conversion:";`
`337`	`338`	`log_conv(conv);`
`@@ -345,9 +346,9 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],`
`345`	`346`
`346`	`347`	`if expected_nargs < nargs {`
`347`	`348`	`cx.span_fatal(`
`348`		`- sp,`
	`349`	`+ sp, istr::from_estr(`
`349`	`350`	`#fmt["too many arguments to #fmt. found %u, expected %u",`
`350`		`- nargs, expected_nargs]);`
	`351`	`+ nargs, expected_nargs]));`
`351`	`352`	`}`
`352`	`353`	`ret tmp_expr;`
`353`	`354`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,16 +10,16 @@ fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, arg: @ast::expr,`
`10`	`10`	`alt arg.node {`
`11`	`11`	`ast::expr_vec(elts, _) { elts }`
`12`	`12`	`_ {`
`13`		`- cx.span_fatal(sp, "#ident_to_str requires a vector argument .")`
	`13`	`+ cx.span_fatal(sp, ~"#ident_to_str requires a vector argument .")`
`14`	`14`	`}`
`15`	`15`	`};`
`16`	`16`	`if vec::len::<@ast::expr>(args) != 1u {`
`17`		`- cx.span_fatal(sp, "malformed #ident_to_str call");`
	`17`	`+ cx.span_fatal(sp, ~"malformed #ident_to_str call");`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`ret make_new_lit(cx, sp,`
`21`	`21`	`ast::lit_str(expr_to_ident(cx, args[0u],`
`22`		`- "expected an ident"),`
	`22`	`+ ~"expected an ident"),`
`23`	`23`	`ast::sk_rc));`
`24`	`24`
`25`	`25`	`}`