---

yaml
---
r: 128957
b: refs/heads/try
c: cb5967e
h: refs/heads/master
i:
  128955: a747a69
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 07d86b46a949a94223da714e35b343243e4ecce4
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a86d9ad15e339ab343a12513f9c90556f677b9ca
-refs/heads/try: 17c630a8dd4d8fbbf7e2fd454593c6529dcc93ab
+refs/heads/try: cb5967e002dc33671f687b957ba8ae46a9de66fb
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/doc/guide-pointers.md

@@ -332,7 +332,7 @@ let z = &x;
 Mutable ones, however, are not:
 
 ```{rust,ignore}
-let x = 5i;
+let mut x = 5i;
 let y = &mut x;
 let z = &mut x; // error: cannot borrow `x` as mutable more than once at a time
 ```

branches/try/src/libcore/str.rs

@@ -1094,13 +1094,25 @@ pub trait StrSlice<'a> {
     /// # Arguments
     ///
     /// - needle - The string to look for
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// assert!("bananas".contains("nana"));
+    /// ```
     fn contains<'a>(&self, needle: &'a str) -> bool;
 
     /// Returns true if a string contains a char.
     ///
     /// # Arguments
     ///
     /// - needle - The char to look for
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// assert!("hello".contains_char('e'));
+    /// ```
     fn contains_char(&self, needle: char) -> bool;
 
     /// An iterator over the characters of `self`. Note, this iterates
@@ -1115,6 +1127,13 @@ pub trait StrSlice<'a> {
     fn chars(&self) -> Chars<'a>;
 
     /// An iterator over the bytes of `self`
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// let v: Vec<u8> = "bors".bytes().collect();
+    /// assert_eq!(v, b"bors".to_vec());
+    /// ```
     fn bytes(&self) -> Bytes<'a>;
 
     /// An iterator over the characters of `self` and their byte offsets.
@@ -1381,9 +1400,21 @@ pub trait StrSlice<'a> {
     fn slice_chars(&self, begin: uint, end: uint) -> &'a str;
 
     /// Returns true if `needle` is a prefix of the string.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// assert!("banana".starts_with("ba"));
+    /// ```
     fn starts_with(&self, needle: &str) -> bool;
 
     /// Returns true if `needle` is a suffix of the string.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// assert!("banana".ends_with("nana"));
+    /// ```
     fn ends_with(&self, needle: &str) -> bool;
 
     /// Returns a string with characters that match `to_trim` removed.
@@ -1525,6 +1556,15 @@ pub trait StrSlice<'a> {
 
     /// Plucks the character starting at the `i`th byte of a string.
     ///
+    /// # Example
+    ///
+    /// ```rust
+    /// let s = "abπc";
+    /// assert_eq!(s.char_at(1), 'b');
+    /// assert_eq!(s.char_at(2), 'π');
+    /// assert_eq!(s.char_at(4), 'c');
+    /// ```
+    ///
     /// # Failure
     ///
     /// If `i` is greater than or equal to the length of the string.
@@ -1540,6 +1580,12 @@ pub trait StrSlice<'a> {
     fn char_at_reverse(&self, i: uint) -> char;
 
     /// Work with the byte buffer of a string as a byte slice.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// assert_eq!("bors".as_bytes(), b"bors");
+    /// ```
     fn as_bytes(&self) -> &'a [u8];
 
     /// Returns the byte index of the first character of `self` that

branches/try/src/liblibc/lib.rs

