Tear out ty_str and ty_vec.

Author: msullivan

src/libstd/rope.rs

@@ -1242,7 +1242,7 @@ mod tests {
           node::empty { ret ~"" }
           node::content(x) {
             let str = @mut ~"";
-            fn aux(str: @mut str, node: @node::node) unsafe {
+            fn aux(str: @mut ~str, node: @node::node) unsafe {
                 alt(*node) {
                   node::leaf(x) {
                     *str += str::slice(

src/rustc/front/test.rs

@@ -272,7 +272,7 @@ fn mk_test_desc_vec_ty(cx: test_ctxt) -> @ast::ty {
                      node: ast::ty_vec(vec_mt),
                      span: dummy_sp()};
     ret @{id: cx.sess.next_node_id(),
-          node: ast::ty_vstore(inner_ty, ast::vstore_uniq),
+          node: ast::ty_uniq({ty: inner_ty, mutbl: ast::m_imm}),
           span: dummy_sp()};
 }
 
@@ -411,14 +411,14 @@ fn mk_main(cx: test_ctxt) -> @ast::item {
                          node: ast::ty_path(str_pt, cx.sess.next_node_id()),
                          span: dummy_sp()};
     let str_ty = @{id: cx.sess.next_node_id(),
-                   node: ast::ty_vstore(str_ty_inner, ast::vstore_uniq),
+                   node: ast::ty_uniq({ty: str_ty_inner, mutbl: ast::m_imm}),
                    span: dummy_sp()};
     let args_mt = {ty: str_ty, mutbl: ast::m_imm};
     let args_ty_inner = @{id: cx.sess.next_node_id(),
                           node: ast::ty_vec(args_mt),
                           span: dummy_sp()};
     let args_ty = {id: cx.sess.next_node_id(),
-                   node: ast::ty_vstore(args_ty_inner, ast::vstore_uniq),
+                   node: ast::ty_uniq({ty: args_ty_inner, mutbl: ast::m_imm}),
                    span: dummy_sp()};
 
 

src/rustc/metadata/tydecode.rs

@@ -277,7 +277,6 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
         }
       }
       'c' { ret ty::mk_char(st.tcx); }
-      'S' { ret ty::mk_str(st.tcx); }
       't' {
         assert (next(st) == '[');
         let def = parse_def(st, conv);
@@ -307,7 +306,6 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
         let mt = parse_mt(st, conv);
         ret ty::mk_rptr(st.tcx, r, mt);
       }
-      'I' { ret ty::mk_vec(st.tcx, parse_mt(st, conv)); }
       'U' { ret ty::mk_unboxed_vec(st.tcx, parse_mt(st, conv)); }
       'V' {
         let mt = parse_mt(st, conv);

src/rustc/metadata/tyencode.rs

@@ -214,7 +214,6 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) {
           ty_f64 { w.write_str(&"MF"); }
         }
       }
-      ty::ty_str { w.write_char('S'); }
       ty::ty_enum(def, substs) {
         w.write_str(&"t[");
         w.write_str(cx.ds(def));
@@ -251,7 +250,6 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) {
         w.write_char('v');
         enc_vstore(w, cx, v);
       }
-      ty::ty_vec(mt) { w.write_char('I'); enc_mt(w, cx, mt); }
       ty::ty_unboxed_vec(mt) { w.write_char('U'); enc_mt(w, cx, mt); }
       ty::ty_rec(fields) {
         w.write_str(&"R[");

src/rustc/middle/borrowck.rs

@@ -516,11 +516,11 @@ impl to_str_methods for borrowck_ctxt {
           cat_comp(_, comp_variant(_)) { ~"enum content" }
           cat_comp(_, comp_index(t, _)) {
             alt ty::get(t).struct {
-              ty::ty_vec(*) | ty::ty_evec(*) {
+              ty::ty_evec(*) {
                 mut_str + ~" vec content"
               }
 
-              ty::ty_str | ty::ty_estr(*) {
+              ty::ty_estr(*) {
                 mut_str + ~" str content"
               }
 

src/rustc/middle/borrowck/categorization.rs

@@ -44,7 +44,7 @@ export opt_deref_kind;
 // pointer adjustment).
 fn opt_deref_kind(t: ty::t) -> option<deref_kind> {
     alt ty::get(t).struct {
-      ty::ty_uniq(*) | ty::ty_vec(*) | ty::ty_str |
+      ty::ty_uniq(*) |
       ty::ty_evec(_, ty::vstore_uniq) |
       ty::ty_estr(ty::vstore_uniq) {
         some(deref_ptr(uniq_ptr))
@@ -100,8 +100,7 @@ impl public_methods for borrowck_ctxt {
         // a borrowed expression must be either an @, ~, or a vec/@, vec/~
         let expr_ty = ty::expr_ty(self.tcx, expr);
         alt ty::get(expr_ty).struct {
-          ty::ty_vec(*) | ty::ty_evec(*) |
-          ty::ty_str | ty::ty_estr(*) {
+          ty::ty_evec(*) | ty::ty_estr(*) {
             self.cat_index(expr, expr)
           }
 

src/rustc/middle/trans/alt.rs

@@ -51,7 +51,7 @@ fn trans_opt(bcx: block, o: opt) -> opt_result {
           ast::expr_vstore(@{node: ast::expr_lit(
               @{node: ast::lit_str(s), _}), _},
                            ast::vstore_uniq) {
-            let strty = ty::mk_str(bcx.tcx());
+            let strty = ty::mk_estr(bcx.tcx(), ty::vstore_uniq);
             let cell = empty_dest_cell();
             bcx = tvec::trans_estr(bcx, s, ast::vstore_uniq, by_val(cell));
             add_clean_temp(bcx, *cell, strty);

src/rustc/middle/trans/base.rs

@@ -626,7 +626,6 @@ fn make_take_glue(bcx: block, v: ValueRef, t: ty::t) {
         Store(bcx, val, v);
         bcx
       }
-      ty::ty_vec(_) | ty::ty_str |
       ty::ty_evec(_, ty::vstore_uniq) | ty::ty_estr(ty::vstore_uniq) {
         let {bcx, val} = tvec::duplicate_uniq(bcx, Load(bcx, v), t);
         Store(bcx, val, v);
@@ -704,8 +703,7 @@ fn make_free_glue(bcx: block, v: ValueRef, t: ty::t) {
         uniq::make_free_glue(bcx, v, t)
       }
       ty::ty_evec(_, ty::vstore_uniq) | ty::ty_estr(ty::vstore_uniq) |
-      ty::ty_evec(_, ty::vstore_box) | ty::ty_estr(ty::vstore_box) |
-      ty::ty_vec(_) | ty::ty_str {
+      ty::ty_evec(_, ty::vstore_box) | ty::ty_estr(ty::vstore_box) {
         make_free_glue(bcx, v,
                        tvec::expand_boxed_vec_ty(bcx.tcx(), t));
         ret;
@@ -769,7 +767,7 @@ fn make_drop_glue(bcx: block, v0: ValueRef, t: ty::t) {
       ty::ty_estr(ty::vstore_box) | ty::ty_evec(_, ty::vstore_box) {
         decr_refcnt_maybe_free(bcx, Load(bcx, v0), t)
       }
-      ty::ty_uniq(_) | ty::ty_vec(_) | ty::ty_str |
+      ty::ty_uniq(_) |
       ty::ty_evec(_, ty::vstore_uniq) | ty::ty_estr(ty::vstore_uniq) {
         free_ty(bcx, Load(bcx, v0), t)
       }
@@ -1235,7 +1233,7 @@ fn drop_ty(cx: block, v: ValueRef, t: ty::t) -> block {
 fn drop_ty_immediate(bcx: block, v: ValueRef, t: ty::t) -> block {
     let _icx = bcx.insn_ctxt(~"drop_ty_immediate");
     alt ty::get(t).struct {
-      ty::ty_uniq(_) | ty::ty_vec(_) | ty::ty_str |
+      ty::ty_uniq(_) |
       ty::ty_evec(_, ty::vstore_uniq) |
       ty::ty_estr(ty::vstore_uniq) {
         free_ty(bcx, v, t)
@@ -1261,7 +1259,6 @@ fn take_ty_immediate(bcx: block, v: ValueRef, t: ty::t) -> result {
       ty::ty_uniq(_) {
         uniq::duplicate(bcx, v, t)
       }
-      ty::ty_str | ty::ty_vec(_) |
       ty::ty_evec(_, ty::vstore_uniq) |
       ty::ty_estr(ty::vstore_uniq) {
         tvec::duplicate_uniq(bcx, v, t)
@@ -2972,9 +2969,7 @@ fn adapt_borrowed_value(lv: lval_result,
         ret {lv: lval_temp(bcx, body_ptr), ty: rptr_ty};
       }
 
-      ty::ty_str | ty::ty_vec(_) |
-      ty::ty_estr(_) |
-      ty::ty_evec(_, _) {
+      ty::ty_estr(_) | ty::ty_evec(_, _) {
         let ccx = bcx.ccx();
         let val = alt lv.kind {
           temporary { lv.val }
@@ -4997,10 +4992,11 @@ fn create_main_wrapper(ccx: @crate_ctxt, sp: span, main_llfn: ValueRef,
 
     fn create_main(ccx: @crate_ctxt, main_llfn: ValueRef,
                    takes_argv: bool) -> ValueRef {
-        let unit_ty = ty::mk_str(ccx.tcx);
+        let unit_ty = ty::mk_estr(ccx.tcx, ty::vstore_uniq);
         let vecarg_ty: ty::arg =
             {mode: ast::expl(ast::by_val),
-             ty: ty::mk_vec(ccx.tcx, {ty: unit_ty, mutbl: ast::m_imm})};
+             ty: ty::mk_evec(ccx.tcx, {ty: unit_ty, mutbl: ast::m_imm},
+                             ty::vstore_uniq)};
         let nt = ty::mk_nil(ccx.tcx);
         let llfty = type_of_fn(ccx, ~[vecarg_ty], nt);
         let llfdecl = decl_fn(ccx.llmod, ~"_rust_main",

src/rustc/middle/trans/reflect.rs

@@ -132,9 +132,7 @@ impl methods for reflector {
           ty::ty_float(ast::ty_f) { self.leaf(~"float") }
           ty::ty_float(ast::ty_f32) { self.leaf(~"f32") }
           ty::ty_float(ast::ty_f64) { self.leaf(~"f64") }
-          ty::ty_str { self.leaf(~"str") }
 
-          ty::ty_vec(mt) { self.visit(~"vec", self.c_mt(mt)) }
           ty::ty_unboxed_vec(mt) { self.visit(~"vec", self.c_mt(mt)) }
           ty::ty_estr(vst) {
             do self.vstore_name_and_extra(t, vst) |name, extra| {

src/rustc/middle/trans/shape.rs

@@ -228,8 +228,7 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t) -> ~[u8] {
       ty::ty_int(ast::ty_i64) { ~[shape_i64] }
       ty::ty_float(ast::ty_f32) { ~[shape_f32] }
       ty::ty_float(ast::ty_f64) { ~[shape_f64] }
-      ty::ty_estr(ty::vstore_uniq) |
-      ty::ty_str {
+      ty::ty_estr(ty::vstore_uniq) {
         shape_of(ccx, tvec::expand_boxed_vec_ty(ccx.tcx, t))
       }
       ty::ty_enum(did, substs) {
@@ -268,8 +267,7 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t) -> ~[u8] {
         add_substr(s, shape_of(ccx, mt.ty));
         s
       }
-      ty::ty_evec(mt, ty::vstore_uniq) |
-      ty::ty_vec(mt) {
+      ty::ty_evec(mt, ty::vstore_uniq) {
         shape_of(ccx, tvec::expand_boxed_vec_ty(ccx.tcx, t))
       }
 
@@ -716,7 +714,7 @@ fn simplify_type(tcx: ty::ctxt, typ: ty::t) -> ty::t {
     }
     fn simplifier(tcx: ty::ctxt, typ: ty::t) -> ty::t {
         alt ty::get(typ).struct {
-          ty::ty_box(_) | ty::ty_opaque_box | ty::ty_uniq(_) | ty::ty_vec(_) |
+          ty::ty_box(_) | ty::ty_opaque_box | ty::ty_uniq(_) |
           ty::ty_evec(_, ty::vstore_uniq) | ty::ty_evec(_, ty::vstore_box) |
           ty::ty_estr(ty::vstore_uniq) | ty::ty_estr(ty::vstore_box) |
           ty::ty_ptr(_) | ty::ty_rptr(_,_) { nilptr(tcx) }