Convert misc compiler bits to istrs. Issue #855

Author: brson

src/comp/driver/rustc.rs

@@ -47,21 +47,21 @@ fn default_configuration(sess: session::session,
    ast::crate_cfg {
     let libc =
         alt sess.get_targ_cfg().os {
-          session::os_win32. { "msvcrt.dll" }
-          session::os_macos. { "libc.dylib" }
-          session::os_linux. { "libc.so.6" }
-          _ { "libc.so" }
+          session::os_win32. { ~"msvcrt.dll" }
+          session::os_macos. { ~"libc.dylib" }
+          session::os_linux. { ~"libc.so.6" }
+          _ { ~"libc.so" }
         };
 
     let mk = attr::mk_name_value_item_str;
 
     ret [ // Target bindings.
-         mk(~"target_os", istr::to_estr(std::os::target_os())),
-        mk(~"target_arch", "x86"),
+         mk(~"target_os", std::os::target_os()),
+        mk(~"target_arch", ~"x86"),
          mk(~"target_libc", libc),
          // Build bindings.
-         mk(~"build_compiler", istr::to_estr(argv0)),
-        mk(~"build_input", istr::to_estr(input))];
+         mk(~"build_compiler", argv0),
+        mk(~"build_input", input)];
 }
 
 fn build_configuration(sess: session::session, argv0: &istr, input: &istr) ->

src/comp/front/attr.rs

@@ -197,8 +197,9 @@ fn span<@T>(item: &T) -> ast::spanned<T> {
     ret {node: item, span: ast_util::dummy_sp()};
 }
 
