Skip to content

Commit 6153d3c

Browse files
borsbors
committed
Auto merge of rust-lang#101212 - eholk:dyn-star, r=compiler-errors
Initial implementation of dyn* This PR adds extremely basic and incomplete support for [dyn*](https://smallcultfollowing.com/babysteps//blog/2022/03/29/dyn-can-we-make-dyn-sized/). The goal is to get something in tree behind a flag to make collaboration easier, and also to make sure the implementation so far is not unreasonable. This PR does quite a few things: * Introduce `dyn_star` feature flag * Adds parsing for `dyn* Trait` types * Defines `dyn* Trait` as a sized type * Adds support for explicit casts, like `42usize as dyn* Debug` * Including const evaluation of such casts * Adds codegen for drop glue so things are cleaned up properly when a `dyn* Trait` object goes out of scope * Adds codegen for method calls, at least for methods that take `&self` Quite a bit is still missing, but this gives us a starting point. Note that this is never intended to become stable surface syntax for Rust, but rather `dyn*` is planned to be used as an implementation detail for async functions in dyn traits. Joint work with `@nikomatsakis` and `@compiler-errors.` r? `@bjorn3`
2 parents a926696 + 0faafbf commit 6153d3c

File tree

69 files changed

+617
-104
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

69 files changed

+617
-104
lines changed

‎compiler/rustc_ast/src/ast.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2072,6 +2072,7 @@ impl TyKind {
20722072
#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
20732073
pub enum TraitObjectSyntax {
20742074
Dyn,
2075+
DynStar,
20752076
None,
20762077
}
20772078

‎compiler/rustc_ast_passes/src/feature_gate.rs

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -554,6 +554,9 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
554554
ast::TyKind::Never => {
555555
gate_feature_post!(&self, never_type, ty.span, "the `!` type is experimental");
556556
}
557+
ast::TyKind::TraitObject(_, ast::TraitObjectSyntax::DynStar, ..) => {
558+
gate_feature_post!(&self, dyn_star, ty.span, "dyn* trait objects are unstable");
559+
}
557560
_ => {}
558561
}
559562
visit::walk_ty(self, ty)

‎compiler/rustc_borrowck/src/type_check/mod.rs

Lines changed: 33 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -30,8 +30,9 @@ use rustc_middle::ty::cast::CastTy;
3030
use rustc_middle::ty::subst::{GenericArgKind, SubstsRef, UserSubsts};
3131
use rustc_middle::ty::visit::TypeVisitable;
3232
use rustc_middle::ty::{
33-
self, CanonicalUserTypeAnnotation, CanonicalUserTypeAnnotations, OpaqueHiddenType,
34-
OpaqueTypeKey, RegionVid, ToPredicate, Ty, TyCtxt, UserType, UserTypeAnnotationIndex,
33+
self, Binder, CanonicalUserTypeAnnotation, CanonicalUserTypeAnnotations, Dynamic,
34+
OpaqueHiddenType, OpaqueTypeKey, RegionVid, ToPredicate, Ty, TyCtxt, UserType,
35+
UserTypeAnnotationIndex,
3536
};
3637
use rustc_span::def_id::CRATE_DEF_ID;
3738
use rustc_span::{Span, DUMMY_SP};
@@ -2013,6 +2014,36 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
20132014
);
20142015
}
20152016

