Remove some duplication

Author: aapoalas

compiler/rustc_hir_analysis/src/coherence/builtin.rs

@@ -503,14 +503,8 @@ pub(crate) fn reborrow_info<'tcx>(
 
     let source = tcx.type_of(impl_did).instantiate_identity();
     let trait_ref = tcx.impl_trait_ref(impl_did).instantiate_identity();
-    let lifetime_params_count = tcx
-        .generics_of(impl_did)
-        .own_params
-        .iter()
-        .filter(|p| matches!(p.kind, ty::GenericParamDefKind::Lifetime))
-        .count();
 
-    if lifetime_params_count != 1 {
+    if trait_impl_lifetime_params_count(tcx, impl_did) != 1 {
         return Err(tcx
             .dcx()
             .emit_err(errors::CoerceSharedNotSingleLifetimeParam { span, trait_name }));
@@ -528,20 +522,8 @@ pub(crate) fn reborrow_info<'tcx>(
         }
     };
 
-    let lifetimes_count = args.iter().filter(|arg| arg.as_region().is_some()).count();
-    let data_fields = def
-        .non_enum_variant()
-        .fields
-        .iter()
-        .filter_map(|f| {
-            // Ignore PhantomData fields
-            let ty = f.ty(tcx, args);
-            if ty.is_phantom_data() {
-                return None;
-            }
-            Some((ty, tcx.def_span(f.did)))
-        })
-        .collect::<Vec<_>>();
+    let lifetimes_count = generic_lifetime_params_count(args);
+    let data_fields = collect_struct_data_fields(tcx, def, args);
 
     if lifetimes_count != 1 {
         let item = tcx.hir_expect_item(impl_did);
@@ -618,14 +600,8 @@ pub(crate) fn coerce_shared_info<'tcx>(
 
     let source = tcx.type_of(impl_did).instantiate_identity();
     let trait_ref = tcx.impl_trait_ref(impl_did).instantiate_identity();
-    let lifetime_params_count = tcx
-        .generics_of(impl_did)
-        .own_params
-        .iter()
-        .filter(|p| matches!(p.kind, ty::GenericParamDefKind::Lifetime))
-        .count();
 
-    if lifetime_params_count != 1 {
+    if trait_impl_lifetime_params_count(tcx, impl_did) != 1 {
         return Err(tcx
             .dcx()
             .emit_err(errors::CoerceSharedNotSingleLifetimeParam { span, trait_name }));
@@ -650,36 +626,10 @@ pub(crate) fn coerce_shared_info<'tcx>(
             // support multiple lifetime arguments (with the reborrowed lifetimes inferred from
             // usage one way or another) and multiple data fields with B allowed to leave out fields
             // from A. The current state is just the simplest choice.
-            let a_lifetimes_count = args_a.iter().filter(|arg| arg.as_region().is_some()).count();
-            let a_data_fields = def_a
-                .non_enum_variant()
-                .fields
-                .iter_enumerated()
-                .filter_map(|(i, f)| {
-                    let a = f.ty(tcx, args_b);
-
-                    if a.is_phantom_data() {
-                        return None;
-                    }
-
-                    Some((i, a, tcx.def_span(f.did)))
-                })
-                .collect::<Vec<_>>();
-            let b_lifetimes_count = args_b.iter().filter(|arg| arg.as_region().is_some()).count();
-            let b_data_fields = def_b
-                .non_enum_variant()
-                .fields
-                .iter_enumerated()
-                .filter_map(|(i, f)| {
-                    let b = f.ty(tcx, args_b);
-
-                    if b.is_phantom_data() {
-                        return None;
-                    }
-
-                    Some((i, b, tcx.def_span(f.did)))
-                })
-                .collect::<Vec<_>>();
+            let a_lifetimes_count = generic_lifetime_params_count(args_a);
+            let a_data_fields = collect_struct_data_fields(tcx, def_a, args_a);
+            let b_lifetimes_count = generic_lifetime_params_count(args_b);
+            let b_data_fields = collect_struct_data_fields(tcx, def_b, args_b);
 
             if a_lifetimes_count != 1
                 || b_lifetimes_count != 1
@@ -702,8 +652,8 @@ pub(crate) fn coerce_shared_info<'tcx>(
             if a_data_fields.len() == 1 {
                 // We found one data field for both: we'll attempt to perform CoerceShared between
                 // them below.
-                let (_a_i, a, span_a) = a_data_fields[0];
-                let (_b_i, b, span_b) = b_data_fields[0];
+                let (a, span_a) = a_data_fields[0];
+                let (b, span_b) = b_data_fields[0];
 
                 Some((a, b, coerce_shared_trait, span_a, span_b))
             } else {
@@ -772,6 +722,37 @@ pub(crate) fn coerce_shared_info<'tcx>(
     Ok(())
 }
 
+fn trait_impl_lifetime_params_count(tcx: TyCtxt<'_>, did: LocalDefId) -> usize {
+    tcx.generics_of(did)
+        .own_params
+        .iter()
+        .filter(|p| matches!(p.kind, ty::GenericParamDefKind::Lifetime))
+        .count()
+}
+
+fn generic_lifetime_params_count(args: &[ty::GenericArg<'_>]) -> usize {
+    args.iter().filter(|arg| arg.as_region().is_some()).count()
+}
+
+fn collect_struct_data_fields<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    def: ty::AdtDef<'tcx>,
+    args: ty::GenericArgsRef<'tcx>,
+) -> Vec<(Ty<'tcx>, Span)> {
+    def.non_enum_variant()
+        .fields
+        .iter()
+        .filter_map(|f| {
+            // Ignore PhantomData fields
+            let ty = f.ty(tcx, args);
+            if ty.is_phantom_data() {
+                return None;
+            }
+            Some((ty, tcx.def_span(f.did)))
+        })
+        .collect()
+}
+
 fn assert_field_type_is_copy<'tcx>(
     tcx: TyCtxt<'tcx>,
     infcx: &InferCtxt<'tcx>,