librustc: Update AutoObject adjustment in writeback.

src/librustc/middle/typeck/check/regionck.rs

@@ -432,7 +432,7 @@ fn visit_expr(rcx: &mut Rcx, expr: &ast::Expr) {
                 // function check_cast_for_escaping_regions() in kind.rs
                 // explaining how it goes about doing that.
 
-                let source_ty = rcx.fcx.expr_ty(expr);
+                let source_ty = rcx.resolve_node_type(expr.id);
                 constrain_regions_in_type(rcx, trait_region,
                                             infer::RelateObjectBound(expr.span), source_ty);
             }

src/librustc/middle/typeck/check/writeback.rs

@@ -260,7 +260,14 @@ impl<'cx> WritebackCx<'cx> {
                         })
                     }
 
-                    adjustment => adjustment
+                    ty::AutoObject(trait_store, bb, def_id, substs) => {
+                        ty::AutoObject(
+                            self.resolve(&trait_store, reason),
+                            self.resolve(&bb, reason),
+                            def_id,
+                            self.resolve(&substs, reason)
+                        )
+                    }
                 };
                 debug!("Adjustments for node {}: {:?}", id, resolved_adjustment);
                 self.tcx().adjustments.borrow_mut().insert(

src/test/run-pass/issue-11612.rs

@@ -0,0 +1,30 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// #11612
+// We weren't updating the auto adjustments with all the resolved
+// type information after type check.
+
+trait A {}
+
+struct B<'a, T> {
+    f: &'a T
+}
+
+impl<'a, T> A for B<'a, T> {}
+
+fn foo(_: &A) {}
+
+fn bar<G>(b: &B<G>) {
+    foo(b);       // Coercion should work
+    foo(b as &A); // Explicit cast should work as well
+}
+
+fn main() {}