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

Diff for: ‎compiler/rustc_ast/src/ast.rs

+1
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

Diff for: ‎compiler/rustc_ast_passes/src/feature_gate.rs

+3
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)

Diff for: ‎compiler/rustc_borrowck/src/type_check/mod.rs

+33-2
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,

Diff for: ‎compiler/rustc_codegen_cranelift/src/base.rs

+4
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);

Diff for: ‎compiler/rustc_codegen_cranelift/src/value_and_place.rs

+2-1
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);

Diff for: ‎compiler/rustc_codegen_ssa/src/meth.rs

+2-3
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;

Diff for: ‎compiler/rustc_codegen_ssa/src/mir/block.rs

+87-2
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

Diff for: ‎compiler/rustc_codegen_ssa/src/mir/rvalue.rs

+16
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
)

Diff for: ‎compiler/rustc_const_eval/src/interpret/cast.rs

+15-1
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)?;

Diff for: ‎compiler/rustc_const_eval/src/interpret/intrinsics.rs

+1-1
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(_)

Diff for: ‎compiler/rustc_const_eval/src/interpret/intrinsics/type_name.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -48,7 +48,7 @@ impl<'tcx> Printer<'tcx> for AbsolutePathPrinter<'tcx> {
4848
| ty::FnPtr(_)
4949
| ty::Never
5050
| ty::Tuple(_)
51-
| ty::Dynamic(_, _) => self.pretty_print_type(ty),
51+
| ty::Dynamic(_, _, _) => self.pretty_print_type(ty),
5252

5353
// Placeholders (all printed as `_` to uniformize them).
5454
ty::Param(_) | ty::Bound(..) | ty::Placeholder(_) | ty::Infer(_) | ty::Error(_) => {

Diff for: ‎compiler/rustc_const_eval/src/transform/check_consts/check.rs

+4
Original file line numberDiff line numberDiff line change
@@ -546,6 +546,10 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
546546
// Since no pointer can ever get exposed (rejected above), this is easy to support.
547547
}
548548

549+
Rvalue::Cast(CastKind::DynStar, _, _) => {
550+
unimplemented!()
551+
}
552+
549553
Rvalue::Cast(CastKind::Misc, _, _) => {}
550554

551555
Rvalue::NullaryOp(NullOp::SizeOf | NullOp::AlignOf, _) => {}

Diff for: ‎compiler/rustc_const_eval/src/transform/validate.rs

+3
Original file line numberDiff line numberDiff line change
@@ -569,6 +569,9 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
569569
);
570570
}
571571
}
572+
CastKind::DynStar => {
573+
// FIXME(dyn-star): make sure nothing needs to be done here.
574+
}
572575
// Nothing to check here
573576
CastKind::PointerFromExposedAddress
574577
| CastKind::PointerExposeAddress

Diff for: ‎compiler/rustc_feature/src/active.rs

+2
Original file line numberDiff line numberDiff line change
@@ -384,6 +384,8 @@ declare_features! (
384384
(active, doc_cfg_hide, "1.57.0", Some(43781), None),
385385
/// Allows `#[doc(masked)]`.
386386
(active, doc_masked, "1.21.0", Some(44027), None),
387+
/// Allows `dyn* Trait` objects.
388+
(incomplete, dyn_star, "CURRENT_RUSTC_VERSION", Some(91611), None),
387389
/// Allows `X..Y` patterns.
388390
(active, exclusive_range_pattern, "1.11.0", Some(37854), None),
389391
/// Allows exhaustive pattern matching on types that contain uninhabited types.

Diff for: ‎compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -544,7 +544,7 @@ pub struct TraitObjectVisitor(pub FxHashSet<DefId>);
544544
impl<'tcx> TypeVisitor<'tcx> for TraitObjectVisitor {
545545
fn visit_ty(&mut self, t: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
546546
match t.kind() {
547-
ty::Dynamic(preds, re) if re.is_static() => {
547+
ty::Dynamic(preds, re, _) if re.is_static() => {
548548
if let Some(def_id) = preds.principal_def_id() {
549549
self.0.insert(def_id);
550550
}

Diff for: ‎compiler/rustc_lint/src/unused.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -222,7 +222,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedResults {
222222
}
223223
has_emitted
224224
}
225-
ty::Dynamic(binder, _) => {
225+
ty::Dynamic(binder, _, _) => {
226226
let mut has_emitted = false;
227227
for predicate in binder.iter() {
228228
if let ty::ExistentialPredicate::Trait(ref trait_ref) =

Diff for: ‎compiler/rustc_middle/src/mir/mod.rs

+1
Original file line numberDiff line numberDiff line change
@@ -1818,6 +1818,7 @@ impl<'tcx> Rvalue<'tcx> {
18181818
// While the model is undecided, we should be conservative. See
18191819
// <https://www.ralfj.de/blog/2022/04/11/provenance-exposed.html>
18201820
Rvalue::Cast(CastKind::PointerExposeAddress, _, _) => false,
1821+
Rvalue::Cast(CastKind::DynStar, _, _) => false,
18211822

18221823
Rvalue::Use(_)
18231824
| Rvalue::CopyForDeref(_)

Diff for: ‎compiler/rustc_middle/src/mir/syntax.rs

+2
Original file line numberDiff line numberDiff line change
@@ -1139,6 +1139,8 @@ pub enum CastKind {
11391139
/// All sorts of pointer-to-pointer casts. Note that reference-to-raw-ptr casts are
11401140
/// translated into `&raw mut/const *r`, i.e., they are not actually casts.
11411141
Pointer(PointerCast),
1142+
/// Cast into a dyn* object.
1143+
DynStar,
11421144
/// Remaining unclassified casts.
11431145
Misc,
11441146
}

Diff for: ‎compiler/rustc_middle/src/ty/cast.rs

+4
Original file line numberDiff line numberDiff line change
@@ -33,6 +33,8 @@ pub enum CastTy<'tcx> {
3333
FnPtr,
3434
/// Raw pointers.
3535
Ptr(ty::TypeAndMut<'tcx>),
36+
/// Casting into a `dyn*` value.
37+
DynStar,
3638
}
3739

3840
/// Cast Kind. See [RFC 401](https://rust-lang.github.io/rfcs/0401-coercions.html)
@@ -50,6 +52,7 @@ pub enum CastKind {
5052
ArrayPtrCast,
5153
FnPtrPtrCast,
5254
FnPtrAddrCast,
55+
DynStarCast,
5356
}
5457

5558
impl<'tcx> CastTy<'tcx> {
@@ -67,6 +70,7 @@ impl<'tcx> CastTy<'tcx> {
6770
ty::Adt(d, _) if d.is_enum() && d.is_payloadfree() => Some(CastTy::Int(IntTy::CEnum)),
6871
ty::RawPtr(mt) => Some(CastTy::Ptr(mt)),
6972
ty::FnPtr(..) => Some(CastTy::FnPtr),
73+
ty::Dynamic(_, _, ty::DynStar) => Some(CastTy::DynStar),
7074
_ => None,
7175
}
7276
}

0 commit comments

Comments
 (0)