Handle upcasting to auto traits properly.

Author: Alexander Regueiro

src/librustc_codegen_ssa/base.rs

@@ -161,25 +161,27 @@ pub fn unsized_info<'tcx, 'a, Bx: BuilderMethods<'a, 'tcx>>(
             // Trait upcast
 
             let source_ptr = old_info.expect("unsized_info: missing old info for trait upcast");
-            let target_trait_ref = target_data.principal()
-                .expect("target trait object of upcast does not have principal");
-
-            let trait_ref = target_trait_ref.with_self_ty(tcx, source);
-            let vtable = tcx.codegen_fulfill_obligation((ty::ParamEnv::reveal_all(), trait_ref));
-            let offset = match vtable {
-                Vtable::VtableObject(ref data) => data.vtable_base,
-                // HACK(alexreg): dubious solution to ICE in `manual-self-impl-for-unsafe-obj` test.
-                Vtable::VtableImpl(_) => 0,
-                _ => bug!("unsized_info: unexpected vtable kind {:?}", vtable),
-            };
+            let target_ptr = if let Some(target_trait_ref) = target_data.principal() {
+                let trait_ref = target_trait_ref.with_self_ty(tcx, source);
+                let vtable = tcx.codegen_fulfill_obligation((ty::ParamEnv::reveal_all(), trait_ref));
+                let offset = match vtable {
+                    Vtable::VtableObject(ref data) => data.vtable_base,
+                    // HACK(alexreg): slightly dubious solution to ICE in
+                    // `manual-self-impl-for-unsafe-obj` test.
+                    Vtable::VtableImpl(_) => 0,
+                    _ => bug!("unsized_info: unexpected vtable kind {:?}", vtable),
+                };
 
-            let vtable_layout = bx.cx().layout_of(tcx.mk_mut_ptr(source));
-            let source_ptr = bx.pointercast(
-                source_ptr,
-                bx.cx().scalar_pair_element_backend_type(vtable_layout, 1, true),
-            );
+                let vtable_layout = bx.cx().layout_of(tcx.mk_mut_ptr(source));
+                let source_ptr = bx.pointercast(
+                    source_ptr,
+                    bx.cx().scalar_pair_element_backend_type(vtable_layout, 1, true),
+                );
 
-            let target_ptr = bx.struct_gep(source_ptr, offset as u64);
+                bx.struct_gep(source_ptr, offset as u64)
+            } else {
+                source_ptr
+            };
 
             let vtable_layout = bx.cx().layout_of(tcx.mk_mut_ptr(target));
             bx.pointercast(

src/librustc_trait_selection/traits/select.rs

@@ -1864,9 +1864,15 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 //
                 // We always upcast when we can because of reason 3 (region bounds).
 
-                // All of a's auto traits need to be in b's auto traits.
-                data_b.auto_traits()
-                  .all(|b| data_a.auto_traits().any(|a| a == b))
+                if self.tcx().features().trait_upcasting {
+                    true
+                } else {
+                    // Just allow upcast kinds 2 and 3 from above.
+                    data_a.principal_def_id() == data_b.principal_def_id() &&
+                        data_b.auto_traits()
+                            // All of a's auto traits need to be in b's auto traits.
+                            .all(|b| data_a.auto_traits().any(|a| a == b))
+                }
             }
 
             // `T` -> `Trait`
@@ -2948,12 +2954,20 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     let iter = data_a
                         .principal()
                         .map(ty::ExistentialPredicate::Trait)
-                        .into_iter()
-                        .chain(data_a.projection_bounds().map(ty::ExistentialPredicate::Projection))
-                        .chain(data_b.auto_traits().map(ty::ExistentialPredicate::AutoTrait));
+                        .into_iter().chain(
+                            data_a
+                                .projection_bounds()
+                                .map(|x| ty::ExistentialPredicate::Projection(x)),
+                        )
+                        .chain(
+                            data_b
+                                .auto_traits()
+                                .map(ty::ExistentialPredicate::AutoTrait),
+                        );
                     tcx.mk_existential_predicates(iter)
                 });
-                let source_ty = tcx.mk_dynamic(existential_predicates, region_b);
+                let source_with_target_auto_traits =
+                    tcx.mk_dynamic(existential_predicates, region_b);
 
                 if tcx.features().trait_upcasting {
                     // Register obligations for `dyn TraitA1 [TraitA2...]: TraitB1 [TraitB2...]`.
@@ -2974,7 +2988,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                                 }
                             })
                             .map(|predicate|
-                                predicate_to_obligation(predicate.with_self_ty(tcx, source_ty))
+                                predicate_to_obligation(predicate.with_self_ty(tcx, source))
                             ),
                     );
                 } else {
@@ -2996,7 +3010,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     // with what our behavior should be there. -nikomatsakis
                     let InferOk { obligations, .. } = self.infcx
                         .at(&obligation.cause, obligation.param_env)
-                        .eq(target, source_ty) // FIXME: see above.
+                        .eq(target, source_with_target_auto_traits) // FIXME: see above.
                         .map_err(|_| Unimplemented)?;
                     nested.extend(obligations);
                 }