---

yaml
---
r: 109171
b: refs/heads/dist-snap
c: c04d484
h: refs/heads/master
i:
  109169: 49ac660
  109167: ee3f14e
v: v3

Author: eddyb

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: f64fdf524a434f0e5cd0bc91d09c144723f3c90d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 7532d20a17dce417e9040e31623e7fcf01971db7
+refs/heads/dist-snap: c04d4846f2a7a49e592f4e98f3e604851d600d4e
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/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/dist-snap/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/dist-snap/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/dist-snap/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/dist-snap/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/dist-snap/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/dist-snap/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/dist-snap/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/dist-snap/src/librustc/middle/typeck/check/vtable.rs

@@ -94,8 +94,7 @@ 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.iter()
-        .rev()
+        substs.tps.rev_iter()
         .zip(type_param_defs.rev_iter())
         .map(|(ty, def)|
             lookup_vtables_for_param(vcx, span, Some(substs),

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

@@ -128,8 +128,7 @@ impl<'a> fold::DocFolder for Stripper<'a> {
                 }
             }
 
-            clean::ViewItemItem(..) |
-            clean::ModuleItem(..) => {
+            clean::ViewItemItem(..) => {
                 if i.visibility != Some(ast::Public) {
                     return None
                 }
@@ -141,6 +140,9 @@ 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) {