---

yaml
---
r: 11721
b: refs/heads/master
c: ddeaea2
h: refs/heads/master
i:
  11719: 072567f
v: v3

Author: pcwalton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 0722786664eaa6008e8fe6536a8c20cac0a81938
+refs/heads/master: ddeaea228723ffa84a17898e08727e0c55a304a1
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/src/rustc/metadata/astencode_gen.rs

@@ -1645,18 +1645,19 @@ fn trans_unary(bcx: block, op: ast::unop, e: @ast::expr,
                                translated using trans_lval(), not \
                                trans_unary()");
       }
-      ast::addr_of {
-        // FIXME: This is wrong.
-        let {bcx, val, kind} = trans_temp_lval(bcx, e);
-        if kind != owned {
-            bcx.sess().span_bug(e.span,
-                                "can't take the address of an rvalue");
-        }
-        ret store_in_dest(bcx, val, dest);
-      }
     }
 }
 
+fn trans_addr_of(cx: block, e: @ast::expr, dest: dest) -> block {
+    // FIXME: This is wrong.
+    let {bcx, val, kind} = trans_temp_lval(cx, e);
+    if kind != owned {
+        bcx.sess().span_bug(e.span,
+                            "can't take the address of an rvalue");
+    }
+    ret store_in_dest(bcx, val, dest);
+}
+
 fn trans_compare(cx: block, op: ast::binop, lhs: ValueRef,
                  _lhs_t: ty::t, rhs: ValueRef, rhs_t: ty::t) -> result {
     if ty::type_is_scalar(rhs_t) {
@@ -3151,6 +3152,7 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block {
         assert op != ast::deref; // lvals are handled above
         ret trans_unary(bcx, op, x, e, dest);
       }
+      ast::expr_addr_of(_, x) { ret trans_addr_of(bcx, x, dest); }
       ast::expr_fn(proto, decl, body, cap_clause) {
         ret closure::trans_expr_fn(
             bcx, proto, decl, body, e.span, e.id, *cap_clause, dest);
@@ -4307,8 +4309,7 @@ fn trans_const_expr(cx: crate_ctxt, e: @ast::expr) -> ValueRef {
         ret alt u {
           ast::box(_)  |
           ast::uniq(_) |
-          ast::deref   |
-          ast::addr_of { cx.sess.span_bug(e.span,
+          ast::deref   { cx.sess.span_bug(e.span,
                            "bad unop type in trans_const_expr"); }
           ast::not    { llvm::LLVMConstNot(te) }
           ast::neg    {

trunk/src/rustc/middle/trans/base.rs

@@ -409,6 +409,10 @@ fn find_pre_post_expr(fcx: fn_ctxt, e: @expr) {
         find_pre_post_expr(fcx, operand);
         copy_pre_post(fcx.ccx, e.id, operand);
       }
+      expr_addr_of(_, operand) {
+        find_pre_post_expr(fcx, operand);
+        copy_pre_post(fcx.ccx, e.id, operand);
+      }
       expr_cast(operand, _) {
         find_pre_post_expr(fcx, operand);
         copy_pre_post(fcx.ccx, e.id, operand);

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

@@ -587,6 +587,9 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool {
       expr_unary(_, operand) {
         ret find_pre_post_state_sub(fcx, pres, operand, e.id, none);
       }
+      expr_addr_of(_, operand) {
+        ret find_pre_post_state_sub(fcx, pres, operand, e.id, none);
+      }
       expr_cast(operand, _) {
         ret find_pre_post_state_sub(fcx, pres, operand, e.id, none);
       }

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

@@ -2198,14 +2198,17 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier,
                 oper_t = check_user_unop(fcx, "-", "unary-", expr, oper_t);
             }
           }
-          ast::addr_of {
-            // FIXME: This is incorrect. Infer the proper region.
-            let tm = { ty: oper_t, mutbl: ast::m_imm };
-            oper_t = ty::mk_rptr(tcx, ty::re_block(0), tm);
-          }
         }
         write_ty(tcx, id, oper_t);
       }
+      ast::expr_addr_of(mutbl, oper) {
+        bot = check_expr(fcx, oper);
+        let oper_t = expr_ty(tcx, oper);
+
+        // FIXME: This is incorrect. Infer the proper region.
+        let tm = { ty: oper_t, mutbl: mutbl };
+        oper_t = ty::mk_rptr(tcx, ty::re_block(0), tm);
+      }
       ast::expr_path(pth) {
         let defn = lookup_def(fcx, pth.span, id);
 

trunk/src/rustc/middle/typeck.rs

@@ -159,7 +159,7 @@ enum binop {
 enum unop {
     box(mutability),
     uniq(mutability),
-    deref, not, neg, addr_of
+    deref, not, neg
 }
 
 // Generally, after typeck you can get the inferred value
@@ -245,6 +245,7 @@ enum expr_ {
     expr_field(@expr, ident, [@ty]),
     expr_index(@expr, @expr),
     expr_path(@path),
+    expr_addr_of(mutability, @expr),
     expr_fail(option<@expr>),
     expr_break,
     expr_cont,

trunk/src/rustc/syntax/ast.rs

@@ -402,6 +402,7 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
           expr_unary(binop, ohs) { expr_unary(binop, fld.fold_expr(ohs)) }
           expr_lit(_) { e }
           expr_cast(expr, ty) { expr_cast(fld.fold_expr(expr), ty) }
+          expr_addr_of(m, ohs) { expr_addr_of(m, fld.fold_expr(ohs)) }
           expr_if(cond, tr, fl) {
             expr_if(fld.fold_expr(cond), fld.fold_block(tr),
                     option::map(fl, fld.fold_expr))

trunk/src/rustc/syntax/fold.rs

@@ -1129,9 +1129,10 @@ fn parse_prefix_expr(p: parser) -> pexpr {
           }
           token::AND {
             p.bump();
+            let m = parse_mutability(p);
             let e = to_expr(parse_prefix_expr(p));
             hi = e.span.hi;
-            ex = ast::expr_unary(ast::addr_of, e);
+            ex = ast::expr_addr_of(m, e);
           }
           _ { ret parse_dot_or_call_expr(p); }
         }

trunk/src/rustc/syntax/parse/parser.rs

@@ -877,6 +877,10 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
         word(s.s, ast_util::unop_to_str(op));
         print_op_maybe_parens(s, expr, parse::parser::unop_prec);
       }
+      ast::expr_addr_of(m, expr) {
+        print_mutability(s, m);
+        print_expr(s, expr);
+      }
       ast::expr_lit(lit) { print_literal(s, lit); }
       ast::expr_cast(expr, ty) {
         print_op_maybe_parens(s, expr, parse::parser::as_prec);

trunk/src/rustc/syntax/print/pprust.rs

@@ -331,6 +331,7 @@ fn visit_expr<E>(ex: @expr, e: E, v: vt<E>) {
       expr_unary(_, a) { v.visit_expr(a, e, v); }
       expr_lit(_) { }
       expr_cast(x, t) { v.visit_expr(x, e, v); v.visit_ty(t, e, v); }
+      expr_addr_of(_, x) { v.visit_expr(x, e, v); }
       expr_if(x, b, eo) {
         v.visit_expr(x, e, v);
         v.visit_block(b, e, v);