Select user type annotations instead of cloning them.

Author: cjgillot

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -948,16 +948,6 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
     /// Equate the inferred type and the annotated type for user type annotations
     #[instrument(skip(self), level = "debug")]
     fn check_user_type_annotations(&mut self) {
-        // Promoted clone the `user_type_annotations` from their original body, because some
-        // statements may refer to them. However, we don't want to apply the other type annotations
-        // while checking the promoted: that would create spurious constraints that we won't be
-        // able to verify. Instead, the annotations are checked on-demand before relating to the
-        // actual type in MIR.
-        if let DefKind::Promoted = self.tcx().def_kind(self.body.source.def_id()) {
-            debug!("promoted: skipping user type annotations");
-            return;
-        }
-
         debug!(?self.user_type_annotations);
         for user_annotation in self.user_type_annotations {
             let CanonicalUserTypeAnnotation { span, ref user_ty, inferred_ty } = *user_annotation;
@@ -1022,23 +1012,12 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         locations: Locations,
         category: ConstraintCategory<'tcx>,
     ) -> Fallible<()> {
-        let CanonicalUserTypeAnnotation {
-            span,
-            user_ty: ref canonical_user_ty,
-            inferred_ty: annotated_type,
-        } = self.user_type_annotations[user_ty.base];
+        let annotated_type = self.user_type_annotations[user_ty.base].inferred_ty;
         trace!(?annotated_type);
-
-        // We may have skipped checking the canonical annotation earlier, so do it now.
-        if let DefKind::Promoted = self.tcx().def_kind(self.body.source.def_id()) {
-            let annotation =
-                self.instantiate_canonical_with_fresh_inference_vars(span, canonical_user_ty);
-            self.ascribe_user_type(annotated_type, annotation, span);
-        }
+        let mut curr_projected_ty = PlaceTy::from_ty(annotated_type);
 
         let tcx = self.infcx.tcx;
 
-        let mut curr_projected_ty = PlaceTy::from_ty(annotated_type);
         for proj in &user_ty.projs {
             if let ty::Alias(ty::Opaque, ..) = curr_projected_ty.ty.kind() {
                 // There is nothing that we can compare here if we go through an opaque type.

compiler/rustc_const_eval/src/transform/promote_consts.rs

@@ -12,13 +12,14 @@
 //! initialization and can otherwise silence errors, if
 //! move analysis runs after promotion on broken MIR.
 
+use rustc_data_structures::fx::FxIndexSet;
 use rustc_hir as hir;
 use rustc_index::{IndexSlice, IndexVec};
 use rustc_middle::mir::traversal::ReversePostorderIter;
 use rustc_middle::mir::visit::{MutVisitor, MutatingUseContext, PlaceContext, Visitor};
 use rustc_middle::mir::*;
 use rustc_middle::ty::subst::InternalSubsts;
-use rustc_middle::ty::{self, List, TyCtxt, TypeVisitableExt};
+use rustc_middle::ty::{self, List, TyCtxt, TypeVisitableExt, UserTypeAnnotationIndex};
 use rustc_span::def_id::LocalDefId;
 use rustc_span::Span;
 
@@ -881,6 +882,22 @@ impl<'a, 'tcx> Promoter<'a, 'tcx> {
         let span = self.promoted.span;
         self.assign(RETURN_PLACE, rvalue, span);
 
+        // Copy user type annotations from the original body to the promoted.
+        // We don't want to keep all the original annotations, as they may create
+        // constants that borrowck will not be able to verify. However, we still
+        // need some of them to borrow-check the promoted itself.
+        //
+        // We don't remove the cloned annotations from the original body, as they
+        // are harmless there.
+        let mut annotation_renumber =
+            RenumberUserTypeAnnotations { tcx, mapping: FxIndexSet::default() };
+        annotation_renumber.visit_body_preserves_cfg(&mut self.promoted);
+        self.promoted.user_type_annotations = annotation_renumber
+            .mapping
+            .iter()
+            .map(|&original_index| self.source.user_type_annotations[original_index].clone())
+            .collect();
+
         let source_def_id = self.source.source.def_id().expect_local();
         let feeder =
             tcx.at(span).create_def(source_def_id, hir::definitions::DefPathData::Promoted);
@@ -935,6 +952,23 @@ impl<'a, 'tcx> MutVisitor<'tcx> for Promoter<'a, 'tcx> {
     }
 }
 
+/// Replaces type annotation indices.
+struct RenumberUserTypeAnnotations<'tcx> {
+    tcx: TyCtxt<'tcx>,
+    mapping: FxIndexSet<UserTypeAnnotationIndex>,
+}
+
+impl<'tcx> MutVisitor<'tcx> for RenumberUserTypeAnnotations<'tcx> {
+    fn tcx(&self) -> TyCtxt<'tcx> {
+        self.tcx
+    }
+
+    fn visit_user_type_annotation_index(&mut self, annotation: &mut UserTypeAnnotationIndex) {
+        let (new_index, _) = self.mapping.insert_full(*annotation);
+        *annotation = UserTypeAnnotationIndex::from_usize(new_index);
+    }
+}
+
 pub fn promote_candidates<'tcx>(
     body: &mut Body<'tcx>,
     tcx: TyCtxt<'tcx>,
@@ -970,7 +1004,7 @@ pub fn promote_candidates<'tcx>(
             IndexVec::new(),
             IndexVec::from_elem_n(scope, 1),
             initial_locals,
-            body.user_type_annotations.clone(),
+            IndexVec::new(),
             0,
             vec![],
             body.span,

compiler/rustc_middle/src/mir/visit.rs

@@ -156,6 +156,12 @@ macro_rules! make_mir_visitor {
                 self.super_ascribe_user_ty(place, variance, user_ty, location);
             }
 
+            fn visit_user_type_annotation_index(
+                &mut self,
+                _index: $(& $mutability)? UserTypeAnnotationIndex,
+            ) {
+            }
+
             fn visit_coverage(
                 &mut self,
                 coverage: & $($mutability)? Coverage,
@@ -724,10 +730,13 @@ macro_rules! make_mir_visitor {
                                 _adt_def,
                                 _variant_index,
                                 substs,
-                                _user_substs,
+                                user_substs,
                                 _active_field_index
                             ) => {
                                 self.visit_substs(substs, location);
+                                if let Some(user_substs) = user_substs {
+                                    self.visit_user_type_annotation_index($(& $mutability)? *user_substs);
+                                }
                             }
                             AggregateKind::Closure(
                                 _,
@@ -881,11 +890,14 @@ macro_rules! make_mir_visitor {
             ) {
                 let Constant {
                     span,
-                    user_ty: _, // no visit method for this
+                    user_ty,
                     literal,
                 } = constant;
 
                 self.visit_span($(& $mutability)? *span);
+                if let Some(user_ty) = user_ty {
+                    self.visit_user_type_annotation_index($(& $mutability)? *user_ty);
+                }
                 match literal {
                     ConstantKind::Ty(ct) => self.visit_ty_const($(&$mutability)? *ct, location),
                     ConstantKind::Val(_, ty) => self.visit_ty($(& $mutability)? *ty, TyContext::Location(location)),
@@ -916,8 +928,9 @@ macro_rules! make_mir_visitor {
 
             fn super_user_type_projection(
                 &mut self,
-                _ty: & $($mutability)? UserTypeProjection,
+                ty: & $($mutability)? UserTypeProjection,
             ) {
+                self.visit_user_type_annotation_index($(&$mutability)? ty.base);
             }
 
             fn super_user_type_annotation(