Get rid of ast::ty_vstore, which was only used for fixed length.

Author: msullivan

src/libsyntax/ast.rs

@@ -503,7 +503,7 @@ enum ty_ {
     ty_tup(~[@ty]),
     ty_path(@path, node_id),
     ty_constr(@ty, ~[@ty_constr]),
-    ty_vstore(@ty, vstore),
+    ty_fixed_length(@ty, option<uint>),
     ty_mac(mac),
     // ty_infer means the type should be inferred instead of it having been
     // specified. This should only appear at the "top level" of a type and not

src/libsyntax/ext/auto_serialize.rs

@@ -497,15 +497,9 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map,
         }]
       }
 
-      // For unique vstores, just pass through to the underlying vec or str
-      ast::ty_vstore(ty, ast::vstore_uniq) {
-        ser_ty(cx, tps, ty, s, v)
-      }
-
-      ast::ty_vstore(_, _) {
-        cx.span_unimpl(ty.span, ~"serialization for vstore types");
+      ast::ty_fixed_length(_, _) {
+        cx.span_unimpl(ty.span, ~"serialization for fixed length types");
       }
-
     }
 }
 
@@ -720,13 +714,8 @@ fn deser_ty(cx: ext_ctxt, tps: deser_tps_map,
         #ast{ std::serialization::read_to_vec($(d), $(l)) }
       }
 
-      // For unique vstores, just pass through to the underlying vec or str
-      ast::ty_vstore(ty, ast::vstore_uniq) {
-        deser_ty(cx, tps, ty, d)
-      }
-
-      ast::ty_vstore(_, _) {
-        cx.span_unimpl(ty.span, ~"deserialization for vstore types");
+      ast::ty_fixed_length(_, _) {
+        cx.span_unimpl(ty.span, ~"deserialization for fixed length types");
       }
     }
 }

src/libsyntax/fold.rs

@@ -506,7 +506,7 @@ fn noop_fold_ty(t: ty_, fld: ast_fold) -> ty_ {
       ty_path(path, id) {ty_path(fld.fold_path(path), fld.new_id(id))}
       ty_constr(ty, constrs) {ty_constr(fld.fold_ty(ty),
                                 vec::map(constrs, |x| fld.fold_ty_constr(x)))}
-      ty_vstore(t, vs) {ty_vstore(fld.fold_ty(t), vs)}
+      ty_fixed_length(t, vs) {ty_fixed_length(fld.fold_ty(t), vs)}
       ty_mac(mac) {ty_mac(fold_mac(mac))}
     }
 }

src/libsyntax/parse/parser.rs

