Initial implementation of dyn*

compiler/rustc_ast/src/ast.rs

@@ -2072,6 +2072,7 @@ impl TyKind {
 #[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
 pub enum TraitObjectSyntax {
  Dyn,
+ DynStar,
  None,
 }
 

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -573,6 +573,9 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
  ast::TyKind::Never => {
  gate_feature_post!(&self, never_type, ty.span, "the `!` type is experimental");
  }
+ ast::TyKind::TraitObject(_, ast::TraitObjectSyntax::DynStar, ..) => {
+ gate_feature_post!(&self, dyn_star, ty.span, "dyn* trait objects are unstable");
+ }
  _ => {}
  }
  visit::walk_ty(self, ty)

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -30,8 +30,9 @@ use rustc_middle::ty::cast::CastTy;
 use rustc_middle::ty::subst::{GenericArgKind, SubstsRef, UserSubsts};
 use rustc_middle::ty::visit::TypeVisitable;
 use rustc_middle::ty::{
- self, CanonicalUserTypeAnnotation, CanonicalUserTypeAnnotations, OpaqueHiddenType,
- OpaqueTypeKey, RegionVid, ToPredicate, Ty, TyCtxt, UserType, UserTypeAnnotationIndex,
+ self, Binder, CanonicalUserTypeAnnotation, CanonicalUserTypeAnnotations, Dynamic,
+ OpaqueHiddenType, OpaqueTypeKey, RegionVid, ToPredicate, Ty, TyCtxt, UserType,
+ UserTypeAnnotationIndex,
 };
 use rustc_span::def_id::CRATE_DEF_ID;
 use rustc_span::{Span, DUMMY_SP};
@@ -2009,6 +2010,36 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
  );
  }
 
