---

yaml
---
r: 63117
b: refs/heads/snap-stage3
c: 8db1d2c
h: refs/heads/master
i:
  63115: ca91601
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: a99ba1180d16394427fcd0fa74ce6dfff96d5566
+refs/heads/snap-stage3: 8db1d2cdde6fafdd396d2ce5c5994492d5bcf8cb
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/doc/tutorial.md

@@ -1442,10 +1442,15 @@ call_closure_with_ten(closure);
 ~~~~
 
 Closures begin with the argument list between vertical bars and are followed by
-a single expression. The types of the arguments are generally omitted,
-as is the return type, because the compiler can almost always infer
-them. In the rare case where the compiler needs assistance, though, the
-arguments and return types may be annotated.
+a single expression. Remember that a block, `{ <expr1>; <expr2>; ... }`, is
+considered a single expression: it evaluates to the result of the last
+expression it contains if that expression is not followed by a semicolon,
+otherwise the block evaluates to `()`.
+
+The types of the arguments are generally omitted, as is the return type,
+because the compiler can almost always infer them. In the rare case where the
+compiler needs assistance, though, the arguments and return types may be
+annotated.
 
 ~~~~
 let square = |x: int| -> uint { x * x as uint };

branches/snap-stage3/mk/rt.mk

@@ -211,7 +211,8 @@ $$(LIBUV_LIB_$(1)_$(2)): $$(LIBUV_DEPS)
 endif
 
 $$(JEMALLOC_LIB_$(1)_$(2)):
-	cd $$(CFG_BUILD_DIR)/rt/$(1)/stage$(2)/jemalloc; $(S)src/rt/jemalloc/configure --disable-experimental
+	cd $$(CFG_BUILD_DIR)/rt/$(1)/stage$(2)/jemalloc; $(S)src/rt/jemalloc/configure \
+		--disable-experimental --build=$(CFG_BUILD_TRIPLE) --host=$(1)
 	$$(Q)$$(MAKE) -C $$(CFG_BUILD_DIR)/rt/$(1)/stage$(2)/jemalloc
 
 # These could go in rt.mk or rustllvm.mk, they're needed for both.

branches/snap-stage3/src/librustc/middle/ty.rs

