Split out generic arg equality for nll query response instantiation

Author: oli-obk

compiler/rustc_infer/src/infer/canonical/query_response.rs

@@ -262,50 +262,20 @@ impl<'tcx> InferCtxt<'tcx> {
 
         let constraint_category = cause.to_constraint_category();
 
-        for (index, original_value) in original_values.var_values.iter().enumerate() {
+        for (index, &original_value) in original_values.var_values.iter().enumerate() {
             // ...with the value `v_r` of that variable from the query.
             let result_value = query_response.instantiate_projected(self.tcx, &result_args, |v| {
                 v.var_values[BoundVar::new(index)]
             });
-            match (original_value.unpack(), result_value.unpack()) {
-                (GenericArgKind::Lifetime(re1), GenericArgKind::Lifetime(re2))
-                    if re1.is_erased() && re2.is_erased() =>
-                {
-                    // No action needed.
-                }
-
-                (GenericArgKind::Lifetime(v_o), GenericArgKind::Lifetime(v_r)) => {
-                    // To make `v_o = v_r`, we emit `v_o: v_r` and `v_r: v_o`.
-                    if v_o != v_r {
-                        output_query_region_constraints
-                            .outlives
-                            .push((ty::OutlivesPredicate(v_o.into(), v_r), constraint_category));
-                        output_query_region_constraints
-                            .outlives
-                            .push((ty::OutlivesPredicate(v_r.into(), v_o), constraint_category));
-                    }
-                }
-
-                (GenericArgKind::Type(v1), GenericArgKind::Type(v2)) => {
-                    obligations.extend(
-                        self.at(&cause, param_env)
-                            .eq(DefineOpaqueTypes::Yes, v1, v2)?
-                            .into_obligations(),
-                    );
-                }
-
-                (GenericArgKind::Const(v1), GenericArgKind::Const(v2)) => {
-                    obligations.extend(
-                        self.at(&cause, param_env)
-                            .eq(DefineOpaqueTypes::Yes, v1, v2)?
-                            .into_obligations(),
-                    );
-                }
-
-                _ => {
-                    bug!("kind mismatch, cannot unify {:?} and {:?}", original_value, result_value);
-                }
-            }
+            self.equate_generic_arg(
+                original_value,
+                result_value,
+                output_query_region_constraints,
+                constraint_category,
+                &mut obligations,
+                cause,
+                param_env,
+            )?;
         }
 
         // ...also include the other query region constraints from the query.
@@ -335,6 +305,57 @@ impl<'tcx> InferCtxt<'tcx> {
         Ok(InferOk { value: user_result, obligations })
     }
 
+    fn equate_generic_arg(
+        &self,
+        original_value: GenericArg<'tcx>,
+        result_value: GenericArg<'tcx>,
+        output_query_region_constraints: &mut QueryRegionConstraints<'tcx>,
+        constraint_category: ConstraintCategory<'tcx>,
+        obligations: &mut Vec<Obligation<'tcx, ty::Predicate<'tcx>>>,
+        cause: &ObligationCause<'tcx>,
+        param_env: ty::ParamEnv<'tcx>,
+    ) -> Result<(), ty::error::TypeError<'tcx>> {
+        Ok(match (original_value.unpack(), result_value.unpack()) {
+            (GenericArgKind::Lifetime(re1), GenericArgKind::Lifetime(re2))
+                if re1.is_erased() && re2.is_erased() =>
+            {
+                // No action needed.
+            }
+
+            (GenericArgKind::Lifetime(v_o), GenericArgKind::Lifetime(v_r)) => {
+                // To make `v_o = v_r`, we emit `v_o: v_r` and `v_r: v_o`.
+                if v_o != v_r {
+                    output_query_region_constraints
+                        .outlives
+                        .push((ty::OutlivesPredicate(v_o.into(), v_r), constraint_category));
+                    output_query_region_constraints
+                        .outlives
+                        .push((ty::OutlivesPredicate(v_r.into(), v_o), constraint_category));
+                }
+            }
+
+            (GenericArgKind::Type(v1), GenericArgKind::Type(v2)) => {
+                obligations.extend(
+                    self.at(&cause, param_env)
+                        .eq(DefineOpaqueTypes::Yes, v1, v2)?
+                        .into_obligations(),
+                );
+            }
+
+            (GenericArgKind::Const(v1), GenericArgKind::Const(v2)) => {
+                obligations.extend(
+                    self.at(&cause, param_env)
+                        .eq(DefineOpaqueTypes::Yes, v1, v2)?
+                        .into_obligations(),
+                );
+            }
+
+            _ => {
+                bug!("kind mismatch, cannot unify {:?} and {:?}", original_value, result_value);
+            }
+        })
+    }
+
     /// Given the original values and the (canonicalized) result from
     /// computing a query, returns an instantiation that can be applied
     /// to the query result to convert the result back into the