Address CoerceShared field relation review

Author: P8L1

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -25,14 +25,15 @@ use rustc_middle::mir::*;
 use rustc_middle::traits::query::NoSolution;
 use rustc_middle::ty::adjustment::PointerCoercion;
 use rustc_middle::ty::cast::CastTy;
+use rustc_middle::ty::reborrow::{self, CoerceSharedFieldPairError};
 use rustc_middle::ty::{
     self, CanonicalUserTypeAnnotation, CanonicalUserTypeAnnotations, CoroutineArgsExt,
     GenericArgsRef, Ty, TyCtxt, TypeVisitableExt, UserArgs, UserTypeAnnotationIndex, fold_regions,
 };
 use rustc_mir_dataflow::move_paths::MoveData;
 use rustc_mir_dataflow::points::DenseLocationMap;
 use rustc_span::def_id::CRATE_DEF_ID;
-use rustc_span::{Span, Spanned, Symbol, sym};
+use rustc_span::{Span, Spanned, sym};
 use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::traits::query::type_op::custom::scrape_region_constraints;
 use rustc_trait_selection::traits::query::type_op::{TypeOp, TypeOpOutput};
@@ -65,42 +66,6 @@ macro_rules! span_mirbug {
     })
 }
 
-#[derive(Clone, Copy)]
-struct ReborrowField<'tcx> {
-    index: FieldIdx,
-    name: Symbol,
-    ty: Ty<'tcx>,
-}
-
-fn reborrow_data_fields<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    def: ty::AdtDef<'tcx>,
-    args: GenericArgsRef<'tcx>,
-) -> Vec<ReborrowField<'tcx>> {
-    def.non_enum_variant()
-        .fields
-        .iter_enumerated()
-        .filter_map(|(index, field)| {
-            let ty = field.ty(tcx, args).skip_norm_wip();
-            (!ty.is_phantom_data()).then_some(ReborrowField { index, name: field.name, ty })
-        })
-        .collect()
-}
-
-fn reborrow_field_styles_match(a: ty::AdtDef<'_>, b: ty::AdtDef<'_>) -> bool {
-    a.non_enum_variant().ctor_kind() == b.non_enum_variant().ctor_kind()
-}
-
-fn find_corresponding_reborrow_field<'a, 'tcx>(
-    source_fields: &'a [ReborrowField<'tcx>],
-    target: ReborrowField<'tcx>,
-    by_index: bool,
-) -> Option<&'a ReborrowField<'tcx>> {
-    source_fields.iter().find(|source| {
-        if by_index { source.index == target.index } else { source.name == target.name }
-    })
-}
-
 pub(crate) mod canonical;
 pub(crate) mod constraint_conversion;
 pub(crate) mod free_region_relations;