@@ -3042,17 +3042,15 @@ pub fn adjust_ty(cx: ctxt,
         Some(@AutoDerefRef(ref adj)) => {
             let mut adjusted_ty = unadjusted_ty;
 
-            if (!ty::type_is_error(adjusted_ty)) {
-                for uint::range(0, adj.autoderefs) |i| {
-                    match ty::deref(cx, adjusted_ty, true) {
-                        Some(mt) => { adjusted_ty = mt.ty; }
-                        None => {
-                            cx.sess.span_bug(
-                                span,
-                                fmt!("The %uth autoderef failed: %s",
-                                     i, ty_to_str(cx,
-                                                  adjusted_ty)));
-                        }
+            for uint::range(0, adj.autoderefs) |i| {
+                match ty::deref(cx, adjusted_ty, true) {
+                    Some(mt) => { adjusted_ty = mt.ty; }
+                    None => {
+                        cx.sess.span_bug(
+                            span,
+                            fmt!("The %uth autoderef failed: %s",
+                                 i, ty_to_str(cx,
+                                              adjusted_ty)));
                     }
                 }
             }

branches/snap-stage3/src/librustc/middle/typeck/check/mod.rs

@@ -2728,8 +2728,13 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
         });
         let mut bot_field = false;
         let mut err_field = false;
+
         let elt_ts = do elts.mapi |i, e| {
-            check_expr_with_opt_hint(fcx, *e, flds.map(|fs| fs[i]));
+            let opt_hint = match flds {
+                Some(ref fs) if i < fs.len() => Some(fs[i]),
+                _ => None
+            };
+            check_expr_with_opt_hint(fcx, *e, opt_hint);
             let t = fcx.expr_ty(*e);
             err_field = err_field || ty::type_is_error(t);
             bot_field = bot_field || ty::type_is_bot(t);

branches/snap-stage3/src/librustc/middle/typeck/check/regionck.rs

@@ -460,10 +460,6 @@ fn constrain_call(rcx: @mut Rcx,
     debug!("constrain_call(call_expr=%s, implicitly_ref_args=%?)",
            call_expr.repr(tcx), implicitly_ref_args);
     let callee_ty = rcx.resolve_node_type(callee_id);
-    if ty::type_is_error(callee_ty) {
-        // Bail, as function type is unknown
-        return;
-    }
     let fn_sig = ty::ty_fn_sig(callee_ty);
 
     // `callee_region` is the scope representing the time in which the
@@ -1112,12 +1108,6 @@ pub mod guarantor {
      -> ExprCategorizationType {
         let mut ct = ct;
         let tcx = rcx.fcx.ccx.tcx;
-
-        if (ty::type_is_error(ct.ty)) {
-            ct.cat.pointer = NotPointer;
-            return ct;
-        }
-
         for uint::range(0, autoderefs) |_| {
             ct.cat.guarantor = guarantor_of_deref(&ct.cat);
 

branches/snap-stage3/src/libsyntax/parse/comments.rs

@@ -347,7 +347,7 @@ pub fn gather_comments_and_literals(span_diagnostic:
         }
 
 
-        let bstart = rdr.pos;
+        let bstart = rdr.last_pos;
         rdr.next_token();
         //discard, and look ahead; we're working with internal state
         let TokenAndSpan {tok: tok, sp: sp} = rdr.peek();

branches/snap-stage3/src/libsyntax/parse/lexer.rs

@@ -161,22 +161,20 @@ fn string_advance_token(r: @mut StringReader) {
     }
 }
 
-fn byte_offset(rdr: &StringReader) -> BytePos {
-    (rdr.pos - rdr.filemap.start_pos)
+fn byte_offset(rdr: &StringReader, pos: BytePos) -> BytePos {
+    (pos - rdr.filemap.start_pos)
 }
 
 pub fn get_str_from(rdr: @mut StringReader, start: BytePos) -> ~str {
-    // I'm pretty skeptical about this subtraction. What if there's a
-    // multi-byte character before the mark?
-    return str::slice(*rdr.src, start.to_uint() - 1u,
-                      byte_offset(rdr).to_uint() - 1u).to_owned();
+    return str::slice(*rdr.src, start.to_uint(),
+                      byte_offset(rdr, rdr.last_pos).to_uint()).to_owned();
 }
 
 // EFFECT: advance the StringReader by one character. If a newline is
 // discovered, add it to the FileMap's list of line start offsets.
 pub fn bump(rdr: &mut StringReader) {
     rdr.last_pos = rdr.pos;
-    let current_byte_offset = byte_offset(rdr).to_uint();;
+    let current_byte_offset = byte_offset(rdr, rdr.pos).to_uint();
     if current_byte_offset < (*rdr.src).len() {
         assert!(rdr.curr != -1 as char);
         let last_char = rdr.curr;
@@ -202,7 +200,7 @@ pub fn is_eof(rdr: @mut StringReader) -> bool {
     rdr.curr == -1 as char
 }
 pub fn nextch(rdr: @mut StringReader) -> char {
-    let offset = byte_offset(rdr).to_uint();
+    let offset = byte_offset(rdr, rdr.pos).to_uint();
     if offset < (*rdr.src).len() {
         return str::char_at(*rdr.src, offset);
     } else { return -1 as char; }
@@ -692,7 +690,7 @@ fn next_token_inner(rdr: @mut StringReader) -> token::Token {
         return token::LIT_INT(c2 as i64, ast::ty_char);
       }
       '"' => {
-        let n = byte_offset(rdr);
+        let n = byte_offset(rdr, rdr.last_pos);
         bump(rdr);
         while rdr.curr != '"' {
             if is_eof(rdr) {

branches/snap-stage3/src/test/compile-fail/unconstrained-none.rs renamed to branches/snap-stage3/src/test/compile-fail/tuple-arity-mismatch.rs

@@ -8,8 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// Issue #5062
+// Issue #6155
+
+fn first((value, _): (int, float)) -> int { value }
 
 fn main() {
-    fmt!("%?", None); //~ ERROR cannot determine a type for this expression: unconstrained type
+    let y = first ((1,2,3)); //~ ERROR expected a tuple with 2 elements but found one with 3 elements
 }