Validate the special layout restriction on DynMetadata

Author: scottmcm

compiler/rustc_const_eval/src/transform/validate.rs

@@ -685,6 +685,15 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
 check_equal(self, location,*f_ty);
 }
  ty::Adt(adt_def, args) => {
+// see <https://github.com/rust-lang/rust/blob/7601adcc764d42c9f2984082b49948af652df986/compiler/rustc_middle/src/ty/layout.rs#L861-L864>
+ifSome(adt_def.did()) == self.tcx.lang_items().dyn_metadata(){
+self.fail(
+ location,
+format!("You can't project to field {f:?} of `DynMetadata` because \
+ layout is weird and thinks it doesn't have fields."),
+);
+}
+
 let var = parent_ty.variant_index.unwrap_or(FIRST_VARIANT);
 letSome(field) = adt_def.variant(var).fields.get(f)else{
 fail_out_of_bounds(self, location);

library/core/src/ptr/metadata.rs

@@ -178,8 +178,8 @@ impl<T: ?Sized> Clone for PtrComponents<T> {
 /// compare equal (since identical vtables can be deduplicated within a codegen unit).
 #[lang = "dyn_metadata"]
 pubstructDynMetadata<Dyn: ?Sized>{
-vtable_ptr:&'staticVTable,
-phantom:crate::marker::PhantomData<Dyn>,
+_vtable_ptr:&'staticVTable,
+_phantom:crate::marker::PhantomData<Dyn>,
 }
 
 extern"C"{
@@ -191,6 +191,17 @@ extern "C" {
 }
 
 impl<Dyn: ?Sized>DynMetadata<Dyn>{
+/// One of the things that rustc_middle does with this being a lang item is
+/// give it `FieldsShape::Primitive`, which means that as far as codegen can
+/// tell, it *is* a reference, and thus doesn't have any fields.
+/// That means we can't use field access, and have to transmute it instead.
+#[inline]
+fnvtable_ptr(self) -> *constVTable{
+// SAFETY: this layout assumption is hard-coded into the compiler.
+// If it's somehow not a size match, the transmute will error.
+unsafe{crate::mem::transmute::<Self,&'staticVTable>(self)}
+}
+
 /// Returns the size of the type associated with this vtable.
 #[inline]
 pubfnsize_of(self) -> usize{
@@ -199,7 +210,7 @@ impl<Dyn: ?Sized> DynMetadata<Dyn> {
 // `Send` part!
 // SAFETY: DynMetadata always contains a valid vtable pointer
 returnunsafe{
-crate::intrinsics::vtable_size(self.vtable_ptras*constVTableas*const())
+crate::intrinsics::vtable_size(self.vtable_ptr()as*const())
 };
 }
 
@@ -208,7 +219,7 @@ impl<Dyn: ?Sized> DynMetadata<Dyn> {
 pubfnalign_of(self) -> usize{
 // SAFETY: DynMetadata always contains a valid vtable pointer
 returnunsafe{
-crate::intrinsics::vtable_align(self.vtable_ptras*constVTableas*const())
+crate::intrinsics::vtable_align(self.vtable_ptr()as*const())
 };
 }
 
@@ -226,7 +237,7 @@ unsafe impl<Dyn: ?Sized> Sync for DynMetadata<Dyn> {}
 
 impl<Dyn: ?Sized> fmt::DebugforDynMetadata<Dyn>{
 fnfmt(&self,f:&mut fmt::Formatter<'_>) -> fmt::Result{
- f.debug_tuple("DynMetadata").field(&(self.vtable_ptras*constVTable)).finish()
+ f.debug_tuple("DynMetadata").field(&self.vtable_ptr()).finish()
 }
 }
 
@@ -248,15 +259,15 @@ impl<Dyn: ?Sized> Eq for DynMetadata<Dyn> {}
 impl<Dyn: ?Sized>PartialEqforDynMetadata<Dyn>{
 #[inline]
 fneq(&self,other:&Self) -> bool{
-crate::ptr::eq::<VTable>(self.vtable_ptr, other.vtable_ptr)
+crate::ptr::eq::<VTable>(self.vtable_ptr(), other.vtable_ptr())
 }
 }
 
 impl<Dyn: ?Sized>OrdforDynMetadata<Dyn>{
 #[inline]
 #[allow(ambiguous_wide_pointer_comparisons)]
 fncmp(&self,other:&Self) -> crate::cmp::Ordering{
-(self.vtable_ptras*constVTable).cmp(&(other.vtable_ptras*constVTable))
+<*constVTable>::cmp(&self.vtable_ptr(),&other.vtable_ptr())
 }
 }
 
@@ -270,6 +281,6 @@ impl<Dyn: ?Sized> PartialOrd for DynMetadata<Dyn> {
 impl<Dyn: ?Sized>HashforDynMetadata<Dyn>{
 #[inline]
 fnhash<H:Hasher>(&self,hasher:&mutH){
-crate::ptr::hash::<VTable,_>(self.vtable_ptr, hasher)
+crate::ptr::hash::<VTable,_>(self.vtable_ptr(), hasher)
 }
 }