---

yaml
---
r: 104954
b: refs/heads/snap-stage3
c: 405b5fc
h: refs/heads/master
v: v3

Author: huonw

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 62f1d68439dcfd509eaca29887afa97f22938373
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 4ca51aeea7187a63b987129d67cf7d348b6c60a9
+refs/heads/snap-stage3: 405b5fc1ee21cc6bc29f97719600bd94066dd58c
 refs/heads/try: db814977d07bd798feb24f6b74c00800ef458a13
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libnum/bigint.rs

@@ -117,7 +117,7 @@ impl TotalOrd for BigUint {
         if s_len < o_len { return Less; }
         if s_len > o_len { return Greater;  }
 
-        for (&self_i, &other_i) in self.data.iter().rev().zip(other.data.iter().rev()) {
+        for (&self_i, &other_i) in self.data.rev_iter().zip(other.data.rev_iter()) {
             if self_i < other_i { return Less; }
             if self_i > other_i { return Greater; }
         }
@@ -788,7 +788,7 @@ impl BigUint {
 
         let mut borrow = 0;
         let mut shifted_rev = Vec::with_capacity(self.data.len());
-        for elem in self.data.iter().rev() {
+        for elem in self.data.rev_iter() {
             shifted_rev.push((*elem >> n_bits) | borrow);
             borrow = *elem << (BigDigit::bits - n_bits);
         }

branches/snap-stage3/src/librustc/driver/driver.rs

@@ -305,9 +305,6 @@ pub fn phase_3_run_analysis_passes(sess: Session,
         time(time_passes, "resolution", (), |_|
              middle::resolve::resolve_crate(&sess, lang_items, krate));
 
-    // Discard MTWT tables that aren't required past resolution.
-    syntax::ext::mtwt::clear_tables();
-
     let named_region_map = time(time_passes, "lifetime resolution", (),
                                 |_| middle::resolve_lifetime::krate(&sess, krate));
 
@@ -588,10 +585,6 @@ pub fn compile_input(sess: Session, cfg: ast::CrateConfig, input: &Input,
         if stop_after_phase_3(&analysis.ty_cx.sess) { return; }
         let (tcx, trans) = phase_4_translate_to_llvm(expanded_crate,
                                                      analysis, &outputs);
-
-        // Discard interned strings as they are no longer required.
-        token::get_ident_interner().clear();
-
         (outputs, trans, tcx.sess)
     };
     phase_5_run_llvm_passes(&sess, &trans, &outputs);

branches/snap-stage3/src/librustc/metadata/tyencode.rs

@@ -280,11 +280,11 @@ fn enc_sty(w: &mut MemWriter, cx: &ctxt, st: &ty::sty) {
             enc_substs(w, cx, substs);
             mywrite!(w, "]");
         }
-        ty::ty_trait(def, ref substs, store, mt, bounds) => {
-            mywrite!(w, "x[{}|", (cx.ds)(def));
+        ty::ty_trait(~ty::TyTrait { def_id, ref substs, store, mutability, bounds }) => {
+            mywrite!(w, "x[{}|", (cx.ds)(def_id));
             enc_substs(w, cx, substs);
             enc_trait_store(w, cx, store);
-            enc_mutability(w, mt);
+            enc_mutability(w, mutability);
             let bounds = ty::ParamBounds {builtin_bounds: bounds,
                                           trait_bounds: Vec::new()};
             enc_bounds(w, cx, &bounds);

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

@@ -288,7 +288,7 @@ fn is_useful(cx: &MatchCheckCtxt, m: &matrix, v: &[@Pat]) -> useful {
                 is_useful_specialized(cx, m, v, vec(n), n, left_ty)
               }
               ty::ty_unboxed_vec(..) | ty::ty_vec(..) => {
-                let max_len = m.iter().rev().fold(0, |max_len, r| {
+                let max_len = m.rev_iter().fold(0, |max_len, r| {
                   match r.get(0).node {
                     PatVec(ref before, _, ref after) => {
                       cmp::max(before.len() + after.len(), max_len)

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

@@ -358,7 +358,7 @@ pub fn check_expr(cx: &mut Context, e: &Expr) {
 fn check_trait_cast(cx: &mut Context, source_ty: ty::t, target_ty: ty::t, span: Span) {
     check_cast_for_escaping_regions(cx, source_ty, target_ty, span);
     match ty::get(target_ty).sty {
-        ty::ty_trait(_, _, _, _, bounds) => {
+        ty::ty_trait(~ty::TyTrait { bounds, .. }) => {
             check_trait_cast_bounds(cx, span, source_ty, bounds);
         }
         _ => {}

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

@@ -911,7 +911,7 @@ fn check_heap_type(cx: &Context, span: Span, ty: ty::t) {
                 }
                 ty::ty_uniq(_) | ty::ty_str(ty::vstore_uniq) |
                 ty::ty_vec(_, ty::vstore_uniq) |
-                ty::ty_trait(_, _, ty::UniqTraitStore, _, _) => {
+                ty::ty_trait(~ty::TyTrait { store: ty::UniqTraitStore, .. }) => {
                     n_uniq += 1;
                 }
                 ty::ty_closure(ref c) if c.sigil == ast::OwnedSigil => {

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

@@ -879,7 +879,7 @@ impl<'a> Liveness<'a> {
     fn propagate_through_block(&mut self, blk: &Block, succ: LiveNode)
                                -> LiveNode {
         let succ = self.propagate_through_opt_expr(blk.expr, succ);
-        blk.stmts.iter().rev().fold(succ, |succ, stmt| {
+        blk.stmts.rev_iter().fold(succ, |succ, stmt| {
             self.propagate_through_stmt(*stmt, succ)
         })
     }
@@ -980,7 +980,7 @@ impl<'a> Liveness<'a> {
                         this.ir.tcx.sess.span_bug(expr.span, "no registered caps");
                      }
                  };
-                 caps.deref().iter().rev().fold(succ, |succ, cap| {
+                 caps.deref().rev_iter().fold(succ, |succ, cap| {
                      this.init_from_succ(cap.ln, succ);
                      let var = this.variable(cap.var_nid, expr.span);
                      this.acc(cap.ln, var, ACC_READ | ACC_USE);
@@ -1121,7 +1121,7 @@ impl<'a> Liveness<'a> {
 
           ExprStruct(_, ref fields, with_expr) => {
             let succ = self.propagate_through_opt_expr(with_expr, succ);
-            fields.iter().rev().fold(succ, |succ, field| {
+            fields.rev_iter().fold(succ, |succ, field| {
                 self.propagate_through_expr(field.expr, succ)
             })
           }
@@ -1173,14 +1173,14 @@ impl<'a> Liveness<'a> {
           }
 
           ExprInlineAsm(ref ia) => {
-            let succ = ia.outputs.iter().rev().fold(succ, |succ, &(_, expr)| {
+            let succ = ia.outputs.rev_iter().fold(succ, |succ, &(_, expr)| {
                 // see comment on lvalues in
                 // propagate_through_lvalue_components()
                 let succ = self.write_lvalue(expr, succ, ACC_WRITE);
                 self.propagate_through_lvalue_components(expr, succ)
             });
             // Inputs are executed first. Propagate last because of rev order
-            ia.inputs.iter().rev().fold(succ, |succ, &(_, expr)| {
+            ia.inputs.rev_iter().fold(succ, |succ, &(_, expr)| {
                 self.propagate_through_expr(expr, succ)
             })
           }

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

@@ -170,7 +170,7 @@ pub enum deref_kind {
 pub fn opt_deref_kind(t: ty::t) -> Option<deref_kind> {
     match ty::get(t).sty {
         ty::ty_uniq(_) |
-        ty::ty_trait(_, _, ty::UniqTraitStore, _, _) |
+        ty::ty_trait(~ty::TyTrait { store: ty::UniqTraitStore, .. }) |
         ty::ty_vec(_, ty::vstore_uniq) |
         ty::ty_str(ty::vstore_uniq) |
         ty::ty_closure(ty::ClosureTy {sigil: ast::OwnedSigil, ..}) => {
@@ -183,7 +183,7 @@ pub fn opt_deref_kind(t: ty::t) -> Option<deref_kind> {
             Some(deref_ptr(BorrowedPtr(kind, r)))
         }
 
-        ty::ty_trait(_, _, ty::RegionTraitStore(r), m, _) => {
+        ty::ty_trait(~ty::TyTrait { store: ty::RegionTraitStore(r), mutability: m, .. }) => {
             let kind = ty::BorrowKind::from_mutbl(m);
             Some(deref_ptr(BorrowedPtr(kind, r)))
         }

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

@@ -5520,8 +5520,7 @@ impl<'a> Resolver<'a> {
         if idents.len() == 0 {
             return ~"???";
         }
-        return self.idents_to_str(idents.move_iter()
-                                        .rev()
+        return self.idents_to_str(idents.move_rev_iter()
                                         .collect::<Vec<ast::Ident>>()
                                         .as_slice());
     }

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

@@ -25,9 +25,7 @@ pub enum ArgKind {
     /// LLVM type or by coercing to another specified type
     Direct,
     /// Pass the argument indirectly via a hidden pointer
-    Indirect,
-    /// Ignore the argument (useful for empty struct)
-    Ignore,
+    Indirect
 }
 
 /// Information about how a specific C type
@@ -70,27 +68,13 @@ impl ArgType {
         }
     }
 
-    pub fn ignore(ty: Type) -> ArgType {
-        ArgType {
-            kind: Ignore,
-            ty: ty,
-            cast: None,
-            pad: None,
-            attr: None,
-        }
-    }
-
     pub fn is_direct(&self) -> bool {
         return self.kind == Direct;
     }
 
     pub fn is_indirect(&self) -> bool {
         return self.kind == Indirect;
     }
-
-    pub fn is_ignore(&self) -> bool {
-        return self.kind == Ignore;
-    }
 }
 
 /// Metadata describing how the arguments to a native function

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

@@ -63,19 +63,8 @@ pub fn compute_abi_info(ccx: &CrateContext,
         ret_ty = ArgType::direct(rty, None, None, None);
     }
 
-    for &t in atys.iter() {
-        let ty = match t.kind() {
-            Struct => {
-                let size = llsize_of_alloc(ccx, t);
-                if size == 0 {
-                    ArgType::ignore(t)
-                } else {
-                    ArgType::indirect(t, Some(ByValAttribute))
-                }
-            }
-            _ => ArgType::direct(t, None, None, None),
-        };
-        arg_tys.push(ty);
+    for &a in atys.iter() {
+        arg_tys.push(ArgType::direct(a, None, None, None));
     }
 
     return FnType {

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

@@ -2126,7 +2126,9 @@ fn type_metadata(cx: &CrateContext,
         ty::ty_closure(ref closurety) => {
             subroutine_type_metadata(cx, &closurety.sig, usage_site_span)
         },
-        ty::ty_trait(def_id, ref substs, trait_store, mutability, ref bounds) => {
+        ty::ty_trait(~ty::TyTrait { def_id, ref substs,
+                                store: trait_store, mutability,
+                                ref bounds }) => {
             trait_metadata(cx, def_id, t, substs, trait_store, mutability, bounds)
         },
         ty::ty_struct(def_id, ref substs) => {

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

@@ -325,10 +325,6 @@ pub fn trans_native_call<'a>(
     for (i, &llarg_rust) in llargs_rust.iter().enumerate() {
         let mut llarg_rust = llarg_rust;
 
-        if arg_tys[i].is_ignore() {
-            continue;
-        }
-
         // Does Rust pass this argument by pointer?
         let rust_indirect = type_of::arg_is_indirect(ccx,
                                                      *passed_arg_tys.get(i));
@@ -905,9 +901,6 @@ fn lltype_for_fn_from_foreign_types(ccx: &CrateContext, tys: &ForeignTypes) -> T
     };
 
     for &arg_ty in tys.fn_ty.arg_tys.iter() {
-        if arg_ty.is_ignore() {
-            continue;
-        }
         // add padding
         match arg_ty.pad {
             Some(ty) => llargument_tys.push(ty),
@@ -956,9 +949,6 @@ fn add_argument_attributes(tys: &ForeignTypes,
     }
 
     for &arg_ty in tys.fn_ty.arg_tys.iter() {
-        if arg_ty.is_ignore() {
-            continue;
-        }
         // skip padding
         if arg_ty.pad.is_some() { i += 1; }
 

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

@@ -310,7 +310,7 @@ fn make_drop_glue<'a>(bcx: &'a Block<'a>, v0: ValueRef, t: ty::t) -> &'a Block<'
                 }
             }
         }
-        ty::ty_trait(_, _, ty::UniqTraitStore, _, _) => {
+        ty::ty_trait(~ty::TyTrait { store: ty::UniqTraitStore, .. }) => {
             let lluniquevalue = GEPi(bcx, v0, [0, abi::trt_field_box]);
             // Only drop the value when it is non-null
             with_cond(bcx, IsNotNull(bcx, Load(bcx, lluniquevalue)), |bcx| {

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

@@ -351,7 +351,7 @@ impl<'a> Reflector<'a> {
             })
           }
 
-          ty::ty_trait(_, _, _, _, _) => {
+          ty::ty_trait(..) => {
               let extra = [
                   self.c_slice(token::intern_and_get_ident(ty_to_str(tcx, t)))
               ];