diff --git a/Makefile.in b/Makefile.in
index a30d6c571b0c1..a4a9c262839ae 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -205,7 +205,7 @@ COMPILER_INPUTS := $(filter-out $(S)src/rustc/driver/rustc.rs,     \
 
 LIBRUSTSYNTAX_CRATE := $(S)src/librustsyntax/rustsyntax.rc
 LIBRUSTSYNTAX_INPUTS := $(wildcard $(addprefix $(S)src/librustsyntax/, \
-                            rustsyntax.rc *.rs))
+                            rustsyntax.rc *.rs */*.rs */*/*.rs))
 
 RUSTC_INPUTS := $(S)src/rustc/driver/rustc.rs
 
diff --git a/mk/tests.mk b/mk/tests.mk
index d48e1427de093..1dc8903e4f4cb 100644
--- a/mk/tests.mk
+++ b/mk/tests.mk
@@ -127,6 +127,8 @@ tidy:
               $(wildcard $(S)src/etc/*.py)  \
               $(COMPILER_CRATE) \
               $(COMPILER_INPUTS) \
+              $(LIBRUSTSYNTAX_CRATE) \
+              $(LIBRUSTSYNTAX_INPUTS) \
               $(CORELIB_CRATE) \
               $(CORELIB_INPUTS) \
               $(STDLIB_CRATE) \
diff --git a/src/librustsyntax/ast.rs b/src/librustsyntax/ast.rs
index 44a37066a56ed..885e0943b9b45 100644
--- a/src/librustsyntax/ast.rs
+++ b/src/librustsyntax/ast.rs
@@ -169,6 +169,14 @@ enum proto {
     proto_block,   // fn&
 }
 
+#[auto_serialize]
+enum vstore {
+    vstore_fixed(option<uint>),   // [1,2,3,4]/_ or 4   FIXME: uint -> @expr
+    vstore_uniq,                  // [1,2,3,4]/~
+    vstore_box,                   // [1,2,3,4]/@
+    vstore_slice(region)          // [1,2,3,4]/&(foo)?
+}
+
 pure fn is_blockish(p: ast::proto) -> bool {
     alt p {
       proto_any | proto_block { true }
@@ -278,6 +286,7 @@ enum alt_mode { alt_check, alt_exhaustive, }
 
 #[auto_serialize]
 enum expr_ {
+    expr_vstore(@expr, vstore),
     expr_vec([@expr], mutability),
     expr_rec([field], option<@expr>),
     expr_call(@expr, [@expr], bool),
@@ -459,6 +468,7 @@ enum ty_ {
     ty_tup([@ty]),
     ty_path(@path, node_id),
     ty_constr(@ty, [@ty_constr]),
+    ty_vstore(@ty, vstore),
     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
diff --git a/src/librustsyntax/ext/auto_serialize.rs b/src/librustsyntax/ext/auto_serialize.rs
index bc11f23d892dd..c834692b5b080 100644
--- a/src/librustsyntax/ext/auto_serialize.rs
+++ b/src/librustsyntax/ext/auto_serialize.rs
@@ -367,8 +367,7 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map,
       }
 
       ast::ty_ptr(_) | ast::ty_rptr(_, _) {
-        cx.span_err(
-            ty.span, #fmt["Cannot serialize pointer types"]);
+        cx.span_err(ty.span, "cannot serialize pointer types");
         []
       }
 
@@ -390,8 +389,7 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map,
       }
 
       ast::ty_fn(_, _) {
-        cx.span_err(
-            ty.span, #fmt["Cannot serialize function types"]);
+        cx.span_err(ty.span, "cannot serialize function types");
         []
       }
 
@@ -448,17 +446,19 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map,
       }
 
       ast::ty_mac(_) {
-        cx.span_err(
-            ty.span, #fmt["Cannot serialize macro types"]);
+        cx.span_err(ty.span, "cannot serialize macro types");
         []
       }
 
       ast::ty_infer {
-        cx.span_err(
-            ty.span, #fmt["Cannot serialize inferred types"]);
+        cx.span_err(ty.span, "cannot serialize inferred types");
         []
       }
 
+      ast::ty_vstore(_, _) {
+        cx.span_unimpl(ty.span, "serialization for vstore types");
+      }
+
       ast::ty_vec(mt) {
         let ser_e =
             cx.expr(
@@ -675,6 +675,10 @@ fn deser_ty(cx: ext_ctxt, tps: deser_tps_map,
         #ast{ fail }
       }
 
+      ast::ty_vstore(_, _) {
+        cx.span_unimpl(ty.span, "deserialization for vstore types");
+      }
+
       ast::ty_vec(mt) {
         let l = deser_lambda(cx, tps, mt.ty, cx.clone(d));
         #ast{ std::serialization::read_to_vec($(d), $(l)) }
diff --git a/src/librustsyntax/fold.rs b/src/librustsyntax/fold.rs
index ec6d871472bcd..afde21d2965b3 100644
--- a/src/librustsyntax/fold.rs
+++ b/src/librustsyntax/fold.rs
@@ -389,6 +389,9 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
                      fld.new_id(i),
                      fld.fold_expr(v))
           }
+          expr_vstore(e, v) {
+            expr_vstore(fld.fold_expr(e), v)
+          }
           expr_vec(exprs, mutt) {
             expr_vec(fld.map_exprs(fld.fold_expr, exprs), mutt)
           }
@@ -497,6 +500,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))}
       // FIXME: constrs likely needs to be folded...
       ty_constr(ty, constrs) {ty_constr(fld.fold_ty(ty), constrs)}
+      ty_vstore(t, vs) {ty_vstore(fld.fold_ty(t), vs)}
       ty_mac(mac) {ty_mac(fold_mac(mac))}
       ty_infer {t}
     }
diff --git a/src/librustsyntax/parse/parser.rs b/src/librustsyntax/parse/parser.rs
index c2f1dd58096a5..d6bb9dcd7ff5d 100644
--- a/src/librustsyntax/parse/parser.rs
+++ b/src/librustsyntax/parse/parser.rs
@@ -382,15 +382,32 @@ fn parse_type_constraints(p: parser) -> [@ast::ty_constr] {
 
 fn parse_ty_postfix(orig_t: ast::ty_, p: parser, colons_before_params: bool,
                     lo: uint) -> @ast::ty {
+
+
+    fn mk_ty(p: parser, t: ast::ty_, lo: uint, hi: uint) -> @ast::ty {
+        @{id: p.get_id(),
+          node: t,
+          span: ast_util::mk_sp(lo, hi)}
+    }
+
+    if p.token == token::BINOP(token::SLASH) {
+        let orig_hi = p.last_span.hi;
+        alt maybe_parse_vstore(p) {
+          none { }
+          some(v) {
+            let t = ast::ty_vstore(mk_ty(p, orig_t, lo, orig_hi), v);
+            ret mk_ty(p, t, lo, p.last_span.hi);
+          }
+        }
+    }
+
     if colons_before_params && p.token == token::MOD_SEP {
         p.bump();
         expect(p, token::LT);
     } else if !colons_before_params && p.token == token::LT {
         p.bump();
     } else {
-        ret @{id: p.get_id(),
-              node: orig_t,
-              span: ast_util::mk_sp(lo, p.last_span.hi)};
+        ret mk_ty(p, orig_t, lo, p.last_span.hi);
     }
 
     // If we're here, we have explicit type parameter instantiation.
@@ -399,12 +416,11 @@ fn parse_ty_postfix(orig_t: ast::ty_, p: parser, colons_before_params: bool,
 
     alt orig_t {
       ast::ty_path(pth, ann) {
-        ret @{id: p.get_id(),
-              node: ast::ty_path(@spanned(lo, p.last_span.hi,
-                                          {global: pth.node.global,
-                                           idents: pth.node.idents,
-                                           types: seq}), ann),
-              span: ast_util::mk_sp(lo, p.last_span.hi)};
+        ret mk_ty(p, ast::ty_path(@spanned(lo, p.last_span.hi,
+                                           {global: pth.node.global,
+                                            idents: pth.node.idents,
+                                            types: seq}), ann),
+                  lo, p.last_span.hi);
       }
       _ { p.fatal("type parameter instantiation only allowed for paths"); }
     }
@@ -428,22 +444,33 @@ fn parse_ret_ty(p: parser) -> (ast::ret_style, @ast::ty) {
     }
 }
 
-fn parse_region(p: parser) -> ast::region {
-    let region_ = alt p.token {
-        token::IDENT(sid, _) if p.look_ahead(1u) == token::DOT {
-            let string = p.get_str(sid);
-            p.bump(); p.bump();
-            if string == "self" {
-                ast::re_self
-            } else if string == "static" {
-                ast::re_static
-            } else {
-                ast::re_named(string)
-            }
+fn region_from_name(p: parser, s: option<str>) -> ast::region {
+    let r = alt s {
+      some (string) {
+        if string == "self" {
+            ast::re_self
+        } else if string == "static" {
+            ast::re_static
+        } else {
+            ast::re_named(string)
         }
-        _ { ast::re_inferred }
+      }
+      none { ast::re_inferred }
     };
-    ret {id: p.get_id(), node: region_};
+
+    {id: p.get_id(), node: r}
+}
+
+fn parse_region(p: parser) -> ast::region {
+    let name =
+        alt p.token {
+          token::IDENT(sid, _) if p.look_ahead(1u) == token::DOT {
+            p.bump(); p.bump();
+            some(p.get_str(sid))
+          }
+          _ { none }
+        };
+    region_from_name(p, name)
 }
 
 fn parse_ty(p: parser, colons_before_params: bool) -> @ast::ty {
@@ -666,6 +693,44 @@ fn have_dollar(p: parser) -> option<ast::mac_> {
     }
 }
 
+fn maybe_parse_vstore(p: parser) -> option<ast::vstore> {
+    if p.token == token::BINOP(token::SLASH) {
+        p.bump();
+        alt p.token {
+          token::AT {
+            p.bump(); some(ast::vstore_box)
+          }
+          token::TILDE {
+            p.bump(); some(ast::vstore_uniq)
+          }
+          token::UNDERSCORE {
+            p.bump(); some(ast::vstore_fixed(none))
+          }
+          token::LIT_INT(i, ast::ty_i) if i >= 0 {
+            p.bump(); some(ast::vstore_fixed(some(i as uint)))
+          }
+          token::BINOP(token::AND) {
+            p.bump();
+            alt p.token {
+              token::IDENT(sid, _) {
+                p.bump();
+                let n = p.get_str(sid);
+                some(ast::vstore_slice(region_from_name(p, some(n))))
+              }
+              _ {
+                some(ast::vstore_slice(region_from_name(p, none)))
+              }
+            }
+          }
+          _ {
+            none
+          }
+        }
+    } else {
+        none
+    }
+}
+
 fn lit_from_token(p: parser, tok: token::token) -> ast::lit_ {
     alt tok {
       token::LIT_INT(i, it) { ast::lit_int(i, it) }
@@ -678,7 +743,7 @@ fn lit_from_token(p: parser, tok: token::token) -> ast::lit_ {
 }
 
 fn parse_lit(p: parser) -> ast::lit {
-    let sp = p.span;
+    let lo = p.span.lo;
     let lit = if eat_word(p, "true") {
         ast::lit_bool(true)
     } else if eat_word(p, "false") {
@@ -688,7 +753,7 @@ fn parse_lit(p: parser) -> ast::lit {
         p.bump();
         lit_from_token(p, tok)
     };
-    ret {node: lit, span: sp};
+    ret {node: lit, span: ast_util::mk_sp(lo, p.last_span.hi)};
 }
 
 fn is_ident(t: token::token) -> bool {
@@ -891,6 +956,7 @@ fn parse_bottom_expr(p: parser) -> pexpr {
         let es =
             parse_seq_to_end(token::RBRACKET, seq_sep(token::COMMA),
                              parse_expr, p);
+        hi = p.span.hi;
         ex = ast::expr_vec(es, mutbl);
     } else if p.token == token::POUND_LT {
         p.bump();
@@ -988,6 +1054,23 @@ fn parse_bottom_expr(p: parser) -> pexpr {
         hi = lit.span.hi;
         ex = ast::expr_lit(@lit);
     }
+
+    // Vstore is legal following expr_lit(lit_str(...)) and expr_vec(...)
+    // only.
+    alt ex {
+      ast::expr_lit(@{node: ast::lit_str(_), span: _}) |
+      ast::expr_vec(_, _)  {
+        alt maybe_parse_vstore(p) {
+          none { }
+          some(v) {
+            hi = p.span.hi;
+            ex = ast::expr_vstore(mk_expr(p, lo, hi, ex), v);
+          }
+        }
+      }
+      _ { }
+    }
+
     ret mk_pexpr(p, lo, hi, ex);
 }
 
@@ -1194,10 +1277,10 @@ type op_spec = {tok: token::token, op: ast::binop, prec: int};
 
 // FIXME make this a const, don't store it in parser state
 fn prec_table() -> @[op_spec] {
-    ret @[// 'as' sits between here with 12
-          {tok: token::BINOP(token::STAR), op: ast::mul, prec: 11},
-          {tok: token::BINOP(token::SLASH), op: ast::div, prec: 11},
-          {tok: token::BINOP(token::PERCENT), op: ast::rem, prec: 11},
+    ret @[{tok: token::BINOP(token::STAR), op: ast::mul, prec: 12},
+          {tok: token::BINOP(token::SLASH), op: ast::div, prec: 12},
+          {tok: token::BINOP(token::PERCENT), op: ast::rem, prec: 12},
+          // 'as' sits between here with 11
           {tok: token::BINOP(token::PLUS), op: ast::add, prec: 10},
           {tok: token::BINOP(token::MINUS), op: ast::subtract, prec: 10},
           {tok: token::BINOP(token::LSL), op: ast::lsl, prec: 9},
@@ -1222,7 +1305,7 @@ fn parse_binops(p: parser) -> @ast::expr {
 
 const unop_prec: int = 100;
 
-const as_prec: int = 12;
+const as_prec: int = 11;
 
 fn parse_more_binops(p: parser, plhs: pexpr, min_prec: int) ->
    @ast::expr {
diff --git a/src/librustsyntax/print/pprust.rs b/src/librustsyntax/print/pprust.rs
index fe9c9531d5ea6..1d2094762f19b 100644
--- a/src/librustsyntax/print/pprust.rs
+++ b/src/librustsyntax/print/pprust.rs
@@ -378,6 +378,10 @@ fn print_type(s: ps, &&ty: @ast::ty) {
         space(s.s);
         word(s.s, constrs_str(cs, ty_constr_to_str));
       }
+      ast::ty_vstore(t, v) {
+        print_type(s, t);
+        print_vstore(s, v);
+      }
       ast::ty_mac(_) {
           fail "print_type doesn't know how to print a ty_mac";
       }
@@ -810,12 +814,36 @@ fn print_mac(s: ps, m: ast::mac) {
     }
 }
 
+fn print_vstore(s: ps, t: ast::vstore) {
+    alt t {
+      ast::vstore_fixed(some(i)) { word_space(s, #fmt("/%u", i)); }
+      ast::vstore_fixed(none) { word_space(s, "/_"); }
+      ast::vstore_uniq { word_space(s, "/~"); }
+      ast::vstore_box { word_space(s, "/@"); }
+      ast::vstore_slice(r) {
+        alt r.node {
+          ast::re_inferred { word_space(s, "/&"); }
+          ast::re_self { word_space(s, "/&self"); }
+          ast::re_static { word_space(s, "/&static"); }
+          ast::re_named(name) {
+            word(s.s, "/&");
+            word_space(s, name);
+          }
+        }
+      }
+    }
+}
+
 fn print_expr(s: ps, &&expr: @ast::expr) {
     maybe_print_comment(s, expr.span.lo);
     ibox(s, indent_unit);
     let ann_node = node_expr(s, expr);
     s.ann.pre(ann_node);
     alt expr.node {
+      ast::expr_vstore(e, v) {
+        print_expr(s, e);
+        print_vstore(s, v);
+      }
       ast::expr_vec(exprs, mutbl) {
         ibox(s, indent_unit);
         word(s.s, "[");
diff --git a/src/librustsyntax/visit.rs b/src/librustsyntax/visit.rs
index b4ffce0730df8..33af7fe366119 100644
--- a/src/librustsyntax/visit.rs
+++ b/src/librustsyntax/visit.rs
@@ -170,11 +170,10 @@ fn skip_ty<E>(_t: @ty, _e: E, _v: vt<E>) {}
 
 fn visit_ty<E>(t: @ty, e: E, v: vt<E>) {
     alt t.node {
-      ty_box(mt) { v.visit_ty(mt.ty, e, v); }
-      ty_uniq(mt) { v.visit_ty(mt.ty, e, v); }
-      ty_vec(mt) { v.visit_ty(mt.ty, e, v); }
-      ty_ptr(mt) { v.visit_ty(mt.ty, e, v); }
-      ty_rptr(_, mt) { v.visit_ty(mt.ty, e, v); }
+      ty_box(mt) | ty_uniq(mt) |
+      ty_vec(mt) | ty_ptr(mt) | ty_rptr(_, mt) {
+        v.visit_ty(mt.ty, e, v);
+      }
       ty_rec(flds) {
         for flds.each {|f| v.visit_ty(f.node.mt.ty, e, v); }
       }
@@ -187,6 +186,9 @@ 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, _) {
+        v.visit_ty(t, e, v);
+      }
       ty_constr(t, cs) {
         v.visit_ty(t, e, v);
         for cs.each {|tc|
@@ -335,6 +337,7 @@ fn visit_expr<E>(ex: @expr, e: E, v: vt<E>) {
         v.visit_expr(pool, e, v);
         v.visit_expr(val, e, v);
       }
+      expr_vstore(x, _) { v.visit_expr(x, e, v); }
       expr_vec(es, _) { visit_exprs(es, e, v); }
       expr_rec(flds, base) {
         for flds.each {|f| v.visit_expr(f.node.expr, e, v); }
diff --git a/src/rustc/metadata/tydecode.rs b/src/rustc/metadata/tydecode.rs
index 7d8fd31d635bd..590f3d33d4bef 100644
--- a/src/rustc/metadata/tydecode.rs
+++ b/src/rustc/metadata/tydecode.rs
@@ -6,6 +6,8 @@ import syntax::ast_util;
 import syntax::ast_util::respan;
 import middle::ty;
 import std::map::hashmap;
+import driver::session;
+import session::session;
 
 export parse_ty_data, parse_def_id, parse_ident;
 export parse_bounds_data;
@@ -176,6 +178,10 @@ fn parse_proto(c: char) -> ast::proto {
     }
 }
 
+fn parse_vstore(st: @pstate) -> ty::vstore {
+    st.tcx.sess.unimpl("tydecode::parse_vstore");
+}
+
 fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
     alt check next(st) {
       'n' { ret ty::mk_nil(st.tcx); }
@@ -231,6 +237,15 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
       '~' { ret ty::mk_uniq(st.tcx, parse_mt(st, conv)); }
       '*' { ret ty::mk_ptr(st.tcx, parse_mt(st, conv)); }
       'I' { ret ty::mk_vec(st.tcx, parse_mt(st, conv)); }
+      'V' {
+        let mt = parse_mt(st, conv);
+        let v = parse_vstore(st);
+        ret ty::mk_evec(st.tcx, mt, v);
+      }
+      'v' {
+        let v = parse_vstore(st);
+        ret ty::mk_estr(st.tcx, v);
+      }
       'R' {
         assert (next(st) == '[');
         let mut fields: [ty::field] = [];
diff --git a/src/rustc/metadata/tyencode.rs b/src/rustc/metadata/tyencode.rs
index fb0a84b603fb3..47643abf27612 100644
--- a/src/rustc/metadata/tyencode.rs
+++ b/src/rustc/metadata/tyencode.rs
@@ -145,6 +145,27 @@ fn enc_region(w: io::writer, r: ty::region) {
       }
     }
 }
+
+fn enc_vstore(w: io::writer, v: ty::vstore) {
+    w.write_char('/');
+    alt v {
+      ty::vstore_fixed(u)  {
+        w.write_uint(u);
+        w.write_char('|');
+      }
+      ty::vstore_uniq {
+        w.write_char('~');
+      }
+      ty::vstore_box {
+        w.write_char('@');
+      }
+      ty::vstore_slice(r) {
+        w.write_char('&');
+        enc_region(w, r);
+      }
+    }
+}
+
 fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) {
     alt st {
       ty::ty_nil { w.write_char('n'); }
@@ -204,6 +225,15 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) {
         enc_region(w, r);
         enc_mt(w, cx, mt);
       }
+      ty::ty_evec(mt, v) {
+        w.write_char('V');
+        enc_mt(w, cx, mt);
+        enc_vstore(w, v);
+      }
+      ty::ty_estr(v) {
+        w.write_char('v');
+        enc_vstore(w, v);
+      }
       ty::ty_vec(mt) { w.write_char('I'); enc_mt(w, cx, mt); }
       ty::ty_rec(fields) {
         w.write_str("R[");
diff --git a/src/rustc/middle/infer.rs b/src/rustc/middle/infer.rs
index aac422dbca7eb..ce836221d7c59 100644
--- a/src/rustc/middle/infer.rs
+++ b/src/rustc/middle/infer.rs
@@ -908,6 +908,15 @@ fn super_tys<C:combine>(
         }
       }
 
+      (ty::ty_evec(a_mt, ty::vstore_slice(a_r)),
+       ty::ty_evec(b_mt, ty::vstore_slice(b_r))) {
+        self.contraregions(a_r, b_r).chain {|r|
+            self.mts(a_mt, b_mt).chain {|mt|
+                ok(ty::mk_evec(tcx, mt, ty::vstore_slice(r)))
+            }
+        }
+      }
+
       (ty::ty_res(a_id, a_t, a_tps), ty::ty_res(b_id, b_t, b_tps))
       if a_id == b_id {
         self.tys(a_t, b_t).chain {|t|
diff --git a/src/rustc/middle/mutbl.rs b/src/rustc/middle/mutbl.rs
index d6488334311e8..fa2e8ddb0d7c3 100644
--- a/src/rustc/middle/mutbl.rs
+++ b/src/rustc/middle/mutbl.rs
@@ -92,12 +92,14 @@ fn expr_root_(tcx: ty::ctxt, ctor_self: option<node_id>,
           expr_index(base, _) {
             let auto_unbox = maybe_auto_unbox(tcx, ty::expr_ty(tcx, base));
             alt ty::get(auto_unbox.t).struct {
+              ty::ty_evec(mt, _) |
               ty::ty_vec(mt) {
                 ds +=
                     [@{mutbl: mt.mutbl == m_mutbl,
                        kind: index,
                        outer_t: auto_unbox.t}];
               }
+              ty::ty_estr(_) |
               ty::ty_str {
                 ds += [@{mutbl: false, kind: index, outer_t: auto_unbox.t}];
               }
diff --git a/src/rustc/middle/region.rs b/src/rustc/middle/region.rs
index c66f09f883606..7d48b6ac02329 100644
--- a/src/rustc/middle/region.rs
+++ b/src/rustc/middle/region.rs
@@ -168,9 +168,10 @@ type region_map = {
     ast_type_to_inferred_region: hashmap<ast::node_id,ty::region>,
     /*
      * Mapping from an address-of operator or alt expression to its containing
-     * block. This is used as the region if the operand is an rvalue.
+     * region (usually ty::region_scope(block). This is used as the region if
+     * the operand is an rvalue.
      */
-    rvalue_to_block: hashmap<ast::node_id,ast::node_id>
+    rvalue_to_region: hashmap<ast::node_id,ty::region>
 };
 
 type region_scope = @{
@@ -366,41 +367,26 @@ fn get_inferred_region(cx: ctxt, sp: syntax::codemap::span) -> ty::region {
     }
 }
 
