Store UserTypeProjections as a flat list of "ops"

Author: Zalathar

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -458,7 +458,7 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for TypeVerifier<'a, 'b, 'tcx> {
         self.super_local_decl(local, local_decl);
 
         for user_ty in
-            local_decl.user_ty.as_deref().into_iter().flat_map(UserTypeProjections::projections)
+            local_decl.user_ty.as_ref().into_iter().flat_map(UserTypeProjections::projections)
         {
             let span = self.typeck.user_type_annotations[user_ty.base].span;
 
@@ -476,7 +476,7 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for TypeVerifier<'a, 'b, 'tcx> {
             if let Err(terr) = self.typeck.relate_type_and_user_type(
                 ty,
                 ty::Invariant,
-                user_ty,
+                &user_ty,
                 Locations::All(span),
                 ConstraintCategory::TypeAnnotation(AnnotationSource::Declaration),
             ) {

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,55 +1562,73 @@ pub struct SourceScopeLocalData {
 /// &'static str`.
 #[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable, TypeFoldable, TypeVisitable)]
 pub struct UserTypeProjections {
-    pub contents: Vec<UserTypeProjection>,
+    /// 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(&self) -> impl Iterator<Item = &UserTypeProjection> + ExactSizeIterator {
-        self.contents.iter()
-    }
-
-    pub fn push_user_type(mut self, base_user_type: UserTypeAnnotationIndex) -> Self {
-        self.contents.push(UserTypeProjection { base: base_user_type, projs: vec![] });
-        self
-    }
-
-    fn map_projections(mut self, f: impl FnMut(UserTypeProjection) -> UserTypeProjection) -> Self {
-        self.contents = self.contents.into_iter().map(f).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()
     }
 }
 
@@ -1635,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, ()));
     }
 }