Parse and translate assignments.

src/comp/front/parser.rs

@@ -564,6 +564,20 @@ io fn parse_or_expr(parser p) -> @ast.expr {
     ret parse_binary_exprs(p, sub, vec(tup(token.OROR, ast.or)));
 }
 
+io fn parse_assign_expr(parser p) -> @ast.expr {
+    auto lo = p.get_span();
+    auto lhs = parse_or_expr(p);
+    alt (p.peek()) {
+        case (token.EQ) {
+            p.bump();
+            auto rhs = parse_expr(p);
+            ret @spanned(lo, rhs.span,
+                         ast.expr_assign(lhs, rhs, none[@ast.ty]));
+        }
+    }
+    ret lhs;
+}
+
 io fn parse_if_expr(parser p) -> @ast.expr {
     auto lo = p.get_span();
     auto hi = lo;
@@ -597,7 +611,7 @@ io fn parse_expr(parser p) -> @ast.expr {
             ret parse_if_expr(p);
         }
         case (_) {
-            ret parse_or_expr(p);
+            ret parse_assign_expr(p);
         }
 
     }

src/comp/middle/trans.rs

@@ -606,6 +606,30 @@ fn trans_if(@block_ctxt cx, &ast.expr cond,
     ret res(next_cx, phi);
 }
 
+fn trans_lval(@block_ctxt cx, &ast.expr e) -> result {
+    alt (e.node) {
+        case (ast.expr_name(?n, ?dopt, _)) {
+            alt (dopt) {
+                case (some[ast.def](?def)) {
+                    alt (def) {
+                        case (ast.def_local(?did)) {
+                            ret res(cx, cx.fcx.lllocals.get(did));
+                        }
+                        case (_) {
+                            cx.fcx.tcx.sess.unimpl("def variant in trans");
+                        }
+                    }
+                }
+                case (none[ast.def]) {
+                    cx.fcx.tcx.sess.err("unresolved expr_name in trans");
+                }
+            }
+        }
+    }
+    cx.fcx.tcx.sess.unimpl("expr variant in trans_lval");
+    fail;
+}
+
 fn trans_expr(@block_ctxt cx, &ast.expr e) -> result {
     alt (e.node) {
         case (ast.expr_lit(?lit, _)) {
@@ -635,24 +659,18 @@ fn trans_expr(@block_ctxt cx, &ast.expr e) -> result {
             ret res(next_cx, sub.val);
         }
 
-        case (ast.expr_name(?n, ?dopt, _)) {
+        case (ast.expr_name(_,_,_)) {
-            alt (dopt) {
+            auto sub = trans_lval(cx, e);
-                case (some[ast.def](?def)) {
+            ret res(sub.bcx, cx.build.Load(sub.val));
-                    alt (def) {
-                        case (ast.def_local(?did)) {
-                            auto llptr = cx.fcx.lllocals.get(did);
-                            ret res(cx, cx.build.Load(llptr));
-                        }
-                        case (_) {
-                            cx.fcx.tcx.sess.unimpl("def variant in trans");
-                        }
-                    }
-                }
-                case (none[ast.def]) {
-                    cx.fcx.tcx.sess.err("unresolved expr_name in trans");
-                }
         }
+
+        case (ast.expr_assign(?dst, ?src, _)) {
+            auto lhs_res = trans_lval(cx, *dst);
+            auto rhs_res = trans_expr(lhs_res.bcx, *src);
+            ret res(rhs_res.bcx,
+                    cx.build.Store(rhs_res.val, lhs_res.val));
         }
+
     }
     cx.fcx.tcx.sess.unimpl("expr variant in trans_expr");
     fail;