---

yaml
---
r: 104956
b: refs/heads/snap-stage3
c: d8590e2
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 62f1d68439dcfd509eaca29887afa97f22938373
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: ddc796096be787613a291c38c076cb499dfb5857
+refs/heads/snap-stage3: d8590e2c9ce7fd48df03d347f591d6892c6e1599
 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.rev_iter().zip(other.data.rev_iter()) {
+        for (&self_i, &other_i) in self.data.iter().rev().zip(other.data.iter().rev()) {
             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.rev_iter() {
+        for elem in self.data.iter().rev() {
             shifted_rev.push((*elem >> n_bits) | borrow);
             borrow = *elem << (BigDigit::bits - n_bits);
         }

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

@@ -305,6 +305,9 @@ 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));
 
@@ -585,6 +588,10 @@ 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/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.rev_iter().fold(0, |max_len, r| {
+                let max_len = m.iter().rev().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/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.rev_iter().fold(succ, |succ, stmt| {
+        blk.stmts.iter().rev().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().rev_iter().fold(succ, |succ, cap| {
+                 caps.deref().iter().rev().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.rev_iter().fold(succ, |succ, field| {
+            fields.iter().rev().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.rev_iter().fold(succ, |succ, &(_, expr)| {
+            let succ = ia.outputs.iter().rev().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.rev_iter().fold(succ, |succ, &(_, expr)| {
+            ia.inputs.iter().rev().fold(succ, |succ, &(_, expr)| {
                 self.propagate_through_expr(expr, succ)
             })
           }

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

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

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

@@ -25,7 +25,9 @@ pub enum ArgKind {
     /// LLVM type or by coercing to another specified type
     Direct,
     /// Pass the argument indirectly via a hidden pointer
-    Indirect
+    Indirect,
+    /// Ignore the argument (useful for empty struct)
+    Ignore,
 }
 
 /// Information about how a specific C type
@@ -68,13 +70,27 @@ 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,8 +63,19 @@ pub fn compute_abi_info(ccx: &CrateContext,
         ret_ty = ArgType::direct(rty, None, None, None);
     }
 
-    for &a in atys.iter() {
-        arg_tys.push(ArgType::direct(a, 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);
     }
 
     return FnType {

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

@@ -325,6 +325,10 @@ 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));
@@ -901,6 +905,9 @@ 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),
@@ -949,6 +956,9 @@ 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/typeck/check/vtable.rs

@@ -94,7 +94,8 @@ fn lookup_vtables(vcx: &VtableContext,
     // We do this backwards for reasons discussed above.
     assert_eq!(substs.tps.len(), type_param_defs.len());
     let mut result: Vec<vtable_param_res> =
-        substs.tps.rev_iter()
+        substs.tps.iter()
+        .rev()
         .zip(type_param_defs.rev_iter())
         .map(|(ty, def)|
             lookup_vtables_for_param(vcx, span, Some(substs),

branches/snap-stage3/src/librustdoc/passes.rs

@@ -128,7 +128,8 @@ impl<'a> fold::DocFolder for Stripper<'a> {
                 }
             }
 
-            clean::ViewItemItem(..) => {
+            clean::ViewItemItem(..) |
+            clean::ModuleItem(..) => {
                 if i.visibility != Some(ast::Public) {
                     return None
                 }
@@ -140,9 +141,6 @@ impl<'a> fold::DocFolder for Stripper<'a> {
                 }
             }
 
-            // handled below
-            clean::ModuleItem(..) => {}
-
             // trait impls for private items should be stripped
             clean::ImplItem(clean::Impl{ for_: clean::ResolvedPath{ id: ref for_id, .. }, .. }) => {
                 if !self.exported_items.contains(for_id) {