2017+
CastKind::DynStar => {
2018+
// get the constraints from the target type (`dyn* Clone`)
2019+
//
2020+
// apply them to prove that the source type `Foo` implements `Clone` etc
2021+
let (existential_predicates, region) = match ty.kind() {
2022+
Dynamic(predicates, region, ty::DynStar) => (predicates, region),
2023+
_ => panic!("Invalid dyn* cast_ty"),
2024+
};
2025+
2026+
let self_ty = op.ty(body, tcx);
2027+
2028+
self.prove_predicates(
2029+
existential_predicates
2030+
.iter()
2031+
.map(|predicate| predicate.with_self_ty(tcx, self_ty)),
2032+
location.to_locations(),
2033+
ConstraintCategory::Cast,
2034+
);
2035+
2036+
let outlives_predicate =
2037+
tcx.mk_predicate(Binder::dummy(ty::PredicateKind::TypeOutlives(
2038+
ty::OutlivesPredicate(self_ty, *region),
2039+
)));
2040+
self.prove_predicate(
2041+
outlives_predicate,
2042+
location.to_locations(),
2043+
ConstraintCategory::Cast,
2044+
);
2045+
}
2046+
20162047
CastKind::Pointer(PointerCast::MutToConstPointer) => {
20172048
let ty::RawPtr(ty::TypeAndMut {
20182049
ty: ty_from,

‎compiler/rustc_codegen_cranelift/src/base.rs

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -701,6 +701,10 @@ fn codegen_stmt<'tcx>(
701701
let operand = codegen_operand(fx, operand);
702702
operand.unsize_value(fx, lval);
703703
}
704+
Rvalue::Cast(CastKind::DynStar, _, _) => {
705+
// FIXME(dyn-star)
706+
unimplemented!()
707+
}
704708
Rvalue::Discriminant(place) => {
705709
let place = codegen_place(fx, place);
706710
let value = place.to_cvalue(fx);

‎compiler/rustc_codegen_cranelift/src/value_and_place.rs

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -815,7 +815,8 @@ pub(crate) fn assert_assignable<'tcx>(
815815
);
816816
// fn(&T) -> for<'l> fn(&'l T) is allowed
817817
}
818-
(&ty::Dynamic(from_traits, _), &ty::Dynamic(to_traits, _)) => {
818+
(&ty::Dynamic(from_traits, _, _from_kind), &ty::Dynamic(to_traits, _, _to_kind)) => {
819+
// FIXME(dyn-star): Do the right thing with DynKinds
819820
for (from, to) in from_traits.iter().zip(to_traits) {
820821
let from =
821822
fx.tcx.normalize_erasing_late_bound_regions(ParamEnv::reveal_all(), from);

‎compiler/rustc_codegen_ssa/src/meth.rs

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -69,7 +69,7 @@ impl<'a, 'tcx> VirtualIndex {
6969
fn expect_dyn_trait_in_self<'tcx>(ty: Ty<'tcx>) -> ty::PolyExistentialTraitRef<'tcx> {
7070
for arg in ty.peel_refs().walk() {
7171
if let GenericArgKind::Type(ty) = arg.unpack() {
72-
if let ty::Dynamic(data, _) = ty.kind() {
72+
if let ty::Dynamic(data, _, _) = ty.kind() {
7373
return data.principal().expect("expected principal trait object");
7474
}
7575
}
@@ -86,15 +86,14 @@ fn expect_dyn_trait_in_self<'tcx>(ty: Ty<'tcx>) -> ty::PolyExistentialTraitRef<'
8686
/// The `trait_ref` encodes the erased self type. Hence if we are
8787
/// making an object `Foo<dyn Trait>` from a value of type `Foo<T>`, then
8888
/// `trait_ref` would map `T: Trait`.
89+
#[instrument(level = "debug", skip(cx))]
8990
pub fn get_vtable<'tcx, Cx: CodegenMethods<'tcx>>(
9091
cx: &Cx,
9192
ty: Ty<'tcx>,
9293
trait_ref: Option<ty::PolyExistentialTraitRef<'tcx>>,
9394
) -> Cx::Value {
9495
let tcx = cx.tcx();
9596

96-
debug!("get_vtable(ty={:?}, trait_ref={:?})", ty, trait_ref);
97-
9897
// Check the cache.
9998
if let Some(&val) = cx.vtables().borrow().get(&(ty, trait_ref)) {
10099
return val;

‎compiler/rustc_codegen_ssa/src/mir/block.rs

Lines changed: 87 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -367,6 +367,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
367367
bx.ret(llval);
368368
}
369369

370+
#[tracing::instrument(level = "trace", skip(self, helper, bx))]
370371
fn codegen_drop_terminator(
371372
&mut self,
372373
helper: TerminatorCodegenHelper<'tcx>,
@@ -397,14 +398,75 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
397398
let (drop_fn, fn_abi) = match ty.kind() {
398399
// FIXME(eddyb) perhaps move some of this logic into
399400
// `Instance::resolve_drop_in_place`?
400-
ty::Dynamic(..) => {
401+
ty::Dynamic(_, _, ty::Dyn) => {
402+
// IN THIS ARM, WE HAVE:
403+
// ty = *mut (dyn Trait)
404+
// which is: exists<T> ( *mut T, Vtable<T: Trait> )
405+
// args[0] args[1]
406+
//
407+
// args = ( Data, Vtable )
408+
// |
409+
// v
410+
// /-------\
411+
// | ... |
412+
// \-------/
413+
//
401414
let virtual_drop = Instance {
402415
def: ty::InstanceDef::Virtual(drop_fn.def_id(), 0),
403416
substs: drop_fn.substs,
404417
};
418+
debug!("ty = {:?}", ty);
419+
debug!("drop_fn = {:?}", drop_fn);
420+
debug!("args = {:?}", args);
405421
let fn_abi = bx.fn_abi_of_instance(virtual_drop, ty::List::empty());
406422
let vtable = args[1];
423+
// Truncate vtable off of args list
424+
args = &args[..1];
425+
(
426+
meth::VirtualIndex::from_index(ty::COMMON_VTABLE_ENTRIES_DROPINPLACE)
427+
.get_fn(&mut bx, vtable, ty, &fn_abi),
428+
fn_abi,
429+
)
430+
}
431+
ty::Dynamic(_, _, ty::DynStar) => {
432+
// IN THIS ARM, WE HAVE:
433+
// ty = *mut (dyn* Trait)
434+
// which is: *mut exists<T: sizeof(T) == sizeof(usize)> (T, Vtable<T: Trait>)
435+
//
436+
// args = [ * ]
437+
// |
438+
// v
439+
// ( Data, Vtable )
440+
// |
441+
// v
442+
// /-------\
443+
// | ... |
444+
// \-------/
445+
//
446+
//
447+
// WE CAN CONVERT THIS INTO THE ABOVE LOGIC BY DOING
448+
//
449+
// data = &(*args[0]).0 // gives a pointer to Data above (really the same pointer)
450+
// vtable = (*args[0]).1 // loads the vtable out
451+
// (data, vtable) // an equivalent Rust `*mut dyn Trait`
452+
//
453+
// SO THEN WE CAN USE THE ABOVE CODE.
454+
let virtual_drop = Instance {
455+
def: ty::InstanceDef::Virtual(drop_fn.def_id(), 0),
456+
substs: drop_fn.substs,
457+
};
458+
debug!("ty = {:?}", ty);
459+
debug!("drop_fn = {:?}", drop_fn);
460+
debug!("args = {:?}", args);
461+
let fn_abi = bx.fn_abi_of_instance(virtual_drop, ty::List::empty());
462+
let data = args[0];
463+
let data_ty = bx.cx().backend_type(place.layout);
464+
let vtable_ptr =
465+
bx.gep(data_ty, data, &[bx.cx().const_i32(0), bx.cx().const_i32(1)]);
466+
let vtable = bx.load(bx.type_i8p(), vtable_ptr, abi::Align::ONE);
467+
// Truncate vtable off of args list
407468
args = &args[..1];
469+
debug!("args' = {:?}", args);
408470
(
409471
meth::VirtualIndex::from_index(ty::COMMON_VTABLE_ENTRIES_DROPINPLACE)
410472
.get_fn(&mut bx, vtable, ty, &fn_abi),
@@ -845,7 +907,30 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
845907
llargs.push(data_ptr);
846908
continue;
847909
}
848-
_ => span_bug!(span, "can't codegen a virtual call on {:?}", op),
910+
Immediate(_) => {
911+
let ty::Ref(_, ty, _) = op.layout.ty.kind() else {
912+
span_bug!(span, "can't codegen a virtual call on {:#?}", op);
913+
};
914+
if !ty.is_dyn_star() {
915+
span_bug!(span, "can't codegen a virtual call on {:#?}", op);
916+
}
917+
// FIXME(dyn-star): Make sure this is done on a &dyn* receiver
918+
let place = op.deref(bx.cx());
919+
let data_ptr = place.project_field(&mut bx, 0);
920+
let meta_ptr = place.project_field(&mut bx, 1);
921+
let meta = bx.load_operand(meta_ptr);
922+
llfn = Some(meth::VirtualIndex::from_index(idx).get_fn(
923+
&mut bx,
924+
meta.immediate(),
925+
op.layout.ty,
926+
&fn_abi,
927+
));
928+
llargs.push(data_ptr.llval);
929+
continue;
930+
}
931+
_ => {
932+
span_bug!(span, "can't codegen a virtual call on {:#?}", op);
933+
}
849934
}
850935
}
851936

‎compiler/rustc_codegen_ssa/src/mir/rvalue.rs

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,7 @@ use super::{FunctionCx, LocalRef};
44

55
use crate::base;
66
use crate::common::{self, IntPredicate};
7+
use crate::meth::get_vtable;
78
use crate::traits::*;
89
use crate::MemFlags;
910

@@ -271,6 +272,21 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
271272
bug!("unexpected non-pair operand");
272273
}
273274
}
275+
mir::CastKind::DynStar => {
276+
let data = match operand.val {
277+
OperandValue::Ref(_, _, _) => todo!(),
278+
OperandValue::Immediate(v) => v,
279+
OperandValue::Pair(_, _) => todo!(),
280+
};
281+
let trait_ref =
282+
if let ty::Dynamic(data, _, ty::DynStar) = cast.ty.kind() {
283+
data.principal()
284+
} else {
285+
bug!("Only valid to do a DynStar cast into a DynStar type")
286+
};
287+
let vtable = get_vtable(bx.cx(), source.ty(self.mir, bx.tcx()), trait_ref);
288+
OperandValue::Pair(data, vtable)
289+
}
274290
mir::CastKind::Pointer(
275291
PointerCast::MutToConstPointer | PointerCast::ArrayToPointer,
276292
)

‎compiler/rustc_const_eval/src/interpret/cast.rs

Lines changed: 15 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -108,6 +108,20 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
108108
_ => span_bug!(self.cur_span(), "closure fn pointer on {:?}", src.layout.ty),
109109
}
110110
}
111+
112+
DynStar => {
113+
if let ty::Dynamic(data, _, ty::DynStar) = cast_ty.kind() {
114+
// Initial cast from sized to dyn trait
115+
let vtable = self.get_vtable_ptr(src.layout.ty, data.principal())?;
116+
let vtable = Scalar::from_maybe_pointer(vtable, self);
117+
let data = self.read_immediate(src)?.to_scalar();
118+
let _assert_pointer_sized = data.to_pointer(self)?;
119+
let val = Immediate::ScalarPair(data, vtable);
120+
self.write_immediate(val, dest)?;
121+
} else {
122+
bug!()
123+
}
124+
}
111125
}
112126
Ok(())
113127
}
@@ -312,7 +326,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
312326
let new_vptr = self.get_vtable_ptr(ty, data_b.principal())?;
313327
self.write_immediate(Immediate::new_dyn_trait(old_data, new_vptr, self), dest)
314328
}
315-
(_, &ty::Dynamic(ref data, _)) => {
329+
(_, &ty::Dynamic(ref data, _, ty::Dyn)) => {
316330
// Initial cast from sized to dyn trait
317331
let vtable = self.get_vtable_ptr(src_pointee_ty, data.principal())?;
318332
let ptr = self.read_scalar(src)?;

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -95,7 +95,7 @@ pub(crate) fn eval_nullary_intrinsic<'tcx>(
9595
| ty::Ref(_, _, _)
9696
| ty::FnDef(_, _)
9797
| ty::FnPtr(_)
98-
| ty::Dynamic(_, _)
98+
| ty::Dynamic(_, _, _)
9999
| ty::Closure(_, _)
100100
| ty::Generator(_, _, _)
101101
| ty::GeneratorWitness(_)

0 commit comments

Comments
 (0)