+ CastKind::DynStar => {
+ // get the constraints from the target type (`dyn* Clone`)
+ //
+ // apply them to prove that the source type `Foo` implements `Clone` etc
+ let (existential_predicates, region) = match ty.kind() {
+ Dynamic(predicates, region, ty::DynStar) => (predicates, region),
+ _ => panic!("Invalid dyn* cast_ty"),
+ };
+
+ let self_ty = op.ty(body, tcx);
+
+ self.prove_predicates(
+ existential_predicates
+ .iter()
+ .map(|predicate| predicate.with_self_ty(tcx, self_ty)),
+ location.to_locations(),
+ ConstraintCategory::Cast,
+ );
+
+ let outlives_predicate =
+ tcx.mk_predicate(Binder::dummy(ty::PredicateKind::TypeOutlives(
+ ty::OutlivesPredicate(self_ty, *region),
+ )));
+ self.prove_predicate(
+ outlives_predicate,
+ location.to_locations(),
+ ConstraintCategory::Cast,
+ );
+ }
+
  CastKind::Pointer(PointerCast::MutToConstPointer) => {
  let ty::RawPtr(ty::TypeAndMut {
  ty: ty_from,

compiler/rustc_codegen_cranelift/src/base.rs

@@ -701,6 +701,10 @@ fn codegen_stmt<'tcx>(
  let operand = codegen_operand(fx, operand);
  operand.unsize_value(fx, lval);
  }
+ Rvalue::Cast(CastKind::DynStar, _, _) => {
+ // FIXME(dyn-star)
+ unimplemented!()
+ }
  Rvalue::Discriminant(place) => {
  let place = codegen_place(fx, place);
  let value = place.to_cvalue(fx);

compiler/rustc_codegen_cranelift/src/value_and_place.rs

@@ -815,7 +815,8 @@ pub(crate) fn assert_assignable<'tcx>(
  );
  // fn(&T) -> for<'l> fn(&'l T) is allowed
  }
- (&ty::Dynamic(from_traits, _), &ty::Dynamic(to_traits, _)) => {
+ (&ty::Dynamic(from_traits, _, _from_kind), &ty::Dynamic(to_traits, _, _to_kind)) => {
+ // FIXME(dyn-star): Do the right thing with DynKinds
  for (from, to) in from_traits.iter().zip(to_traits) {
  let from =
  fx.tcx.normalize_erasing_late_bound_regions(ParamEnv::reveal_all(), from);

compiler/rustc_codegen_ssa/src/meth.rs

@@ -69,7 +69,7 @@ impl<'a, 'tcx> VirtualIndex {
 fn expect_dyn_trait_in_self<'tcx>(ty: Ty<'tcx>) -> ty::PolyExistentialTraitRef<'tcx> {
  for arg in ty.peel_refs().walk() {
  if let GenericArgKind::Type(ty) = arg.unpack() {
- if let ty::Dynamic(data, _) = ty.kind() {
+ if let ty::Dynamic(data, _, _) = ty.kind() {
  return data.principal().expect("expected principal trait object");
  }
  }
@@ -86,15 +86,14 @@ fn expect_dyn_trait_in_self<'tcx>(ty: Ty<'tcx>) -> ty::PolyExistentialTraitRef<'
 /// The `trait_ref` encodes the erased self type. Hence if we are
 /// making an object `Foo<dyn Trait>` from a value of type `Foo<T>`, then
 /// `trait_ref` would map `T: Trait`.
+#[instrument(level = "debug", skip(cx))]
 pub fn get_vtable<'tcx, Cx: CodegenMethods<'tcx>>(
  cx: &Cx,
  ty: Ty<'tcx>,
  trait_ref: Option<ty::PolyExistentialTraitRef<'tcx>>,
 ) -> Cx::Value {
  let tcx = cx.tcx();
 
- debug!("get_vtable(ty={:?}, trait_ref={:?})", ty, trait_ref);
-
  // Check the cache.
  if let Some(&val) = cx.vtables().borrow().get(&(ty, trait_ref)) {
  return val;

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -367,6 +367,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
  bx.ret(llval);
  }
 
+ #[tracing::instrument(level = "trace", skip(self, helper, bx))]
  fn codegen_drop_terminator(
  &mut self,
  helper: TerminatorCodegenHelper<'tcx>,
@@ -397,14 +398,75 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
  let (drop_fn, fn_abi) = match ty.kind() {
  // FIXME(eddyb) perhaps move some of this logic into
  // `Instance::resolve_drop_in_place`?
- ty::Dynamic(..) => {
+ ty::Dynamic(_, _, ty::Dyn) => {
+ // IN THIS ARM, WE HAVE:
+ // ty = *mut (dyn Trait)
+ // which is: exists<T> ( *mut T, Vtable<T: Trait> )
+ // args[0] args[1]
+ //
+ // args = ( Data, Vtable )
+ // |
+ // v
+ // /-------\
+ // | ... |
+ // \-------/
+ //
  let virtual_drop = Instance {
  def: ty::InstanceDef::Virtual(drop_fn.def_id(), 0),
  substs: drop_fn.substs,
  };
+ debug!("ty = {:?}", ty);
+ debug!("drop_fn = {:?}", drop_fn);
+ debug!("args = {:?}", args);
  let fn_abi = bx.fn_abi_of_instance(virtual_drop, ty::List::empty());
  let vtable = args[1];
+ // Truncate vtable off of args list
+ args = &args[..1];
+ (
+ meth::VirtualIndex::from_index(ty::COMMON_VTABLE_ENTRIES_DROPINPLACE)
+ .get_fn(&mut bx, vtable, ty, &fn_abi),
+ fn_abi,
+ )
+ }
+ ty::Dynamic(_, _, ty::DynStar) => {
+ // IN THIS ARM, WE HAVE:
+ // ty = *mut (dyn* Trait)
+ // which is: *mut exists<T: sizeof(T) == sizeof(usize)> (T, Vtable<T: Trait>)
+ //
+ // args = [ * ]
+ // |
+ // v
+ // ( Data, Vtable )
+ // |
+ // v
+ // /-------\
+ // | ... |
+ // \-------/
+ //
+ //
+ // WE CAN CONVERT THIS INTO THE ABOVE LOGIC BY DOING
+ //
+ // data = &(*args[0]).0 // gives a pointer to Data above (really the same pointer)
+ // vtable = (*args[0]).1 // loads the vtable out
+ // (data, vtable) // an equivalent Rust `*mut dyn Trait`
+ //
+ // SO THEN WE CAN USE THE ABOVE CODE.
+ let virtual_drop = Instance {
+ def: ty::InstanceDef::Virtual(drop_fn.def_id(), 0),
+ substs: drop_fn.substs,
+ };
+ debug!("ty = {:?}", ty);
+ debug!("drop_fn = {:?}", drop_fn);
+ debug!("args = {:?}", args);
+ let fn_abi = bx.fn_abi_of_instance(virtual_drop, ty::List::empty());
+ let data = args[0];
+ let data_ty = bx.cx().backend_type(place.layout);
+ let vtable_ptr =
+ bx.gep(data_ty, data, &[bx.cx().const_i32(0), bx.cx().const_i32(1)]);
+ let vtable = bx.load(bx.type_i8p(), vtable_ptr, abi::Align::ONE);
+ // Truncate vtable off of args list
  args = &args[..1];
+ debug!("args' = {:?}", args);
  (
  meth::VirtualIndex::from_index(ty::COMMON_VTABLE_ENTRIES_DROPINPLACE)
  .get_fn(&mut bx, vtable, ty, &fn_abi),
@@ -845,7 +907,30 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
  llargs.push(data_ptr);
  continue;
  }
- _ => span_bug!(span, "can't codegen a virtual call on {:?}", op),
+ Immediate(_) => {
+ let ty::Ref(_, ty, _) = op.layout.ty.kind() else {
+ span_bug!(span, "can't codegen a virtual call on {:#?}", op);
+ };
+ if !ty.is_dyn_star() {
+ span_bug!(span, "can't codegen a virtual call on {:#?}", op);
+ }
+ // FIXME(dyn-star): Make sure this is done on a &dyn* receiver
+ let place = op.deref(bx.cx());
+ let data_ptr = place.project_field(&mut bx, 0);
+ let meta_ptr = place.project_field(&mut bx, 1);
+ let meta = bx.load_operand(meta_ptr);
+ llfn = Some(meth::VirtualIndex::from_index(idx).get_fn(
+ &mut bx,
+ meta.immediate(),
+ op.layout.ty,
+ &fn_abi,
+ ));
+ llargs.push(data_ptr.llval);
+ continue;
+ }
+ _ => {
+ span_bug!(span, "can't codegen a virtual call on {:#?}", op);
+ }
  }
  }
 

compiler/rustc_codegen_ssa/src/mir/rvalue.rs

@@ -4,6 +4,7 @@ use super::{FunctionCx, LocalRef};
 
 use crate::base;
 use crate::common::{self, IntPredicate};
+use crate::meth::get_vtable;
 use crate::traits::*;
 use crate::MemFlags;
 
@@ -271,6 +272,21 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
  bug!("unexpected non-pair operand");
  }
  }
+ mir::CastKind::DynStar => {
+ let data = match operand.val {
+ OperandValue::Ref(_, _, _) => todo!(),
+ OperandValue::Immediate(v) => v,
+ OperandValue::Pair(_, _) => todo!(),
+ };
+ let trait_ref =
+ if let ty::Dynamic(data, _, ty::DynStar) = cast.ty.kind() {
+ data.principal()
+ } else {
+ bug!("Only valid to do a DynStar cast into a DynStar type")
+ };
+ let vtable = get_vtable(bx.cx(), source.ty(self.mir, bx.tcx()), trait_ref);
+ OperandValue::Pair(data, vtable)
+ }
  mir::CastKind::Pointer(
  PointerCast::MutToConstPointer | PointerCast::ArrayToPointer,
  )

compiler/rustc_const_eval/src/interpret/cast.rs

@@ -108,6 +108,20 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  _ => span_bug!(self.cur_span(), "closure fn pointer on {:?}", src.layout.ty),
  }
  }
+
+ DynStar => {
+ if let ty::Dynamic(data, _, ty::DynStar) = cast_ty.kind() {
+ // Initial cast from sized to dyn trait
+ let vtable = self.get_vtable_ptr(src.layout.ty, data.principal())?;
+ let vtable = Scalar::from_maybe_pointer(vtable, self);
+ let data = self.read_immediate(src)?.to_scalar();
+ let _assert_pointer_sized = data.to_pointer(self)?;
+ let val = Immediate::ScalarPair(data, vtable);
+ self.write_immediate(val, dest)?;
+ } else {
+ bug!()
+ }
+ }
  }
  Ok(())
  }
@@ -312,7 +326,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  let new_vptr = self.get_vtable_ptr(ty, data_b.principal())?;
  self.write_immediate(Immediate::new_dyn_trait(old_data, new_vptr, self), dest)
  }
- (_, &ty::Dynamic(ref data, _)) => {
+ (_, &ty::Dynamic(ref data, _, ty::Dyn)) => {
  // Initial cast from sized to dyn trait
  let vtable = self.get_vtable_ptr(src_pointee_ty, data.principal())?;
  let ptr = self.read_scalar(src)?;

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -95,7 +95,7 @@ pub(crate) fn eval_nullary_intrinsic<'tcx>(
  | ty::Ref(_, _, _)
  | ty::FnDef(_, _)
  | ty::FnPtr(_)
- | ty::Dynamic(_, _)
+ | ty::Dynamic(_, _, _)
  | ty::Closure(_, _)
  | ty::Generator(_, _, _)
  | ty::GeneratorWitness(_)

compiler/rustc_const_eval/src/interpret/intrinsics/type_name.rs

@@ -48,7 +48,7 @@ impl<'tcx> Printer<'tcx> for AbsolutePathPrinter<'tcx> {
  | ty::FnPtr(_)
  | ty::Never
  | ty::Tuple(_)
- | ty::Dynamic(_, _) => self.pretty_print_type(ty),
+ | ty::Dynamic(_, _, _) => self.pretty_print_type(ty),
 
  // Placeholders (all printed as `_` to uniformize them).
  ty::Param(_) | ty::Bound(..) | ty::Placeholder(_) | ty::Infer(_) | ty::Error(_) => {

compiler/rustc_const_eval/src/transform/check_consts/check.rs

@@ -546,6 +546,10 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
  // Since no pointer can ever get exposed (rejected above), this is easy to support.
  }
 
+ Rvalue::Cast(CastKind::DynStar, _, _) => {
+ unimplemented!()
+ }
+
  Rvalue::Cast(CastKind::Misc, _, _) => {}
 
  Rvalue::NullaryOp(NullOp::SizeOf | NullOp::AlignOf, _) => {}

compiler/rustc_const_eval/src/transform/validate.rs

@@ -569,6 +569,9 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
  );
  }
  }
