Auto merge of rust-lang#137156 - Zalathar:proj-perf, r=<try>

bors · bors · commit 1d0df2d7a57a · 2025-02-17T06:00:31.000Z
[EXPERIMENTAL] Perf experiments for user-type projection and visiting primary bindings

r? ghost
`@rustbot` experimental
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -457,38 +457,38 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for TypeVerifier<'a, 'b, 'tcx> {
     fn visit_local_decl(&mut self, local: Local, local_decl: &LocalDecl<'tcx>) {
         self.super_local_decl(local, local_decl);
 
-        if let Some(user_ty) = &local_decl.user_ty {
-            for (user_ty, span) in user_ty.projections_and_spans() {
-                let ty = if !local_decl.is_nonref_binding() {
-                    // If we have a binding of the form `let ref x: T = ..`
-                    // then remove the outermost reference so we can check the
-                    // type annotation for the remaining type.
-                    if let ty::Ref(_, rty, _) = local_decl.ty.kind() {
-                        *rty
-                    } else {
-                        bug!("{:?} with ref binding has wrong type {}", local, local_decl.ty);
-                    }
-                } else {
-                    local_decl.ty
-                };
+        for user_ty in
+            local_decl.user_ty.as_ref().into_iter().flat_map(UserTypeProjections::projections)
+        {
+            let span = self.typeck.user_type_annotations[user_ty.base].span;
+
+            let ty = if local_decl.is_nonref_binding() {
+                local_decl.ty
+            } else if let &ty::Ref(_, rty, _) = local_decl.ty.kind() {
+                // If we have a binding of the form `let ref x: T = ..`
+                // then remove the outermost reference so we can check the
+                // type annotation for the remaining type.
+                rty
+            } else {
+                bug!("{:?} with ref binding has wrong type {}", local, local_decl.ty);
+            };
 
-                if let Err(terr) = self.typeck.relate_type_and_user_type(
-                    ty,
-                    ty::Invariant,
-                    user_ty,
-                    Locations::All(*span),
-                    ConstraintCategory::TypeAnnotation(AnnotationSource::Declaration),
-                ) {
-                    span_mirbug!(
-                        self,
-                        local,
-                        "bad user type on variable {:?}: {:?} != {:?} ({:?})",
-                        local,
-                        local_decl.ty,
-                        local_decl.user_ty,
-                        terr,
-                    );
-                }
+            if let Err(terr) = self.typeck.relate_type_and_user_type(
+                ty,
+                ty::Invariant,
+                &user_ty,
+                Locations::All(span),
+                ConstraintCategory::TypeAnnotation(AnnotationSource::Declaration),
+            ) {
+                span_mirbug!(
+                    self,
+                    local,
+                    "bad user type on variable {:?}: {:?} != {:?} ({:?})",
+                    local,
+                    local_decl.ty,
+                    local_decl.user_ty,
+                    terr,
+                );
             }
         }
     }
diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
@@ -2,6 +2,7 @@
 //!
 //! [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/mir/index.html
 
+use std::assert_matches::assert_matches;
 use std::borrow::Cow;
 use std::fmt::{self, Debug, Formatter};
 use std::ops::{Index, IndexMut};
@@ -37,7 +38,7 @@ use crate::ty::codec::{TyDecoder, TyEncoder};
 use crate::ty::print::{FmtPrinter, Printer, pretty_print_const, with_no_trimmed_paths};
 use crate::ty::visit::TypeVisitableExt;
 use crate::ty::{
-    self, AdtDef, GenericArg, GenericArgsRef, Instance, InstanceKind, List, Ty, TyCtxt, TypingEnv,
+    self, GenericArg, GenericArgsRef, Instance, InstanceKind, List, Ty, TyCtxt, TypingEnv,
     UserTypeAnnotationIndex,
 };
 
@@ -64,6 +65,7 @@ use pretty::pretty_print_const_value;
 pub use statement::*;
 pub use syntax::*;
 pub use terminator::*;
+use thin_vec::ThinVec;
 
 pub use self::generic_graph::graphviz_safe_def_name;
 pub use self::graphviz::write_mir_graphviz;
@@ -985,7 +987,7 @@ pub struct LocalDecl<'tcx> {
     /// borrow checker needs this information since it can affect
     /// region inference.
     // FIXME(matthewjasper) Don't store in this in `Body`
-    pub user_ty: Option<Box<UserTypeProjections>>,
+    pub user_ty: Option<UserTypeProjections>,
 
     /// The *syntactic* (i.e., not visibility) source scope the local is defined
     /// in. If the local was defined in a let-statement, this
@@ -1560,64 +1562,73 @@ pub struct SourceScopeLocalData {
 /// &'static str`.
 #[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable, TypeFoldable, TypeVisitable)]
 pub struct UserTypeProjections {
-    pub contents: Vec<(UserTypeProjection, Span)>,
+    /// Instead of storing the projected user types directly, we store a flat list
+    /// of "operations" that can be used to build the projections as needed.
+    ///
+    /// The list happens to be stored in reverse order, because that's slightly
+    /// more convenient for the code that builds the list of ops.
+    ops_reversed: ThinVec<ProjectedUserTypesOp>,
+    // If this struct ever ceases to be pointer-sized, its field in `LocalDecl`
+    // should probably be boxed again.
 }
 
-impl<'tcx> UserTypeProjections {
-    pub fn none() -> Self {
-        UserTypeProjections { contents: vec![] }
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.contents.is_empty()
-    }
-
-    pub fn projections_and_spans(
-        &self,
-    ) -> impl Iterator<Item = &(UserTypeProjection, Span)> + ExactSizeIterator {
-        self.contents.iter()
-    }
-
-    pub fn projections(&self) -> impl Iterator<Item = &UserTypeProjection> + ExactSizeIterator {
-        self.contents.iter().map(|&(ref user_type, _span)| user_type)
-    }
-
-    pub fn push_projection(mut self, user_ty: &UserTypeProjection, span: Span) -> Self {
-        self.contents.push((user_ty.clone(), span));
-        self
-    }
-
-    fn map_projections(
-        mut self,
-        mut f: impl FnMut(UserTypeProjection) -> UserTypeProjection,
-    ) -> Self {
-        self.contents = self.contents.into_iter().map(|(proj, span)| (f(proj), span)).collect();
-        self
-    }
-
-    pub fn index(self) -> Self {
-        self.map_projections(|pat_ty_proj| pat_ty_proj.index())
-    }
-
-    pub fn subslice(self, from: u64, to: u64) -> Self {
-        self.map_projections(|pat_ty_proj| pat_ty_proj.subslice(from, to))
-    }
+/// One of a list of "operations" that can be used to reconstruct user-type projections.
+#[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable, TypeFoldable, TypeVisitable)]
+pub enum ProjectedUserTypesOp {
+    PushUserType { base: UserTypeAnnotationIndex },
+
+    Index,
+    Subslice { from: u64, to: u64 },
+    Deref,
+    Leaf { field: FieldIdx },
+    Variant { name: Symbol, variant: VariantIdx, field: FieldIdx },
+}
 
-    pub fn deref(self) -> Self {
-        self.map_projections(|pat_ty_proj| pat_ty_proj.deref())
+impl UserTypeProjections {
+    pub fn from_ops_reversed(ops_reversed: impl Iterator<Item = ProjectedUserTypesOp>) -> Self {
+        let ops_reversed = ops_reversed.collect::<ThinVec<_>>();
+        // The "first" op should always be `PushUserType`, because it would be
+        // useless for other ops to modify an empty list of projections.
+        assert_matches!(
+            ops_reversed.last(),
+            None | Some(ProjectedUserTypesOp::PushUserType { .. })
+        );
+        Self { ops_reversed }
     }
 
-    pub fn leaf(self, field: FieldIdx) -> Self {
-        self.map_projections(|pat_ty_proj| pat_ty_proj.leaf(field))
-    }
+    pub fn is_empty(&self) -> bool {
+        self.ops_reversed.is_empty()
+    }
+
+    pub fn projections(&self) -> impl Iterator<Item = UserTypeProjection> + ExactSizeIterator {
+        let mut projections = vec![];
+        // Iterate over the list of ops in "non-reversed" order.
+        for op in self.ops_reversed.iter().rev() {
+            match *op {
+                ProjectedUserTypesOp::PushUserType { base } => {
+                    // Add a new user type to the list of projections, which
+                    // will then be modified by subsequent projection ops.
+                    projections.push(UserTypeProjection { base, projs: vec![] });
+                }
 
-    pub fn variant(
-        self,
-        adt_def: AdtDef<'tcx>,
-        variant_index: VariantIdx,
-        field_index: FieldIdx,
-    ) -> Self {
-        self.map_projections(|pat_ty_proj| pat_ty_proj.variant(adt_def, variant_index, field_index))
+                ProjectedUserTypesOp::Index => {
+                    projections.iter_mut().for_each(|p| p.index());
+                }
+                ProjectedUserTypesOp::Subslice { from, to } => {
+                    projections.iter_mut().for_each(|p| p.subslice(from, to));
+                }
+                ProjectedUserTypesOp::Deref => {
+                    projections.iter_mut().for_each(|p| p.deref());
+                }
+                ProjectedUserTypesOp::Leaf { field } => {
+                    projections.iter_mut().for_each(|p| p.leaf(field));
+                }
+                ProjectedUserTypesOp::Variant { name, variant, field } => {
+                    projections.iter_mut().for_each(|p| p.variant(name, variant, field));
+                }
+            }
+        }
+        projections.into_iter()
     }
 }
 
@@ -1644,38 +1655,25 @@ pub struct UserTypeProjection {
 }
 
 impl UserTypeProjection {
-    pub(crate) fn index(mut self) -> Self {
+    fn index(&mut self) {
         self.projs.push(ProjectionElem::Index(()));
-        self
     }
 
-    pub(crate) fn subslice(mut self, from: u64, to: u64) -> Self {
+    fn subslice(&mut self, from: u64, to: u64) {
         self.projs.push(ProjectionElem::Subslice { from, to, from_end: true });
-        self
     }
 
-    pub(crate) fn deref(mut self) -> Self {
+    fn deref(&mut self) {
         self.projs.push(ProjectionElem::Deref);
-        self
     }
 
-    pub(crate) fn leaf(mut self, field: FieldIdx) -> Self {
+    fn leaf(&mut self, field: FieldIdx) {
         self.projs.push(ProjectionElem::Field(field, ()));
-        self
     }
 
-    pub(crate) fn variant(
-        mut self,
-        adt_def: AdtDef<'_>,
-        variant_index: VariantIdx,
-        field_index: FieldIdx,
-    ) -> Self {
-        self.projs.push(ProjectionElem::Downcast(
-            Some(adt_def.variant(variant_index).name),
-            variant_index,
-        ));
-        self.projs.push(ProjectionElem::Field(field_index, ()));
-        self
+    fn variant(&mut self, name: Symbol, variant: VariantIdx, field: FieldIdx) {
+        self.projs.push(ProjectionElem::Downcast(Some(name), variant));
+        self.projs.push(ProjectionElem::Field(field, ()));
     }
 }
 
diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs
@@ -222,13 +222,6 @@ macro_rules! make_mir_visitor {
                 self.super_ty(ty);
             }
 
-            fn visit_user_type_projection(
-                &mut self,
-                ty: & $($mutability)? UserTypeProjection,
-            ) {
-                self.super_user_type_projection(ty);
-            }
-
             fn visit_user_type_annotation(
                 &mut self,
                 index: UserTypeAnnotationIndex,
@@ -818,14 +811,13 @@ macro_rules! make_mir_visitor {
             fn super_ascribe_user_ty(&mut self,
                                      place: & $($mutability)? Place<'tcx>,
                                      variance: $(& $mutability)? ty::Variance,
-                                     user_ty: & $($mutability)? UserTypeProjection,
+                                     _user_ty: & $($mutability)? UserTypeProjection,
                                      location: Location) {
                 self.visit_place(
                     place,
                     PlaceContext::NonUse(NonUseContext::AscribeUserTy($(* &$mutability *)? variance)),
                     location
                 );
-                self.visit_user_type_projection(user_ty);
             }
 
             fn super_coverage(&mut self,
@@ -850,7 +842,7 @@ macro_rules! make_mir_visitor {
                 let LocalDecl {
                     mutability: _,
                     ty,
-                    user_ty,
+                    user_ty: _,
                     source_info,
                     local_info: _,
                 } = local_decl;
@@ -861,11 +853,6 @@ macro_rules! make_mir_visitor {
                     local,
                     source_info: *source_info,
                 });
-                if let Some(user_ty) = user_ty {
-                    for (user_ty, _) in & $($mutability)? user_ty.contents {
-                        self.visit_user_type_projection(user_ty);
-                    }
-                }
             }
 
             fn super_var_debug_info(
@@ -945,12 +932,6 @@ macro_rules! make_mir_visitor {
                 self.visit_source_scope($(& $mutability)? *scope);
             }
 
-            fn super_user_type_projection(
-                &mut self,
-                _ty: & $($mutability)? UserTypeProjection,
-            ) {
-            }
-
             fn super_user_type_annotation(
                 &mut self,
                 _index: UserTypeAnnotationIndex,
diff --git a/compiler/rustc_mir_build/src/builder/block.rs b/compiler/rustc_mir_build/src/builder/block.rs
@@ -199,19 +199,15 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                             None,
                             Some((Some(&destination), initializer_span)),
                         );
-                        this.visit_primary_bindings(
-                            pattern,
-                            UserTypeProjections::none(),
-                            &mut |this, _, _, node, span, _, _| {
-                                this.storage_live_binding(
-                                    block,
-                                    node,
-                                    span,
-                                    OutsideGuard,
-                                    ScheduleDrops::Yes,
-                                );
-                            },
-                        );
+                        this.visit_primary_bindings(pattern, &mut |this, node, span| {
+                            this.storage_live_binding(
+                                block,
+                                node,
+                                span,
+                                OutsideGuard,
+                                ScheduleDrops::Yes,
+                            );
+                        });
                         let else_block_span = this.thir[*else_block].span;
                         let (matching, failure) =
                             this.in_if_then_scope(last_remainder_scope, else_block_span, |this| {
@@ -295,20 +291,16 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         });
 
                         debug!("ast_block_stmts: pattern={:?}", pattern);
-                        this.visit_primary_bindings(
-                            pattern,
-                            UserTypeProjections::none(),
-                            &mut |this, _, _, node, span, _, _| {
-                                this.storage_live_binding(
-                                    block,
-                                    node,
-                                    span,
-                                    OutsideGuard,
-                                    ScheduleDrops::Yes,
-                                );
-                                this.schedule_drop_for_binding(node, span, OutsideGuard);
-                            },
-                        )
+                        this.visit_primary_bindings(pattern, &mut |this, node, span| {
+                            this.storage_live_binding(
+                                block,
+                                node,
+                                span,
+                                OutsideGuard,
+                                ScheduleDrops::Yes,
+                            );
+                            this.schedule_drop_for_binding(node, span, OutsideGuard);
+                        })
                     }
 
                     // Enter the visibility scope, after evaluating the initializer.
diff --git a/compiler/rustc_mir_build/src/builder/matches/mod.rs b/compiler/rustc_mir_build/src/builder/matches/mod.rs