@@ -49,7 +49,8 @@ import ast::{_mod, add, alt_check, alt_exhaustive, arg, arm, attribute,
              tt_delim, tt_dotdotdot, tt_flat, tt_interpolate, ty, ty_, ty_bot,
              ty_box, ty_constr, ty_constr_, ty_constr_arg, ty_field, ty_fn,
              ty_infer, ty_mac, ty_method, ty_nil, ty_param, ty_path, ty_ptr,
-             ty_rec, ty_rptr, ty_tup, ty_u32, ty_uniq, ty_vec, ty_vstore,
+             ty_rec, ty_rptr, ty_tup, ty_u32, ty_uniq, ty_vec,
+             ty_fixed_length,
              unchecked_blk, uniq, unsafe_blk, unsafe_fn, variant, view_item,
              view_item_, view_item_export, view_item_import, view_item_use,
              view_path, view_path_glob, view_path_list, view_path_simple,
@@ -554,11 +555,11 @@ class parser {
 
         let sp = mk_sp(lo, self.last_span.hi);
         ret @{id: self.get_id(),
-              node: alt self.maybe_parse_vstore() {
-                // Consider a vstore suffix like /@ or /~
+              node: alt self.maybe_parse_fixed_vstore() {
+                // Consider a fixed vstore suffix (/N or /_)
                 none { t }
                 some(v) {
-                  ty_vstore(@{id: self.get_id(), node:t, span: sp}, v)
+                  ty_fixed_length(@{id: self.get_id(), node:t, span: sp}, v)
                 } },
               span: sp}
     }
@@ -650,15 +651,15 @@ class parser {
         }
     }
 
-    fn maybe_parse_vstore() -> option<vstore> {
+    fn maybe_parse_fixed_vstore() -> option<option<uint>> {
         if self.token == token::BINOP(token::SLASH) {
             self.bump();
             alt copy self.token {
               token::UNDERSCORE {
-                self.bump(); some(vstore_fixed(none))
+                self.bump(); some(none)
               }
               token::LIT_INT_UNSUFFIXED(i) if i >= 0i64 {
-                self.bump(); some(vstore_fixed(some(i as uint)))
+                self.bump(); some(some(i as uint))
               }
               _ {
                 none
@@ -1029,11 +1030,11 @@ class parser {
         alt ex {
           expr_lit(@{node: lit_str(_), span: _}) |
           expr_vec(_, _)  {
-            alt self.maybe_parse_vstore() {
+            alt self.maybe_parse_fixed_vstore() {
               none { }
               some(v) {
                 hi = self.span.hi;
-                ex = expr_vstore(self.mk_expr(lo, hi, ex), v);
+                ex = expr_vstore(self.mk_expr(lo, hi, ex), vstore_fixed(v));
               }
             }
           }

src/libsyntax/print/pprust.rs

@@ -378,18 +378,10 @@ fn print_type_ex(s: ps, &&ty: @ast::ty, print_colons: bool) {
         space(s.s);
         word(s.s, constrs_str(cs, ty_constr_to_str));
       }
-      ast::ty_vstore(t, v) {
-        alt v {
-          ast::vstore_fixed(_) {
-            print_type(s, t);
-            word(s.s, ~"/");
-            print_vstore(s, v);
-          }
-          _ {
-            print_vstore(s, v);
-            print_type(s, t);
-          }
-        }
+      ast::ty_fixed_length(t, v) {
+        print_type(s, t);
+        word(s.s, ~"/");
+        print_vstore(s, ast::vstore_fixed(v));
       }
       ast::ty_mac(_) {
           fail ~"print_type doesn't know how to print a ty_mac";

src/libsyntax/visit.rs

@@ -200,7 +200,7 @@ fn visit_ty<E>(t: @ty, e: E, v: vt<E>) {
         v.visit_ty(decl.output, e, v);
       }
       ty_path(p, _) { visit_path(p, e, v); }
-      ty_vstore(t, _) {
+      ty_fixed_length(t, _) {
         v.visit_ty(t, e, v);
       }
       ty_constr(t, cs) {

src/rustc/middle/lint.rs

@@ -464,7 +464,7 @@ fn check_item_old_vecs(cx: ty::ctxt, it: @ast::item) {
                     old_strs, t.id, it.id,
                     t.span, ~"deprecated str type");
               }
-              ast::ty_vstore(inner, _) |
+              ast::ty_fixed_length(inner, _) |
               ast::ty_box({ty: inner, _}) |
               ast::ty_uniq({ty: inner, _}) |
               ast::ty_rptr(_, {ty: inner, _}) {

src/rustc/middle/region.rs

@@ -566,8 +566,7 @@ fn determine_rp_in_ty(ty: @ast::ty,
     // like path/r, add to the worklist/set
     alt ty.node {
       ast::ty_rptr(r, _) |
-      ast::ty_path(@{rp: some(r), _}, _) |
-      ast::ty_vstore(_, ast::vstore_slice(r)) => {
+      ast::ty_path(@{rp: some(r), _}, _) => {
         #debug["referenced type with regions %s", pprust::ty_to_str(ty)];
         if cx.region_is_relevant(r) {
             cx.add_rp(cx.item_id);
@@ -644,4 +643,4 @@ fn determine_rp_in_crate(sess: session,
 
     // return final set
     ret cx.region_paramd_items;
-}
+}

src/rustc/middle/typeck/astconv.rs

@@ -316,7 +316,7 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy>(
           }
         }
       }
-      ast::ty_vstore(a_t, ast::vstore_fixed(some(u))) {
+      ast::ty_fixed_length(a_t, some(u)) {
         mk_maybe_vstore(self, rscope, {ty: a_t, mutbl: ast::m_imm},
                         ty::vstore_fixed(u),
                         |ty| {
@@ -327,14 +327,11 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy>(
                             ty.ty
                         })
       }
-      ast::ty_vstore(_, ast::vstore_fixed(none)) {
+      ast::ty_fixed_length(_, none) {
         tcx.sess.span_bug(
             ast_ty.span,
             ~"implied fixed length for bound");
       }
-      ast::ty_vstore(_, _) {
-        tcx.sess.span_bug(ast_ty.span, ~"vstore in type??");
-      }
       ast::ty_constr(t, cs) {
         let mut out_cs = ~[];
         for cs.each |constr| {