+ CastKind::DynStar => {
+ // FIXME(dyn-star): make sure nothing needs to be done here.
+ }
  // Nothing to check here
  CastKind::PointerFromExposedAddress
  | CastKind::PointerExposeAddress

compiler/rustc_feature/src/active.rs

@@ -380,6 +380,8 @@ declare_features! (
  (active, doc_cfg_hide, "1.57.0", Some(43781), None),
  /// Allows `#[doc(masked)]`.
  (active, doc_masked, "1.21.0", Some(44027), None),
+ /// Allows `dyn* Trait` objects.
+ (incomplete, dyn_star, "CURRENT_RUSTC_VERSION", Some(91611), None),
  /// Allows `X..Y` patterns.
  (active, exclusive_range_pattern, "1.11.0", Some(37854), None),
  /// Allows exhaustive pattern matching on types that contain uninhabited types.

compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs

@@ -544,7 +544,7 @@ pub struct TraitObjectVisitor(pub FxHashSet<DefId>);
 impl<'tcx> TypeVisitor<'tcx> for TraitObjectVisitor {
  fn visit_ty(&mut self, t: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
  match t.kind() {
- ty::Dynamic(preds, re) if re.is_static() => {
+ ty::Dynamic(preds, re, _) if re.is_static() => {
  if let Some(def_id) = preds.principal_def_id() {
  self.0.insert(def_id);
  }

compiler/rustc_lint/src/unused.rs

@@ -222,7 +222,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedResults {
  }
  has_emitted
  }
- ty::Dynamic(binder, _) => {
+ ty::Dynamic(binder, _, _) => {
  let mut has_emitted = false;
  for predicate in binder.iter() {
  if let ty::ExistentialPredicate::Trait(ref trait_ref) =

compiler/rustc_middle/src/mir/mod.rs

@@ -1834,6 +1834,7 @@ impl<'tcx> Rvalue<'tcx> {
  // While the model is undecided, we should be conservative. See
  // <https://www.ralfj.de/blog/2022/04/11/provenance-exposed.html>
  Rvalue::Cast(CastKind::PointerExposeAddress, _, _) => false,
+ Rvalue::Cast(CastKind::DynStar, _, _) => false,
 
  Rvalue::Use(_)
  | Rvalue::CopyForDeref(_)

compiler/rustc_middle/src/mir/syntax.rs

@@ -1139,6 +1139,8 @@ pub enum CastKind {
  /// All sorts of pointer-to-pointer casts. Note that reference-to-raw-ptr casts are
  /// translated into `&raw mut/const *r`, i.e., they are not actually casts.
  Pointer(PointerCast),
+ /// Cast into a dyn* object.
+ DynStar,
  /// Remaining unclassified casts.
  Misc,
 }

compiler/rustc_middle/src/ty/cast.rs

@@ -33,6 +33,8 @@ pub enum CastTy<'tcx> {
  FnPtr,
  /// Raw pointers.
  Ptr(ty::TypeAndMut<'tcx>),
+ /// Casting into a `dyn*` value.
+ DynStar,
 }
 
 /// Cast Kind. See [RFC 401](https://rust-lang.github.io/rfcs/0401-coercions.html)
@@ -50,6 +52,7 @@ pub enum CastKind {
  ArrayPtrCast,
  FnPtrPtrCast,
  FnPtrAddrCast,
+ DynStarCast,
 }
 
 impl<'tcx> CastTy<'tcx> {
@@ -67,6 +70,7 @@ impl<'tcx> CastTy<'tcx> {
  ty::Adt(d, _) if d.is_enum() && d.is_payloadfree() => Some(CastTy::Int(IntTy::CEnum)),
  ty::RawPtr(mt) => Some(CastTy::Ptr(mt)),
  ty::FnPtr(..) => Some(CastTy::FnPtr),
+ ty::Dynamic(_, _, ty::DynStar) => Some(CastTy::DynStar),
  _ => None,
  }
  }