---

yaml
---
r: 4801
b: refs/heads/master
c: c2d2dad
h: refs/heads/master
i:
  4799: f747cd9
v: v3

Author: brson

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: ec898244f7b543dfe4c5a04fd42e638d7c521f7b
+refs/heads/master: c2d2dad093401ad97f19f96def0aa3f3f2a863bb

trunk/src/comp/metadata/tydecode.rs

@@ -217,7 +217,6 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t {
       '@' { ret ty::mk_box(st.tcx, parse_mt(st, sd)); }
       '~' { ret ty::mk_uniq(st.tcx, parse_ty(st, sd)); }
       '*' { ret ty::mk_ptr(st.tcx, parse_mt(st, sd)); }
-      'V' { ret ty::mk_vec(st.tcx, parse_mt(st, sd)); }
       'I' { ret ty::mk_ivec(st.tcx, parse_mt(st, sd)); }
       'R' {
         assert (next(st) as char == '[');

trunk/src/comp/metadata/tyencode.rs

@@ -128,7 +128,6 @@ fn enc_sty(w: &io::writer, cx: &@ctxt, st: &ty::sty) {
       ty::ty_box(mt) { w.write_char('@'); enc_mt(w, cx, mt); }
       ty::ty_uniq(t) { w.write_char('~'); enc_ty(w, cx, t); }
       ty::ty_ptr(mt) { w.write_char('*'); enc_mt(w, cx, mt); }
-      ty::ty_vec(mt) { w.write_char('V'); enc_mt(w, cx, mt); }
       ty::ty_ivec(mt) { w.write_char('I'); enc_mt(w, cx, mt); }
       ty::ty_rec(fields) {
         w.write_str("R[");

trunk/src/comp/middle/alias.rs

@@ -364,7 +364,7 @@ fn check_for(cx: &ctx, local: &@ast::local, seq: &@ast::expr, blk: &ast::blk,
     // If this is a mutable vector, don't allow it to be touched.
     let seq_t = ty::expr_ty(cx.tcx, seq);
     alt ty::struct(cx.tcx, seq_t) {
-      ty::ty_vec(mt) | ty::ty_ivec(mt) {
+      ty::ty_ivec(mt) {
         if mt.mut != ast::imm { unsafe = ~[seq_t]; }
       }
       ty::ty_str. | ty::ty_istr. {/* no-op */ }
@@ -584,12 +584,6 @@ fn expr_root(cx: &ctx, ex: @ast::expr, autoderef: bool) ->
           ast::expr_index(base, _) {
             let auto_unbox = maybe_auto_unbox(cx, ty::expr_ty(cx.tcx, base));
             alt ty::struct(cx.tcx, auto_unbox.t) {
-              ty::ty_vec(mt) {
-                ds +=
-                    ~[@{mut: mt.mut != ast::imm,
-                        kind: index,
-                        outer_t: auto_unbox.t}];
-              }
               ty::ty_ivec(mt) {
                 ds +=
                     ~[@{mut: mt.mut != ast::imm,
@@ -666,7 +660,7 @@ fn ty_can_unsafely_include(cx: &ctx, needle: ty::t, haystack: ty::t,
             }
             ret false;
           }
-          ty::ty_box(mt) | ty::ty_vec(mt) | ty::ty_ptr(mt) {
+          ty::ty_box(mt) | ty::ty_ptr(mt) {
             ret helper(tcx, needle, mt.ty, get_mut(mut, mt));
           }
           ty::ty_uniq(t) { ret helper(tcx, needle, t, false); }

trunk/src/comp/middle/gc.rs

@@ -130,7 +130,7 @@ fn type_is_gc_relevant(cx: &ty::ctxt, ty: &ty::t) -> bool {
         ty::ty_ivec(tm) { ret type_is_gc_relevant(cx, tm.ty); }
         ty::ty_constr(sub, _) { ret type_is_gc_relevant(cx, sub); }
 
-        ty::ty_str. | ty::ty_box(_) | ty::ty_uniq(_) | ty::ty_vec(_) |
+        ty::ty_str. | ty::ty_box(_) | ty::ty_uniq(_) |
         ty::ty_fn(_,_,_,_,_) | ty::ty_native_fn(_,_,_) | ty::ty_obj(_) |
         ty::ty_param(_,_) | ty::ty_res(_,_,_) { ret true; }
 

trunk/src/comp/middle/shape.rs

@@ -343,11 +343,6 @@ fn shape_of(ccx : &@crate_ctxt, t : ty::t) -> [u8] {
         s += ~[shape_uniq];
         add_substr(s, shape_of(ccx, subt));
       }
-      ty::ty_vec(mt) {
-        s += ~[shape_evec];
-        add_bool(s, ty::type_is_pod(ccx.tcx, mt.ty));
-        add_substr(s, shape_of(ccx, mt.ty));
-      }
       ty::ty_ivec(mt) {
         s += ~[shape_ivec];
         add_bool(s, ty::type_is_pod(ccx.tcx, mt.ty));

trunk/src/comp/middle/trans.rs

@@ -214,7 +214,6 @@ fn type_of_inner(cx: &@crate_ctxt, sp: &span, t: &ty::t) -> TypeRef {
       ty::ty_tag(did, _) { llty = type_of_tag(cx, sp, did, t); }
       ty::ty_box(mt) { llty = T_ptr(T_box(type_of_inner(cx, sp, mt.ty))); }
       ty::ty_uniq(t) { llty = T_ptr(type_of_inner(cx, sp, t)); }
-      ty::ty_vec(mt) { llty = T_ptr(T_vec(type_of_inner(cx, sp, mt.ty))); }
       ty::ty_ivec(mt) {
         if ty::type_has_dynamic_size(cx.tcx, mt.ty) {
             llty = T_opaque_ivec();
@@ -501,7 +500,6 @@ fn simplify_type(ccx: &@crate_ctxt, typ: &ty::t) -> ty::t {
         alt ty::struct(ccx.tcx, typ) {
           ty::ty_box(_) { ret ty::mk_imm_box(ccx.tcx, ty::mk_nil(ccx.tcx)); }
           ty::ty_uniq(_) { ret ty::mk_uniq(ccx.tcx, ty::mk_nil(ccx.tcx)); }
-          ty::ty_vec(_) { ret ty::mk_imm_vec(ccx.tcx, ty::mk_nil(ccx.tcx)); }
           ty::ty_fn(_, _, _, _, _) {
             ret ty::mk_tup(ccx.tcx,
                            ~[ty::mk_imm_box(ccx.tcx, ty::mk_nil(ccx.tcx)),
@@ -1318,15 +1316,6 @@ fn make_free_glue(cx: &@block_ctxt, v0: ValueRef, t: &ty::t) {
                 rslt(cx, C_nil())
             }
           }
-          ty::ty_vec(_) {
-            let v = cx.build.Load(v0);
-            let rs = iter_sequence(cx, v, t, bind drop_ty(_, _, _));
-            if !bcx_ccx(cx).sess.get_opts().do_gc {
-                trans_non_gc_free(rs.bcx, v)
-            } else {
-                rslt(cx, C_nil())
-            }
-          }
           ty::ty_box(body_mt) {
             let v = cx.build.Load(v0);
             let body =
@@ -1430,7 +1419,6 @@ fn make_drop_glue(cx: &@block_ctxt, v0: ValueRef, t: &ty::t) {
     let rs =
         alt ty::struct(ccx.tcx, t) {
           ty::ty_str. { decr_refcnt_maybe_free(cx, v0, v0, t) }
-          ty::ty_vec(_) { decr_refcnt_maybe_free(cx, v0, v0, t) }
           ty::ty_ivec(tm) {
             let v1;
             if ty::type_has_dynamic_size(ccx.tcx, tm.ty) {
@@ -1981,9 +1969,6 @@ fn iter_sequence(cx: @block_ctxt, v: ValueRef, t: &ty::t, f: &val_and_ty_fn)
 
 
     alt ty::struct(bcx_tcx(cx), t) {
-      ty::ty_vec(elt) {
-        ret iter_sequence_body(cx, v, elt.ty, f, false, false);
-      }
       ty::ty_str. {
         let et = ty::mk_mach(bcx_tcx(cx), ast::ty_u8);
         ret iter_sequence_body(cx, v, et, f, true, false);
@@ -4776,65 +4761,6 @@ fn trans_tup(cx: &@block_ctxt, elts: &[@ast::expr], id: ast::node_id)
     ret rslt(bcx, tup_val);
 }
 
-fn trans_vec(cx: &@block_ctxt, args: &[@ast::expr], id: ast::node_id) ->
-   result {
-    let t = node_id_type(bcx_ccx(cx), id);
-    let unit_ty = t;
-    alt ty::struct(bcx_tcx(cx), t) {
-      ty::ty_vec(mt) { unit_ty = mt.ty; }
-      _ { bcx_ccx(cx).sess.bug("non-vec type in trans_vec"); }
-    }
-    let bcx = cx;
-    let unit_sz = size_of(bcx, unit_ty);
-    bcx = unit_sz.bcx;
-    let data_sz =
-        bcx.build.Mul(C_uint(std::vec::len::<@ast::expr>(args)), unit_sz.val);
-    // FIXME: pass tydesc properly.
-
-    let vec_val =
-        bcx.build.Call(bcx_ccx(bcx).upcalls.new_vec,
-                       ~[bcx.fcx.lltaskptr, data_sz,
-                         C_null(T_ptr(bcx_ccx(bcx).tydesc_type))]);
-    let llty = type_of(bcx_ccx(bcx), bcx.sp, t);
-    vec_val = bcx.build.PointerCast(vec_val, llty);
-    add_clean_temp(bcx, vec_val, t);
-    let body = bcx.build.GEP(vec_val, ~[C_int(0), C_int(abi::vec_elt_data)]);
-    let pseudo_tup_ty =
-        ty::mk_tup(bcx_tcx(cx),
-                       std::vec::init_elt::<ty::t>(unit_ty,
-                                                  std::vec::len(args)));
-    let i: int = 0;
-    for e: @ast::expr in args {
-        let src = trans_lval(bcx, e);
-        bcx = src.res.bcx;
-        let dst_res = GEP_tup_like(bcx, pseudo_tup_ty, body, ~[0, i]);
-        bcx = dst_res.bcx;
-        // Cast the destination type to the source type. This is needed to
-        // make tags work, for a subtle combination of reasons:
-        //
-        // (1) "dst_res" above is derived from "body", which is in turn
-        //     derived from "vec_val".
-        // (2) "vec_val" has the LLVM type "llty".
-        // (3) "llty" is the result of calling type_of() on a vector type.
-        // (4) For tags, type_of() returns a different type depending on
-        //     on whether the tag is behind a box or not. Vector types are
-        //     considered boxes.
-        // (5) "src_res" is derived from "unit_ty", which is not behind a box.
-
-        let dst_val;
-        if !ty::type_has_dynamic_size(bcx_tcx(cx), unit_ty) {
-            let llunit_ty = type_of(bcx_ccx(cx), bcx.sp, unit_ty);
-            dst_val = bcx.build.PointerCast(dst_res.val, T_ptr(llunit_ty));
-        } else { dst_val = dst_res.val; }
-        bcx = move_val_if_temp(bcx, INIT, dst_val, src, unit_ty).bcx;
-        i += 1;
-    }
-    let fill = bcx.build.GEP(vec_val, ~[C_int(0), C_int(abi::vec_elt_fill)]);
-    bcx.build.Store(data_sz, fill);
-    ret rslt(bcx, vec_val);
-}
-
-
 // TODO: Move me to ivec::
 fn trans_ivec(bcx: @block_ctxt, args: &[@ast::expr], id: ast::node_id) ->
    result {

trunk/src/comp/middle/ty.rs

@@ -89,7 +89,6 @@ export mk_type;
 export mk_uint;
 export mk_uniq;
 export mk_var;
-export mk_vec;
 export mk_iter_body_fn;
 export mode;
 export mo_val;
@@ -147,7 +146,6 @@ export ty_uint;
 export ty_uniq;
 export ty_var;
 export ty_var_id;
-export ty_vec;
 export ty_param_substs_opt_and_ty_to_monotype;
 export ty_fn_args;
 export type_constr;
@@ -263,7 +261,6 @@ tag sty {
     ty_tag(def_id, [t]);
     ty_box(mt);
     ty_uniq(t);
-    ty_vec(mt);
     ty_ivec(mt);
     ty_ptr(mt);
     ty_rec([field]);
@@ -465,7 +462,6 @@ fn mk_raw_ty(cx: &ctxt, st: &sty, _in_cname: &option::t<str>) -> @raw_t {
       }
       ty_box(m) { derive_flags_mt(cx, has_params, has_vars, m); }
       ty_uniq(tt) { derive_flags_t(cx, has_params, has_vars, tt); }
-      ty_vec(m) { derive_flags_mt(cx, has_params, has_vars, m); }
       ty_ivec(m) { derive_flags_mt(cx, has_params, has_vars, m); }
       ty_ptr(m) { derive_flags_mt(cx, has_params, has_vars, m); }
       ty_rec(flds) {
@@ -567,14 +563,8 @@ fn mk_mut_ptr(cx: &ctxt, ty: &t) -> t {
     ret mk_ptr(cx, {ty: ty, mut: ast::mut});
 }
 
-fn mk_vec(cx: &ctxt, tm: &mt) -> t { ret gen_ty(cx, ty_vec(tm)); }
-
 fn mk_ivec(cx: &ctxt, tm: &mt) -> t { ret gen_ty(cx, ty_ivec(tm)); }
 
-fn mk_imm_vec(cx: &ctxt, typ: &t) -> t {
-    ret gen_ty(cx, ty_vec({ty: typ, mut: ast::imm}));
-}
-
 fn mk_rec(cx: &ctxt, fs: &[field]) -> t { ret gen_ty(cx, ty_rec(fs)); }
 
 fn mk_constr(cx: &ctxt, t: &t, cs: &[@type_constr]) -> t {
@@ -644,7 +634,6 @@ fn walk_ty(cx: &ctxt, walker: ty_walk, ty: t) {
       ty_type. {/* no-op */ }
       ty_native(_) {/* no-op */ }
       ty_box(tm) { walk_ty(cx, walker, tm.ty); }
-      ty_vec(tm) { walk_ty(cx, walker, tm.ty); }
       ty_ivec(tm) { walk_ty(cx, walker, tm.ty); }
       ty_ptr(tm) { walk_ty(cx, walker, tm.ty); }
       ty_tag(tid, subtys) {
@@ -719,9 +708,6 @@ fn fold_ty(cx: &ctxt, fld: fold_mode, ty_0: t) -> t {
       ty_ptr(tm) {
         ty = mk_ptr(cx, {ty: fold_ty(cx, fld, tm.ty), mut: tm.mut});
       }
-      ty_vec(tm) {
-        ty = mk_vec(cx, {ty: fold_ty(cx, fld, tm.ty), mut: tm.mut});
-      }
       ty_ivec(tm) {
         ty = mk_ivec(cx, {ty: fold_ty(cx, fld, tm.ty), mut: tm.mut});
       }
@@ -860,7 +846,6 @@ fn type_is_sequence(cx: &ctxt, ty: &t) -> bool {
     alt struct(cx, ty) {
       ty_str. { ret true; }
       ty_istr. { ret true; }
-      ty_vec(_) { ret true; }
       ty_ivec(_) { ret true; }
       _ { ret false; }
     }
@@ -877,10 +862,6 @@ fn type_is_str(cx: &ctxt, ty: &t) -> bool {
 fn sequence_is_interior(cx: &ctxt, ty: &t) -> bool {
     alt struct(cx, ty) {
 
-      // TODO: Or-patterns
-      ty::ty_vec(_) {
-        ret false;
-      }
       ty::ty_str. { ret false; }
       ty::ty_ivec(_) { ret true; }
       ty::ty_istr. { ret true; }
@@ -892,7 +873,6 @@ fn sequence_element_type(cx: &ctxt, ty: &t) -> t {
     alt struct(cx, ty) {
       ty_str. { ret mk_mach(cx, ast::ty_u8); }
       ty_istr. { ret mk_mach(cx, ast::ty_u8); }
-      ty_vec(mt) { ret mt.ty; }
       ty_ivec(mt) { ret mt.ty; }
       _ { cx.sess.bug("sequence_element_type called on non-sequence value"); }
     }
@@ -929,7 +909,6 @@ fn type_is_box(cx: &ctxt, ty: &t) -> bool {
 fn type_is_boxed(cx: &ctxt, ty: &t) -> bool {
     alt struct(cx, ty) {
       ty_str. { ret true; }
-      ty_vec(_) { ret true; }
       ty_box(_) { ret true; }
       _ { ret false; }
     }
@@ -1068,7 +1047,7 @@ fn type_kind(cx: &ctxt, ty: &t) -> ast::kind {
 
       // Those with refcounts-to-inner raise pinned to shared,
       // lower unique to shared. Therefore just set result to shared.
-      ty_box(mt) | ty_vec(mt) {
+      ty_box(mt) {
         result = ast::kind_shared;
       }
 
@@ -1155,7 +1134,6 @@ fn type_has_dynamic_size(cx: &ctxt, ty: &t) -> bool {
         ret false;
       }
       ty_box(_) { ret false; }
-      ty_vec(_) { ret false; }
       ty_ivec(mt) { ret type_has_dynamic_size(cx, mt.ty); }
       ty_ptr(_) { ret false; }
       ty_rec(fields) {
@@ -1272,7 +1250,6 @@ fn type_owns_heap_mem(cx: &ctxt, ty: &t) -> bool {
         result = false;
       }
       ty_box(_) { result = false; }
-      ty_vec(_) { result = false; }
       ty_fn(_, _, _, _, _) { result = false; }
       ty_native_fn(_, _, _) { result = false; }
       ty_obj(_) { result = false; }
@@ -1326,7 +1303,7 @@ fn type_is_pod(cx : &ctxt, ty : &t) -> bool {
         }
 
         // Boxed types
-        ty_str. | ty_istr. | ty_box(_) | ty_vec(_) | ty_ivec(_) |
+        ty_str. | ty_istr. | ty_box(_) | ty_ivec(_) |
         ty_fn(_,_,_,_,_) | ty_native_fn(_,_,_) | ty_obj(_) { result = false; }
 
         // Structural types
@@ -1489,7 +1466,6 @@ fn hash_type_structure(st: &sty) -> uint {
         ret h;
       }
       ty_box(mt) { ret hash_subty(19u, mt.ty); }
-      ty_vec(mt) { ret hash_subty(20u, mt.ty); }
       ty_ivec(mt) { ret hash_subty(21u, mt.ty); }
       ty_rec(fields) {
         let h = 26u;
@@ -1651,9 +1627,6 @@ fn equal_type_structures(a: &sty, b: &sty) -> bool {
       ty_box(mt_a) {
         alt b { ty_box(mt_b) { ret equal_mt(mt_a, mt_b); } _ { ret false; } }
       }
-      ty_vec(mt_a) {
-        alt b { ty_vec(mt_b) { ret equal_mt(mt_a, mt_b); } _ { ret false; } }
-      }
       ty_ivec(mt_a) {
         alt b { ty_ivec(mt_b) { ret equal_mt(mt_a, mt_b); } _ { ret false; } }
       }
@@ -2502,26 +2475,6 @@ mod unify {
               _ { ret ures_err(terr_mismatch); }
             }
           }
-          ty::ty_vec(expected_mt) {
-            alt struct(cx.tcx, actual) {
-              ty::ty_vec(actual_mt) {
-                let mut;
-                alt unify_mut(expected_mt.mut, actual_mt.mut) {
-                  none. { ret ures_err(terr_vec_mutability); }
-                  some(m) { mut = m; }
-                }
-                let result = unify_step(cx, expected_mt.ty, actual_mt.ty);
-                alt result {
-                  ures_ok(result_sub) {
-                    let mt = {ty: result_sub, mut: mut};
-                    ret ures_ok(mk_vec(cx.tcx, mt));
-                  }
-                  _ { ret result; }
-                }
-              }
-              _ { ret ures_err(terr_mismatch); }
-            }
-          }
           ty::ty_ivec(expected_mt) {
             alt struct(cx.tcx, actual) {
               ty::ty_ivec(actual_mt) {
@@ -3055,7 +3008,6 @@ fn is_binopable(cx: &ctxt, ty: t, op: ast::binop) -> bool {
           ty_ptr(_) { tycat_int }
           ty_str. { tycat_str }
           ty_istr. { tycat_str }
-          ty_vec(_) { tycat_vec }
           ty_ivec(_) { tycat_vec }
           ty_rec(_) { tycat_struct }
           ty_tup(_) { tycat_struct }