---

yaml
---
r: 3245
b: refs/heads/master
c: 5148131
h: refs/heads/master
i:
  3243: e679b63
v: v3

Author: brson

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 364cd5763c118eb7bc73a36c7eefcd842f506f8f
+refs/heads/master: 514813148b68d86a0dd9b5ebea9ec4fc415fdac0

trunk/src/comp/front/parser.rs

@@ -1201,7 +1201,7 @@ fn parse_assign_expr(&parser p) -> @ast::expr {
             p.bump();
             auto rhs = parse_expr(p);
             ret @spanned(lo, rhs.span.hi,
-                         ast::expr_recv(rhs, lhs, p.get_ann()));
+                         ast::expr_recv(lhs, rhs, p.get_ann()));
         }
         case (token::DARROW) {
             p.bump();

trunk/src/comp/middle/trans.rs

@@ -6429,30 +6429,30 @@ fn trans_send(&@block_ctxt cx, &@ast::expr lhs, &@ast::expr rhs,
 fn trans_recv(&@block_ctxt cx, &@ast::expr lhs, &@ast::expr rhs,
               &ast::ann ann) -> result {
     auto bcx = cx;
-    auto data = trans_lval(bcx, lhs);
+    auto data = trans_lval(bcx, rhs);
     assert (data.is_mem);
     bcx = data.res.bcx;
     auto unit_ty = node_ann_type(bcx.fcx.lcx.ccx, ann);
     // FIXME: calculate copy init-ness in typestate.
 
-    ret recv_val(bcx, data.res.val, rhs, unit_ty, DROP_EXISTING);
+    ret recv_val(bcx, data.res.val, lhs, unit_ty, DROP_EXISTING);
 }
 
-fn recv_val(&@block_ctxt cx, ValueRef lhs, &@ast::expr rhs, &ty::t unit_ty,
+fn recv_val(&@block_ctxt cx, ValueRef to, &@ast::expr from, &ty::t unit_ty,
             copy_action action) -> result {
     auto bcx = cx;
-    auto prt = trans_expr(bcx, rhs);
+    auto prt = trans_expr(bcx, from);
     bcx = prt.bcx;
-    auto lldataptr = bcx.build.PointerCast(lhs, T_ptr(T_ptr(T_i8())));
+    auto lldataptr = bcx.build.PointerCast(to, T_ptr(T_ptr(T_i8())));
     auto llportptr = bcx.build.PointerCast(prt.val, T_opaque_port_ptr());
     bcx.build.Call(bcx.fcx.lcx.ccx.upcalls.recv,
                    [bcx.fcx.lltaskptr, lldataptr, llportptr]);
-    auto data_load = load_if_immediate(bcx, lhs, unit_ty);
-    auto cp = copy_val(bcx, action, lhs, data_load, unit_ty);
+    auto data_load = load_if_immediate(bcx, to, unit_ty);
+    auto cp = copy_val(bcx, action, to, data_load, unit_ty);
     bcx = cp.bcx;
     // TODO: Any cleanup need to be done here?
 
-    ret res(bcx, lhs);
+    ret res(bcx, to);
 }
 
 

trunk/src/comp/middle/tstate/pre_post_conditions.rs

@@ -387,12 +387,12 @@ fn find_pre_post_expr(&fn_ctxt fcx, @expr e) {
             }
         }
         case (expr_recv(?lhs, ?rhs, ?a)) {
-            alt (lhs.node) {
-                case (expr_path(?p, ?a_lhs)) {
-                    gen_if_local(fcx, lhs, rhs, a, a_lhs, p);
+            alt (rhs.node) {
+                case (expr_path(?p, ?a_rhs)) {
+                    gen_if_local(fcx, rhs, lhs, a, a_rhs, p);
                 }
                 case (_) {
-                    // doesn't check that lhs is an lval, but
+                    // doesn't check that rhs is an lval, but
                     // that's probably ok
 
                     find_pre_post_exprs(fcx, [lhs, rhs], a);

trunk/src/comp/middle/tstate/states.rs

@@ -447,31 +447,31 @@ fn find_pre_post_state_expr(&fn_ctxt fcx, &prestate pres, @expr e) -> bool {
         }
         case (expr_recv(?lhs, ?rhs, ?a)) {
             extend_prestate_ann(fcx.ccx, a, pres);
-            alt (lhs.node) {
-                case (expr_path(?p, ?a_lhs)) {
+            alt (rhs.node) {
+                case (expr_path(?p, ?a_rhs)) {
                     // receive to local var
 
-                    changed = pure_exp(fcx.ccx, a_lhs, pres) || changed;
+                    changed = pure_exp(fcx.ccx, a_rhs, pres) || changed;
                     changed =
-                        find_pre_post_state_expr(fcx, pres, rhs) || changed;
+                        find_pre_post_state_expr(fcx, pres, lhs) || changed;
                     changed =
                         extend_poststate_ann(fcx.ccx, a,
-                                             expr_poststate(fcx.ccx, rhs)) ||
+                                             expr_poststate(fcx.ccx, lhs)) ||
                             changed;
-                    changed = gen_if_local(fcx, a_lhs, a, p) || changed;
+                    changed = gen_if_local(fcx, a_rhs, a, p) || changed;
                 }
                 case (_) {
                     // receive to something that must already have been init'd
 
                     changed =
-                        find_pre_post_state_expr(fcx, pres, lhs) || changed;
+                        find_pre_post_state_expr(fcx, pres, rhs) || changed;
                     changed =
                         find_pre_post_state_expr(fcx,
-                                                 expr_poststate(fcx.ccx, lhs),
-                                                 rhs) || changed;
+                                                 expr_poststate(fcx.ccx, rhs),
+                                                 lhs) || changed;
                     changed =
                         extend_poststate_ann(fcx.ccx, a,
-                                             expr_poststate(fcx.ccx, rhs)) ||
+                                             expr_poststate(fcx.ccx, lhs)) ||
                             changed;
                 }
             }

trunk/src/comp/middle/typeck.rs

@@ -1705,9 +1705,9 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
             require_impure(fcx.ccx.tcx.sess, fcx.purity, expr.span);
             check_expr(fcx, lhs);
             check_expr(fcx, rhs);
-            auto item_t = expr_ty(fcx.ccx.tcx, lhs);
+            auto item_t = expr_ty(fcx.ccx.tcx, rhs);
             auto port_t = ty::mk_port(fcx.ccx.tcx, item_t);
-            demand::simple(fcx, expr.span, port_t, expr_ty(fcx.ccx.tcx, rhs));
+            demand::simple(fcx, expr.span, port_t, expr_ty(fcx.ccx.tcx, lhs));
             write::ty_only_fixup(fcx, a.id, item_t);
         }
         case (ast::expr_if(?cond, ?thn, ?elsopt, ?a)) {

trunk/src/comp/pretty/pprust.rs

@@ -750,10 +750,10 @@ fn print_expr(&ps s, &@ast::expr expr) {
             print_expr(s, rhs);
         }
         case (ast::expr_recv(?lhs, ?rhs, _)) {
-            print_expr(s, rhs);
+            print_expr(s, lhs);
             space(s.s);
             word_space(s, "|>");
-            print_expr(s, lhs);
+            print_expr(s, rhs);
         }
         case (ast::expr_field(?expr, ?id, _)) {
             print_expr(s, expr);