---

yaml
---
r: 128319
b: refs/heads/snap-stage3
c: 48edb32
h: refs/heads/master
i:
  128317: f955b6c
  128315: 4b13034
  128311: f31883b
  128303: 4e40055
  128287: 57fd85a
  128255: 5fe6864
v: v3

Author: thestinger

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: cb9c1e0e702f4a1a5dfc909b15b74e8556013c06
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: ec9476cd63af58d55e552532d14040d972392bd6
+refs/heads/snap-stage3: 48edb32a3fc8ba6cc3db9a9d11f5201a919391f5
 refs/heads/try: 73b8f60b60d8a2a7ca5a7d49d59771350b867951
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

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

@@ -257,14 +257,6 @@ mod test {
         assert_eq!(_1_0i.inv(), _1_0i.inv());
     }
 
-    #[test]
-    #[should_fail]
-    fn test_divide_by_zero_natural() {
-        let n = Complex::new(2i, 3i);
-        let d = Complex::new(0, 0);
-        let _x = n / d;
-    }
-
     #[test]
     #[should_fail]
     #[ignore]

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

@@ -1947,10 +1947,12 @@ pub fn trans_named_tuple_constructor<'a>(mut bcx: &'a Block<'a>,
     };
 
     if !type_is_zero_size(ccx, result_ty) {
+        let repr = adt::represent_type(ccx, result_ty);
+
         match args {
             callee::ArgExprs(exprs) => {
                 let fields = exprs.iter().map(|x| *x).enumerate().collect::<Vec<_>>();
-                bcx = expr::trans_adt(bcx, result_ty, disr, fields.as_slice(),
+                bcx = expr::trans_adt(bcx, &*repr, disr, fields.as_slice(),
                                       None, expr::SaveIn(llresult));
             }
             _ => ccx.sess().bug("expected expr as arguments for variant/struct tuple constructor")
@@ -2278,7 +2280,7 @@ pub fn get_fn_llvm_attributes(ccx: &CrateContext, fn_ty: ty::t)
         match ty::get(ret_ty).sty {
             // `~` pointer return values never alias because ownership
             // is transferred
-            ty::ty_uniq(it)  if match ty::get(it).sty {
+            ty::ty_uniq(it) if match ty::get(it).sty {
                 ty::ty_str | ty::ty_vec(..) | ty::ty_trait(..) => true, _ => false
             } => {}
             ty::ty_uniq(_) => {
@@ -2354,15 +2356,21 @@ pub fn get_fn_llvm_attributes(ccx: &CrateContext, fn_ty: ty::t)
             }
 
             // `&mut` pointer parameters never alias other parameters, or mutable global data
-            // `&` pointer parameters never alias either (for LLVM's purposes) as long as the
-            // interior is safe
+            //
+            // `&T` where `T` contains no `UnsafeCell<U>` is immutable, and can be marked as both
+            // `readonly` and `noalias`, as LLVM's definition of `noalias` is based solely on
+            // memory dependencies rather than pointer equality
             ty::ty_rptr(b, mt) if mt.mutbl == ast::MutMutable ||
                                   !ty::type_contents(ccx.tcx(), mt.ty).interior_unsafe() => {
 
                 let llsz = llsize_of_real(ccx, type_of::type_of(ccx, mt.ty));
                 attrs.arg(idx, llvm::NoAliasAttribute)
                      .arg(idx, llvm::DereferenceableAttribute(llsz));
 
+                if mt.mutbl == ast::MutImmutable {
+                    attrs.arg(idx, llvm::ReadOnlyAttribute);
+                }
+
                 match b {
                     ReLateBound(_, BrAnon(_)) => {
                         attrs.arg(idx, llvm::NoCaptureAttribute);

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

@@ -330,12 +330,13 @@ pub fn trans_for<'a>(
     // Check the discriminant; if the `None` case, exit the loop.
     let option_representation = adt::represent_type(loopback_bcx_out.ccx(),
                                                     method_result_type);
+    let i8_type = Type::i8(loopback_bcx_out.ccx());
     let lldiscriminant = adt::trans_get_discr(loopback_bcx_out,
                                               &*option_representation,
                                               option_datum.val,
-                                              None);
-    let i1_type = Type::i1(loopback_bcx_out.ccx());
-    let llcondition = Trunc(loopback_bcx_out, lldiscriminant, i1_type);
+                                              Some(i8_type));
+    let llzero = C_u8(loopback_bcx_out.ccx(), 0);
+    let llcondition = ICmp(loopback_bcx_out, IntNE, lldiscriminant, llzero);
     CondBr(loopback_bcx_out, llcondition, body_bcx_in.llbb, cleanup_llbb);
 
     // Now we're in the body. Unpack the `Option` value into the programmer-

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

@@ -746,17 +746,18 @@ fn trans_rvalue_dps_unadjusted<'a>(bcx: &'a Block<'a>,
             controlflow::trans_block(bcx, &**blk, dest)
         }
         ast::ExprStruct(_, ref fields, base) => {
-            trans_struct(bcx,
-                         fields.as_slice(),
-                         base,
-                         expr.span,
-                         expr.id,
-                         dest)
+            trans_rec_or_struct(bcx,
+                                fields.as_slice(),
+                                base,
+                                expr.span,
+                                expr.id,
+                                dest)
         }
         ast::ExprTup(ref args) => {
+            let repr = adt::represent_type(bcx.ccx(), expr_ty(bcx, expr));
             let numbered_fields: Vec<(uint, Gc<ast::Expr>)> =
                 args.iter().enumerate().map(|(i, arg)| (i, *arg)).collect();
-            trans_adt(bcx, expr_ty(bcx, expr), 0, numbered_fields.as_slice(), None, dest)
+            trans_adt(bcx, &*repr, 0, numbered_fields.as_slice(), None, dest)
         }
         ast::ExprLit(lit) => {
             match lit.node {
@@ -1041,13 +1042,16 @@ pub fn with_field_tys<R>(tcx: &ty::ctxt,
     }
 }
 
-fn trans_struct<'a>(bcx: &'a Block<'a>,
-                    fields: &[ast::Field],
-                    base: Option<Gc<ast::Expr>>,
-                    expr_span: codemap::Span,
-                    id: ast::NodeId,
-                    dest: Dest) -> &'a Block<'a> {
+fn trans_rec_or_struct<'a>(
+                       bcx: &'a Block<'a>,
+                       fields: &[ast::Field],
+                       base: Option<Gc<ast::Expr>>,
+                       expr_span: codemap::Span,
+                       id: ast::NodeId,
+                       dest: Dest)
+                       -> &'a Block<'a> {
     let _icx = push_ctxt("trans_rec");
+    let bcx = bcx;
 
     let ty = node_id_type(bcx, id);
     let tcx = bcx.tcx();
@@ -1088,7 +1092,8 @@ fn trans_struct<'a>(bcx: &'a Block<'a>,
             }
         };
 
-        trans_adt(bcx, ty, discr, numbered_fields.as_slice(), optbase, dest)
+        let repr = adt::represent_type(bcx.ccx(), ty);
+        trans_adt(bcx, &*repr, discr, numbered_fields.as_slice(), optbase, dest)
     })
 }
 
@@ -1116,71 +1121,60 @@ pub struct StructBaseInfo {
  * - `optbase` contains information on the base struct (if any) from
  * which remaining fields are copied; see comments on `StructBaseInfo`.
  */
-pub fn trans_adt<'a>(mut bcx: &'a Block<'a>,
-                     ty: ty::t,
+pub fn trans_adt<'a>(bcx: &'a Block<'a>,
+                     repr: &adt::Repr,
                      discr: ty::Disr,
                      fields: &[(uint, Gc<ast::Expr>)],
                      optbase: Option<StructBaseInfo>,
                      dest: Dest) -> &'a Block<'a> {
     let _icx = push_ctxt("trans_adt");
     let fcx = bcx.fcx;
-    let repr = adt::represent_type(bcx.ccx(), ty);
-
-    // If we don't care about the result, just make a
-    // temporary stack slot
+    let mut bcx = bcx;
     let addr = match dest {
-        SaveIn(pos) => pos,
-        Ignore => alloc_ty(bcx, ty, "temp"),
+        Ignore => {
+            for &(_i, ref e) in fields.iter() {
+                bcx = trans_into(bcx, &**e, Ignore);
+            }
+            for sbi in optbase.iter() {
+                // FIXME #7261: this moves entire base, not just certain fields
+                bcx = trans_into(bcx, &*sbi.expr, Ignore);
+            }
+            return bcx;
+        }
+        SaveIn(pos) => pos
     };
 
     // This scope holds intermediates that must be cleaned should
     // failure occur before the ADT as a whole is ready.
     let custom_cleanup_scope = fcx.push_custom_cleanup_scope();
 
-    // First we trans the base, if we have one, to the dest
-    for base in optbase.iter() {
-        assert_eq!(discr, 0);
-
-        match ty::expr_kind(bcx.tcx(), &*base.expr) {
-            ty::LvalueExpr => {
-                let base_datum = unpack_datum!(bcx, trans_to_lvalue(bcx, &*base.expr, "base"));
-                for &(i, t) in base.fields.iter() {
-                    let datum = base_datum.get_element(
-                            t, |srcval| adt::trans_field_ptr(bcx, &*repr, srcval, discr, i));
-                    let dest = adt::trans_field_ptr(bcx, &*repr, addr, discr, i);
-                    bcx = datum.store_to(bcx, dest);
-                }
-            },
-            ty::RvalueDpsExpr | ty::RvalueDatumExpr => {
-                bcx = trans_into(bcx, &*base.expr, SaveIn(addr));
-            },
-            ty::RvalueStmtExpr => bcx.tcx().sess.bug("unexpected expr kind for struct base expr")
-        }
-    }
-
-    // Now, we just overwrite the fields we've explicity specified
     for &(i, ref e) in fields.iter() {
-        let dest = adt::trans_field_ptr(bcx, &*repr, addr, discr, i);
+        let dest = adt::trans_field_ptr(bcx, repr, addr, discr, i);
         let e_ty = expr_ty_adjusted(bcx, &**e);
         bcx = trans_into(bcx, &**e, SaveIn(dest));
         let scope = cleanup::CustomScope(custom_cleanup_scope);
         fcx.schedule_lifetime_end(scope, dest);
         fcx.schedule_drop_mem(scope, dest, e_ty);
     }
 
-    adt::trans_set_discr(bcx, &*repr, addr, discr);
+    for base in optbase.iter() {
+        // FIXME #6573: is it sound to use the destination's repr on the base?
+        // And, would it ever be reasonable to be here with discr != 0?
+        let base_datum = unpack_datum!(bcx, trans_to_lvalue(bcx, &*base.expr, "base"));
+        for &(i, t) in base.fields.iter() {
+            let datum = base_datum.get_element(
+                t,
+                |srcval| adt::trans_field_ptr(bcx, repr, srcval, discr, i));
+            let dest = adt::trans_field_ptr(bcx, repr, addr, discr, i);
+            bcx = datum.store_to(bcx, dest);
+        }
+    }
+
+    adt::trans_set_discr(bcx, repr, addr, discr);
 
     fcx.pop_custom_cleanup_scope(custom_cleanup_scope);
 
-    // If we don't care about the result drop the temporary we made
-    match dest {
-        SaveIn(_) => bcx,
-        Ignore => {
-            bcx = glue::drop_ty(bcx, addr, ty);
-            base::call_lifetime_end(bcx, addr);
-            bcx
-        }
-    }
+    return bcx;
 }
 
 

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

@@ -250,9 +250,8 @@ fn trans_struct_drop<'a>(bcx: &'a Block<'a>,
         let args = vec!(self_arg);
 
         // Add all the fields as a value which needs to be cleaned at the end of
-        // this scope. Iterate in reverse order so a Drop impl doesn't reverse
-        // the order in which fields get dropped.
-        for (i, ty) in st.fields.iter().enumerate().rev() {
+        // this scope.
+        for (i, ty) in st.fields.iter().enumerate() {
             let llfld_a = adt::struct_field_ptr(variant_cx, &*st, value, i, false);
             variant_cx.fcx.schedule_drop_mem(cleanup::CustomScope(field_scope),
                                              llfld_a, *ty);

branches/snap-stage3/src/libstd/io/util.rs

@@ -48,12 +48,10 @@ impl<R: Reader> Reader for LimitReader<R> {
         }
 
         let len = cmp::min(self.limit, buf.len());
-        let res = self.inner.read(buf.mut_slice_to(len));
-        match res {
-            Ok(len) => self.limit -= len,
-            _ => {}
-        }
-        res
+        self.inner.read(buf.mut_slice_to(len)).map(|len| {
+            self.limit -= len;
+            len
+        })
     }
 }
 
@@ -69,8 +67,6 @@ impl<R: Buffer> Buffer for LimitReader<R> {
     }
 
     fn consume(&mut self, amt: uint) {
-        // Don't let callers reset the limit by passing an overlarge value
-        let amt = cmp::min(amt, self.limit);
         self.limit -= amt;
         self.inner.consume(amt);
     }
@@ -101,7 +97,6 @@ impl Buffer for ZeroReader {
         static DATA: [u8, ..64] = [0, ..64];
         Ok(DATA.as_slice())
     }
-
     fn consume(&mut self, _amt: uint) {}
 }
 
@@ -122,10 +117,7 @@ impl Buffer for NullReader {
     fn consume(&mut self, _amt: uint) {}
 }
 
-/// A `Writer` which multiplexes writes to a set of `Writer`s.
-///
-/// The `Writer`s are delegated to in order. If any `Writer` returns an error,
-/// that error is returned immediately and remaining `Writer`s are not called.
+/// A `Writer` which multiplexes writes to a set of `Writers`.
 pub struct MultiWriter {
     writers: Vec<Box<Writer>>
 }
@@ -140,22 +132,24 @@ impl MultiWriter {
 impl Writer for MultiWriter {
     #[inline]
     fn write(&mut self, buf: &[u8]) -> io::IoResult<()> {
+        let mut ret = Ok(());
         for writer in self.writers.mut_iter() {
-            try!(writer.write(buf));
+            ret = ret.and(writer.write(buf));
         }
-        Ok(())
+        return ret;
     }
 
     #[inline]
     fn flush(&mut self) -> io::IoResult<()> {
+        let mut ret = Ok(());
         for writer in self.writers.mut_iter() {
-            try!(writer.flush());
+            ret = ret.and(writer.flush());
         }
-        Ok(())
+        return ret;
     }
 }
 
-/// A `Reader` which chains input from multiple `Reader`s, reading each to
+/// A `Reader` which chains input from multiple `Readers`, reading each to
 /// completion before moving onto the next.
 pub struct ChainedReader<I, R> {
     readers: I,
@@ -235,16 +229,17 @@ pub fn copy<R: Reader, W: Writer>(r: &mut R, w: &mut W) -> io::IoResult<()> {
     }
 }
 
-/// An adaptor converting an `Iterator<u8>` to a `Reader`.
+/// A `Reader` which converts an `Iterator<u8>` into a `Reader`.
 pub struct IterReader<T> {
     iter: T,
 }
 
 impl<T: Iterator<u8>> IterReader<T> {
-    /// Creates a new `IterReader` which will read from the specified
-    /// `Iterator`.
+    /// Create a new `IterReader` which will read from the specified `Iterator`.
     pub fn new(iter: T) -> IterReader<T> {
-        IterReader { iter: iter }
+        IterReader {
+            iter: iter,
+        }
     }
 }
 
@@ -256,7 +251,7 @@ impl<T: Iterator<u8>> Reader for IterReader<T> {
             *slot = elt;
             len += 1;
         }
-        if len == 0 && buf.len() != 0 {
+        if len == 0 {
             Err(io::standard_error(io::EndOfFile))
         } else {
             Ok(len)
@@ -302,14 +297,6 @@ mod test {
         assert_eq!(0, r.limit());
     }
 
-    #[test]
-    fn test_limit_reader_overlong_consume() {
-        let mut r = MemReader::new(vec![0, 1, 2, 3, 4, 5]);
-        let mut r = LimitReader::new(r.by_ref(), 1);
-        r.consume(2);
-        assert_eq!(vec![], r.read_to_end().unwrap());
-    }
-
     #[test]
     fn test_null_writer() {
         let mut s = NullWriter;
@@ -428,11 +415,4 @@ mod test {
 
         assert_eq!(r.read(buf).unwrap_err().kind, io::EndOfFile);
     }
-
-    #[test]
-    fn iter_reader_zero_length() {
-        let mut r = IterReader::new(range(0u8, 8));
-        let mut buf = [];
-        assert_eq!(Ok(0), r.read(buf));
-    }
 }