---

yaml
---
r: 23677
b: refs/heads/master
c: b808cfb
h: refs/heads/master
i:
  23675: e46ad6c
v: v3

Author: pcwalton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 49c9ac175f07505f2113feaca3546d4b8b44dfa8
+refs/heads/master: b808cfbb74a6d9ee01d22a1754f8ddfe3022b1e5
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/try: ffbe0e0e00374358b789b0037bcb3a577cd218be

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

@@ -3151,6 +3151,9 @@ fn trans_arg_expr(cx: block, arg: ty::arg, lldestty: TypeRef, e: @ast::expr,
 // routine consults this table and performs these adaptations.  It returns a
 // new location for the borrowed result as well as a new type for the argument
 // that reflects the borrowed value and not the original.
+//
+// NB: "e" has already been translated; do not translate it again. If you do,
+// this will cause problems with autoderef and method receivers (bug #3357).
 fn adapt_borrowed_value(lv: lval_result,
                         e: @ast::expr,
                         e_ty: ty::t) -> {lv: lval_result,
@@ -3200,7 +3203,7 @@ fn adapt_borrowed_value(lv: lval_result,
 
       _ => {
         // Just take a reference. This is basically like trans_addr_of.
-        let mut {bcx, val, kind} = trans_temp_lval(bcx, e);
+        let mut {bcx, val, kind} = lv;
         let is_immediate = ty::type_is_immediate(e_ty);
         if (kind == lv_temporary && is_immediate) || kind == lv_owned_imm {
             val = do_spill(bcx, val, e_ty);

trunk/src/rustc/middle/typeck/check/method.rs

@@ -183,6 +183,7 @@ struct lookup {
             match ty::deref(self.tcx(), self.self_ty, false) {
               None => break,
               Some(mt) => {
+                debug!("(checking method) ... autodereffing");
                 self.self_ty = mt.ty;
                 self.derefs += 1u;
               }

trunk/src/test/run-pass/autoderef-and-borrow-method-receiver.rs

@@ -0,0 +1,15 @@
+struct Foo {
+    x: int;
+}
+
+impl Foo {
+    fn f(&self) {}
+}
+
+fn g(x: &mut Foo) {
+    x.f();
+}
+
+fn main() {
+}
+