---

yaml
---
r: 5013
b: refs/heads/master
c: 9857048
h: refs/heads/master
i:
  5011: 2d6947a
v: v3

Author: brson

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 3dc24194434ee918a2ee6e02065c1f11dfb10415
+refs/heads/master: 9857048929c1adc90a19b2027931ac73a28f21dc

trunk/src/comp/back/link.rs

@@ -35,16 +35,16 @@ tag output_type {
 fn llvm_err(sess: session::session, msg: &istr) {
     let buf = llvm::LLVMRustGetLastError();
     if buf == std::ptr::null() {
-        sess.fatal(istr::to_estr(msg));
+        sess.fatal(msg);
     } else {
         sess.fatal(
-            istr::to_estr(msg + ~": " + istr::str_from_cstr(buf)));
+            msg + ~": " + istr::str_from_cstr(buf));
     }
 }
 
 fn link_intrinsics(sess: session::session, llmod: ModuleRef) {
     let path =
-        fs::connect(istr::from_estr(sess.get_opts().sysroot),
+        fs::connect(sess.get_opts().sysroot,
                     ~"lib/intrinsics.bc");
     let membuf = istr::as_buf(path, { |buf|
         llvm::LLVMRustCreateMemoryBufferWithContentsOfFile(buf)
@@ -374,8 +374,9 @@ fn build_link_meta(sess: &session::session, c: &ast::crate, output: &istr,
 
     fn warn_missing(sess: &session::session, name: &istr, default: &istr) {
         if !sess.get_opts().library { ret; }
-        sess.warn(#fmt["missing crate link meta '%s', using '%s' as default",
-                       istr::to_estr(name), istr::to_estr(default)]);
+        sess.warn(istr::from_estr(
+            #fmt["missing crate link meta '%s', using '%s' as default",
+                       istr::to_estr(name), istr::to_estr(default)]));
     }
 
     fn crate_meta_name(sess: &session::session, _crate: &ast::crate,

trunk/src/comp/driver/rustc.rs

@@ -416,8 +416,8 @@ fn build_session_options(binary: str, match: &getopts::match, binary_dir: str)
           time_passes: time_passes,
           time_llvm_passes: time_llvm_passes,
           output_type: output_type,
-          library_search_paths: library_search_paths,
-          sysroot: sysroot,
+          library_search_paths: istr::from_estrs(library_search_paths),
+          sysroot: istr::from_estr(sysroot),
           cfg: cfg,
           test: test,
           parse_only: parse_only,
@@ -442,8 +442,8 @@ fn parse_pretty(sess: session::session, name: &istr) -> pp_mode {
     } else if istr::eq(name, ~"typed") {
         ret ppm_typed;
     } else if istr::eq(name, ~"identified") { ret ppm_identified; }
-    sess.fatal("argument to `pretty` must be one of `normal`, `typed`, or "
-               + "`identified`");
+    sess.fatal(~"argument to `pretty` must be one of `normal`, `typed`, or "
+               + ~"`identified`");
 }
 
 fn opts() -> [getopts::opt] {
@@ -486,16 +486,16 @@ fn main(args: [str]) {
     let glue = opt_present(match, ~"glue");
     if glue {
         if n_inputs > 0u {
-            sess.fatal("No input files allowed with --glue.");
+            sess.fatal(~"No input files allowed with --glue.");
         }
         let out = option::from_maybe::<istr>(~"glue.bc", output_file);
         middle::trans::make_common_glue(sess, out);
         ret;
     }
     if n_inputs == 0u {
-        sess.fatal("No input filename given.");
+        sess.fatal(~"No input filename given.");
     } else if n_inputs > 1u {
-        sess.fatal("Multiple input filenames provided.");
+        sess.fatal(~"Multiple input filenames provided.");
     }
     let ifile = match.free[0];
     let saved_out_filename: str = "";
@@ -631,9 +631,11 @@ fn main(args: [str]) {
 
     let err_code = run::run_program(prog, gcc_args);
     if 0 != err_code {
-        sess.err(#fmt["linking with gcc failed with code %d", err_code]);
-        sess.note(#fmt["gcc arguments: %s",
-                       istr::to_estr(istr::connect(gcc_args, ~" "))]);
+        sess.err(istr::from_estr(
+            #fmt["linking with gcc failed with code %d", err_code]));
+        sess.note(istr::from_estr(
+            #fmt["gcc arguments: %s",
+                       istr::to_estr(istr::connect(gcc_args, ~" "))]));
         sess.abort_if_errors();
     }
     // Clean up on Darwin

trunk/src/comp/driver/session.rs

@@ -38,15 +38,15 @@ type options =
      time_passes: bool,
      time_llvm_passes: bool,
      output_type: back::link::output_type,
-     library_search_paths: [str],
-     sysroot: str,
+     library_search_paths: [istr],
+     sysroot: istr,
      cfg: ast::crate_cfg,
      test: bool,
      parse_only: bool,
      no_trans: bool,
      do_gc: bool};
 
-type crate_metadata = {name: str, data: [u8]};
+type crate_metadata = {name: istr, data: [u8]};
 
 obj session(targ_cfg: @config,
             opts: @options,
@@ -59,50 +59,54 @@ obj session(targ_cfg: @config,
     fn get_targ_cfg() -> @config { ret targ_cfg; }
     fn get_opts() -> @options { ret opts; }
     fn get_cstore() -> metadata::cstore::cstore { cstore }
-    fn span_fatal(sp: span, msg: str) -> ! {
+    fn span_fatal(sp: span, msg: &istr) -> ! {
         // FIXME: Use constants, but rustboot doesn't know how to export them.
-        codemap::emit_error(some(sp), istr::from_estr(msg), parse_sess.cm);
+        codemap::emit_error(some(sp), msg, parse_sess.cm);
         fail;
     }
-    fn fatal(msg: str) -> ! {
-        codemap::emit_error(none, istr::from_estr(msg), parse_sess.cm);
+    fn fatal(msg: &istr) -> ! {
+        codemap::emit_error(none, msg, parse_sess.cm);
         fail;
     }
-    fn span_err(sp: span, msg: str) {
-        codemap::emit_error(some(sp), istr::from_estr(msg), parse_sess.cm);
+    fn span_err(sp: span, msg: &istr) {
+        codemap::emit_error(some(sp), msg, parse_sess.cm);
         err_count += 1u;
     }
-    fn err(msg: str) {
-        codemap::emit_error(none, istr::from_estr(msg), parse_sess.cm);
+    fn err(msg: &istr) {
+        codemap::emit_error(none, msg, parse_sess.cm);
         err_count += 1u;
     }
     fn abort_if_errors() {
-        if err_count > 0u { self.fatal("aborting due to previous errors"); }
+        if err_count > 0u { self.fatal(~"aborting due to previous errors"); }
     }
-    fn span_warn(sp: span, msg: str) {
+    fn span_warn(sp: span, msg: &istr) {
         // FIXME: Use constants, but rustboot doesn't know how to export them.
-        codemap::emit_warning(some(sp), istr::from_estr(msg), parse_sess.cm);
+        codemap::emit_warning(some(sp), msg, parse_sess.cm);
     }
-    fn warn(msg: str) {
-        codemap::emit_warning(none, istr::from_estr(msg), parse_sess.cm);
+    fn warn(msg: &istr) {
+        codemap::emit_warning(none, msg, parse_sess.cm);
     }
-    fn span_note(sp: span, msg: str) {
+    fn span_note(sp: span, msg: &istr) {
         // FIXME: Use constants, but rustboot doesn't know how to export them.
-        codemap::emit_note(some(sp), istr::from_estr(msg), parse_sess.cm);
+        codemap::emit_note(some(sp), msg, parse_sess.cm);
     }
-    fn note(msg: str) {
-        codemap::emit_note(none, istr::from_estr(msg), parse_sess.cm);
+    fn note(msg: &istr) {
+        codemap::emit_note(none, msg, parse_sess.cm);
     }
-    fn span_bug(sp: span, msg: str) -> ! {
-        self.span_fatal(sp, #fmt["internal compiler error %s", msg]);
+    fn span_bug(sp: span, msg: &istr) -> ! {
+        self.span_fatal(sp,
+                        istr::from_estr(#fmt["internal compiler error %s",
+                                             istr::to_estr(msg)]));
     }
-    fn bug(msg: str) -> ! {
-        self.fatal(#fmt["internal compiler error %s", msg]);
+    fn bug(msg: &istr) -> ! {
+        self.fatal(istr::from_estr(
+            #fmt["internal compiler error %s",
+                 istr::to_estr(msg)]));
     }
-    fn span_unimpl(sp: span, msg: str) -> ! {
-        self.span_bug(sp, "unimplemented " + msg);
+    fn span_unimpl(sp: span, msg: &istr) -> ! {
+        self.span_bug(sp, ~"unimplemented " + msg);
     }
-    fn unimpl(msg: str) -> ! { self.bug("unimplemented " + msg); }
+    fn unimpl(msg: &istr) -> ! { self.bug(~"unimplemented " + msg); }
     fn get_codemap() -> codemap::codemap { ret parse_sess.cm; }
     fn lookup_pos(pos: uint) -> codemap::loc {
         ret codemap::lookup_char_pos(parse_sess.cm, pos);
@@ -111,8 +115,8 @@ obj session(targ_cfg: @config,
     fn next_node_id() -> ast::node_id {
         ret syntax::parse::parser::next_node_id(parse_sess);
     }
-    fn span_str(sp: span) -> str {
-        ret istr::to_estr(codemap::span_to_str(sp, self.get_codemap()));
+    fn span_str(sp: span) -> istr {
+        ret codemap::span_to_str(sp, self.get_codemap());
     }
     fn set_main_id(d: node_id) { main_fn = some(d); }
     fn get_main_id() -> option::t<node_id> { main_fn }

trunk/src/comp/front/attr.rs

@@ -185,9 +185,9 @@ fn require_unique_names(sess: &session::session, metas: &[@ast::meta_item]) {
     for meta: @ast::meta_item in metas {
         let name = get_meta_item_name(meta);
         if map.contains_key(name) {
-            sess.span_fatal(meta.span,
+            sess.span_fatal(meta.span, istr::from_estr(
                             #fmt["duplicate meta item `%s`",
-                                 istr::to_estr(name)]);
+                                 istr::to_estr(name)]));
         }
         map.insert(name, ());
     }

trunk/src/comp/metadata/creader.rs

@@ -36,7 +36,7 @@ fn read_crates(sess: session::session, crate: &ast::crate) {
         @{sess: sess,
           crate_cache: @std::map::new_str_hash::<int>(),
           library_search_paths:
-          istr::from_estrs(sess.get_opts().library_search_paths),
+          sess.get_opts().library_search_paths,
           mutable next_crate_num: 1};
     let v =
         visit::mk_simple_visitor(@{visit_view_item:
@@ -230,8 +230,9 @@ fn load_library_crate(sess: &session::session, span: span, ident: &ast::ident,
     alt find_library_crate(sess, ident, metas, library_search_paths) {
       some(t) { ret t; }
       none. {
-        sess.span_fatal(span, #fmt["can't find crate for '%s'",
-                                   istr::to_estr(ident)]);
+        sess.span_fatal(span, istr::from_estr(
+                        #fmt["can't find crate for '%s'",
+                                   istr::to_estr(ident)]));
       }
     }
 }

trunk/src/comp/metadata/csearch.rs

@@ -63,7 +63,7 @@ fn translate_def_id(sess: &session::session, searched_crate: ast::crate_num,
     let local_cnum =
         alt cmeta.cnum_map.find(ext_cnum) {
           option::some(n) { n }
-          option::none. { sess.bug("didn't find a crate in the cnum_map") }
+          option::none. { sess.bug(~"didn't find a crate in the cnum_map") }
         };
 
     ret {crate: local_cnum, node: node_id};