@@ -2607,13 +2572,15 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         category: ConstraintCategory<'tcx>,
     ) -> Result<(), ()> {
         let tcx = self.tcx();
+        let borrowed_ty = self.normalize(ty::Unnormalized::new_wip(borrowed_ty), location);
+        let dest_ty = self.normalize(ty::Unnormalized::new_wip(dest_ty), location);
 
         if let (
             ty::Ref(borrow_region, _, Mutability::Mut),
             ty::Ref(ref_region, _, Mutability::Not),
         ) = (borrowed_ty.kind(), dest_ty.kind())
         {
-            if let Err(terr) = self.relate_types(
+            if let Err(terr) = self.relate_types_structurally_relating_aliases(
                 borrowed_ty.peel_refs(),
                 ty::Variance::Covariant,
                 dest_ty.peel_refs(),
@@ -2647,48 +2614,48 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             (ty::Adt(borrowed_adt, borrowed_args), ty::Adt(dest_adt, dest_args))
                 if borrowed_adt.did() != dest_adt.did() =>
             {
-                let borrowed_fields = reborrow_data_fields(tcx, *borrowed_adt, *borrowed_args);
-                let dest_fields = reborrow_data_fields(tcx, *dest_adt, *dest_args);
-
-                if !reborrow_field_styles_match(*borrowed_adt, *dest_adt) {
-                    span_mirbug!(
-                        self,
-                        borrowed_place,
-                        "generic shared reborrow has unsupported field structure: \
-                         {borrowed_ty:?} -> {dest_ty:?}"
-                    );
-                    return Err(());
-                }
-
-                let by_index =
-                    matches!(dest_adt.non_enum_variant().ctor_kind(), Some(hir::def::CtorKind::Fn));
-
-                for dest_field in dest_fields {
-                    let Some(borrowed_field) =
-                        find_corresponding_reborrow_field(&borrowed_fields, dest_field, by_index)
-                    else {
+                let field_pairs = match reborrow::coerce_shared_field_pairs(
+                    tcx,
+                    *borrowed_adt,
+                    *borrowed_args,
+                    *dest_adt,
+                    *dest_args,
+                ) {
+                    Ok(field_pairs) => field_pairs,
+                    Err(CoerceSharedFieldPairError::FieldStyleMismatch) => {
+                        span_mirbug!(
+                            self,
+                            borrowed_place,
+                            "generic shared reborrow has unsupported field structure: \
+                             {borrowed_ty:?} -> {dest_ty:?}"
+                        );
+                        return Err(());
+                    }
+                    Err(CoerceSharedFieldPairError::MissingSourceField { .. }) => {
                         span_mirbug!(
                             self,
                             borrowed_place,
                             "generic shared reborrow is missing a source field: \
                              {borrowed_ty:?} -> {dest_ty:?}"
                         );
                         return Err(());
-                    };
+                    }
+                };
 
+                for field_pair in field_pairs {
                     self.add_generic_shared_reborrow_constraints(
                         location,
                         borrowed_place,
-                        borrowed_field.ty,
-                        dest_field.ty,
+                        field_pair.source.ty,
+                        field_pair.target.ty,
                         category,
                     )?;
                 }
 
                 Ok(())
             }
             _ => {
-                if let Err(terr) = self.relate_types(
+                if let Err(terr) = self.relate_types_structurally_relating_aliases(
                     borrowed_ty,
                     ty::Variance::Covariant,
                     dest_ty,

compiler/rustc_borrowck/src/type_check/relate_tys.rs

@@ -40,8 +40,35 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         locations: Locations,
         category: ConstraintCategory<'tcx>,
     ) -> Result<(), NoSolution> {
-        NllTypeRelating::new(self, locations, category, UniverseInfo::relate(a, b), v)
-            .relate(a, b)?;
+        NllTypeRelating::new(
+            self,
+            locations,
+            category,
+            UniverseInfo::relate(a, b),
+            v,
+            StructurallyRelateAliases::No,
+        )
+        .relate(a, b)?;
+        Ok(())
+    }
+
+    pub(super) fn relate_types_structurally_relating_aliases(
+        &mut self,
+        a: Ty<'tcx>,
+        v: ty::Variance,
+        b: Ty<'tcx>,
+        locations: Locations,
+        category: ConstraintCategory<'tcx>,
+    ) -> Result<(), NoSolution> {
+        NllTypeRelating::new(
+            self,
+            locations,
+            category,
+            UniverseInfo::relate(a, b),
+            v,
+            StructurallyRelateAliases::Yes,
+        )
+        .relate(a, b)?;
         Ok(())
     }
 
@@ -53,8 +80,15 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         locations: Locations,
         category: ConstraintCategory<'tcx>,
     ) -> Result<(), NoSolution> {
-        NllTypeRelating::new(self, locations, category, UniverseInfo::other(), ty::Invariant)
-            .relate(a, b)?;
+        NllTypeRelating::new(
+            self,
+            locations,
+            category,
+            UniverseInfo::other(),
+            ty::Invariant,
+            StructurallyRelateAliases::No,
+        )
+        .relate(a, b)?;
         Ok(())
     }
 }
@@ -81,6 +115,8 @@ struct NllTypeRelating<'a, 'b, 'tcx> {
     ambient_variance: ty::Variance,
 
     ambient_variance_info: ty::VarianceDiagInfo<TyCtxt<'tcx>>,
+
+    structurally_relate_aliases: StructurallyRelateAliases,
 }
 
 impl<'a, 'b, 'tcx> NllTypeRelating<'a, 'b, 'tcx> {
@@ -90,6 +126,7 @@ impl<'a, 'b, 'tcx> NllTypeRelating<'a, 'b, 'tcx> {
         category: ConstraintCategory<'tcx>,
         universe_info: UniverseInfo<'tcx>,
         ambient_variance: ty::Variance,
+        structurally_relate_aliases: StructurallyRelateAliases,
     ) -> Self {
         Self {
             type_checker,
@@ -98,6 +135,7 @@ impl<'a, 'b, 'tcx> NllTypeRelating<'a, 'b, 'tcx> {
             universe_info,
             ambient_variance,
             ambient_variance_info: ty::VarianceDiagInfo::default(),
+            structurally_relate_aliases,
         }
     }
 
@@ -553,7 +591,7 @@ impl<'b, 'tcx> PredicateEmittingRelation<InferCtxt<'tcx>> for NllTypeRelating<'_
     }
 
     fn structurally_relate_aliases(&self) -> StructurallyRelateAliases {
-        StructurallyRelateAliases::No
+        self.structurally_relate_aliases
     }
 
     fn param_env(&self) -> ty::ParamEnv<'tcx> {

compiler/rustc_codegen_cranelift/src/base.rs

@@ -7,12 +7,12 @@ use cranelift_module::ModuleError;
 use rustc_ast::InlineAsmOptions;
 use rustc_codegen_ssa::base::is_call_from_compiler_builtins_to_upstream_monomorphization;
 use rustc_data_structures::profiling::SelfProfilerRef;
-use rustc_hir::def::CtorKind;
 use rustc_index::IndexVec;
 use rustc_middle::ty::TypeVisitableExt;
 use rustc_middle::ty::adjustment::PointerCoercion;
 use rustc_middle::ty::layout::{FnAbiOf, HasTypingEnv as _};
 use rustc_middle::ty::print::with_no_trimmed_paths;
+use rustc_middle::ty::reborrow::{self, CoerceSharedFieldPairError};
 use rustc_session::config::OutputFilenames;
 use rustc_span::Symbol;
 
@@ -959,7 +959,8 @@ fn codegen_reborrow_into<'tcx>(
     source_place: Place<'tcx>,
     dest: CPlace<'tcx>,
 ) {
-    let source_ty = source_place.ty(fx.mir, fx.tcx).ty;
+    let source_ty = fx.monomorphize(source_place.ty(fx.mir, fx.tcx).ty);
+    let target_ty = fx.monomorphize(target_ty);
     let (ty::Adt(source_def, source_args), ty::Adt(target_def, target_args)) =
         (source_ty.kind(), target_ty.kind())
     else {
@@ -974,41 +975,28 @@ fn codegen_reborrow_into<'tcx>(
         return;
     }
 
-    let source_variant = source_def.non_enum_variant();
-    let target_variant = target_def.non_enum_variant();
-    if source_variant.ctor_kind() != target_variant.ctor_kind() {
-        bug!("generic shared reborrow has mismatched field styles");
-    }
-
-    let by_index = matches!(target_variant.ctor_kind(), Some(CtorKind::Fn));
-    for (target_index, target_field) in target_variant.fields.iter_enumerated() {
-        let target_field_ty = target_field.ty(fx.tcx, target_args).skip_norm_wip();
-        if target_field_ty.is_phantom_data() {
-            continue;
+    let field_pairs = match reborrow::coerce_shared_field_pairs(
+        fx.tcx,
+        *source_def,
+        *source_args,
+        *target_def,
+        *target_args,
+    ) {
+        Ok(field_pairs) => field_pairs,
+        Err(CoerceSharedFieldPairError::FieldStyleMismatch) => {
+            bug!("generic shared reborrow has mismatched field styles");
         }
-
-        let source = source_variant
-            .fields
-            .iter_enumerated()
-            .find(|(source_index, source_field)| {
-                if by_index {
-                    *source_index == target_index
-                } else {
-                    source_field.name == target_field.name
-                }
-            })
-            .unwrap_or_else(|| bug!("generic shared reborrow is missing a source field"));
-
-        let source_index = source.0;
-        let source_field = source.1;
-        let source_field_ty = source_field.ty(fx.tcx, source_args).skip_norm_wip();
-        if source_field_ty.is_phantom_data() {
-            bug!("generic shared reborrow source field is PhantomData");
+        Err(CoerceSharedFieldPairError::MissingSourceField { .. }) => {
+            bug!("generic shared reborrow is missing a source field");
         }
+    };
 
-        let source_field_place =
-            source_place.project_deeper(&[PlaceElem::Field(source_index, source_field_ty)], fx.tcx);
-        let field_dest = dest.place_field(fx, target_index);
+    for field_pair in field_pairs {
+        let source_field_ty = fx.monomorphize(field_pair.source.ty);
+        let target_field_ty = fx.monomorphize(field_pair.target.ty);
+        let source_field_place = source_place
+            .project_deeper(&[PlaceElem::Field(field_pair.source.index, source_field_ty)], fx.tcx);
+        let field_dest = dest.place_field(fx, field_pair.target.index);
         codegen_reborrow_into(fx, target_field_ty, source_field_place, field_dest);
     }