rustc: Store the lhs and rhs of receive exprs in left to right order

With the changing of receive semantics the parser has been putting the rhs
expression in the first argument of expr_recv and the lhs in the second, and
all subsequent passes have been referring to them backwords (but still doing
the right thing because they were assuming that lhs was the port and rhs was
the receiver).

This makes all code agree on what lhs and rhs mean for receive expressions.

6 files changed, 27 insertions, 27 deletions

diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs
index ccf5f0e3003..e986ab482d0 100644
--- a/src/comp/front/parser.rs
+++ b/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();
diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs
index f2e35ad0546..f0c477f8fea 100644
--- a/src/comp/middle/trans.rs
+++ b/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);
 }
 
 
diff --git a/src/comp/middle/tstate/pre_post_conditions.rs b/src/comp/middle/tstate/pre_post_conditions.rs
index 42b12323437..30e11ddad83 100644
--- a/src/comp/middle/tstate/pre_post_conditions.rs
+++ b/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);
diff --git a/src/comp/middle/tstate/states.rs b/src/comp/middle/tstate/states.rs
index b7c710e85c2..07f3890b82d 100644
--- a/src/comp/middle/tstate/states.rs
+++ b/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;
                 }
             }
diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs
index b96c7ccdb7d..acd38539396 100644
--- a/src/comp/middle/typeck.rs
+++ b/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)) {
diff --git a/src/comp/pretty/pprust.rs b/src/comp/pretty/pprust.rs
index b8f28a1f7f2..7117bb7a18c 100644
--- a/src/comp/pretty/pprust.rs
+++ b/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);