Ignore PhantomData when checking CoerceUnsized implementations

src/librustc_trans/trans/expr.rs

@@ -538,7 +538,12 @@ fn coerce_unsized<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                                               Rvalue::new(ByRef)));
                 } else {
                     // Otherwise, simply copy the data from the source.
-                    assert_eq!(src_ty, target_ty);
+                    let is_phantom = if let &ty::TyStruct(def_id, _) = &src_ty.sty {
+                        Some(def_id) == bcx.tcx().lang_items.phantom_data()
+                    } else {
+                        false
+                    };
+                    assert!(is_phantom || src_ty == target_ty);
                     memcpy_ty(bcx, ll_target, ll_source, src_ty);
                 }
             }

src/librustc_typeck/coherence/mod.rs

@@ -485,12 +485,24 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> {
 
                     let origin = infer::Misc(span);
                     let fields = tcx.lookup_struct_fields(def_id_a);
+
                     let diff_fields = fields.iter().enumerate().filter_map(|(i, f)| {
                         let ty = tcx.lookup_field_type_unsubstituted(def_id_a, f.id);
                         let (a, b) = (ty.subst(tcx, substs_a), ty.subst(tcx, substs_b));
+
+                        // Ignore PhantomData -- doesn't matter
+                        if let &ty::TyStruct(def_id, _) = &ty.sty {
+                            if Some(def_id) == tcx.lang_items.phantom_data() {
+                                return None;
+                            }
+                        }
+
                         if infcx.sub_types(false, origin, b, a).is_ok() {
+                            // Ignore fields that aren't significantly changed
                             None
                         } else {
+                            // Collect up all fields that were significantly changed
+                            // i.e. those that contain T in coerce_unsized T -> U
                             Some((i, a, b))
                         }
                     }).collect::<Vec<_>>();

src/test/compile-fail/issue-26905.rs

@@ -0,0 +1,33 @@
+// Copyright 2015 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.
+
+#![feature(unsize, coerce_unsized)]
+
+// Verfies that non-PhantomData ZSTs still cause coercions to fail.
+// They might have additional semantics that we don't want to bulldoze.
+
+use std::marker::{Unsize, PhantomData};
+use std::ops::CoerceUnsized;
+
+struct NotPhantomData<T>(PhantomData<T>);
+
+struct MyRc<T: ?Sized> {
+    _ptr: *const T,
+    _boo: NotPhantomData<T>, //~ERROR
+}
+
+impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<MyRc<U>> for MyRc<T>{ }
+
+fn main() {
+    let data = [1, 2, 3];
+    let iter = data.iter();
+    let x = MyRc { _ptr: &iter, _boo: NotPhantomData(PhantomData) };
+    let _y: MyRc<Iterator<Item=&u32>> = x;
+}

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

@@ -0,0 +1,30 @@
+// Copyright 2015 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.
+
+#![feature(unsize, coerce_unsized)]
+
+// Verfies that PhantomData is ignored for DST coercions
+
+use std::marker::{Unsize, PhantomData};
+use std::ops::CoerceUnsized;
+
+struct MyRc<T: ?Sized> {
+    _ptr: *const T,
+    _boo: PhantomData<T>,
+}
+
+impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<MyRc<U>> for MyRc<T>{ }
+
+fn main() {
+    let data = [1, 2, 3];
+    let iter = data.iter();
+    let x = MyRc { _ptr: &iter, _boo: PhantomData };
+    let _y: MyRc<Iterator<Item=&u32>> = x;
+}