fn super_mir(&mut self,
mir: & $($mutability)* Mir<'tcx>) {
+ if let Some(yield_ty) = &$($mutability)* mir.yield_ty {
+ self.visit_ty(yield_ty, TyContext::YieldTy(SourceInfo {
+ span: mir.span,
+ scope: ARGUMENT_VISIBILITY_SCOPE,
+ }));
+ }
+
// for best performance, we want to use an iterator rather
// than a for-loop, to avoid calling Mir::invalidate for
// each basic block.
/// The return type of the function.
ReturnTy(SourceInfo),
+ YieldTy(SourceInfo),
+
/// A type found at some location.
Location(Location),
}
fn visit_ty(&mut self, ty: &ty::Ty<'tcx>, ty_context: TyContext) {
match ty_context {
TyContext::ReturnTy(source_info) |
+ TyContext::YieldTy(source_info) |
TyContext::LocalDecl { source_info, .. } => {
span_bug!(source_info.span,
"should not be visiting outside of the CFG: {:?}",
self.equate_normalized_input_or_output(start_position, input_ty, mir_input_ty);
}
+ assert!(
+ mir.yield_ty.is_some() && universal_regions.yield_ty.is_some() ||
+ mir.yield_ty.is_none() && universal_regions.yield_ty.is_none()
+ );
+ if let Some(mir_yield_ty) = mir.yield_ty {
+ let ur_yield_ty = universal_regions.yield_ty.unwrap();
+ self.equate_normalized_input_or_output(start_position, ur_yield_ty, mir_yield_ty);
+ }
+
// Return types are a bit more complex. They may contain existential `impl Trait`
// types.
debug!(
/// our special inference variable there, we would mess that up.
pub region_bound_pairs: Vec<(ty::Region<'tcx>, GenericKind<'tcx>)>,
+ pub yield_ty: Option<Ty<'tcx>>,
+
relations: UniversalRegionRelations,
}
num_universals
);
+ let yield_ty = match defining_ty {
+ DefiningTy::Generator(def_id, substs, _) => {
+ Some(substs.generator_yield_ty(def_id, self.infcx.tcx))
+ }
+ _ => None,
+ };
+
UniversalRegions {
indices,
fr_static,
unnormalized_output_ty,
unnormalized_input_tys,
region_bound_pairs: self.region_bound_pairs,
+ yield_ty: yield_ty,
relations: self.relations,
}
}