-fn mk_name_value_item_str(name: ast::ident, value: str) -> @ast::meta_item {
-    let value_lit = span(ast::lit_str(istr::from_estr(value), ast::sk_rc));
+fn mk_name_value_item_str(name: ast::ident,
+                          value: &istr) -> @ast::meta_item {
+    let value_lit = span(ast::lit_str(value, ast::sk_rc));
     ret mk_name_value_item(name, value_lit);
 }
 

src/comp/metadata/decoder.rs

@@ -310,7 +310,7 @@ fn get_meta_items(md: &ebml::doc) -> [@ast::meta_item] {
         let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
         let vd = ebml::get_doc(meta_item_doc, tag_meta_item_value);
         let n = istr::unsafe_from_bytes(ebml::doc_data(nd));
-        let v = str::unsafe_from_bytes(ebml::doc_data(vd));
+        let v = istr::unsafe_from_bytes(ebml::doc_data(vd));
         // FIXME (#611): Should be able to decode meta_name_value variants,
         // but currently they can't be encoded
         items += [attr::mk_name_value_item_str(n, v)];

src/comp/metadata/encoder.rs

@@ -511,10 +511,10 @@ fn synthesize_crate_attrs(ecx: &@encode_ctxt, crate: &@crate) -> [attribute] {
 
         let name_item =
             attr::mk_name_value_item_str(
-                ~"name", istr::to_estr(ecx.ccx.link_meta.name));
+                ~"name", ecx.ccx.link_meta.name);
         let vers_item =
             attr::mk_name_value_item_str(
-                ~"vers", istr::to_estr(ecx.ccx.link_meta.vers));
+                ~"vers", ecx.ccx.link_meta.vers);
 
         let other_items =
             {

src/comp/middle/kind.rs

@@ -112,44 +112,45 @@ fn type_and_kind(tcx: &ty::ctxt, e: &@ast::expr) ->
 }
 
 fn need_expr_kind(tcx: &ty::ctxt, e: &@ast::expr, k_need: ast::kind,
-                  descr: &str) {
+                  descr: &istr) {
     let tk = type_and_kind(tcx, e);
-    log #fmt["for %s: want %s type, got %s type %s", descr,
+    log #fmt["for %s: want %s type, got %s type %s", istr::to_estr(descr),
              kind_to_str(k_need), kind_to_str(tk.kind),
              istr::to_estr(util::ppaux::ty_to_str(tcx, tk.ty))];
 
     if !kind_lteq(k_need, tk.kind) {
         let s =
             #fmt["mismatched kinds for %s: needed %s type, got %s type %s",
-                 descr, kind_to_str(k_need), kind_to_str(tk.kind),
+                 istr::to_estr(descr), kind_to_str(k_need),
+                 kind_to_str(tk.kind),
                  istr::to_estr(util::ppaux::ty_to_str(tcx, tk.ty))];
         tcx.sess.span_err(e.span, istr::from_estr(s));
     }
 }
 
 fn need_shared_lhs_rhs(tcx: &ty::ctxt, a: &@ast::expr, b: &@ast::expr,
-                       op: &str) {
-    need_expr_kind(tcx, a, ast::kind_shared, op + " lhs");
-    need_expr_kind(tcx, b, ast::kind_shared, op + " rhs");
+                       op: &istr) {
+    need_expr_kind(tcx, a, ast::kind_shared, op + ~" lhs");
+    need_expr_kind(tcx, b, ast::kind_shared, op + ~" rhs");
 }
 
 fn check_expr(tcx: &ty::ctxt, e: &@ast::expr) {
     alt e.node {
-      ast::expr_move(a, b) { need_shared_lhs_rhs(tcx, a, b, "<-"); }
-      ast::expr_assign(a, b) { need_shared_lhs_rhs(tcx, a, b, "="); }
-      ast::expr_assign_op(_, a, b) { need_shared_lhs_rhs(tcx, a, b, "op="); }
-      ast::expr_swap(a, b) { need_shared_lhs_rhs(tcx, a, b, "<->"); }
+      ast::expr_move(a, b) { need_shared_lhs_rhs(tcx, a, b, ~"<-"); }
+      ast::expr_assign(a, b) { need_shared_lhs_rhs(tcx, a, b, ~"="); }
+      ast::expr_assign_op(_, a, b) { need_shared_lhs_rhs(tcx, a, b, ~"op="); }
+      ast::expr_swap(a, b) { need_shared_lhs_rhs(tcx, a, b, ~"<->"); }
       ast::expr_copy(a) {
-        need_expr_kind(tcx, a, ast::kind_shared, "'copy' operand");
+        need_expr_kind(tcx, a, ast::kind_shared, ~"'copy' operand");
       }
       ast::expr_ret(option::some(a)) {
-        need_expr_kind(tcx, a, ast::kind_shared, "'ret' operand");
+        need_expr_kind(tcx, a, ast::kind_shared, ~"'ret' operand");
       }
       ast::expr_be(a) {
-        need_expr_kind(tcx, a, ast::kind_shared, "'be' operand");
+        need_expr_kind(tcx, a, ast::kind_shared, ~"'be' operand");
       }
       ast::expr_fail(option::some(a)) {
-        need_expr_kind(tcx, a, ast::kind_shared, "'fail' operand");
+        need_expr_kind(tcx, a, ast::kind_shared, ~"'fail' operand");
       }
       ast::expr_call(callee, _) {
         let tpt = ty::expr_ty_params_and_ty(tcx, callee);

src/comp/middle/trans_alt.rs

@@ -58,9 +58,9 @@ fn variant_opt(ccx: &@crate_ctxt, pat_id: ast::node_id) -> opt {
 }
 
 type bind_map = [{ident: ast::ident, val: ValueRef}];
-fn assoc(key: str, list: &bind_map) -> option::t<ValueRef> {
+fn assoc(key: &istr, list: &bind_map) -> option::t<ValueRef> {
     for elt: {ident: ast::ident, val: ValueRef} in list {
-        if istr::eq(elt.ident, istr::from_estr(key)) { ret some(elt.val); }
+        if istr::eq(elt.ident, key) { ret some(elt.val); }
     }
     ret none;
 }
@@ -304,7 +304,7 @@ fn compile_submatch(bcx: @block_ctxt, m: &match, vals: [ValueRef],
             // the actual arm block.
             for each @{key, val} in data.id_map.items() {
                 bcx.fcx.lllocals.insert
-                    (val, option::get(assoc(istr::to_estr(key),
+                    (val, option::get(assoc(key,
                                             m[0].bound)));
             }
             let {bcx: guard_bcx, val: guard_val} =
@@ -474,7 +474,7 @@ fn make_phi_bindings(bcx: &@block_ctxt, map: &[exit_node],
         let vals = [];
         for ex: exit_node in map {
             if ex.to as uint == our_block {
-                alt assoc(istr::to_estr(item.key), ex.bound) {
+                alt assoc(item.key, ex.bound) {
                   some(val) { llbbs += [ex.from]; vals += [val]; }
                   none. { }
                 }

src/comp/middle/ty.rs

@@ -243,7 +243,7 @@ fn method_ty_to_fn_ty(cx: &ctxt, m: method) -> t {
 // Never construct these manually. These are interned.
 type raw_t =
     {struct: sty,
-     cname: option::t<str>,
+     cname: option::t<istr>,
      hash: uint,
      has_params: bool,
      has_vars: bool};
@@ -427,8 +427,8 @@ fn mk_ctxt(s: session::session, dm: resolve::def_map,
 
 
 // Type constructors
-fn mk_raw_ty(cx: &ctxt, st: &sty, _in_cname: &option::t<str>) -> @raw_t {
-    let cname = none;
+fn mk_raw_ty(cx: &ctxt, st: &sty, _in_cname: &option::t<istr>) -> @raw_t {
+    let cname: option::t<istr> = none;
     let h = hash_type_info(st, cname);
     let has_params: bool = false;
     let has_vars: bool = false;
@@ -505,11 +505,11 @@ fn mk_raw_ty(cx: &ctxt, st: &sty, _in_cname: &option::t<str>) -> @raw_t {
           has_vars: has_vars};
 }
 
-fn intern(cx: &ctxt, st: &sty, cname: &option::t<str>) {
+fn intern(cx: &ctxt, st: &sty, cname: &option::t<istr>) {
     interner::intern(*cx.ts, mk_raw_ty(cx, st, cname));
 }
 
-fn gen_ty_full(cx: &ctxt, st: &sty, cname: &option::t<str>) -> t {
+fn gen_ty_full(cx: &ctxt, st: &sty, cname: &option::t<istr>) -> t {
     let raw_type = mk_raw_ty(cx, st, cname);
     ret interner::intern(*cx.ts, raw_type);
 }
@@ -617,7 +617,7 @@ fn struct(cx: &ctxt, typ: t) -> sty {
 
 
 // Returns the canonical name of the given type.
-fn cname(cx: &ctxt, typ: t) -> option::t<str> {
+fn cname(cx: &ctxt, typ: t) -> option::t<istr> {
     ret interner::get(*cx.ts, typ).cname;
 }
 
@@ -794,7 +794,7 @@ fn fold_ty(cx: &ctxt, fld: fold_mode, ty_0: t) -> t {
 
 // Type utilities
 
-fn rename(cx: &ctxt, typ: t, new_cname: str) -> t {
+fn rename(cx: &ctxt, typ: t, new_cname: &istr) -> t {
     ret gen_ty_full(cx, struct(cx, typ), some(new_cname));
 }
 
@@ -1538,11 +1538,11 @@ fn hash_type_structure(st: &sty) -> uint {
     }
 }
 
-fn hash_type_info(st: &sty, cname_opt: &option::t<str>) -> uint {
+fn hash_type_info(st: &sty, cname_opt: &option::t<istr>) -> uint {
     let h = hash_type_structure(st);
     alt cname_opt {
       none. {/* no-op */ }
-      some(s) { h += h << 5u + str::hash(s); }
+      some(s) { h += h << 5u + istr::hash(s); }
     }
     ret h;
 }
@@ -1606,7 +1606,7 @@ fn eq_raw_ty(a: &@raw_t, b: &@raw_t) -> bool {
       none. { alt b.cname { none. {/* ok */ } _ { ret false; } } }
       some(s_a) {
         alt b.cname {
-          some(s_b) { if !str::eq(s_a, s_b) { ret false; } }
+          some(s_b) { if !istr::eq(s_a, s_b) { ret false; } }
           _ { ret false; }
         }
       }

src/comp/middle/typeck.rs

@@ -417,7 +417,7 @@ fn ast_ty_to_ty(tcx: &ty::ctxt, getter: &ty_getter, ast_ty: &@ast::ty) ->
     alt cname {
       none. {/* no-op */ }
       some(cname_str) {
-        typ = ty::rename(tcx, typ, istr::to_estr(cname_str));
+        typ = ty::rename(tcx, typ, cname_str);
       }
     }
     tcx.ast_ty_to_ty_cache.insert(ast_ty, some(typ));
@@ -629,7 +629,7 @@ mod collect {
                  ty_params: &[ast::ty_param]) -> ty::ty_param_kinds_and_ty {
         let methods = get_obj_method_types(cx, ob);
         let t_obj = ty::mk_obj(cx.tcx, ty::sort_methods(methods));
-        t_obj = ty::rename(cx.tcx, t_obj, istr::to_estr(id));
+        t_obj = ty::rename(cx.tcx, t_obj, id);
         ret {kinds: ty_param_kinds(ty_params), ty: t_obj};
     }
     fn ty_of_obj_ctor(cx: @ctxt, id: &ast::ident, ob: &ast::_obj,

src/comp/syntax/ext/env.rs

@@ -28,15 +28,15 @@ fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, arg: @ast::expr,
 
     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::none. { ret make_new_str(cx, sp, ~""); }
       option::some(s) {
-        ret make_new_str(cx, sp, istr::to_estr(s));
+        ret make_new_str(cx, sp, s);
       }
     }
 }
 
-fn make_new_str(cx: &ext_ctxt, sp: codemap::span, s: str) -> @ast::expr {
-    ret make_new_lit(cx, sp, ast::lit_str(istr::from_estr(s), ast::sk_rc));
+fn make_new_str(cx: &ext_ctxt, sp: codemap::span, s: &istr) -> @ast::expr {
+    ret make_new_lit(cx, sp, ast::lit_str(s, ast::sk_rc));
 }
 //
 // Local Variables: