Drive unsizing coercions using just the target pointer type.

Author: eddyb

src/librustc/middle/astencode.rs

@@ -844,8 +844,6 @@ trait rbml_writer_helpers<'tcx> {
     fn emit_autoref<'a>(&mut self, autoref: &ty::AutoRef<'tcx>);
     fn emit_auto_deref_ref<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>,
                                auto_deref_ref: &ty::AutoDerefRef<'tcx>);
-    fn emit_auto_unsize<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>,
-                            unsize: &ty::AutoUnsize<'tcx>);
 }
 
 impl<'a, 'tcx> rbml_writer_helpers<'tcx> for Encoder<'a> {
@@ -1067,29 +1065,14 @@ impl<'a, 'tcx> rbml_writer_helpers<'tcx> for Encoder<'a> {
                 this.emit_option(|this| {
                     match auto_deref_ref.unsize {
                         None => this.emit_option_none(),
-                        Some(ref uk) => this.emit_option_some(|this| Ok(this.emit_auto_unsize(ecx, uk))),
+                        Some(target) => this.emit_option_some(|this| {
+                            Ok(this.emit_ty(ecx, target))
+                        })
                     }
                 })
             })
         });
     }
-
-    fn emit_auto_unsize<'b>(&mut self, ecx: &e::EncodeContext<'b, 'tcx>,
-                            unsize: &ty::AutoUnsize<'tcx>) {
-        use serialize::Encoder;
-
-        self.emit_struct("AutoUnsize", 3, |this| {
-            this.emit_struct_field("leaf_source", 0, |this| {
-                Ok(this.emit_ty(ecx, unsize.leaf_source))
-            });
-            this.emit_struct_field("leaf_target", 1, |this| {
-                Ok(this.emit_ty(ecx, unsize.leaf_target))
-            });
-            this.emit_struct_field("target", 2, |this| {
-                Ok(this.emit_ty(ecx, unsize.target))
-            })
-        });
-    }
 }
 
 trait write_tag_and_id {
@@ -1304,8 +1287,6 @@ trait rbml_decoder_decoder_helpers<'tcx> {
                                    -> ty::AutoDerefRef<'tcx>;
     fn read_autoref<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
                             -> ty::AutoRef<'tcx>;
-    fn read_auto_unsize<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
-                                -> ty::AutoUnsize<'tcx>;
     fn convert_def_id(&mut self,
                       dcx: &DecodeContext,
                       source: DefIdSource,
@@ -1614,7 +1595,7 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
                 unsize: this.read_struct_field("unsize", 2, |this| {
                     this.read_option(|this, b| {
                         if b {
-                            Ok(Some(this.read_auto_unsize(dcx)))
+                            Ok(Some(this.read_ty(dcx)))
                         } else {
                             Ok(None)
                         }
@@ -1650,23 +1631,6 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
         }).unwrap()
     }
 
-    fn read_auto_unsize<'b, 'c>(&mut self, dcx: &DecodeContext<'b, 'c, 'tcx>)
-                                -> ty::AutoUnsize<'tcx> {
-        self.read_struct("AutoUnsize", 3, |this| {
-            Ok(ty::AutoUnsize {
-                leaf_source: this.read_struct_field("leaf_source", 0, |this| {
-                    Ok(this.read_ty(dcx))
-                }).unwrap(),
-                leaf_target: this.read_struct_field("leaf_target", 1, |this| {
-                    Ok(this.read_ty(dcx))
-                }).unwrap(),
-                target: this.read_struct_field("target", 2, |this| {
-                    Ok(this.read_ty(dcx))
-                }).unwrap()
-            })
-        }).unwrap()
-    }
-
     fn read_closure_kind<'b, 'c>(&mut self, _dcx: &DecodeContext<'b, 'c, 'tcx>)
                                  -> ty::ClosureKind
     {

src/librustc/middle/ty.rs

@@ -284,17 +284,6 @@ pub enum AutoAdjustment<'tcx> {
     AdjustDerefRef(AutoDerefRef<'tcx>),
 }
 
-// In the case of `&Struct<[T; N]>` -> `&Struct<[T]>`, the types are:
-// * leaf_source: `[T; N]`
-// * leaf_target: `[T]`
-// * target: `&Struct<[T]>`
-#[derive(Copy, Clone, Debug)]
-pub struct AutoUnsize<'tcx> {
-    pub leaf_source: Ty<'tcx>,
-    pub leaf_target: Ty<'tcx>,
-    pub target: Ty<'tcx>
-}
-
 #[derive(Copy, Clone, Debug)]
 pub struct AutoDerefRef<'tcx> {
     /// Apply a number of dereferences, producing an lvalue.
@@ -304,7 +293,8 @@ pub struct AutoDerefRef<'tcx> {
     pub autoref: Option<AutoRef<'tcx>>,
 
     /// Unsize a pointer/reference value, e.g. &[T; n] to &[T].
-    pub unsize: Option<AutoUnsize<'tcx>>,
+    /// The stored type is the target pointer type.
+    pub unsize: Option<Ty<'tcx>>,
 }
 
 #[derive(Copy, Clone, PartialEq, Debug)]
@@ -4490,8 +4480,8 @@ pub fn adjust_ty<'tcx, F>(cx: &ctxt<'tcx>,
                         }
                     }
 
-                    if let Some(ref unsize) = adj.unsize {
-                        unsize.target
+                    if let Some(target) = adj.unsize {
+                        target
                     } else {
                         adjust_ty_for_autoref(cx, adjusted_ty, adj.autoref)
                     }
@@ -5557,6 +5547,47 @@ pub fn tup_fields<'tcx>(v: &[Ty<'tcx>]) -> Vec<field<'tcx>> {
     }).collect()
 }
 
+/// Returns the deeply last field of nested structures, or the same type,
+/// if not a structure at all. Corresponds to the only possible unsized
+/// field, and its type can be used to determine unsizing strategy.
+pub fn struct_tail<'tcx>(cx: &ctxt<'tcx>, mut ty: Ty<'tcx>) -> Ty<'tcx> {
+    while let ty_struct(def_id, substs) = ty.sty {
+        match struct_fields(cx, def_id, substs).last() {
+            Some(f) => ty = f.mt.ty,
+            None => break
+        }
+    }
+    ty
+}
+
+/// Same as applying struct_tail on `source` and `target`, but only
+/// keeps going as long as the two types are instances of the same
+/// structure definitions.
+/// For `(Foo<Foo<T>>, Foo<Trait>)`, the result will be `(Foo<T>, Trait)`,
+/// whereas struct_tail produces `T`, and `Trait`, respectively.
+pub fn struct_lockstep_tails<'tcx>(cx: &ctxt<'tcx>,
+                                   source: Ty<'tcx>,
+                                   target: Ty<'tcx>)
+                                   -> (Ty<'tcx>, Ty<'tcx>) {
+    let (mut a, mut b) = (source, target);
+    while let (&ty_struct(a_did, a_substs), &ty_struct(b_did, b_substs)) = (&a.sty, &b.sty) {
+        if a_did != b_did {
+            continue;
+        }
+        if let Some(a_f) = struct_fields(cx, a_did, a_substs).last() {
+            if let Some(b_f) = struct_fields(cx, b_did, b_substs).last() {
+                a = a_f.mt.ty;
+                b = b_f.mt.ty;
+            } else {
+                break;
+            }
+        } else {
+            break;
+        }
+    }
+    (a, b)
+}
+
 #[derive(Copy, Clone)]
 pub struct ClosureUpvar<'tcx> {
     pub def: def::Def,
@@ -6699,15 +6730,6 @@ impl<'tcx> Repr<'tcx> for AutoAdjustment<'tcx> {
     }
 }
 
-impl<'tcx> Repr<'tcx> for AutoUnsize<'tcx> {
-    fn repr(&self, tcx: &ctxt<'tcx>) -> String {
-        format!("unsize({} => {}) => {}",
-                self.leaf_source.repr(tcx),
-                self.leaf_target.repr(tcx),
-                self.target.repr(tcx))
-    }
-}
-
 impl<'tcx> Repr<'tcx> for AutoDerefRef<'tcx> {
     fn repr(&self, tcx: &ctxt<'tcx>) -> String {
         format!("AutoDerefRef({}, unsize={}, {})",
@@ -7138,14 +7160,6 @@ impl<'tcx> HasProjectionTypes for BareFnTy<'tcx> {
     }
 }
 
-impl<'tcx> HasProjectionTypes for AutoUnsize<'tcx> {
-    fn has_projection_types(&self) -> bool {
-        self.leaf_source.has_projection_types() ||
-        self.leaf_target.has_projection_types() ||
-        self.target.has_projection_types()
-    }
-}
-
 pub trait ReferencesError {
     fn references_error(&self) -> bool;
 }

src/librustc/middle/ty_fold.rs

@@ -467,16 +467,6 @@ impl<'tcx> TypeFoldable<'tcx> for ty::InstantiatedPredicates<'tcx> {
     }
 }
 
