1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
// compile-flags: --edition=2021
#![feature(rustc_attrs)]
use core::any::Any;
use core::marker::PhantomData;
fn main() {
test::<MaskedStorage<GenericComp<Pos>>>(make());
//~^ ERROR evaluate(Binder(TraitPredicate(<MaskedStorage<GenericComp<Pos>> as std::marker::Sized>, polarity:Positive), [])) = Ok(EvaluatedToOk)
//~| ERROR evaluate(Binder(TraitPredicate(<MaskedStorage<GenericComp<Pos>> as std::marker::Sized>, polarity:Positive), [])) = Ok(EvaluatedToOk)
test::<MaskedStorage<GenericComp2<Pos>>>(make());
//~^ ERROR evaluate(Binder(TraitPredicate(<MaskedStorage<GenericComp2<Pos>> as std::marker::Sized>, polarity:Positive), [])) = Ok(EvaluatedToOkModuloRegions)
//~| ERROR evaluate(Binder(TraitPredicate(<MaskedStorage<GenericComp2<Pos>> as std::marker::Sized>, polarity:Positive), [])) = Ok(EvaluatedToOkModuloRegions)
}
#[rustc_evaluate_where_clauses]
fn test<T: Sized>(_: T) {}
fn make<T>() -> T {
todo!()
}
struct DerefWrap<T>(T);
impl<T> core::ops::Deref for DerefWrap<T> {
type Target = T;
fn deref(&self) -> &Self::Target {
&self.0
}
}
struct Storage<T, D> {
phantom: PhantomData<(T, D)>,
}
type ReadStorage<T> = Storage<T, DerefWrap<MaskedStorage<T>>>;
pub trait Component {
type Storage;
}
struct VecStorage;
struct Pos;
impl Component for Pos {
type Storage = VecStorage;
}
struct GenericComp<T> {
_t: T,
}
impl<T: 'static> Component for GenericComp<T> {
type Storage = VecStorage;
}
struct GenericComp2<T> {
_t: T,
}
impl<T: 'static> Component for GenericComp2<T> where for<'a> &'a bool: 'a {
type Storage = VecStorage;
}
struct ReadData {
pos_interpdata: ReadStorage<GenericComp<Pos>>,
}
trait System {
type SystemData;
fn run(data: Self::SystemData, any: Box<dyn Any>);
}
struct Sys;
impl System for Sys {
type SystemData = (ReadData, ReadStorage<Pos>);
fn run((data, pos): Self::SystemData, any: Box<dyn Any>) {
<ReadStorage<GenericComp<Pos>> as SystemData>::setup(any);
ParJoin::par_join((&pos, &data.pos_interpdata));
}
}
trait ParJoin {
fn par_join(self)
where
Self: Sized,
{
}
}
impl<'a, T, D> ParJoin for &'a Storage<T, D>
where
T: Component,
D: core::ops::Deref<Target = MaskedStorage<T>>,
T::Storage: Sync,
{
}
impl<A, B> ParJoin for (A, B)
where
A: ParJoin,
B: ParJoin,
{
}
pub trait SystemData {
fn setup(any: Box<dyn Any>);
}
impl<T: 'static> SystemData for ReadStorage<T>
where
T: Component,
{
fn setup(any: Box<dyn Any>) {
let storage: &MaskedStorage<T> = any.downcast_ref().unwrap();
<dyn Any as CastFrom<MaskedStorage<T>>>::cast(&storage);
}
}
pub struct MaskedStorage<T: Component> {
_inner: T::Storage,
}
pub unsafe trait CastFrom<T> {
fn cast(t: &T) -> &Self;
}
unsafe impl<T> CastFrom<T> for dyn Any
where
T: Any + 'static,
{
fn cast(t: &T) -> &Self {
t
}
}
|
