Skip to content

Commit 6e3c7df

Browse files
rust-timerrust-timer
authored
Unrolled build for rust-lang#138861
Rollup merge of rust-lang#138861 - compiler-errors:flags-tweaks, r=lcnr Tweak type flags, fix missing flags from coroutine kind ty Firstly, make sure we visit the coroutine kind ty. Since this kind ty is either infer (before upvar computation), or `()` or `i8`/`i16`/`i32`, this isn't really that big of a deal, since other types in the coroutine will also be infer, so we're not misreporting `ty.has_infer()` or anything, but it's still wrong not to do this. Furthermore, remove `HAS_TY_COROUTINE`, since nobody used it, and also remove special casing for `STILL_FURTHER_SPECIALIZABLE` since it's likely not important anymore? I have a vague recollection that it was important for polymorphization(?), but no tests seem to rely on this behavior. r? lcnr or reassign
2 parents aa8f0fd + 77a106e commit 6e3c7df

File tree

3 files changed

+24
-85
lines changed

3 files changed

+24
-85
lines changed

‎compiler/rustc_middle/src/ty/flags.rs

+15-74
Original file line numberDiff line numberDiff line change
@@ -101,63 +101,13 @@ impl FlagComputation {
101101

102102
&ty::Param(_) => {
103103
self.add_flags(TypeFlags::HAS_TY_PARAM);
104-
self.add_flags(TypeFlags::STILL_FURTHER_SPECIALIZABLE);
105104
}
106105

107-
ty::Coroutine(_, args) => {
108-
let args = args.as_coroutine();
109-
let should_remove_further_specializable =
110-
!self.flags.contains(TypeFlags::STILL_FURTHER_SPECIALIZABLE);
111-
self.add_args(args.parent_args());
112-
if should_remove_further_specializable {
113-
self.flags -= TypeFlags::STILL_FURTHER_SPECIALIZABLE;
114-
}
115-
116-
self.add_ty(args.resume_ty());
117-
self.add_ty(args.return_ty());
118-
self.add_ty(args.witness());
119-
self.add_ty(args.yield_ty());
120-
self.add_ty(args.tupled_upvars_ty());
121-
}
122-
123-
ty::CoroutineWitness(_, args) => {
124-
let should_remove_further_specializable =
125-
!self.flags.contains(TypeFlags::STILL_FURTHER_SPECIALIZABLE);
106+
&ty::Closure(_, args)
107+
| &ty::Coroutine(_, args)
108+
| &ty::CoroutineClosure(_, args)
109+
| &ty::CoroutineWitness(_, args) => {
126110
self.add_args(args);
127-
if should_remove_further_specializable {
128-
self.flags -= TypeFlags::STILL_FURTHER_SPECIALIZABLE;
129-
}
130-
self.add_flags(TypeFlags::HAS_TY_COROUTINE);
131-
}
132-
133-
&ty::Closure(_, args) => {
134-
let args = args.as_closure();
135-
let should_remove_further_specializable =
136-
!self.flags.contains(TypeFlags::STILL_FURTHER_SPECIALIZABLE);
137-
self.add_args(args.parent_args());
138-
if should_remove_further_specializable {
139-
self.flags -= TypeFlags::STILL_FURTHER_SPECIALIZABLE;
140-
}
141-
142-
self.add_ty(args.sig_as_fn_ptr_ty());
143-
self.add_ty(args.kind_ty());
144-
self.add_ty(args.tupled_upvars_ty());
145-
}
146-
147-
&ty::CoroutineClosure(_, args) => {
148-
let args = args.as_coroutine_closure();
149-
let should_remove_further_specializable =
150-
!self.flags.contains(TypeFlags::STILL_FURTHER_SPECIALIZABLE);
151-
self.add_args(args.parent_args());
152-
if should_remove_further_specializable {
153-
self.flags -= TypeFlags::STILL_FURTHER_SPECIALIZABLE;
154-
}
155-
156-
self.add_ty(args.kind_ty());
157-
self.add_ty(args.signature_parts_ty());
158-
self.add_ty(args.tupled_upvars_ty());
159-
self.add_ty(args.coroutine_captures_by_ref_ty());
160-
self.add_ty(args.coroutine_witness_ty());
161111
}
162112

163113
&ty::Bound(debruijn, _) => {
@@ -167,21 +117,17 @@ impl FlagComputation {
167117

168118
&ty::Placeholder(..) => {
169119
self.add_flags(TypeFlags::HAS_TY_PLACEHOLDER);
170-
self.add_flags(TypeFlags::STILL_FURTHER_SPECIALIZABLE);
171120
}
172121

173-
&ty::Infer(infer) => {
174-
self.add_flags(TypeFlags::STILL_FURTHER_SPECIALIZABLE);
175-
match infer {
176-
ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_) => {
177-
self.add_flags(TypeFlags::HAS_TY_FRESH)
178-
}
122+
&ty::Infer(infer) => match infer {
123+
ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_) => {
124+
self.add_flags(TypeFlags::HAS_TY_FRESH)
125+
}
179126

180-
ty::TyVar(_) | ty::IntVar(_) | ty::FloatVar(_) => {
181-
self.add_flags(TypeFlags::HAS_TY_INFER)
182-
}
127+
ty::TyVar(_) | ty::IntVar(_) | ty::FloatVar(_) => {
128+
self.add_flags(TypeFlags::HAS_TY_INFER)
183129
}
184-
}
130+
},
185131

186132
&ty::Adt(_, args) => {
187133
self.add_args(args);
@@ -358,24 +304,19 @@ impl FlagComputation {
358304
self.add_args(uv.args);
359305
self.add_flags(TypeFlags::HAS_CT_PROJECTION);
360306
}
361-
ty::ConstKind::Infer(infer) => {
362-
self.add_flags(TypeFlags::STILL_FURTHER_SPECIALIZABLE);
363-
match infer {
364-
InferConst::Fresh(_) => self.add_flags(TypeFlags::HAS_CT_FRESH),
365-
InferConst::Var(_) => self.add_flags(TypeFlags::HAS_CT_INFER),
366-
}
367-
}
307+
ty::ConstKind::Infer(infer) => match infer {
308+
InferConst::Fresh(_) => self.add_flags(TypeFlags::HAS_CT_FRESH),
309+
InferConst::Var(_) => self.add_flags(TypeFlags::HAS_CT_INFER),
310+
},
368311
ty::ConstKind::Bound(debruijn, _) => {
369312
self.add_bound_var(debruijn);
370313
self.add_flags(TypeFlags::HAS_CT_BOUND);
371314
}
372315
ty::ConstKind::Param(_) => {
373316
self.add_flags(TypeFlags::HAS_CT_PARAM);
374-
self.add_flags(TypeFlags::STILL_FURTHER_SPECIALIZABLE);
375317
}
376318
ty::ConstKind::Placeholder(_) => {
377319
self.add_flags(TypeFlags::HAS_CT_PLACEHOLDER);
378-
self.add_flags(TypeFlags::STILL_FURTHER_SPECIALIZABLE);
379320
}
380321
ty::ConstKind::Value(cv) => self.add_ty(cv.ty),
381322
ty::ConstKind::Expr(e) => self.add_args(e.args()),

‎compiler/rustc_type_ir/src/flags.rs

+9-7
Original file line numberDiff line numberDiff line change
@@ -111,18 +111,20 @@ bitflags::bitflags! {
111111

112112
/// Does this value have parameters/placeholders/inference variables which could be
113113
/// replaced later, in a way that would change the results of `impl` specialization?
114-
const STILL_FURTHER_SPECIALIZABLE = 1 << 21;
114+
const STILL_FURTHER_SPECIALIZABLE = TypeFlags::HAS_TY_PARAM.bits()
115+
| TypeFlags::HAS_TY_PLACEHOLDER.bits()
116+
| TypeFlags::HAS_TY_INFER.bits()
117+
| TypeFlags::HAS_CT_PARAM.bits()
118+
| TypeFlags::HAS_CT_PLACEHOLDER.bits()
119+
| TypeFlags::HAS_CT_INFER.bits();
115120

116121
/// Does this value have `InferTy::FreshTy/FreshIntTy/FreshFloatTy`?
117-
const HAS_TY_FRESH = 1 << 22;
122+
const HAS_TY_FRESH = 1 << 21;
118123

119124
/// Does this value have `InferConst::Fresh`?
120-
const HAS_CT_FRESH = 1 << 23;
121-
122-
/// Does this have `Coroutine` or `CoroutineWitness`?
123-
const HAS_TY_COROUTINE = 1 << 24;
125+
const HAS_CT_FRESH = 1 << 22;
124126

125127
/// Does this have any binders with bound vars (e.g. that need to be anonymized)?
126-
const HAS_BINDER_VARS = 1 << 25;
128+
const HAS_BINDER_VARS = 1 << 23;
127129
}
128130
}

‎compiler/rustc_type_ir/src/visit.rs

-4
Original file line numberDiff line numberDiff line change
@@ -269,10 +269,6 @@ pub trait TypeVisitableExt<I: Interner>: TypeVisitable<I> {
269269
self.has_type_flags(TypeFlags::HAS_TY_OPAQUE)
270270
}
271271

272-
fn has_coroutines(&self) -> bool {
273-
self.has_type_flags(TypeFlags::HAS_TY_COROUTINE)
274-
}
275-
276272
fn references_error(&self) -> bool {
277273
self.has_type_flags(TypeFlags::HAS_ERROR)
278274
}

0 commit comments

Comments
 (0)