-impl<'tcx> TypeFoldable<'tcx> for ty::AutoUnsize<'tcx> {
-    fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> ty::AutoUnsize<'tcx> {
-        ty::AutoUnsize {
-            leaf_source: self.leaf_source.fold_with(folder),
-            leaf_target: self.leaf_target.fold_with(folder),
-            target: self.target.fold_with(folder)
-        }
-    }
-}
-
 impl<'tcx,O> TypeFoldable<'tcx> for traits::Obligation<'tcx,O>
     where O : TypeFoldable<'tcx>
 {

src/librustc_trans/trans/common.rs

@@ -146,33 +146,6 @@ pub fn type_is_fat_ptr<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool {
     }
 }
 
-// Return the smallest part of `ty` which is unsized. Fails if `ty` is sized.
-// 'Smallest' here means component of the static representation of the type; not
-// the size of an object at runtime.
-pub fn unsized_part_of_type<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
-    match ty.sty {
-        ty::ty_str | ty::ty_trait(..) | ty::ty_vec(..) => ty,
-        ty::ty_struct(def_id, substs) => {
-            let unsized_fields: Vec<_> =
-                ty::struct_fields(cx, def_id, substs)
-                .iter()
-                .map(|f| f.mt.ty)
-                .filter(|ty| !type_is_sized(cx, *ty))
-                .collect();
-
-            // Exactly one of the fields must be unsized.
-            assert!(unsized_fields.len() == 1);
-
-            unsized_part_of_type(cx, unsized_fields[0])
-        }
-        _ => {
-            assert!(type_is_sized(cx, ty),
-                    "unsized_part_of_type failed even though ty is unsized");
-            panic!("called unsized_part_of_type with sized ty");
-        }
-    }
-}
-
 // Some things don't need cleanups during unwinding because the
 // task can free them all at once later. Currently only things
 // that only contain scalars and shared boxes can avoid unwind

src/librustc_trans/trans/consts.rs

@@ -277,10 +277,10 @@ pub fn const_expr<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                 ety_adjusted = dt;
             }
 
