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.

Author: brson

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();

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);
 }
 
 

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);

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;
                 }
             }

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)) {

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);