-fn resolve_region_binding(cx: ctxt, span: span, region: ast::region) {
-
-    let id = region.id;
-    let rm = cx.region_map;
+fn resolve_region_binding(cx: ctxt, span: span,
+                          region: ast::region) -> ty::region {
     alt region.node {
-      ast::re_inferred {
-        // option::may(cx.scope.resolve_anon()) {|r|
-        //     rm.ast_type_to_region.insert(id, r);
-        // }
-      }
-
-      ast::re_static { /* fallthrough */ }
-
+      ast::re_inferred { ty::re_default }
+      ast::re_static { ty::re_static }
       ast::re_named(ident) {
         alt cx.scope.resolve_ident(ident) {
-          some(r) {
-            rm.ast_type_to_region.insert(id, r);
-          }
-
+          some(r) { r }
           none {
-            cx.sess.span_err(
+            cx.sess.span_fatal(
                 span,
                 #fmt["the region `%s` is not declared", ident]);
           }
         }
       }
-
       ast::re_self {
         alt cx.scope.resolve_self() {
-          some(r) {
-            rm.ast_type_to_region.insert(id, r);
-          }
-
+          some(r) { r }
           none {
-            cx.sess.span_err(
+            cx.sess.span_fatal(
                 span,
                 "the `self` region is not allowed here");
           }
@@ -414,8 +400,10 @@ fn resolve_ty(ty: @ast::ty, cx: ctxt, visitor: visit::vt<ctxt>) {
     cx.region_map.ast_type_to_inferred_region.insert(ty.id, inferred_region);
 
     alt ty.node {
+      ast::ty_vstore(_, ast::vstore_slice(r)) |
       ast::ty_rptr(r, _) {
-        resolve_region_binding(cx, ty.span, r);
+        let region = resolve_region_binding(cx, ty.span, r);
+        cx.region_map.ast_type_to_region.insert(ty.id, region);
       }
       _ { /* nothing to do */ }
     }
@@ -503,12 +491,17 @@ fn resolve_expr(expr: @ast::expr, cx: ctxt, visitor: visit::vt<ctxt>) {
                           in_alt: false with cx};
             visit::visit_expr(expr, new_cx, visitor);
         }
+        ast::expr_vstore(e, ast::vstore_slice(r)) {
+          let region = resolve_region_binding(cx, e.span, r);
+          cx.region_map.rvalue_to_region.insert(expr.id, region);
+        }
         ast::expr_addr_of(_, subexpr) | ast::expr_alt(subexpr, _, _) {
             // Record the block that this expression appears in, in case the
             // operand is an rvalue.
             alt cx.parent {
                 pa_block(blk_id) {
-                    cx.region_map.rvalue_to_block.insert(subexpr.id, blk_id);
+                  let region = ty::re_scope(blk_id);
+                  cx.region_map.rvalue_to_region.insert(subexpr.id, region);
                 }
                 _ { cx.sess.span_bug(expr.span, "expr outside of block?!"); }
             }
@@ -521,7 +514,8 @@ fn resolve_expr(expr: @ast::expr, cx: ctxt, visitor: visit::vt<ctxt>) {
 fn resolve_local(local: @ast::local, cx: ctxt, visitor: visit::vt<ctxt>) {
     alt cx.parent {
         pa_block(blk_id) {
-            cx.region_map.rvalue_to_block.insert(local.node.id, blk_id);
+          let region = ty::re_scope(blk_id);
+          cx.region_map.rvalue_to_region.insert(local.node.id, region);
         }
         _ { cx.sess.span_bug(local.span, "local outside of block?!"); }
     }
@@ -565,7 +559,7 @@ fn resolve_crate(sess: session, def_map: resolve::def_map, crate: @ast::crate)
                                   local_blocks: map::int_hash(),
                                   ast_type_to_inferred_region:
                                     map::int_hash(),
-                                  rvalue_to_block: map::int_hash()},
+                                  rvalue_to_region: map::int_hash()},
                     scope: root_scope(0),
                     mut queued_locals: [],
                     parent: pa_crate,
diff --git a/src/rustc/middle/trans/base.rs b/src/rustc/middle/trans/base.rs
index fcb983a7291fc..6c3e81b499915 100644
--- a/src/rustc/middle/trans/base.rs
+++ b/src/rustc/middle/trans/base.rs
@@ -573,7 +573,8 @@ fn make_take_glue(bcx: block, v: ValueRef, t: ty::t) {
     let _icx = bcx.insn_ctxt("make_take_glue");
     // NB: v is a *pointer* to type t here, not a direct value.
     let bcx = alt ty::get(t).struct {
-      ty::ty_box(_) | ty::ty_opaque_box {
+      ty::ty_box(_) | ty::ty_opaque_box |
+      ty::ty_evec(_, ty::vstore_box) | ty::ty_estr(ty::vstore_box) {
         incr_refcnt_of_boxed(bcx, Load(bcx, v)); bcx
       }
       ty::ty_uniq(_) {
@@ -581,7 +582,8 @@ fn make_take_glue(bcx: block, v: ValueRef, t: ty::t) {
         Store(bcx, val, v);
         bcx
       }
-      ty::ty_vec(_) | ty::ty_str {
+      ty::ty_vec(_) | ty::ty_str |
+      ty::ty_evec(_, ty::vstore_uniq) | ty::ty_estr(ty::vstore_uniq) {
         let {bcx, val} = tvec::duplicate(bcx, Load(bcx, v), t);
         Store(bcx, val, v);
         bcx
@@ -629,6 +631,12 @@ fn make_free_glue(bcx: block, v: ValueRef, t: ty::t) {
         let bcx = drop_ty(bcx, body, body_mt.ty);
         trans_free(bcx, v)
       }
+
+      ty::ty_estr(ty::vstore_box) {
+        let v = PointerCast(bcx, v, type_of(ccx, t));
+        trans_free(bcx, v)
+      }
+
       ty::ty_opaque_box {
         let v = PointerCast(bcx, v, type_of(ccx, t));
         let td = Load(bcx, GEPi(bcx, v, [0, abi::box_field_tydesc]));
@@ -641,9 +649,13 @@ fn make_free_glue(bcx: block, v: ValueRef, t: ty::t) {
         let v = PointerCast(bcx, v, type_of(ccx, t));
         uniq::make_free_glue(bcx, v, t)
       }
+      ty::ty_evec(_, ty::vstore_uniq) | ty::ty_estr(ty::vstore_uniq) |
       ty::ty_vec(_) | ty::ty_str {
         tvec::make_free_glue(bcx, PointerCast(bcx, v, type_of(ccx, t)), t)
       }
+      ty::ty_evec(_, _) {
+          bcx.sess().unimpl("trans::base::make_free_glue on other evec");
+      }
       ty::ty_fn(_) {
         closure::make_fn_glue(bcx, v, t, free_ty)
       }
@@ -660,7 +672,8 @@ fn make_drop_glue(bcx: block, v0: ValueRef, t: ty::t) {
     let _icx = bcx.insn_ctxt("make_drop_glue");
     let ccx = bcx.ccx();
     let bcx = alt ty::get(t).struct {
-      ty::ty_box(_) | ty::ty_opaque_box {
+      ty::ty_box(_) | ty::ty_opaque_box |
+      ty::ty_estr(ty::vstore_box) {
         decr_refcnt_maybe_free(bcx, Load(bcx, v0), t)
       }
       ty::ty_uniq(_) | ty::ty_vec(_) | ty::ty_str {
@@ -900,6 +913,10 @@ fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t,
             cx = f(cx, llfld_a, fld.mt.ty);
         }
       }
+      ty::ty_estr(ty::vstore_fixed(n)) |
+      ty::ty_evec(_, ty::vstore_fixed(n)) {
+        cx = tvec::iter_vec_raw(cx, av, t, C_uint(cx.ccx(), n), f);
+      }
       ty::ty_tup(args) {
         for vec::eachi(args) {|i, arg|
             let llfld_a = GEPi(cx, av, [0, i as int]);
@@ -1111,8 +1128,14 @@ 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 { free_ty(bcx, v, t) }
-      ty::ty_box(_) | ty::ty_opaque_box {
+      ty::ty_uniq(_) | ty::ty_vec(_) | ty::ty_str |
+      ty::ty_evec(_, ty::vstore_uniq) |
+      ty::ty_estr(ty::vstore_uniq) {
+        free_ty(bcx, v, t)
+      }
+      ty::ty_box(_) | ty::ty_opaque_box |
+      ty::ty_evec(_, ty::vstore_box) |
+      ty::ty_estr(ty::vstore_box) {
         decr_refcnt_maybe_free(bcx, v, t)
       }
       _ { bcx.tcx().sess.bug("drop_ty_immediate: non-box ty"); }
@@ -1122,14 +1145,20 @@ fn drop_ty_immediate(bcx: block, v: ValueRef, t: ty::t) -> block {
 fn take_ty_immediate(bcx: block, v: ValueRef, t: ty::t) -> result {
     let _icx = bcx.insn_ctxt("take_ty_immediate");
     alt ty::get(t).struct {
-      ty::ty_box(_) | ty::ty_opaque_box {
+      ty::ty_box(_) | ty::ty_opaque_box |
+      ty::ty_evec(_, ty::vstore_box) |
+      ty::ty_estr(ty::vstore_box) {
         incr_refcnt_of_boxed(bcx, v);
         rslt(bcx, v)
       }
       ty::ty_uniq(_) {
         uniq::duplicate(bcx, v, t)
       }
-      ty::ty_str | ty::ty_vec(_) { tvec::duplicate(bcx, v, t) }
+      ty::ty_str | ty::ty_vec(_) |
+      ty::ty_evec(_, ty::vstore_uniq) |
+      ty::ty_estr(ty::vstore_uniq) {
+        tvec::duplicate(bcx, v, t)
+      }
       _ { rslt(bcx, v) }
     }
 }
@@ -1207,7 +1236,7 @@ fn copy_val_no_check(bcx: block, action: copy_action, dst: ValueRef,
     let _icx = bcx.insn_ctxt("copy_val_no_check");
     let ccx = bcx.ccx();
     let mut bcx = bcx;
-    if ty::type_is_scalar(t) {
+    if ty::type_is_scalar(t) || ty::type_is_slice(t) {
         Store(bcx, src, dst);
         ret bcx;
     }
@@ -1239,7 +1268,7 @@ fn move_val(cx: block, action: copy_action, dst: ValueRef,
     let mut src_val = src.val;
     let tcx = cx.tcx();
     let mut cx = cx;
-    if ty::type_is_scalar(t) {
+    if ty::type_is_scalar(t) || ty::type_is_slice(t) {
         if src.kind == owned { src_val = Load(cx, src_val); }
         Store(cx, src_val, dst);
         ret cx;
@@ -1299,9 +1328,9 @@ fn trans_lit(cx: block, lit: ast::lit, dest: dest) -> block {
     let _icx = cx.insn_ctxt("trans_lit");
     if dest == ignore { ret cx; }
     alt lit.node {
-      ast::lit_str(s) { ret tvec::trans_str(cx, s, dest); }
+      ast::lit_str(s) { tvec::trans_str(cx, s, dest) }
       _ {
-        ret store_in_dest(cx, trans_crate_lit(cx.ccx(), lit), dest);
+        store_in_dest(cx, trans_crate_lit(cx.ccx(), lit), dest)
       }
     }
 }
@@ -2255,8 +2284,36 @@ fn trans_index(cx: block, ex: @ast::expr, base: @ast::expr,
     maybe_name_value(cx.ccx(), unit_sz, "unit_sz");
     let scaled_ix = Mul(bcx, ix_val, unit_sz);
     maybe_name_value(cx.ccx(), scaled_ix, "scaled_ix");
-    let lim = tvec::get_fill(bcx, v);
-    let body = tvec::get_dataptr(bcx, v, type_of(ccx, unit_ty));
+
+    let (lim,  body) = alt ty::get(base_ty).struct {
+      ty::ty_estr(ty::vstore_fixed(n)) |
+      ty::ty_evec(_, ty::vstore_fixed(n)) {
+        // FIXME: support static bounds-check elimination
+        // and/or error checking here.
+        let lim = C_uint(bcx.ccx(), n);
+        let body = GEPi(bcx, v, [0, 0]);
+        (lim, body)
+      }
+      ty::ty_estr(ty::vstore_slice(_)) |
+      ty::ty_evec(_, ty::vstore_slice(_)) {
+        let body = Load(bcx, GEPi(bcx, v, [0, 0]));
+        let lim = Load(bcx, GEPi(bcx, v, [0, 1]));
+        (lim, body)
+      }
+
+      ty::ty_estr(_) | ty::ty_evec(_, _) {
+        bcx.sess().unimpl(#fmt("unsupported evec/estr type trans_index"));
+      }
+      _ {
+        let lim = tvec::get_fill(bcx, v);
+        let body = tvec::get_dataptr(bcx, v, type_of(ccx, unit_ty));
+        (lim, body)
+      }
+    };
+
+    #debug("trans_index: lim %s", val_str(bcx.ccx().tn, lim));
+    #debug("trans_index: body %s", val_str(bcx.ccx().tn, body));
+
     let bounds_check = ICmp(bcx, lib::llvm::IntUGE, scaled_ix, lim);
     let bcx = with_cond(bcx, bounds_check) {|bcx|
         // fail: bad bounds check.
@@ -3017,6 +3074,7 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block {
         ret trans_rec(bcx, args, base, e.id, dest);
       }
       ast::expr_tup(args) { ret trans_tup(bcx, args, dest); }
+      ast::expr_vstore(e, v) { ret tvec::trans_vstore(bcx, e, v, dest); }
       ast::expr_lit(lit) { ret trans_lit(bcx, *lit, dest); }
       ast::expr_vec(args, _) { ret tvec::trans_vec(bcx, args, e.id, dest); }
       ast::expr_binary(op, lhs, rhs) {
diff --git a/src/rustc/middle/trans/shape.rs b/src/rustc/middle/trans/shape.rs
index 5460b4c8f2874..f79a77ce1d6bc 100644
--- a/src/rustc/middle/trans/shape.rs
+++ b/src/rustc/middle/trans/shape.rs
@@ -58,6 +58,8 @@ const shape_bare_fn: u8 = 27u8;
 const shape_tydesc: u8 = 28u8;
 const shape_send_tydesc: u8 = 29u8;
 const shape_rptr: u8 = 31u8;
+const shape_fixedvec: u8 = 32u8;
+const shape_slice: u8 = 33u8;
 
 fn hash_res_info(ri: res_info) -> uint {
     let mut h = 5381u;
@@ -305,6 +307,7 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t, ty_param_map: [uint]) -> [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 {
         let mut s = [shape_vec];
         add_bool(s, true); // type is POD
@@ -340,18 +343,67 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t, ty_param_map: [uint]) -> [u8] {
           }
         }
       }
+      ty::ty_estr(ty::vstore_box) |
+      ty::ty_evec(_, ty::vstore_box) |
       ty::ty_box(_) | ty::ty_opaque_box { [shape_box] }
       ty::ty_uniq(mt) {
         let mut s = [shape_uniq];
         add_substr(s, shape_of(ccx, mt.ty, ty_param_map));
         s
       }
+      ty::ty_evec(mt, ty::vstore_uniq) |
       ty::ty_vec(mt) {
         let mut s = [shape_vec];
         add_bool(s, ty::type_is_pod(ccx.tcx, mt.ty));
         add_substr(s, shape_of(ccx, mt.ty, ty_param_map));
         s
       }
+
+      // FIXME: grotesque hacks for encoding fixed-size evecs and estrs.
+
+      ty::ty_estr(ty::vstore_fixed(n)) {
+        let mut s = [shape_struct], sub = [];
+        let mut i = 0u;
+        let u8_t = ty::mk_mach_uint(ccx.tcx, ast::ty_u8);
+        while i < n {
+            sub += shape_of(ccx, u8_t, ty_param_map);
+        }
+        add_substr(s, sub);
+        s
+      }
+
+      ty::ty_evec(mt, ty::vstore_fixed(n)) {
+        let mut s = [shape_struct], sub = [];
+        let mut i = 0u;
+        while i < n {
+            sub += shape_of(ccx, mt.ty, ty_param_map);
+        }
+        add_substr(s, sub);
+        s
+      }
+
+
+      // FIXME: slightly-less-grotesque hack for encoding slic,e evecs and
+      // estrs.
+
+      ty::ty_estr(ty::vstore_slice(r)) {
+        let mut s = [shape_struct], sub = [];
+        let u8_mt = {ty: ty::mk_mach_uint(ccx.tcx, ast::ty_u8),
+                     mutbl: ast::m_imm };
+        sub += shape_of(ccx, ty::mk_rptr(ccx.tcx, r, u8_mt), ty_param_map);
+        sub += shape_of(ccx, ty::mk_uint(ccx.tcx), ty_param_map);
+        add_substr(s, sub);
+        s
+      }
+
+      ty::ty_evec(mt, ty::vstore_slice(r)) {
+        let mut s = [shape_struct], sub = [];
+        sub += shape_of(ccx, ty::mk_rptr(ccx.tcx, r, mt), ty_param_map);
+        sub += shape_of(ccx, ty::mk_uint(ccx.tcx), ty_param_map);
+        add_substr(s, sub);
+        s
+      }
+
       ty::ty_rec(fields) {
         let mut s = [shape_struct], sub = [];
         for vec::each(fields) {|f|
@@ -632,12 +684,18 @@ 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_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) }
           ty::ty_fn(_) { ty::mk_tup(tcx, [nilptr(tcx), nilptr(tcx)]) }
           ty::ty_res(_, sub, tps) {
             let sub1 = ty::substitute_type_params(tcx, tps, sub);
             ty::mk_tup(tcx, [ty::mk_int(tcx), simplify_type(tcx, sub1)])
           }
+          ty::ty_evec(_, ty::vstore_slice(_)) |
+          ty::ty_estr(ty::vstore_slice(_)) {
+            ty::mk_tup(tcx, [nilptr(tcx), ty::mk_int(tcx)])
+          }
           _ { typ }
         }
     }
diff --git a/src/rustc/middle/trans/tvec.rs b/src/rustc/middle/trans/tvec.rs
index f3d0659194224..1008d9ed8c6ab 100644
--- a/src/rustc/middle/trans/tvec.rs
+++ b/src/rustc/middle/trans/tvec.rs
@@ -6,6 +6,7 @@ import base::{call_memmove, shared_malloc,
                INIT, copy_val, load_if_immediate, get_tydesc,
                sub_block, do_spill_noroot,
                dest, bcx_icx};
+import syntax::codemap::span;
 import shape::llsize_of;
 import build::*;
 import common::*;
@@ -129,6 +130,50 @@ fn trans_vec(bcx: block, args: [@ast::expr], id: ast::node_id,
     ret base::store_in_dest(bcx, vptr, dest);
 }
 
+fn trans_vstore(bcx: block, e: @ast::expr,
+                v: ast::vstore, dest: dest) -> block {
+    alt e.node {
+      ast::expr_lit(@{node: ast::lit_str(s), span: _}) {
+        ret trans_estr(bcx, s, v, e.span, dest);
+      }
+      ast::expr_vec(es, mutbl) {
+        bcx.ccx().sess.span_unimpl(e.span, "unhandled tvec::trans_vstore");
+      }
+      _ {
+        bcx.sess().span_bug(e.span, "vstore on non-sequence type");
+      }
+    }
+}
+
+fn trans_estr(bcx: block, s: str, vstore: ast::vstore,
+              sp: span, dest: dest) -> block {
+    let _icx = bcx.insn_ctxt("tvec::trans_estr");
+    let ccx = bcx.ccx();
+
+    let c = alt vstore {
+      ast::vstore_fixed(_)
+      {
+        // "hello"/_  =>  [i8 x 6] in llvm
+        #debug("trans_estr: fixed: %s", s);
+        C_postr(s)
+      }
+
+      ast::vstore_slice(_) {
+        // "hello"  =>  (*i8,uint) in llvm
+        #debug("trans_estr: slice '%s'", s);
+        let cs = PointerCast(bcx, C_cstr(ccx, s), T_ptr(T_i8()));
+        C_struct([cs, C_uint(ccx, str::len(s))])
+      }
+
+      _ {
+        bcx.ccx().sess.span_unimpl(sp, "unhandled tvec::trans_estr");
+      }
+    };
+
+    #debug("trans_estr: type: %s", val_str(ccx.tn, c));
+    base::store_in_dest(bcx, c, dest)
+}
+
 fn trans_str(bcx: block, s: str, dest: dest) -> block {
     let _icx = bcx.insn_ctxt("tvec::trans_str");
     let ccx = bcx.ccx();
diff --git a/src/rustc/middle/trans/type_of.rs b/src/rustc/middle/trans/type_of.rs
index 7f471e76bb727..eef0f0b510183 100644
--- a/src/rustc/middle/trans/type_of.rs
+++ b/src/rustc/middle/trans/type_of.rs
@@ -48,14 +48,37 @@ fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef {
       ty::ty_int(t) { T_int_ty(cx, t) }
       ty::ty_uint(t) { T_uint_ty(cx, t) }
       ty::ty_float(t) { T_float_ty(cx, t) }
+      ty::ty_estr(ty::vstore_uniq) |
       ty::ty_str { T_ptr(T_vec(cx, T_i8())) }
       ty::ty_enum(did, _) { type_of_enum(cx, did, t) }
+      ty::ty_estr(ty::vstore_box) { T_ptr(T_box(cx, T_i8())) }
+      ty::ty_evec(mt, ty::vstore_box) |
       ty::ty_box(mt) { T_ptr(T_box(cx, type_of(cx, mt.ty))) }
       ty::ty_opaque_box { T_ptr(T_box(cx, T_i8())) }
       ty::ty_uniq(mt) { T_ptr(type_of(cx, mt.ty)) }
+      ty::ty_evec(mt, ty::vstore_uniq) |
       ty::ty_vec(mt) { T_ptr(T_vec(cx, type_of(cx, mt.ty))) }
       ty::ty_ptr(mt) { T_ptr(type_of(cx, mt.ty)) }
       ty::ty_rptr(_, mt) { T_ptr(type_of(cx, mt.ty)) }
+
+      ty::ty_evec(mt, ty::vstore_slice(_)) {
+        T_struct([T_ptr(type_of(cx, mt.ty)),
+                  T_uint_ty(cx, ast::ty_u)])
+      }
+
+      ty::ty_estr(ty::vstore_slice(_)) {
+        T_struct([T_ptr(T_i8()),
+                  T_uint_ty(cx, ast::ty_u)])
+      }
+
+      ty::ty_estr(ty::vstore_fixed(n)) {
+        T_array(T_i8(), n + 1u /* +1 for trailing null */)
+      }
+
+      ty::ty_evec(mt, ty::vstore_fixed(n)) {
+        T_array(type_of(cx, mt.ty), n)
+      }
+
       ty::ty_rec(fields) {
         let mut tys: [TypeRef] = [];
         for vec::each(fields) {|f|
diff --git a/src/rustc/middle/trans/type_use.rs b/src/rustc/middle/trans/type_use.rs
index cbed8a0dbc553..4b993f8224cb4 100644
--- a/src/rustc/middle/trans/type_use.rs
+++ b/src/rustc/middle/trans/type_use.rs
@@ -136,7 +136,9 @@ fn node_type_needs(cx: ctx, use: uint, id: node_id) {
 
 fn mark_for_expr(cx: ctx, e: @expr) {
     alt e.node {
-      expr_vec(_, _) | expr_rec(_, _) | expr_tup(_) |
+      expr_vstore(_, _) |
+      expr_vec(_, _) |
+      expr_rec(_, _) | expr_tup(_) |
       expr_unary(box(_), _) | expr_unary(uniq(_), _) |
       expr_cast(_, _) | expr_binary(add, _, _) |
       expr_copy(_) | expr_move(_, _) {
diff --git a/src/rustc/middle/tstate/pre_post_conditions.rs b/src/rustc/middle/tstate/pre_post_conditions.rs
index ec7c8354d8c71..fc74db67b3797 100644
--- a/src/rustc/middle/tstate/pre_post_conditions.rs
+++ b/src/rustc/middle/tstate/pre_post_conditions.rs
@@ -321,7 +321,14 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) {
           _ { }
         }
       }
-      expr_vec(args, _) { find_pre_post_exprs(fcx, args, e.id); }
+      expr_vstore(ee, _) {
+        find_pre_post_expr(fcx, ee);
+        let p = expr_pp(fcx.ccx, ee);
+        set_pre_and_post(fcx.ccx, e.id, p.precondition, p.postcondition);
+      }
+      expr_vec(args, _) {
+        find_pre_post_exprs(fcx, args, e.id);
+      }
       expr_path(p) {
         let rslt = expr_pp(fcx.ccx, e);
         clear_pp(rslt);
diff --git a/src/rustc/middle/tstate/states.rs b/src/rustc/middle/tstate/states.rs
index 8ec37b9c0cb67..7d3016a663610 100644
--- a/src/rustc/middle/tstate/states.rs
+++ b/src/rustc/middle/tstate/states.rs
@@ -358,6 +358,12 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool {
       expr_new(p, _, v) {
         ret find_pre_post_state_two(fcx, pres, p, v, e.id, oper_pure);
       }
+      expr_vstore(ee, _) {
+        let mut changed = find_pre_post_state_expr(fcx, pres, ee);
+        set_prestate_ann(fcx.ccx, e.id, expr_prestate(fcx.ccx, ee));
+        set_poststate_ann(fcx.ccx, e.id, expr_poststate(fcx.ccx, ee));
+        ret changed;
+      }
       expr_vec(elts, _) {
         ret find_pre_post_state_exprs(fcx, pres, e.id,
                                       vec::from_elem(vec::len(elts),
diff --git a/src/rustc/middle/ty.rs b/src/rustc/middle/ty.rs
index f4d134459be02..0852edcbea673 100644
--- a/src/rustc/middle/ty.rs
+++ b/src/rustc/middle/ty.rs
@@ -80,6 +80,9 @@ export ty_fn_proto, ty_fn_ret, ty_fn_ret_style;
 export ty_int, mk_int, mk_mach_int, mk_char;
 export ty_str, mk_str, type_is_str;
 export ty_vec, mk_vec, type_is_vec;
+export ty_estr, mk_estr;
+export ty_evec, mk_evec;
+export vstore, vstore_fixed, vstore_uniq, vstore_box, vstore_slice;
 export ty_nil, mk_nil, type_is_nil;
 export ty_iface, mk_iface;
 export ty_res, mk_res;
@@ -115,7 +118,7 @@ export type_is_sequence;
 export type_is_signed;
 export type_is_structural;
 export type_is_copyable;
-export type_is_tup_like;
+export type_is_slice;
 export type_is_unique;
 export type_is_c_like_enum;
 export type_structurally_contains;
@@ -164,6 +167,13 @@ type constr_table = hashmap<ast::node_id, [constr]>;
 
 type mt = {ty: t, mutbl: ast::mutability};
 
+enum vstore {
+    vstore_fixed(uint),
+    vstore_uniq,
+    vstore_box,
+    vstore_slice(region)
+}
+
 type field_ty = {
   ident: ident,
   id: def_id,
@@ -293,10 +303,12 @@ enum sty {
     ty_uint(ast::uint_ty),
     ty_float(ast::float_ty),
     ty_str,
+    ty_estr(vstore),
     ty_enum(def_id, [t]),
     ty_box(mt),
     ty_uniq(mt),
     ty_vec(mt),
+    ty_evec(mt, vstore),
     ty_ptr(mt),
     ty_rptr(region, mt),
     ty_rec([field]),
@@ -458,8 +470,15 @@ fn mk_t_with_id(cx: ctxt, st: sty, o_def_id: option<ast::def_id>) -> t {
         has_rptrs |= t.has_rptrs;
     }
     alt st {
+      ty_estr(vstore_slice(_)) {
+        has_rptrs = true;
+      }
+      ty_evec(mt, vstore_slice(_)) {
+        has_rptrs = true;
+        derive_flags(has_params, has_vars, has_rptrs, mt.ty);
+      }
       ty_nil | ty_bot | ty_bool | ty_int(_) | ty_float(_) | ty_uint(_) |
-      ty_str | ty_type | ty_opaque_closure_ptr(_) |
+      ty_str | ty_estr(_) | ty_type | ty_opaque_closure_ptr(_) |
       ty_opaque_box {}
       ty_param(_, _) { has_params = true; }
       ty_var(_) | ty_self(_) { has_vars = true; }
@@ -468,7 +487,7 @@ fn mk_t_with_id(cx: ctxt, st: sty, o_def_id: option<ast::def_id>) -> t {
             derive_flags(has_params, has_vars, has_rptrs, tt);
         }
       }
-      ty_box(m) | ty_uniq(m) | ty_vec(m) | ty_ptr(m) {
+      ty_box(m) | ty_uniq(m) | ty_vec(m) | ty_evec(m, _) | ty_ptr(m) {
         derive_flags(has_params, has_vars, has_rptrs, m.ty);
       }
       ty_rptr(r, m) {
@@ -536,6 +555,10 @@ fn mk_char(cx: ctxt) -> t { mk_t(cx, ty_int(ast::ty_char)) }
 
 fn mk_str(cx: ctxt) -> t { mk_t(cx, ty_str) }
 
+fn mk_estr(cx: ctxt, t: vstore) -> t {
+    mk_t(cx, ty_estr(t))
+}
+
 fn mk_enum(cx: ctxt, did: ast::def_id, tys: [t]) -> t {
     mk_t(cx, ty_enum(did, tys))
 }
@@ -567,6 +590,10 @@ fn mk_nil_ptr(cx: ctxt) -> t {
 
 fn mk_vec(cx: ctxt, tm: mt) -> t { mk_t(cx, ty_vec(tm)) }
 
+fn mk_evec(cx: ctxt, tm: mt, t: vstore) -> t {
+    mk_t(cx, ty_evec(tm, t))
+}
+
 fn mk_rec(cx: ctxt, fs: [field]) -> t { mk_t(cx, ty_rec(fs)) }
 
 fn mk_constr(cx: ctxt, t: t, cs: [@type_constr]) -> t {
@@ -630,9 +657,10 @@ fn maybe_walk_ty(ty: t, f: fn(t) -> bool) {
     if !f(ty) { ret; }
     alt get(ty).struct {
       ty_nil | ty_bot | ty_bool | ty_int(_) | ty_uint(_) | ty_float(_) |
-      ty_str | ty_type | ty_opaque_box |
+      ty_str | ty_estr(_) | ty_type | ty_opaque_box |
       ty_opaque_closure_ptr(_) | ty_var(_) | ty_param(_, _) {}
-      ty_box(tm) | ty_vec(tm) | ty_ptr(tm) | ty_rptr(_, tm) {
+      ty_box(tm) | ty_vec(tm) | ty_evec(tm, _) |
+      ty_ptr(tm) | ty_rptr(_, tm) {
         maybe_walk_ty(tm.ty, f);
       }
       ty_enum(_, subtys) | ty_iface(_, subtys) | ty_class(_, subtys)
@@ -674,6 +702,9 @@ fn fold_sty(sty: sty, fldop: fn(t) -> t) -> sty {
       ty_vec(tm) {
         ty_vec({ty: fldop(tm.ty), mutbl: tm.mutbl})
       }
+      ty_evec(tm, vst) {
+        ty_evec({ty: fldop(tm.ty), mutbl: tm.mutbl}, vst)
+      }
       ty_enum(tid, subtys) {
         ty_enum(tid, vec::map(subtys) {|t| fldop(t) })
       }
@@ -718,7 +749,7 @@ fn fold_sty(sty: sty, fldop: fn(t) -> t) -> sty {
         ty_class(did, new_tps)
       }
       ty_nil | ty_bot | ty_bool | ty_int(_) | ty_uint(_) | ty_float(_) |
-      ty_str | ty_type | ty_opaque_closure_ptr(_) |
+      ty_str | ty_estr(_) | ty_type | ty_opaque_closure_ptr(_) |
       ty_opaque_box | ty_var(_) | ty_param(_, _) {
         sty
       }
@@ -751,6 +782,15 @@ fn fold_region(cx: ctxt, t0: t, fldop: fn(region, bool) -> region) -> t {
             let m_t1 = do_fold(cx, t1, true, fldop);
             ty::mk_rptr(cx, m_r, {ty: m_t1, mutbl: m})
           }
+          ty_estr(vstore_slice(r)) {
+            let m_r = fldop(r, under_r);
+            ty::mk_estr(cx, vstore_slice(m_r))
+          }
+          ty_evec({ty: t1, mutbl: m}, vstore_slice(r)) {
+            let m_r = fldop(r, under_r);
+            let m_t1 = do_fold(cx, t1, true, fldop);
+            ty::mk_evec(cx, {ty: m_t1, mutbl: m}, vstore_slice(m_r))
+          }
           ty_fn(_) {
             // do not recurse into functions, which introduce fresh bindings
             t0
@@ -786,7 +826,8 @@ fn type_is_bool(ty: t) -> bool { get(ty).struct == ty_bool }
 fn type_is_structural(ty: t) -> bool {
     alt get(ty).struct {
       ty_rec(_) | ty_class(_,_) | ty_tup(_) | ty_enum(_, _) | ty_fn(_) |
-      ty_iface(_, _) | ty_res(_, _, _) { true }
+      ty_iface(_, _) | ty_res(_, _, _) | ty_evec(_, vstore_fixed(_))
+      | ty_estr(vstore_fixed(_)) { true }
       _ { false }
     }
 }
@@ -797,26 +838,23 @@ fn type_is_copyable(cx: ctxt, ty: t) -> bool {
 
 fn type_is_sequence(ty: t) -> bool {
     alt get(ty).struct {
-      ty_str { ret true; }
-      ty_vec(_) { ret true; }
-      _ { ret false; }
+      ty_str | ty_estr(_) | ty_vec(_) | ty_evec(_, _) { true }
+      _ { false }
     }
 }
 
-fn type_is_str(ty: t) -> bool { get(ty).struct == ty_str }
-
-fn sequence_element_type(cx: ctxt, ty: t) -> t {
+fn type_is_str(ty: t) -> bool {
     alt get(ty).struct {
-      ty_str { ret mk_mach_uint(cx, ast::ty_u8); }
-      ty_vec(mt) { ret mt.ty; }
-      _ { cx.sess.bug("sequence_element_type called on non-sequence value"); }
+      ty_str | ty_estr(_) { true }
+      _ { false }
     }
 }
 
-pure fn type_is_tup_like(ty: t) -> bool {
+fn sequence_element_type(cx: ctxt, ty: t) -> t {
     alt get(ty).struct {
-      ty_rec(_) | ty_tup(_) { true }
-      _ { false }
+      ty_str | ty_estr(_) { ret mk_mach_uint(cx, ast::ty_u8); }
+      ty_vec(mt) | ty_evec(mt, _) { ret mt.ty; }
+      _ { cx.sess.bug("sequence_element_type called on non-sequence value"); }
     }
 }
 
@@ -842,6 +880,13 @@ pure fn type_is_boxed(ty: t) -> bool {
     }
 }
 
+pure fn type_is_slice(ty: t) -> bool {
+    alt get(ty).struct {
+      ty_evec(_, vstore_slice(_)) | ty_estr(vstore_slice(_)) { true }
+      _ { ret false; }
+    }
+}
+
 pure fn type_is_unique_box(ty: t) -> bool {
     alt get(ty).struct {
       ty_uniq(_) { ret true; }
@@ -858,8 +903,8 @@ pure fn type_is_unsafe_ptr(ty: t) -> bool {
 
 pure fn type_is_vec(ty: t) -> bool {
     ret alt get(ty).struct {
-          ty_vec(_) { true }
-          ty_str { true }
+          ty_vec(_) | ty_evec(_, _) { true }
+          ty_str | ty_estr(_) { true }
           _ { false }
         };
 }
@@ -867,8 +912,8 @@ pure fn type_is_vec(ty: t) -> bool {
 pure fn type_is_unique(ty: t) -> bool {
     alt get(ty).struct {
       ty_uniq(_) { ret true; }
-      ty_vec(_) { true }
-      ty_str { true }
+      ty_vec(_) | ty_evec(_, vstore_uniq) { true }
+      ty_str | ty_estr(vstore_uniq) { true }
       _ { ret false; }
     }
 }
@@ -897,7 +942,10 @@ fn type_needs_drop(cx: ctxt, ty: t) -> bool {
     let result = alt get(ty).struct {
       // scalar types
       ty_nil | ty_bot | ty_bool | ty_int(_) | ty_float(_) | ty_uint(_) |
-      ty_type | ty_ptr(_) | ty_rptr(_, _) { false }
+      ty_type | ty_ptr(_) | ty_rptr(_, _) |
+      ty_estr(vstore_fixed(_)) | ty_estr(vstore_slice(_)) |
+      ty_evec(_, vstore_slice(_)) { false }
+      ty_evec(mt, vstore_fixed(_)) { type_needs_drop(cx, mt.ty) }
       ty_rec(flds) {
         for flds.each {|f| if type_needs_drop(cx, f.mt.ty) { accum = true; } }
         accum
@@ -983,7 +1031,12 @@ fn type_needs_unwind_cleanup_(cx: ctxt, ty: t,
             }
             !needs_unwind_cleanup
           }
-          ty_uniq(_) | ty_str | ty_vec(_) | ty_res(_, _, _) {
+          ty_uniq(_) | ty_str | ty_vec(_) | ty_res(_, _, _) |
+          ty_estr(vstore_uniq) |
+          ty_estr(vstore_box) |
+          ty_evec(_, vstore_uniq) |
+          ty_evec(_, vstore_box)
+          {
             // Once we're inside a box, the annihilator will find
             // it and destroy it.
             if !encountered_box {
@@ -1046,6 +1099,17 @@ fn lower_kind(a: kind, b: kind) -> kind {
     if kind_lteq(a, b) { a } else { b }
 }
 
+#[test]
+fn test_kinds() {
+    // The kind "lattice" is nocopy <= copy <= send
+    assert kind_lteq(kind_sendable, kind_sendable);
+    assert kind_lteq(kind_copyable, kind_sendable);
+    assert kind_lteq(kind_copyable, kind_copyable);
+    assert kind_lteq(kind_noncopyable, kind_sendable);
+    assert kind_lteq(kind_noncopyable, kind_copyable);
+    assert kind_lteq(kind_noncopyable, kind_noncopyable);
+}
+
 fn type_kind(cx: ctxt, ty: t) -> kind {
     alt cx.kind_cache.find(ty) {
       some(result) { ret result; }
@@ -1061,15 +1125,33 @@ fn type_kind(cx: ctxt, ty: t) -> kind {
       ty_ptr(_) | ty_str { kind_sendable }
       ty_type { kind_copyable }
       ty_fn(f) { proto_kind(f.proto) }
+
+      // Closures have kind determined by capture mode
       ty_opaque_closure_ptr(ck_block) { kind_noncopyable }
       ty_opaque_closure_ptr(ck_box) { kind_copyable }
       ty_opaque_closure_ptr(ck_uniq) { kind_sendable }
-      // Those with refcounts-to-inner raise pinned to shared,
-      // lower unique to shared. Therefore just set result to shared.
+
+      // Those with refcounts raise noncopyable to copyable,
+      // lower sendable to copyable. Therefore just set result to copyable.
       ty_box(_) | ty_iface(_, _) | ty_opaque_box { kind_copyable }
       ty_rptr(_, _) { kind_copyable }
-      // Boxes and unique pointers raise pinned to shared.
+
+      // Unique boxes and vecs have the kind of their contained type.
       ty_vec(tm) | ty_uniq(tm) { type_kind(cx, tm.ty) }
+
+      // Slice and refcounted evecs are copyable; uniques and interiors
+      // depend on the their contained type.
+      ty_evec(_, vstore_box) |
+      ty_evec(_, vstore_slice(_)) { kind_copyable }
+      ty_evec(tm, vstore_uniq) |
+      ty_evec(tm, vstore_fixed(_)) { type_kind(cx, tm.ty)  }
+
+      // All estrs are copyable; uniques and interiors are sendable.
+      ty_estr(vstore_box) |
+      ty_estr(vstore_slice(_)) { kind_copyable }
+      ty_estr(vstore_uniq) |
+      ty_estr(vstore_fixed(_)) { kind_sendable  }
+
       // Records lower to the lowest of their members.
       ty_rec(flds) {
         let mut lowest = kind_sendable;
@@ -1152,6 +1234,7 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool {
           ty_uint(_) |
           ty_float(_) |
           ty_str |
+          ty_estr(_) |
           ty_fn(_) |
           ty_var(_) |
           ty_param(_, _) |
@@ -1159,6 +1242,7 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool {
           ty_type |
           ty_opaque_box |
           ty_opaque_closure_ptr(_) |
+          ty_evec(_, _) |
           ty_vec(_) {
             false
           }
@@ -1277,6 +1361,9 @@ fn type_structurally_contains(cx: ctxt, ty: t, test: fn(sty) -> bool) ->
         let sty = substitute_type_params(cx, tps, sub);
         ret type_structurally_contains(cx, sty, test);
       }
+      ty_evec(mt, vstore_fixed(_)) {
+        ret type_structurally_contains(cx, mt.ty, test);
+      }
       _ { ret false; }
     }
 }
@@ -1288,6 +1375,11 @@ fn type_allows_implicit_copy(cx: ctxt, ty: t) -> bool {
     ret !type_structurally_contains(cx, ty, {|sty|
         alt sty {
           ty_param(_, _) { true }
+
+          ty_evec(_, _) | ty_estr(_) {
+            cx.sess.unimpl("estr/evec in type_allows_implicit_copy");
+          }
+
           ty_vec(mt) {
             mt.mutbl != ast::m_imm
           }
@@ -1302,9 +1394,11 @@ fn type_allows_implicit_copy(cx: ctxt, ty: t) -> bool {
 fn type_structurally_contains_uniques(cx: ctxt, ty: t) -> bool {
     ret type_structurally_contains(cx, ty, {|sty|
         alt sty {
-          ty_uniq(_) { true }
-          ty_vec(_) { true }
-          ty_str { true }
+          ty_uniq(_) |
+          ty_vec(_) |
+          ty_evec(_, vstore_uniq) |
+          ty_str |
+          ty_estr(vstore_uniq) { true }
           _ { false }
         }
     });
@@ -1365,6 +1459,10 @@ fn type_is_pod(cx: ctxt, ty: t) -> bool {
       ty_tup(elts) {
         for elts.each {|elt| if !type_is_pod(cx, elt) { result = false; } }
       }
+      ty_estr(vstore_fixed(_)) { result = true; }
+      ty_evec(mt, vstore_fixed(_)) {
+        result = type_is_pod(cx, mt.ty);
+      }
       ty_res(_, inner, tps) {
         result = type_is_pod(cx, substitute_type_params(cx, tps, inner));
       }
@@ -1503,6 +1601,7 @@ fn hash_type_structure(st: sty) -> uint {
       ty_float(t) {
         alt t { ast::ty_f { 13u } ast::ty_f32 { 14u } ast::ty_f64 { 15u } }
       }
+      ty_estr(_) { 16u }
       ty_str { 17u }
       ty_enum(did, tys) {
         let mut h = hash_def(18u, did);
@@ -1510,6 +1609,7 @@ fn hash_type_structure(st: sty) -> uint {
         h
       }
       ty_box(mt) { hash_subty(19u, mt.ty) }
+      ty_evec(mt, _) { hash_subty(20u, mt.ty) }
       ty_vec(mt) { hash_subty(21u, mt.ty) }
       ty_rec(fields) {
         let mut h = 26u;
@@ -1849,15 +1949,15 @@ fn set_default_mode(cx: ctxt, m: ast::mode, m_def: ast::rmode) {
 fn ty_sort_str(cx: ctxt, t: t) -> str {
     alt get(t).struct {
       ty_nil | ty_bot | ty_bool | ty_int(_) |
-      ty_uint(_) | ty_float(_) | ty_str | ty_type | ty_opaque_box |
-      ty_opaque_closure_ptr(_) {
+      ty_uint(_) | ty_float(_) | ty_estr(_) | ty_str |
+      ty_type | ty_opaque_box | ty_opaque_closure_ptr(_) {
         ty_to_str(cx, t)
       }
 
       ty_enum(_, _) { "enum" }
       ty_box(_) { "@-ptr" }
       ty_uniq(_) { "~-ptr" }
-      ty_vec(_) { "vector" }
+      ty_evec(_, _) | ty_vec(_) { "vector" }
       ty_ptr(_) { "*-ptr" }
       ty_rptr(_, _) { "&-ptr" }
       ty_rec(_) { "record" }
@@ -2312,14 +2412,11 @@ fn is_binopable(_cx: ctxt, ty: t, op: ast::binop) -> bool {
     fn tycat(ty: t) -> int {
         alt get(ty).struct {
           ty_bool { tycat_bool }
-          ty_int(_) { tycat_int }
-          ty_uint(_) { tycat_int }
+          ty_int(_) | ty_uint(_) { tycat_int }
           ty_float(_) { tycat_float }
-          ty_str { tycat_str }
-          ty_vec(_) { tycat_vec }
-          ty_rec(_) { tycat_struct }
-          ty_tup(_) { tycat_struct }
-          ty_enum(_, _) { tycat_struct }
+          ty_estr(_) | ty_str { tycat_str }
+          ty_evec(_, _) | ty_vec(_) { tycat_vec }
+          ty_rec(_) | ty_tup(_) | ty_enum(_, _) { tycat_struct }
           ty_bot { tycat_bot }
           _ { tycat_other }
         }
diff --git a/src/rustc/middle/typeck.rs b/src/rustc/middle/typeck.rs
index f89a34e668ffe..bfc3806b3828f 100644
--- a/src/rustc/middle/typeck.rs
+++ b/src/rustc/middle/typeck.rs
@@ -276,6 +276,43 @@ fn type_is_c_like_enum(fcx: @fn_ctxt, sp: span, typ: ty::t) -> bool {
 
 enum mode { m_collect, m_check, m_check_tyvar(@fn_ctxt), }
 
+fn ast_ty_vstore_to_vstore(tcx: ty::ctxt, ty: @ast::ty,
+                           v: ast::vstore) -> ty::vstore {
+    alt v {
+      ast::vstore_fixed(none) {
+        tcx.sess.span_bug(ty.span,
+                          "implied fixed length in ast_ty_vstore_to_vstore");
+      }
+      ast::vstore_fixed(some(u)) {
+        ty::vstore_fixed(u)
+      }
+      ast::vstore_uniq { ty::vstore_uniq }
+      ast::vstore_box { ty::vstore_box }
+      ast::vstore_slice(r) {
+        ty::vstore_slice(tcx.region_map.ast_type_to_region.get(ty.id))
+      }
+    }
+}
+
+fn ast_expr_vstore_to_vstore(fcx: @fn_ctxt, e: @ast::expr, n: uint,
+                             v: ast::vstore) -> ty::vstore {
+    alt v {
+      ast::vstore_fixed(none) { ty::vstore_fixed(n) }
+      ast::vstore_fixed(some(u)) {
+        if n != u {
+            let s = #fmt("fixed-size sequence mismatch: %u vs. %u",u, n);
+            fcx.ccx.tcx.sess.span_err(e.span,s);
+        }
+        ty::vstore_fixed(u)
+      }
+      ast::vstore_uniq { ty::vstore_uniq }
+      ast::vstore_box { ty::vstore_box }
+      ast::vstore_slice(r) {
+        ty::vstore_slice(region_of(fcx, e))
+      }
+    }
+}
+
 // Parses the programmer's textual representation of a type into our
 // internal notion of a type. `getter` is a function that returns the type
 // corresponding to a definition ID:
@@ -361,19 +398,8 @@ fn ast_ty_to_ty(tcx: ty::ctxt, mode: mode, &&ast_ty: @ast::ty) -> ty::t {
             ty::mk_ptr(tcx, ast_mt_to_mt(tcx, mode, mt))
           }
           ast::ty_rptr(region, mt) {
-            let r = alt region.node {
-              ast::re_inferred {
-                // this must be replaced later by a fixup_regions() pass
-                ty::re_default
-              }
-              ast::re_self | ast::re_named(_) {
-                tcx.region_map.ast_type_to_region.get(region.id)
-              }
-              ast::re_static {
-                ty::re_static
-              }
-            };
-            ty::mk_rptr(tcx, r, ast_mt_to_mt(tcx, mode, mt))
+            let region = tcx.region_map.ast_type_to_region.get(region.id);
+            ty::mk_rptr(tcx, region, ast_mt_to_mt(tcx, mode, mt))
           }
           ast::ty_tup(fields) {
             let flds = vec::map(fields, bind do_ast_ty_to_ty(tcx, mode, _));
@@ -436,6 +462,19 @@ fn ast_ty_to_ty(tcx: ty::ctxt, mode: mode, &&ast_ty: @ast::ty) -> ty::t {
               }
             }
           }
+          ast::ty_vstore(t, vst) {
+            let vst = ast_ty_vstore_to_vstore(tcx, ast_ty, vst);
+            let ty = alt ty::get(do_ast_ty_to_ty(tcx, mode, t)).struct {
+              ty::ty_vec(mt) { ty::mk_evec(tcx, mt, vst) }
+              ty::ty_str { ty::mk_estr(tcx, vst) }
+              _ {
+                tcx.sess.span_fatal(ast_ty.span,
+                                    "found sequence storage modifier \
+                                     on non-sequence type");
+              }
+            };
+            fixup_regions_to_block(tcx, ty, ast_ty)
+          }
           ast::ty_constr(t, cs) {
             let mut out_cs = [];
             for cs.each {|constr|
@@ -2464,8 +2503,7 @@ fn region_of(fcx: @fn_ctxt, expr: @ast::expr) -> ty::region {
             }
         }
         _ {
-            let blk_id = fcx.ccx.tcx.region_map.rvalue_to_block.get(expr.id);
-            ret ty::re_scope(blk_id);
+            ret fcx.ccx.tcx.region_map.rvalue_to_region.get(expr.id);
         }
     }
 }
@@ -2799,6 +2837,31 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier,
     let id = expr.id;
     let mut bot = false;
     alt expr.node {
+
+      ast::expr_vstore(ev, vst) {
+        let typ = alt ev.node {
+          ast::expr_lit(@{node: ast::lit_str(s), span:_}) {
+            let tt = ast_expr_vstore_to_vstore(fcx, expr,
+                                               str::len(s), vst);
+            ty::mk_estr(tcx, tt)
+          }
+          ast::expr_vec(args, mutbl) {
+            let tt = ast_expr_vstore_to_vstore(fcx, expr,
+                                               vec::len(args), vst);
+            let t: ty::t = next_ty_var(fcx);
+            for args.each {|e| bot |= check_expr_with(fcx, e, t); }
+            ty::mk_evec(tcx, {ty: t, mutbl: mutbl}, tt)
+          }
+          _ {
+            tcx.sess.span_bug(expr.span, "vstore modifier on non-sequence")
+          }
+        };
+        let region = fcx.ccx.tcx.region_map.rvalue_to_region.get(expr.id);
+        let typ = replace_default_region(tcx, region, typ);
+        fcx.write_ty(ev.id, typ);
+        fcx.write_ty(id, typ);
+      }
+
       ast::expr_lit(lit) {
         let typ = check_lit(fcx.ccx, lit);
         fcx.write_ty(id, typ);
@@ -3002,7 +3065,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier,
         let pattern_ty = next_ty_var(fcx);
         bot = check_expr_with(fcx, discrim, pattern_ty);
 
-        let parent_block = tcx.region_map.rvalue_to_block.get(discrim.id);
+        let parent_region = tcx.region_map.rvalue_to_region.get(discrim.id);
 
         // Typecheck the patterns first, so that we get types for all the
         // bindings.
@@ -3011,9 +3074,9 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier,
             let pcx = {
                 fcx: fcx,
                 map: pat_util::pat_id_map(tcx.def_map, arm.pats[0]),
-                alt_region: ty::re_scope(parent_block),
+                alt_region: parent_region,
                 block_region: ty::re_scope(arm.body.node.id),
-                pat_region: ty::re_scope(parent_block)
+                pat_region: parent_region
             };
 
             for arm.pats.each {|p| check_pat(pcx, p, pattern_ty);}
@@ -3319,10 +3382,12 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier,
         bot |= check_expr(fcx, idx);
         let idx_t = fcx.expr_ty(idx);
         alt structure_of(fcx, expr.span, base_t) {
+          ty::ty_evec(mt, _) |
           ty::ty_vec(mt) {
             require_integral(fcx, idx.span, idx_t);
             fcx.write_ty(id, mt.ty);
           }
+          ty::ty_estr(_) |
           ty::ty_str {
             require_integral(fcx, idx.span, idx_t);
             let typ = ty::mk_mach_uint(tcx, ast::ty_u8);
@@ -3454,8 +3519,7 @@ fn check_decl_local(fcx: @fn_ctxt, local: @ast::local) -> bool {
       _ {/* fall through */ }
     }
 
-    let block_id = fcx.ccx.tcx.region_map.rvalue_to_block.get(local.node.id);
-    let region = ty::re_scope(block_id);
+    let region = fcx.ccx.tcx.region_map.rvalue_to_region.get(local.node.id);
     let pcx = {
         fcx: fcx,
         map: pat_util::pat_id_map(fcx.ccx.tcx.def_map, local.node.pat),
diff --git a/src/test/run-pass/estr-internal.rs b/src/test/run-pass/estr-internal.rs
new file mode 100644
index 0000000000000..d7f7fd6b41a4e
--- /dev/null
+++ b/src/test/run-pass/estr-internal.rs
@@ -0,0 +1,8 @@
+fn main() {
+    let x : str/5 = "hello"/5;
+    let _y : str/5 = "there"/_;
+    let mut z = "thing"/_;
+    z = x;
+    assert z[0] == ('h' as u8);
+    assert z[4] == ('o' as u8);
+}
diff --git a/src/test/run-pass/estr-shared.rs b/src/test/run-pass/estr-shared.rs
new file mode 100644
index 0000000000000..6fc0f296d8d29
--- /dev/null
+++ b/src/test/run-pass/estr-shared.rs
@@ -0,0 +1,4 @@
+// xfail-test
+fn main() {
+    let x : str/@ = "hello"/@;
+}
diff --git a/src/test/run-pass/estr-slice.rs b/src/test/run-pass/estr-slice.rs
new file mode 100644
index 0000000000000..f91474cba8b36
--- /dev/null
+++ b/src/test/run-pass/estr-slice.rs
@@ -0,0 +1,7 @@
+fn main() {
+    let x = "hello"/&;
+    let mut y = "there"/&;
+    y = x;
+    assert y[0] == 'h' as u8;
+    assert y[4] == 'o' as u8;
+}
\ No newline at end of file
diff --git a/src/test/run-pass/estr-uniq.rs b/src/test/run-pass/estr-uniq.rs
new file mode 100644
index 0000000000000..178f1c8c26be9
--- /dev/null
+++ b/src/test/run-pass/estr-uniq.rs
@@ -0,0 +1,4 @@
+// xfail-test
+fn main() {
+    let x : str/~ = "hello"/~;
+}