---

yaml
---
r: 152926
b: refs/heads/try2
c: a208842
h: refs/heads/master
v: v3

Author: tbu-

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: e6d6c8beaa6a0b77334bdbed7105b3c3c17420be
+refs/heads/try2: a208842b9d2e62ffeaa8d6b7e02ce523efae033c
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/guide-macros.md

@@ -355,7 +355,6 @@ macro_rules! biased_match_rec (
             _ => { $err }
         }
     );
-    // Produce the requested values
     ( binds $( $bind_res:ident ),* ) => ( ($( $bind_res ),*) )
 )
 
@@ -365,7 +364,7 @@ macro_rules! biased_match (
     ( $( ($e:expr) ~ ($p:pat) else $err:stmt ; )*
       binds $bind_res:ident
     ) => (
-        let $bind_res = biased_match_rec!(
+        let ( $( $bind_res ),* ) = biased_match_rec!(
             $( ($e) ~ ($p) else $err ; )*
             binds $bind_res
         );

branches/try2/src/doc/guide.md

@@ -411,64 +411,3 @@ rest of your Rust career.
 
 Next, we'll learn more about Rust itself, by starting to write a more complicated
 program. We hope you want to do more with Rust than just print "Hello, world!"
-
-## If
-
-## Functions
-
-return
-
-comments
-
-## Testing
-
-attributes
-
-stability markers
-
-## Crates and Modules
-
-visibility
-
-## Compound Data Types
-
-Tuples
-
-Structs
-
-Enums
-
-## Match
-
-## Looping
-
-for
-
-while
-
-loop
-
-break/continue
-
-iterators
-
-## Lambdas
-
-## Generics
-
-## Traits
-
-## Operators and built-in Traits
-
-## Ownership and Lifetimes
-
-Move vs. Copy
-
-Allocation
-
-## Tasks
-
-## Macros
-
-## Unsafe
-

branches/try2/src/doc/tutorial.md

@@ -493,12 +493,11 @@ 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 (see "destructuring"
-below). 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.
+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/try2/src/libcollections/vec.rs

@@ -956,14 +956,17 @@ impl<T> Vec<T> {
     ///
     /// # Failure
     ///
-    /// Fails if `index` is out of bounds of the vector.
+    /// Fails if `index` is not between `0` and the vector's length (both
+    /// bounds inclusive).
     ///
     /// # Example
     ///
     /// ```rust
     /// let mut vec = vec!(1i, 2, 3);
     /// vec.insert(1, 4);
     /// assert_eq!(vec, vec!(1, 4, 2, 3));
+    /// vec.insert(4, 5);
+    /// assert_eq!(vec, vec!(1, 4, 2, 3, 5));
     /// ```
     pub fn insert(&mut self, index: uint, element: T) {
         let len = self.len();

branches/try2/src/librustc/lint/builtin.rs

@@ -975,52 +975,14 @@ declare_lint!(UNNECESSARY_PARENS, Warn,
 pub struct UnnecessaryParens;
 
 impl UnnecessaryParens {
-    fn check_unnecessary_parens_core(&self, cx: &Context, value: &ast::Expr, msg: &str,
-                                     struct_lit_needs_parens: bool) {
+    fn check_unnecessary_parens_core(&self, cx: &Context, value: &ast::Expr, msg: &str) {
         match value.node {
-            ast::ExprParen(ref inner) => {
-                let necessary = struct_lit_needs_parens && contains_exterior_struct_lit(&**inner);
-                if !necessary {
-                    cx.span_lint(UNNECESSARY_PARENS, value.span,
-                                 format!("unnecessary parentheses around {}",
-                                         msg).as_slice())
-                }
+            ast::ExprParen(_) => {
+                cx.span_lint(UNNECESSARY_PARENS, value.span,
+                    format!("unnecessary parentheses around {}", msg).as_slice())
             }
             _ => {}
         }
-
-        /// Expressions that syntatically contain an "exterior" struct
-        /// literal i.e. not surrounded by any parens or other
-        /// delimiters, e.g. `X { y: 1 }`, `X { y: 1 }.method()`, `foo
-        /// == X { y: 1 }` and `X { y: 1 } == foo` all do, but `(X {
-        /// y: 1 }) == foo` does not.
-        fn contains_exterior_struct_lit(value: &ast::Expr) -> bool {
-            match value.node {
-                ast::ExprStruct(..) => true,
-
-                ast::ExprAssign(ref lhs, ref rhs) |
-                ast::ExprAssignOp(_, ref lhs, ref rhs) |
-                ast::ExprBinary(_, ref lhs, ref rhs) => {
-                    // X { y: 1 } + X { y: 2 }
-                    contains_exterior_struct_lit(&**lhs) ||
-                        contains_exterior_struct_lit(&**rhs)
-                }
-                ast::ExprUnary(_, ref x) |
-                ast::ExprCast(ref x, _) |
-                ast::ExprField(ref x, _, _) |
-                ast::ExprIndex(ref x, _) => {
-                    // &X { y: 1 }, X { y: 1 }.y
-                    contains_exterior_struct_lit(&**x)
-                }
-
-                ast::ExprMethodCall(_, _, ref exprs) => {
-                    // X { y: 1 }.bar(...)
-                    contains_exterior_struct_lit(&**exprs.get(0))
-                }
-
-                _ => false
-            }
-        }
     }
 }
 
@@ -1030,16 +992,16 @@ impl LintPass for UnnecessaryParens {
     }
 
     fn check_expr(&mut self, cx: &Context, e: &ast::Expr) {
-        let (value, msg, struct_lit_needs_parens) = match e.node {
-            ast::ExprIf(cond, _, _) => (cond, "`if` condition", true),
-            ast::ExprWhile(cond, _) => (cond, "`while` condition", true),
-            ast::ExprMatch(head, _) => (head, "`match` head expression", true),
-            ast::ExprRet(Some(value)) => (value, "`return` value", false),
-            ast::ExprAssign(_, value) => (value, "assigned value", false),
-            ast::ExprAssignOp(_, _, value) => (value, "assigned value", false),
+        let (value, msg) = match e.node {
+            ast::ExprIf(cond, _, _) => (cond, "`if` condition"),
+            ast::ExprWhile(cond, _) => (cond, "`while` condition"),
+            ast::ExprMatch(head, _) => (head, "`match` head expression"),
+            ast::ExprRet(Some(value)) => (value, "`return` value"),
+            ast::ExprAssign(_, value) => (value, "assigned value"),
+            ast::ExprAssignOp(_, _, value) => (value, "assigned value"),
             _ => return
         };
-        self.check_unnecessary_parens_core(cx, &*value, msg, struct_lit_needs_parens);
+        self.check_unnecessary_parens_core(cx, &*value, msg);
     }
 
     fn check_stmt(&mut self, cx: &Context, s: &ast::Stmt) {
@@ -1053,7 +1015,7 @@ impl LintPass for UnnecessaryParens {
             },
             _ => return
         };
-        self.check_unnecessary_parens_core(cx, &*value, msg, false);
+        self.check_unnecessary_parens_core(cx, &*value, msg);
     }
 }
 

branches/try2/src/librustc/middle/trans/expr.rs

@@ -277,19 +277,15 @@ fn apply_adjustments<'a>(bcx: &'a Block<'a>,
         auto_ref(bcx, datum, expr)
     }
 
-    fn auto_borrow_obj<'a>(mut bcx: &'a Block<'a>,
+    fn auto_borrow_obj<'a>(bcx: &'a Block<'a>,
                            expr: &ast::Expr,
                            source_datum: Datum<Expr>)
                            -> DatumBlock<'a, Expr> {
         let tcx = bcx.tcx();
         let target_obj_ty = expr_ty_adjusted(bcx, expr);
         debug!("auto_borrow_obj(target={})", target_obj_ty.repr(tcx));
 
-        // Arrange cleanup, if not already done. This is needed in
-        // case we are auto-borrowing a Box<Trait> to &Trait
-        let datum = unpack_datum!(
-            bcx, source_datum.to_lvalue_datum(bcx, "autoborrowobj", expr.id));
-        let mut datum = datum.to_expr_datum();
+        let mut datum = source_datum.to_expr_datum();
         datum.ty = target_obj_ty;
         DatumBlock::new(bcx, datum)
     }

branches/try2/src/libsyntax/ast.rs

@@ -401,7 +401,6 @@ pub enum Decl_ {
     DeclItem(Gc<Item>),
 }
 
-/// represents one arm of a 'match'
 #[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
 pub struct Arm {
     pub attrs: Vec<Attribute>,