---

yaml
---
r: 115455
b: refs/heads/try
c: 81bc32d
h: refs/heads/master
i:
  115453: 4e4b4f6
  115451: c94f493
  115447: 31f561b
  115439: 1ca2770
  115423: eba69c9
  115391: d2dcacd
  115327: 4bd0a7a
  115199: 2219769
v: v3

Author: iliekturtles

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: bee4e6adac17f87b1cdc26ab69f8c0f5d82575a3
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ec0258a381b88b5574e3f8ce72ae553ac3a574b7
-refs/heads/try: fd625dda9a25c054d622e20822f2889f17b15aa6
+refs/heads/try: 81bc32d9750f34a2218e6ba8f2d2c1a101f8a8a1
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/doc/tutorial.md

@@ -468,19 +468,16 @@ Unlike in C, there is no "falling through" between arms: only one arm
 executes, and it doesn't have to explicitly `break` out of the
 construct when it is finished.
 
-A `match` arm consists of a *pattern*, then an arrow `=>`, followed by
-an *action* (expression). Literals are valid patterns and match only
-their own value. A single arm may match multiple different patterns by
-combining them with the pipe operator (`|`), so long as every pattern
-binds the same set of variables. Ranges of numeric literal patterns
-can be expressed with two dots, as in `M..N`. The underscore (`_`) is
-a wildcard pattern that matches any single value. (`..`) is a different
-wildcard that can match one or more fields in an `enum` variant.
-
-The patterns in a match arm are followed by a fat arrow, `=>`, then an
-expression to evaluate. Each case is separated by commas. It's often
-convenient to use a block expression for each case, in which case the
-commas are optional.
+A `match` arm consists of a *pattern*, then a fat arrow `=>`, followed
+by an *action* (expression). Each case is separated by commas. It is
+often convenient to use a block expression for each case, in which case
+the commas are optional as shown below. Literals are valid patterns and
+match only their own value. A single arm may match multiple different
+patterns by combining them with the pipe operator (`|`), so long as every
+pattern binds the same set of variables. Ranges of numeric literal
+patterns can be expressed with two dots, as in `M..N`. The underscore
+(`_`) is a wildcard pattern that matches any single value. (`..`) is a
+different wildcard that can match one or more fields in an `enum` variant.
 
 ~~~
 # let my_number = 1;

branches/try/src/librustc/middle/trans/adt.rs

@@ -779,26 +779,6 @@ pub fn trans_const(ccx: &CrateContext, r: &Repr, discr: Disr,
     }
 }
 
-/**
- * Compute struct field offsets relative to struct begin.
- */
-fn compute_struct_field_offsets(ccx: &CrateContext, st: &Struct) -> Vec<u64> {
-    let mut offsets = vec!();
-
-    let mut offset = 0;
-    for &ty in st.fields.iter() {
-        let llty = type_of::sizing_type_of(ccx, ty);
-        if !st.packed {
-            let type_align = machine::llalign_of_min(ccx, llty) as u64;
-            offset = roundup(offset, type_align);
-        }
-        offsets.push(offset);
-        offset += machine::llsize_of_alloc(ccx, llty) as u64;
-    }
-    assert_eq!(st.fields.len(), offsets.len());
-    offsets
-}
-
 /**
  * Building structs is a little complicated, because we might need to
  * insert padding if a field's value is less aligned than its type.
@@ -813,32 +793,26 @@ fn build_const_struct(ccx: &CrateContext, st: &Struct, vals: &[ValueRef])
     -> Vec<ValueRef> {
     assert_eq!(vals.len(), st.fields.len());
 
-    let target_offsets = compute_struct_field_offsets(ccx, st);
-
-    // offset of current value
     let mut offset = 0;
     let mut cfields = Vec::new();
-    for (&val, &target_offset) in vals.iter().zip(target_offsets.iter()) {
-        if !st.packed {
-            let val_align = machine::llalign_of_min(ccx, val_ty(val))
-                /*bad*/as u64;
-            offset = roundup(offset, val_align);
-        }
+    for (i, &ty) in st.fields.iter().enumerate() {
+        let llty = type_of::sizing_type_of(ccx, ty);
+        let type_align = machine::llalign_of_min(ccx, llty)
+            /*bad*/as u64;
+        let val_align = machine::llalign_of_min(ccx, val_ty(vals[i]))
+            /*bad*/as u64;
+        let target_offset = roundup(offset, type_align);
+        offset = roundup(offset, val_align);
         if offset != target_offset {
             cfields.push(padding(ccx, target_offset - offset));
             offset = target_offset;
         }
-        assert!(!is_undef(val));
-        cfields.push(val);
-        offset += machine::llsize_of_alloc(ccx, val_ty(val)) as u64;
-    }
-
-    assert!(offset <= st.size);
-    if offset != st.size {
-        cfields.push(padding(ccx, st.size - offset));
+        assert!(!is_undef(vals[i]));
+        cfields.push(vals[i]);
+        offset += machine::llsize_of_alloc(ccx, llty) as u64
     }
 
-    cfields
+    return cfields;
 }
 
 fn padding(ccx: &CrateContext, size: u64) -> ValueRef {

branches/try/src/librustc/middle/trans/base.rs

@@ -186,6 +186,8 @@ fn decl_fn(llmod: ModuleRef, name: &str, cc: lib::llvm::CallConv,
             }
         }
         // `~` pointer return values never alias because ownership is transferred
+        // FIXME #6750 ~Trait cannot be directly marked as
+        // noalias because the actual object pointer is nested.
         ty::ty_uniq(..) // | ty::ty_trait(_, _, ty::UniqTraitStore, _, _)
          => {
             unsafe {
@@ -256,25 +258,23 @@ pub fn decl_rust_fn(ccx: &CrateContext, has_env: bool,
         let llarg = unsafe { llvm::LLVMGetParam(llfn, (offset + i) as c_uint) };
         match ty::get(arg_ty).sty {
             // `~` pointer parameters never alias because ownership is transferred
-            ty::ty_uniq(..) => {
+            // FIXME #6750 ~Trait cannot be directly marked as
+            // noalias because the actual object pointer is nested.
+            ty::ty_uniq(..) | // ty::ty_trait(_, _, ty::UniqTraitStore, _, _) |
+            ty::ty_closure(~ty::ClosureTy {store: ty::UniqTraitStore, ..}) => {
                 unsafe {
                     llvm::LLVMAddAttribute(llarg, lib::llvm::NoAliasAttribute as c_uint);
                 }
-            }
-            // `&mut` pointer parameters never alias other parameters, or mutable global data
-            ty::ty_rptr(_, mt) if mt.mutbl == ast::MutMutable => {
-                unsafe {
-                    llvm::LLVMAddAttribute(llarg, lib::llvm::NoAliasAttribute as c_uint);
-                }
-            }
-            // When a reference in an argument has no named lifetime, it's impossible for that
-            // reference to escape this function (returned or stored beyond the call by a closure).
+            },
+            // When a reference in an argument has no named lifetime, it's
+            // impossible for that reference to escape this function(ie, be
+            // returned).
             ty::ty_rptr(ReLateBound(_, BrAnon(_)), _) => {
                 debug!("marking argument of {} as nocapture because of anonymous lifetime", name);
                 unsafe {
                     llvm::LLVMAddAttribute(llarg, lib::llvm::NoCaptureAttribute as c_uint);
                 }
-            }
+            },
             _ => {
                 // For non-immediate arguments the callee gets its own copy of
                 // the value on the stack, so there are no aliases