---

yaml
---
r: 160659
b: refs/heads/master
c: 1217b82
h: refs/heads/master
i:
  160657: 4f8942d
  160655: 15f728a
v: v3

Author: pnkfelix

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 91b88c54c2d2af73bcf23d383b4d5d524d222b14
+refs/heads/master: 1217b829e85ec4720ba9a1c43c173d4015eae651
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: c9f6d696420107f82304b992cf623b806995fe18
 refs/heads/try: 225de0d60f8ca8dcc62ab2fd8818ebbda4b58cfe

trunk/src/librustc/middle/mem_categorization.rs

@@ -410,7 +410,28 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
     }
 
     fn pat_ty(&self, pat: &ast::Pat) -> McResult<Ty<'tcx>> {
-        self.typer.node_ty(pat.id)
+        let tcx = self.typer.tcx();
+        let base_ty = self.typer.node_ty(pat.id);
+        // FIXME (Issue #18207): This code detects whether we are
+        // looking at a `ref x`, and if so, figures out what the type
+        // *being borrowed* is.  But ideally we would put in a more
+        // fundamental fix to this conflated use of the node id.
+        let ret_ty = match pat.node {
+            ast::PatIdent(ast::BindByRef(_), _, _) => {
+                // a bind-by-ref means that the base_ty will be the type of the ident itself,
+                // but what we want here is the type of the underlying value being borrowed.
+                // So peel off one-level, turning the &T into T.
+                base_ty.map(|t| {
+                    ty::deref(t, false).unwrap_or_else(|| {
+                        panic!("encountered BindByRef with non &-type");
+                    }).ty
+                })
+            }
+            _ => base_ty,
+        };
+        debug!("pat_ty(pat={}) base_ty={} ret_ty={}",
+               pat.repr(tcx), base_ty.repr(tcx), ret_ty.repr(tcx));
+        ret_ty
     }
 
     pub fn cat_expr(&self, expr: &ast::Expr) -> McResult<cmt<'tcx>> {