---

yaml
---
r: 49084
b: refs/heads/snap-stage3
c: b93393e
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 3bbcac322669cff3abde5be937cc4ec3860f3985
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: c317d3f6fa9475e65b6276743c09444441059ca7
+refs/heads/snap-stage3: b93393e907eddab513fa2be541af4356b8203282
 refs/heads/try: 2a8fb58d79e685d5ca07b039badcf2ae3ef077ea
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/librustc/middle/astencode.rs

@@ -681,7 +681,6 @@ impl vtable_decoder_helpers for reader::Decoder {
         @self.read_to_vec(|| self.read_vtable_origin(xcx) )
     }
 
-    #[cfg(stage0)]
     fn read_vtable_origin(&self, xcx: @ExtendedDecodeContext)
         -> typeck::vtable_origin {
         do self.read_enum(~"vtable_origin") {
@@ -716,44 +715,6 @@ impl vtable_decoder_helpers for reader::Decoder {
             }
         }
     }
-
-    #[cfg(stage1)]
-    #[cfg(stage2)]
-    #[cfg(stage3)]
-    fn read_vtable_origin(&self, xcx: @ExtendedDecodeContext)
-        -> typeck::vtable_origin {
-        do self.read_enum("vtable_origin") {
-            do self.read_enum_variant(["vtable_static", "vtable_param"]) |i| {
-                match i {
-                  0 => {
-                    typeck::vtable_static(
-                        do self.read_enum_variant_arg(0u) {
-                            self.read_def_id(xcx)
-                        },
-                        do self.read_enum_variant_arg(1u) {
-                            self.read_tys(xcx)
-                        },
-                        do self.read_enum_variant_arg(2u) {
-                            self.read_vtable_res(xcx)
-                        }
-                    )
-                  }
-                  1 => {
-                    typeck::vtable_param(
-                        do self.read_enum_variant_arg(0u) {
-                            self.read_uint()
-                        },
-                        do self.read_enum_variant_arg(1u) {
-                            self.read_uint()
-                        }
-                    )
-                  }
-                  // hard to avoid - user input
-                  _ => fail!(~"bad enum variant")
-                }
-            }
-        }
-    }
 }
 
 // ______________________________________________________________________

branches/snap-stage3/src/librustc/middle/check_const.rs

