librustc: change driver::session::Session::str_of to return @~str

Author: erickt

src/librustc/back/link.rs

@@ -655,7 +655,7 @@ pub fn mangle(sess: Session, ss: path) -> ~str {
 
     for ss.each |s| {
         match *s { path_name(s) | path_mod(s) => {
-          let sani = sanitize(sess.str_of(s));
+          let sani = sanitize(*sess.str_of(s));
           n += fmt!("%u%s", str::len(sani), sani);
         } }
     }

src/librustc/driver/session.rs

@@ -253,8 +253,8 @@ pub impl Session {
         self.debugging_opt(no_monomorphic_collapse)
     }
 
-    fn str_of(id: ast::ident) -> ~str {
-        /*bad*/copy *self.parse_sess.interner.get(id)
+    fn str_of(id: ast::ident) -> @~str {
+        self.parse_sess.interner.get(id)
     }
     fn ident_of(+st: ~str) -> ast::ident {
         self.parse_sess.interner.intern(@st)

src/librustc/metadata/encoder.rs

@@ -104,13 +104,13 @@ pub fn reachable(ecx: @encode_ctxt, id: node_id) -> bool {
 }
 
 fn encode_name(ecx: @encode_ctxt, ebml_w: writer::Encoder, name: ident) {
-    ebml_w.wr_tagged_str(tag_paths_data_name, ecx.tcx.sess.str_of(name));
+    ebml_w.wr_tagged_str(tag_paths_data_name, *ecx.tcx.sess.str_of(name));
 }
 
 fn encode_impl_type_basename(ecx: @encode_ctxt, ebml_w: writer::Encoder,
                              name: ident) {
     ebml_w.wr_tagged_str(tag_item_impl_type_basename,
-                         ecx.tcx.sess.str_of(name));
+                         *ecx.tcx.sess.str_of(name));
 }
 
 pub fn encode_def_id(ebml_w: writer::Encoder, id: def_id) {
@@ -305,7 +305,7 @@ fn encode_path(ecx: @encode_ctxt, ebml_w: writer::Encoder,
           ast_map::path_name(name) => (tag_path_elt_name, name)
         };
 
-        ebml_w.wr_tagged_str(tag, ecx.tcx.sess.str_of(name));
+        ebml_w.wr_tagged_str(tag, *ecx.tcx.sess.str_of(name));
     }
 
     do ebml_w.wr_tag(tag_path) {
@@ -333,7 +333,7 @@ fn encode_info_for_mod(ecx: @encode_ctxt, ebml_w: writer::Encoder,
                 let (ident, did) = (item.ident, item.id);
                 debug!("(encoding info for module) ... encoding impl %s \
                         (%?/%?)",
-                        ecx.tcx.sess.str_of(ident),
+                        *ecx.tcx.sess.str_of(ident),
                         did,
                         ast_map::node_id_to_str(ecx.tcx.items, did, ecx.tcx
                                                 .sess.parse_sess.interner));
@@ -353,15 +353,15 @@ fn encode_info_for_mod(ecx: @encode_ctxt, ebml_w: writer::Encoder,
     match ecx.reexports2.find(&id) {
         Some(ref exports) => {
             debug!("(encoding info for module) found reexports for %d", id);
-            for (*exports).each |exp| {
+            for exports.each |exp| {
                 debug!("(encoding info for module) reexport '%s' for %d",
-                       exp.name, id);
+                       *exp.name, id);
                 ebml_w.start_tag(tag_items_data_item_reexport);
                 ebml_w.start_tag(tag_items_data_item_reexport_def_id);
                 ebml_w.wr_str(def_to_str(exp.def_id));
                 ebml_w.end_tag();
                 ebml_w.start_tag(tag_items_data_item_reexport_name);
-                ebml_w.wr_str(exp.name);
+                ebml_w.wr_str(*exp.name);
                 ebml_w.end_tag();
                 ebml_w.end_tag();
             }
@@ -447,7 +447,7 @@ fn encode_info_for_struct(ecx: @encode_ctxt, ebml_w: writer::Encoder,
         global_index.push({val: id, pos: ebml_w.writer.tell()});
         ebml_w.start_tag(tag_items_data_item);
         debug!("encode_info_for_struct: doing %s %d",
-               tcx.sess.str_of(nm), id);
+               *tcx.sess.str_of(nm), id);
         encode_visibility(ebml_w, vis);
         encode_name(ecx, ebml_w, nm);
         encode_path(ecx, ebml_w, path, ast_map::path_name(nm));
@@ -470,7 +470,7 @@ fn encode_info_for_ctor(ecx: @encode_ctxt, ebml_w: writer::Encoder,
         encode_type_param_bounds(ebml_w, ecx, tps);
         let its_ty = node_id_to_type(ecx.tcx, id);
         debug!("fn name = %s ty = %s its node id = %d",
-               ecx.tcx.sess.str_of(ident),
+               *ecx.tcx.sess.str_of(ident),
                ty_to_str(ecx.tcx, its_ty), id);
         encode_type(ecx, ebml_w, its_ty);
         encode_path(ecx, ebml_w, path, ast_map::path_name(ident));
@@ -515,7 +515,7 @@ fn encode_info_for_method(ecx: @encode_ctxt,
                           m: @method,
                           +all_tps: ~[ty_param]) {
     debug!("encode_info_for_method: %d %s %u", m.id,
-           ecx.tcx.sess.str_of(m.ident), all_tps.len());
+           *ecx.tcx.sess.str_of(m.ident), all_tps.len());
     ebml_w.start_tag(tag_items_data_item);
     encode_def_id(ebml_w, local_def(m.id));
     match m.self_ty.node {
@@ -678,7 +678,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: writer::Encoder,
                                ebml_w,
                                dtor.node.id,
                                ecx.tcx.sess.ident_of(
-                                   ecx.tcx.sess.str_of(item.ident) +
+                                   *ecx.tcx.sess.str_of(item.ident) +
                                    ~"_dtor"),
                                path,
                                if tps.len() > 0u {
@@ -1186,7 +1186,7 @@ fn encode_crate_dep(ecx: @encode_ctxt, ebml_w: writer::Encoder,
                     dep: decoder::crate_dep) {
     ebml_w.start_tag(tag_crate_dep);
     ebml_w.start_tag(tag_crate_dep_name);
-    ebml_w.writer.write(str::to_bytes(ecx.tcx.sess.str_of(dep.name)));
+    ebml_w.writer.write(str::to_bytes(*ecx.tcx.sess.str_of(dep.name)));
     ebml_w.end_tag();
     ebml_w.start_tag(tag_crate_dep_vers);
     ebml_w.writer.write(str::to_bytes(*dep.vers));

src/librustc/metadata/tyencode.rs

@@ -175,7 +175,7 @@ fn enc_bound_region(w: io::Writer, cx: @ctxt, br: ty::bound_region) {
       }
       ty::br_named(s) => {
         w.write_char('[');
-        w.write_str(cx.tcx.sess.str_of(s));
+        w.write_str(*cx.tcx.sess.str_of(s));
         w.write_char(']')
       }
       ty::br_cap_avoid(id, br) => {
@@ -282,7 +282,7 @@ fn enc_sty(w: io::Writer, cx: @ctxt, +st: ty::sty) {
       ty::ty_rec(fields) => {
         w.write_str(&"R[");
         for fields.each |field| {
-            w.write_str(cx.tcx.sess.str_of(field.ident));
+            w.write_str(*cx.tcx.sess.str_of(field.ident));
             w.write_char('=');
             enc_mt(w, cx, field.mt);
         }

src/librustc/middle/astencode.rs

@@ -96,7 +96,7 @@ pub fn encode_inlined_item(ecx: @e::encode_ctxt,
                            maps: Maps) {
     debug!("> Encoding inlined item: %s::%s (%u)",
            ast_map::path_to_str(path, ecx.tcx.sess.parse_sess.interner),
-           ecx.tcx.sess.str_of(ii.ident()),
+           *ecx.tcx.sess.str_of(ii.ident()),
            ebml_w.writer.tell());
 
     let id_range = ast_util::compute_id_range_for_inlined_item(ii);
@@ -108,7 +108,7 @@ pub fn encode_inlined_item(ecx: @e::encode_ctxt,
 
     debug!("< Encoded inlined fn: %s::%s (%u)",
            ast_map::path_to_str(path, ecx.tcx.sess.parse_sess.interner),
-           ecx.tcx.sess.str_of(ii.ident()),
+           *ecx.tcx.sess.str_of(ii.ident()),
            ebml_w.writer.tell());
 }
 
@@ -132,10 +132,10 @@ pub fn decode_inlined_item(cdata: cstore::crate_metadata,
                                           to_id_range: to_id_range});
         let raw_ii = decode_ast(ast_doc);
         let ii = renumber_ast(xcx, raw_ii);
-        debug!("Fn named: %s", tcx.sess.str_of(ii.ident()));
+        debug!("Fn named: %s", *tcx.sess.str_of(ii.ident()));
         debug!("< Decoded inlined fn: %s::%s",
                ast_map::path_to_str(path, tcx.sess.parse_sess.interner),
-               tcx.sess.str_of(ii.ident()));
+               *tcx.sess.str_of(ii.ident()));
         ast_map::map_decoded_item(tcx.sess.diagnostic(),
                                   dcx.tcx.items, path, ii);
         decode_side_tables(xcx, ast_doc);

src/librustc/middle/check_match.rs

@@ -143,13 +143,13 @@ pub fn check_exhaustive(cx: @MatchCheckCtxt, sp: span, pats: ~[@pat]) {
             match ty::get(ty).sty {
                 ty::ty_bool => {
                     match (*ctor) {
-                        val(const_bool(true)) => Some(~"true"),
-                        val(const_bool(false)) => Some(~"false"),
+                        val(const_bool(true)) => Some(@~"true"),
+                        val(const_bool(false)) => Some(@~"false"),
                         _ => None
                     }
                 }
                 ty::ty_enum(id, _) => {
-                    let vid = match (*ctor) {
+                    let vid = match *ctor {
                         variant(id) => id,
                         _ => fail!(~"check_exhaustive: non-variant ctor"),
                     };
@@ -163,8 +163,8 @@ pub fn check_exhaustive(cx: @MatchCheckCtxt, sp: span, pats: ~[@pat]) {
                     }
                 }
                 ty::ty_unboxed_vec(*) | ty::ty_evec(*) => {
-                    match (*ctor) {
-                        vec(n) => Some(fmt!("vectors of length %u", n)),
+                    match *ctor {
+                        vec(n) => Some(@fmt!("vectors of length %u", n)),
                     _ => None
                     }
                 }
@@ -173,7 +173,7 @@ pub fn check_exhaustive(cx: @MatchCheckCtxt, sp: span, pats: ~[@pat]) {
         }
     };
     let msg = ~"non-exhaustive patterns" + match ext {
-        Some(ref s) => ~": " + (*s) + ~" not covered",
+        Some(ref s) => ~": " + **s + ~" not covered",
         None => ~""
     };
     cx.tcx.sess.span_err(sp, msg);

src/librustc/middle/liveness.rs

@@ -383,11 +383,11 @@ impl IrMaps {
         }
     }
 
-    fn variable_name(&mut self, var: Variable) -> ~str {
+    fn variable_name(&mut self, var: Variable) -> @~str {
         match copy self.var_kinds[*var] {
             Local(LocalInfo {ident: nm, _}) |
             Arg(_, nm, _) => self.tcx.sess.str_of(nm),
-            ImplicitRet => ~"<implicit-ret>"
+            ImplicitRet => @~"<implicit-ret>"
         }
     }
 
@@ -1777,7 +1777,7 @@ impl @Liveness {
                 self.tcx.sess.span_err(
                     move_expr.span,
                     fmt!("illegal move from argument `%s`, which is not \
-                          copy or move mode", self.tcx.sess.str_of(name)));
+                          copy or move mode", *self.tcx.sess.str_of(name)));
                 return;
               }
               Local(*) | ImplicitRet => {
@@ -1798,7 +1798,7 @@ impl @Liveness {
                     move_expr.span,
                     fmt!("`%s` moved into closure environment here \
                           because its type is moved by default",
-                         name));
+                         *name));
             }
             expr_path(*) => {
                 self.report_illegal_read(
@@ -1838,7 +1838,7 @@ impl @Liveness {
             move_expr.span,
             fmt!("%s`%s` moved here because %s has type %s, \
                   which is moved by default (use `copy` to override)",
-                 expr_descr, name, pronoun,
+                 expr_descr, *name, pronoun,
                  ty_to_str(self.tcx, move_expr_ty)));
     }
 
@@ -1858,12 +1858,12 @@ impl @Liveness {
           FreeVarNode(span) => {
             self.tcx.sess.span_err(
                 span,
-                fmt!("capture of %s: `%s`", msg, name));
+                fmt!("capture of %s: `%s`", msg, *name));
           }
           ExprNode(span) => {
             self.tcx.sess.span_err(
                 span,
-                fmt!("use of %s: `%s`", msg, name));
+                fmt!("use of %s: `%s`", msg, *name));
           }
           ExitNode | VarDefNode(_) => {
             self.tcx.sess.span_bug(
@@ -1873,9 +1873,9 @@ impl @Liveness {
         }
     }
 
-    fn should_warn(var: Variable) -> Option<~str> {
+    fn should_warn(var: Variable) -> Option<@~str> {
         let name = self.ir.variable_name(var);
-        if name[0] == ('_' as u8) {None} else {Some(name)}
+        if name[0] == ('_' as u8) { None } else { Some(name) }
     }
 
     fn warn_about_unused_args(decl: fn_decl, entry_ln: LiveNode) {
@@ -1913,11 +1913,11 @@ impl @Liveness {
                     // FIXME(#3266)--make liveness warnings lintable
                     self.tcx.sess.span_warn(
                         sp, fmt!("variable `%s` is assigned to, \
-                                  but never used", *name));
+                                  but never used", **name));
                 } else {
                     // FIXME(#3266)--make liveness warnings lintable
                     self.tcx.sess.span_warn(
-                        sp, fmt!("unused variable: `%s`", *name));
+                        sp, fmt!("unused variable: `%s`", **name));
                 }
             }
             return true;
@@ -1931,7 +1931,7 @@ impl @Liveness {
                 // FIXME(#3266)--make liveness warnings lintable
                 self.tcx.sess.span_warn(
                     sp,
-                    fmt!("value assigned to `%s` is never read", *name));
+                    fmt!("value assigned to `%s` is never read", **name));
             }
         }
     }

src/librustc/middle/mem_categorization.rs

@@ -629,7 +629,7 @@ pub impl mem_categorization_ctxt {
                 self.tcx.sess.span_bug(
                     node.span(),
                     fmt!("Cannot find field `%s` in type `%s`",
-                         self.tcx.sess.str_of(f_name),
+                         *self.tcx.sess.str_of(f_name),
                          ty_to_str(self.tcx, base_cmt.ty)));
             }
         };
@@ -995,7 +995,7 @@ pub impl mem_categorization_ctxt {
                  self.ptr_sigil(ptr), derefs)
           }
           cat_comp(cmt, comp) => {
-            fmt!("%s.%s", self.cat_to_repr(cmt.cat), self.comp_to_repr(comp))
+            fmt!("%s.%s", self.cat_to_repr(cmt.cat), *self.comp_to_repr(comp))
           }
           cat_discr(cmt, _) => self.cat_to_repr(cmt.cat)
         }
@@ -1018,13 +1018,13 @@ pub impl mem_categorization_ctxt {
         }
     }
 
-    fn comp_to_repr(&self, comp: comp_kind) -> ~str {
+    fn comp_to_repr(&self, comp: comp_kind) -> @~str {
         match comp {
           comp_field(fld, _) => self.tcx.sess.str_of(fld),
-          comp_index(*) => ~"[]",
-          comp_tuple => ~"()",
-          comp_anon_field => ~"<anonymous field>",
-          comp_variant(_) => ~"<enum>"
+          comp_index(*) => @~"[]",
+          comp_tuple => @~"()",
+          comp_anon_field => @~"<anonymous field>",
+          comp_variant(_) => @~"<enum>"
         }
     }
 
@@ -1043,7 +1043,7 @@ pub impl mem_categorization_ctxt {
           }
           lp_comp(lp, comp) => {
             fmt!("%s.%s", self.lp_to_str(lp),
-                 self.comp_to_repr(comp))
+                 *self.comp_to_repr(comp))
           }
         }
     }