@@ -304,7 +304,7 @@ extern {}
 // If/when libprim happens, this can be removed in favor of that
 pub enum Nullable<T> {
     Null,
-    Some(T)
+    NotNull(T)
 }
 
 pub mod types {

branches/try/src/librustc/middle/cfg/construct.rs

@@ -473,14 +473,15 @@ impl<'a> CFGBuilder<'a> {
             ast::ExprInlineAsm(ref inline_asm) => {
                 let inputs = inline_asm.inputs.iter();
                 let outputs = inline_asm.outputs.iter();
-                fn extract_expr<A>(&(_, expr): &(A, Gc<ast::Expr>)) -> Gc<ast::Expr> { expr }
                 let post_inputs = self.exprs(inputs.map(|a| {
                     debug!("cfg::construct InlineAsm id:{} input:{:?}", expr.id, a);
-                    extract_expr(a)
+                    let &(_, expr) = a;
+                    expr
                 }), pred);
                 let post_outputs = self.exprs(outputs.map(|a| {
                     debug!("cfg::construct InlineAsm id:{} output:{:?}", expr.id, a);
-                    extract_expr(a)
+                    let &(_, expr, _) = a;
+                    expr
                 }), post_inputs);
                 self.add_node(expr.id, [post_outputs])
             }

branches/try/src/librustc/middle/expr_use_visitor.rs

@@ -380,8 +380,9 @@ impl<'d,'t,TYPER:mc::Typer> ExprUseVisitor<'d,'t,TYPER> {
                     self.consume_expr(&**input);
                 }
 
-                for &(_, ref output) in ia.outputs.iter() {
-                    self.mutate_expr(expr, &**output, JustWrite);
+                for &(_, ref output, is_rw) in ia.outputs.iter() {
+                    self.mutate_expr(expr, &**output,
+                                           if is_rw { WriteAndRead } else { JustWrite });
                 }
             }
 

branches/try/src/librustc/middle/liveness.rs

@@ -1192,9 +1192,10 @@ impl<'a> Liveness<'a> {
           }
 
           ExprInlineAsm(ref ia) => {
-            let succ = ia.outputs.iter().rev().fold(succ, |succ, &(_, ref expr)| {
-                // see comment on lvalues in
-                // propagate_through_lvalue_components()
+
+            let succ = ia.outputs.iter().rev().fold(succ, |succ, &(_, ref 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)
             });
@@ -1437,7 +1438,7 @@ fn check_expr(this: &mut Liveness, expr: &Expr) {
         }
 
         // Output operands must be lvalues
-        for &(_, ref out) in ia.outputs.iter() {
+        for &(_, ref out, _) in ia.outputs.iter() {
           this.check_lvalue(&**out);
           this.visit_expr(&**out, ());
         }

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

@@ -36,13 +36,27 @@ pub fn trans_inline_asm<'a>(bcx: &'a Block<'a>, ia: &ast::InlineAsm)
 
     let temp_scope = fcx.push_custom_cleanup_scope();
 
+    let mut ext_inputs = Vec::new();
+    let mut ext_constraints = Vec::new();
+
     // Prepare the output operands
-    let outputs = ia.outputs.iter().map(|&(ref c, ref out)| {
+    let outputs = ia.outputs.iter().enumerate().map(|(i, &(ref c, ref out, is_rw))| {
         constraints.push((*c).clone());
 
         let out_datum = unpack_datum!(bcx, expr::trans(bcx, &**out));
         output_types.push(type_of::type_of(bcx.ccx(), out_datum.ty));
-        out_datum.val
+        let val = out_datum.val;
+        if is_rw {
+            ext_inputs.push(unpack_result!(bcx, {
+                callee::trans_arg_datum(bcx,
+                                       expr_ty(bcx, &**out),
+                                       out_datum,
+                                       cleanup::CustomScope(temp_scope),
+                                       callee::DontAutorefArg)
+            }));
+            ext_constraints.push(i.to_string());
+        }
+        val
 
     }).collect::<Vec<_>>();
 
@@ -58,14 +72,15 @@ pub fn trans_inline_asm<'a>(bcx: &'a Block<'a>, ia: &ast::InlineAsm)
                                    cleanup::CustomScope(temp_scope),
                                    callee::DontAutorefArg)
         })
-    }).collect::<Vec<_>>();
+    }).collect::<Vec<_>>().append(ext_inputs.as_slice());
 
     // no failure occurred preparing operands, no need to cleanup
     fcx.pop_custom_cleanup_scope(temp_scope);
 
     let mut constraints =
         String::from_str(constraints.iter()
                                     .map(|s| s.get().to_string())
+                                    .chain(ext_constraints.move_iter())
                                     .collect::<Vec<String>>()
                                     .connect(",")
                                     .as_slice());

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

@@ -176,11 +176,15 @@ fn classify_ty(ty: Type) -> Vec<RegClass> {
     }
 
     fn classify_struct(tys: &[Type],
-                       cls: &mut [RegClass], i: uint,
-                       off: uint) {
+                       cls: &mut [RegClass],
+                       i: uint,
+                       off: uint,
+                       packed: bool) {
         let mut field_off = off;
         for ty in tys.iter() {
-            field_off = align(field_off, *ty);
+            if !packed {
+                field_off = align(field_off, *ty);
+            }
             classify(*ty, cls, i, field_off);
             field_off += ty_size(*ty);
         }
@@ -219,7 +223,7 @@ fn classify_ty(ty: Type) -> Vec<RegClass> {
                 unify(cls, ix + off / 8u, SSEDs);
             }
             Struct => {
-                classify_struct(ty.field_types().as_slice(), cls, ix, off);
+                classify_struct(ty.field_types().as_slice(), cls, ix, off, ty.is_packed());
             }
             Array => {
                 let len = ty.array_length();

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

@@ -3729,7 +3729,7 @@ fn populate_scope_map(cx: &CrateContext,
                     walk_expr(cx, &**exp, scope_stack, scope_map);
                 }
 
-                for &(_, ref exp) in outputs.iter() {
+                for &(_, ref exp, _) in outputs.iter() {
                     walk_expr(cx, &**exp, scope_stack, scope_map);
                 }
             }

branches/try/src/librustc/middle/typeck/check/mod.rs

@@ -3332,7 +3332,7 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
           for &(_, ref input) in ia.inputs.iter() {
               check_expr(fcx, &**input);
           }
-          for &(_, ref out) in ia.outputs.iter() {
+          for &(_, ref out, _) in ia.outputs.iter() {
               check_expr(fcx, &**out);
           }
           fcx.write_nil(id);