-            if let Some(ref unsize) = adj.unsize {
-                let unsize = monomorphize::apply_param_substs(cx.tcx(),
+            if let Some(target) = adj.unsize {
+                let target = monomorphize::apply_param_substs(cx.tcx(),
                                                               param_substs,
-                                                              unsize);
+                                                              &target);
 
                 let pointee_ty = ty::deref(ty, true)
                     .expect("consts: unsizing got non-pointer type").ty;
@@ -297,11 +297,12 @@ pub fn const_expr<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                     (llconst, None)
                 };
 
-                let unsized_ty = ty::deref(unsize.target, true)
+                let unsized_ty = ty::deref(target, true)
                     .expect("consts: unsizing got non-pointer target type").ty;
                 let ptr_ty = type_of::in_memory_type_of(cx, unsized_ty).ptr_to();
                 let base = ptrcast(base, ptr_ty);
-                let info = expr::unsized_info(cx, &unsize, old_info, param_substs);
+                let info = expr::unsized_info(cx, pointee_ty, unsized_ty,
+                                              old_info, param_substs);
 
                 let prev_const = cx.const_unsized().borrow_mut()
                                    .insert(base, llconst);

src/librustc_trans/trans/expr.rs

@@ -292,16 +292,17 @@ pub fn copy_fat_ptr(bcx: Block, src_ptr: ValueRef, dst_ptr: ValueRef) {
 /// Retrieve the information we are losing (making dynamic) in an unsizing
 /// adjustment.
 ///
-/// The `unadjusted_val` argument is a bit funny. It is intended
-/// for use in an upcast, where the new vtable for an object will
-/// be drived from the old one. Hence it is a pointer to the fat
-/// pointer.
+/// The `old_info` argument is a bit funny. It is intended for use
+/// in an upcast, where the new vtable for an object will be drived
+/// from the old one.
 pub fn unsized_info<'ccx, 'tcx>(ccx: &CrateContext<'ccx, 'tcx>,
-                                unsize: &ty::AutoUnsize<'tcx>,
+                                source: Ty<'tcx>,
+                                target: Ty<'tcx>,
                                 old_info: Option<ValueRef>,
                                 param_substs: &'tcx subst::Substs<'tcx>)
                                 -> ValueRef {
-    match (&unsize.leaf_source.sty, &unsize.leaf_target.sty) {
+    let (source, target) = ty::struct_lockstep_tails(ccx.tcx(), source, target);
+    match (&source.sty, &target.sty) {
         (&ty::ty_vec(_, Some(len)), &ty::ty_vec(_, None)) => C_uint(ccx, len),
         (&ty::ty_trait(_), &ty::ty_trait(_)) => {
             // For now, upcasts are limited to changes in marker
@@ -311,15 +312,16 @@ pub fn unsized_info<'ccx, 'tcx>(ccx: &CrateContext<'ccx, 'tcx>,
         }
         (_, &ty::ty_trait(box ty::TyTrait { ref principal, .. })) => {
             // Note that we preserve binding levels here:
-            let substs = principal.0.substs.with_self_ty(unsize.leaf_source).erase_regions();
+            let substs = principal.0.substs.with_self_ty(source).erase_regions();
             let substs = ccx.tcx().mk_substs(substs);
             let trait_ref = ty::Binder(Rc::new(ty::TraitRef { def_id: principal.def_id(),
                                                                substs: substs }));
             consts::ptrcast(meth::get_vtable(ccx, trait_ref, param_substs),
                             Type::vtable_ptr(ccx))
         }
-        _ => ccx.sess().bug(&format!("unsized_info: invalid unsizing {}",
-                                     unsize.repr(ccx.tcx())))
+        _ => ccx.sess().bug(&format!("unsized_info: invalid unsizing {} -> {}",
+                                     source.repr(ccx.tcx()),
+                                     target.repr(ccx.tcx())))
     }
 }
 
@@ -386,8 +388,9 @@ fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                 datum = unpack_datum!(bcx, apply_autoref(bcx, expr, datum));
             }
 
-            if let Some(ref unsize) = adj.unsize {
-                datum = unpack_datum!(bcx, unsize_pointer(bcx, datum, unsize));
+            if let Some(target) = adj.unsize {
+                datum = unpack_datum!(bcx, unsize_pointer(bcx, datum,
+                                                          bcx.monomorphize(&target)));
             }
         }
     }
@@ -412,11 +415,10 @@ fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
 
     fn unsize_pointer<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                                   datum: Datum<'tcx, Expr>,
-                                  unsize: &ty::AutoUnsize<'tcx>)
+                                  target: Ty<'tcx>)
                                   -> DatumBlock<'blk, 'tcx, Expr> {
         let mut bcx = bcx;
-        let unsize = bcx.monomorphize(unsize);
-        let unsized_ty = ty::deref(unsize.target, true)
+        let unsized_ty = ty::deref(target, true)
             .expect("expr::unsize got non-pointer target type").ty;
         debug!("unsize_lvalue(unsized_ty={})", unsized_ty.repr(bcx.tcx()));
 
@@ -442,20 +444,21 @@ fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             (datum.val, None)
         };
 
-        let info = unsized_info(bcx.ccx(), &unsize, old_info, bcx.fcx.param_substs);
+        let info = unsized_info(bcx.ccx(), pointee_ty, unsized_ty,
+                                old_info, bcx.fcx.param_substs);
 
         // Compute the base pointer. This doesn't change the pointer value,
         // but merely its type.
         let ptr_ty = type_of::in_memory_type_of(bcx.ccx(), unsized_ty).ptr_to();
         let base = PointerCast(bcx, base, ptr_ty);
 
-        let llty = type_of::type_of(bcx.ccx(), unsize.target);
+        let llty = type_of::type_of(bcx.ccx(), target);
         // HACK(eddyb) get around issues with lifetime intrinsics.
         let scratch = alloca_no_lifetime(bcx, llty, "__fat_ptr");
         Store(bcx, base, get_dataptr(bcx, scratch));
         Store(bcx, info, get_len(bcx, scratch));
 
-        DatumBlock::new(bcx, Datum::new(scratch, unsize.target,
+        DatumBlock::new(bcx, Datum::new(scratch, target,
                                         RvalueExpr(Rvalue::new(ByRef))))
     }
 }

src/librustc_trans/trans/type_of.rs

@@ -358,14 +358,14 @@ pub fn in_memory_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) ->
                   cx.tn().find_type("str_slice").unwrap()
               } else {
                   let ptr_ty = in_memory_type_of(cx, ty).ptr_to();
-                  let unsized_part = unsized_part_of_type(cx.tcx(), ty);
+                  let unsized_part = ty::struct_tail(cx.tcx(), ty);
                   let info_ty = match unsized_part.sty {
                       ty::ty_str | ty::ty_vec(..) => {
                           Type::uint_from_ty(cx, ast::TyUs(false))
                       }
                       ty::ty_trait(_) => Type::vtable_ptr(cx),
                       _ => panic!("Unexpected type returned from \
-                                   unsized_part_of_type: {} for ty={}",
+                                   struct_tail: {} for ty={}",
                                   unsized_part.repr(cx.tcx()), ty.repr(cx.tcx()))
                   };
                   Type::struct_(cx, &[ptr_ty, info_ty], false)