---

yaml
---
r: 97595
b: refs/heads/snap-stage3
c: 02d8621
h: refs/heads/master
i:
  97593: 31e2838
  97591: 7048f70
v: v3

Author: rcatolino

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 0da105a8b7b6b1e0568e8ff20f6ff4b13cc7ecc2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: ff7ecca20e116b8365d8095fa9618dc11e54cfbe
+refs/heads/snap-stage3: 02d86216f39d78d614c684e72250cd37e5c6339a
 refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/doc/guide-container.md

@@ -130,7 +130,7 @@ A typical mutable container will implement at least `iter()`, `mut_iter()` and
 ### Freezing
 
 Unlike most other languages with external iterators, Rust has no *iterator
-invalidation*. As long as an iterator is still in scope, the compiler will prevent
+invalidation*. As long an iterator is still in scope, the compiler will prevent
 modification of the container through another handle.
 
 ~~~

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

@@ -730,6 +730,7 @@ pub fn trans_const(ccx: &CrateContext, r: &Repr, discr: Disr,
             if discr == nndiscr {
                 C_struct(build_const_struct(ccx, nonnull, vals), false)
             } else {
+                assert_eq!(vals.len(), 0);
                 let vals = nonnull.fields.iter().enumerate().map(|(i, &ty)| {
                     let llty = type_of::sizing_type_of(ccx, ty);
                     if i == ptrfield { C_null(llty) } else { C_undef(llty) }

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

@@ -213,11 +213,13 @@ impl PurityState {
     }
 }
 
-/// Whether `check_binop` allows overloaded operators to be invoked.
+/// Whether `check_binop` is part of an assignment or not.
+/// Used to know wether we allow user overloads and to print
+/// better messages on error.
 #[deriving(Eq)]
-enum AllowOverloadedOperatorsFlag {
-    AllowOverloadedOperators,
-    DontAllowOverloadedOperators,
+enum IsBinopAssignment{
+    SimpleBinop,
+    BinopAssignment,
 }
 
 #[deriving(Clone)]
@@ -2086,7 +2088,7 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
                    rhs: @ast::Expr,
                    // Used only in the error case
                    expected_result: Option<ty::t>,
-                   allow_overloaded_operators: AllowOverloadedOperatorsFlag
+                   is_binop_assignment: IsBinopAssignment
                   ) {
         let tcx = fcx.ccx.tcx;
 
@@ -2136,9 +2138,9 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
 
         }
 
-        // Check for overloaded operators if allowed.
+        // Check for overloaded operators if not an assignment.
         let result_t;
-        if allow_overloaded_operators == AllowOverloadedOperators {
+        if is_binop_assignment == SimpleBinop {
             result_t = check_user_binop(fcx,
                                         callee_id,
                                         expr,
@@ -2150,13 +2152,14 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
         } else {
             fcx.type_error_message(expr.span,
                                    |actual| {
-                                        format!("binary operation {} cannot be \
-                                              applied to type `{}`",
-                                             ast_util::binop_to_str(op),
-                                             actual)
+                                        format!("binary assignment operation \
+                                                {}= cannot be applied to type `{}`",
+                                                ast_util::binop_to_str(op),
+                                                actual)
                                    },
                                    lhs_t,
                                    None);
+            check_expr(fcx, rhs);
             result_t = ty::mk_err();
         }
 
@@ -2760,7 +2763,7 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
                     lhs,
                     rhs,
                     expected,
-                    AllowOverloadedOperators);
+                    SimpleBinop);
 
         let lhs_ty = fcx.expr_ty(lhs);
         let rhs_ty = fcx.expr_ty(rhs);
@@ -2781,7 +2784,7 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
                     lhs,
                     rhs,
                     expected,
-                    DontAllowOverloadedOperators);
+                    BinopAssignment);
 
         let lhs_t = fcx.expr_ty(lhs);
         let result_t = fcx.expr_ty(expr);

branches/snap-stage3/src/librustdoc/lib.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -109,13 +109,7 @@ pub fn usage(argv0: &str) {
 }
 
 pub fn main_args(args: &[~str]) -> int {
-    let matches = match groups::getopts(args.tail(), opts()) {
-        Ok(m) => m,
-        Err(err) => {
-            println(err.to_err_msg());
-            return 1;
-        }
-    };
+    let matches = groups::getopts(args.tail(), opts()).unwrap();
     if matches.opt_present("h") || matches.opt_present("help") {
         usage(args[0]);
         return 0;

branches/snap-stage3/src/test/run-pass/enum-nullable-const-null-with-fields.rs renamed to branches/snap-stage3/src/test/compile-fail/assignment-operator-unimplemented.rs

@@ -8,12 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::result::{Result,Ok};
-static C: Result<(), ~int> = Ok(());
+struct Foo;
 
-// This is because of yet another bad assertion (ICE) about the null side of a nullable enum.
-// So we won't actually compile if the bug is present, but we check the value in main anyway.
-
-pub fn main() {
-    assert!(C.is_ok());
+fn main() {
+  let mut a = Foo;
+  let ref b = Foo;
+  a += *b; //~ Error: binary assignment operation += cannot be applied to type `Foo`
 }

branches/snap-stage3/src/test/compile-fail/issue-5239-1.rs

@@ -11,5 +11,5 @@
 // Regression test for issue #5239
 
 fn main() {
-    let x: |int| -> int = |ref x| { x += 1; }; //~ ERROR binary operation + cannot be applied to type `&int`
+    let x: |int| -> int = |ref x| { x += 1; }; //~ ERROR binary assignment operation += cannot be applied to type `&int`
 }