---

yaml
---
r: 273356
b: refs/heads/beta
c: 00c9420
h: refs/heads/master

Author: nikomatsakis

[refs]

@@ -23,7 +23,7 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
-refs/heads/beta: 1922041e7f69407e7fa40bf90e8ec47d49a97fd2
+refs/heads/beta: 00c942016033abb6dea1015c017bea5517af25a0
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/src/librustc_typeck/check/coercion.rs

@@ -113,7 +113,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
     }
 
     /// Unify two types (using sub or lub) and produce a noop coercion.
-    fn unify(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> CoerceResult<'tcx> {
+    fn unify_and_identity(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> CoerceResult<'tcx> {
         let infcx = self.fcx.infcx();
         infcx.commit_if_ok(|_| {
             let trace = TypeTrace::types(self.origin, false, a, b);
@@ -187,7 +187,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
             }
             _ => {
                 // Otherwise, just use unification rules.
-                self.unify(a, b)
+                self.unify_and_identity(a, b)
             }
         }
     }
@@ -219,7 +219,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
                 try!(coerce_mutbls(mt_a.mutbl, mutbl_b));
                 (r_a, mt_a.mutbl)
             }
-            _ => return self.unify(a, b)
+            _ => return self.unify_and_identity(a, b)
         };
 
         let span = self.origin.span();
@@ -251,7 +251,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
             }
             let ty = self.tcx().mk_ref(r_borrow,
                                         TypeAndMut {ty: inner_ty, mutbl: mutbl_b});
-            match self.unify(ty, b) {
+            match self.unify_and_identity(ty, b) {
                 Err(err) => {
                     if first_error.is_none() {
                         first_error = Some(err);
@@ -404,14 +404,14 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
             match (fn_ty_a.unsafety, fn_ty_b.unsafety) {
                 (hir::Unsafety::Normal, hir::Unsafety::Unsafe) => {
                     let unsafe_a = self.tcx().safe_to_unsafe_fn_ty(fn_ty_a);
-                    return self.unify(unsafe_a, b).map(|(ty, _)| {
+                    return self.unify_and_identity(unsafe_a, b).map(|(ty, _)| {
                         (ty, AdjustUnsafeFnPointer)
                     });
                 }
                 _ => {}
             }
         }
-        self.unify(a, b)
+        self.unify_and_identity(a, b)
     }
 
     fn coerce_from_fn_item(&self,
@@ -430,11 +430,11 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
         match b.sty {
             ty::TyFnPtr(_) => {
                 let a_fn_pointer = self.tcx().mk_ty(ty::TyFnPtr(fn_ty_a));
-                self.unify(a_fn_pointer, b).map(|(ty, _)| {
+                self.unify_and_identity(a_fn_pointer, b).map(|(ty, _)| {
                     (ty, AdjustReifyFnPointer)
                 })
             }
-            _ => self.unify(a, b)
+            _ => self.unify_and_identity(a, b)
         }
     }
 
@@ -451,13 +451,13 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
             ty::TyRef(_, mt) => (true, mt),
             ty::TyRawPtr(mt) => (false, mt),
             _ => {
-                return self.unify(a, b);
+                return self.unify_and_identity(a, b);
             }
         };
 
         // Check that the types which they point at are compatible.
         let a_unsafe = self.tcx().mk_ptr(ty::TypeAndMut{ mutbl: mutbl_b, ty: mt_a.ty });
-        let (ty, noop) = try!(self.unify(a_unsafe, b));
+        let (ty, noop) = try!(self.unify_and_identity(a_unsafe, b));
         try!(coerce_mutbls(mt_a.mutbl, mutbl_b));
 
         // Although references and unsafe ptrs have the same