@@ -156,6 +156,7 @@ pub fn check_expr(sess: Session,
           expr_paren(e) => { check_expr(sess, def_map, method_map,
                                          tcx, e, is_const, v); }
           expr_vstore(_, expr_vstore_slice) |
+          expr_vstore(_, expr_vstore_fixed(_)) |
           expr_vec(_, m_imm) |
           expr_addr_of(m_imm, _) |
           expr_field(*) |

branches/snap-stage3/src/librustc/middle/const_eval.rs

@@ -110,6 +110,7 @@ pub fn classify(e: @expr,
 
               ast::expr_vstore(e, vstore) => {
                   match vstore {
+                      ast::expr_vstore_fixed(_) |
                       ast::expr_vstore_slice => classify(e, tcx),
                       ast::expr_vstore_uniq |
                       ast::expr_vstore_box |

branches/snap-stage3/src/librustc/middle/liveness.rs

@@ -1335,7 +1335,7 @@ pub impl Liveness {
             self.propagate_through_expr(l, ln)
           }
 
-          expr_log(l, r) |
+          expr_log(_, l, r) |
           expr_index(l, r) |
           expr_binary(_, l, r) => {
             self.propagate_through_exprs(~[l, r], succ)

branches/snap-stage3/src/librustc/middle/moves.rs

@@ -567,7 +567,7 @@ pub impl VisitContext {
                 self.consume_block(blk, visitor);
             }
 
-            expr_log(a_expr, b_expr) => {
+            expr_log(_, a_expr, b_expr) => {
                 self.consume_expr(a_expr, visitor);
                 self.use_expr(b_expr, Read, visitor);
             }

branches/snap-stage3/src/librustc/middle/trans/consts.rs

@@ -466,6 +466,9 @@ fn const_expr_unadjusted(cx: @CrateContext, e: @ast::expr) -> ValueRef {
             let (v, _, _) = const_vec(cx, e, *es);
             v
           }
+          ast::expr_vstore(e, ast::expr_vstore_fixed(_)) => {
+            const_expr(cx, e)
+          }
           ast::expr_vstore(sub, ast::expr_vstore_slice) => {
             match sub.node {
               ast::expr_lit(ref lit) => {

branches/snap-stage3/src/librustc/middle/trans/expr.rs

@@ -507,7 +507,7 @@ fn trans_rvalue_stmt_unadjusted(bcx: block, expr: @ast::expr) -> block {
         ast::expr_ret(ex) => {
             return controlflow::trans_ret(bcx, ex);
         }
-        ast::expr_log(lvl, a) => {
+        ast::expr_log(_, lvl, a) => {
             return controlflow::trans_log(expr, lvl, bcx, a);
         }
         ast::expr_while(cond, ref body) => {
@@ -714,6 +714,9 @@ fn trans_rvalue_dps_unadjusted(bcx: block, expr: @ast::expr,
         ast::expr_vstore(contents, ast::expr_vstore_mut_slice) => {
             return tvec::trans_slice_vstore(bcx, expr, contents, dest);
         }
+        ast::expr_vstore(contents, ast::expr_vstore_fixed(_)) => {
+            return tvec::trans_fixed_vstore(bcx, expr, contents, dest);
+        }
         ast::expr_vec(*) | ast::expr_repeat(*) => {
             return tvec::trans_fixed_vstore(bcx, expr, expr, dest);
         }

branches/snap-stage3/src/librustc/middle/trans/type_use.rs

@@ -329,7 +329,7 @@ pub fn mark_for_expr(cx: Context, e: @expr) {
         type_needs(cx, use_repr, ty::type_autoderef(cx.ccx.tcx, base_ty));
         mark_for_method_call(cx, e.id, e.callee_id);
       }
-      expr_log(_, val) => {
+      expr_log(_, _, val) => {
         node_type_needs(cx, use_tydesc, val.id);
       }
       expr_call(f, _, _) => {

branches/snap-stage3/src/librustc/middle/ty.rs

@@ -3117,6 +3117,7 @@ pub fn expr_kind(tcx: ctxt,
         ast::expr_lit(@codemap::spanned {node: lit_str(_), _}) |
         ast::expr_vstore(_, ast::expr_vstore_slice) |
         ast::expr_vstore(_, ast::expr_vstore_mut_slice) |
+        ast::expr_vstore(_, ast::expr_vstore_fixed(_)) |
         ast::expr_vec(*) => {
             RvalueDpsExpr
         }

branches/snap-stage3/src/librustc/middle/typeck/check/mod.rs

@@ -2402,7 +2402,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
         }
         fcx.write_bot(id);
       }
-      ast::expr_log(lv, e) => {
+      ast::expr_log(_, lv, e) => {
         check_expr_has_type(fcx, lv,
                                   ty::mk_mach_uint(tcx, ast::ty_u32));
 
@@ -3337,6 +3337,14 @@ pub fn ast_expr_vstore_to_vstore(fcx: @mut FnCtxt,
                                  v: ast::expr_vstore)
                               -> ty::vstore {
     match v {
+        ast::expr_vstore_fixed(None) => ty::vstore_fixed(n),
+        ast::expr_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::expr_vstore_uniq => ty::vstore_uniq,
         ast::expr_vstore_box | ast::expr_vstore_mut_box => ty::vstore_box,
         ast::expr_vstore_slice | ast::expr_vstore_mut_slice => {

branches/snap-stage3/src/libstd/ebml.rs

@@ -337,7 +337,6 @@ pub mod reader {
             self.push_doc(self.next_doc(EsEnum), f)
         }
 
-        #[cfg(stage0)]
         fn read_enum_variant<T>(&self, f: &fn(uint) -> T) -> T {
             debug!("read_enum_variant()");
             let idx = self._next_uint(EsEnumVid);
@@ -347,18 +346,6 @@ pub mod reader {
             }
         }
 
-        #[cfg(stage1)]
-        #[cfg(stage2)]
-        #[cfg(stage3)]
-        fn read_enum_variant<T>(&self, _names: &[&str], f: &fn(uint) -> T) -> T {
-            debug!("read_enum_variant()");
-            let idx = self._next_uint(EsEnumVid);
-            debug!("  idx=%u", idx);
-            do self.push_doc(self.next_doc(EsEnumBody)) {
-                f(idx)
-            }
-        }
-
         fn read_enum_variant_arg<T>(&self, idx: uint, f: &fn() -> T) -> T {
             debug!("read_enum_variant_arg(idx=%u)", idx);
             f()
@@ -412,37 +399,8 @@ pub mod reader {
             debug!("read_tup_elt(idx=%u)", idx);
             f()
         }
-
-        #[cfg(stage0)]
-        fn read_option<T>(&self, f: &fn() -> T) -> Option<T> {
-            debug!("read_option()");
-            do self.read_enum("Option") || {
-                do self.read_enum_variant |idx| {
-                    match idx {
-                        0 => None,
-                        1 => Some(f()),
-                        _ => fail!(),
-                    }
-                }
-            }
-        }
-
-        #[cfg(stage1)]
-        #[cfg(stage2)]
-        #[cfg(stage3)]
-        fn read_option<T>(&self, f: &fn() -> T) -> Option<T> {
-            debug!("read_option()");
-            do self.read_enum("Option") || {
-                do self.read_enum_variant(["None", "Some"]) |idx| {
-                    match idx {
-                        0 => None,
-                        1 => Some(f()),
-                        _ => fail!(),
-                    }
-                }
-            }
-        }
     }
+
 }
 
 pub mod writer {
@@ -708,19 +666,9 @@ pub mod writer {
 
         fn emit_tup(&self, _len: uint, f: &fn()) { f() }
         fn emit_tup_elt(&self, _idx: uint, f: &fn()) { f() }
-
-        fn emit_option(&self, f: &fn()) {
-            self.emit_enum("Option", f);
-        }
-        fn emit_option_none(&self) {
-            self.emit_enum_variant("None", 0, 0, || ())
-        }
-        fn emit_option_some(&self, f: &fn()) {
-            self.emit_enum_variant("Some", 1, 1, f)
-        }
     }
-}
 
+}
 // ___________________________________________________________________________
 // Testing