When computing opaque types in the next solver, take an initial pass pre-fallback where we equate hidden types but do not report errors

Author: jackh726

compiler/rustc_hir_typeck/src/lib.rs

@@ -218,6 +218,12 @@ fn typeck_with_inspect<'tcx>(
     // the future.
     fcx.check_repeat_exprs();
 
+    // We need to handle opaque types before emitting ambiguity errors as applying
+    // defining uses may guide type inference.
+    if fcx.next_trait_solver() {
+        fcx.try_handle_opaque_type_uses_next();
+    }
+
     fcx.type_inference_fallback();
 
     // Even though coercion casts provide type hints, we check casts after fallback for

compiler/rustc_hir_typeck/src/opaque_types.rs

@@ -14,6 +14,29 @@ use tracing::{debug, instrument};
 use crate::FnCtxt;
 
 impl<'tcx> FnCtxt<'_, 'tcx> {
+    /// This takes all the opaque type uses during HIR typeck. It first computes
+    /// the concrete hidden type by iterating over all defining uses.
+    ///
+    /// A use during HIR typeck is defining if all non-lifetime arguments are
+    /// unique generic parameters and the hidden type does not reference any
+    /// inference variables.
+    ///
+    /// It then uses these defining uses to guide inference for all other uses.
+    ///
+    /// Unlike `handle_opaque_type_uses_next`, this does not report errors.
+    pub(super) fn try_handle_opaque_type_uses_next(&mut self) {
+        // We clone the opaques instead of stealing them here as they are still used for
+        // normalization in the next generation trait solver.
+        let mut opaque_types: Vec<_> = self.infcx.clone_opaque_types();
+        for entry in &mut opaque_types {
+            *entry = self.resolve_vars_if_possible(*entry);
+        }
+        debug!(?opaque_types);
+
+        self.compute_concrete_opaque_types(&opaque_types, true);
+        self.apply_computed_concrete_opaque_types(&opaque_types);
+    }
+
     /// This takes all the opaque type uses during HIR typeck. It first computes
     /// the concrete hidden type by iterating over all defining uses.
     ///
@@ -35,7 +58,7 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
         }
         debug!(?opaque_types);
 
-        self.compute_concrete_opaque_types(&opaque_types);
+        self.compute_concrete_opaque_types(&opaque_types, false);
         self.apply_computed_concrete_opaque_types(&opaque_types);
     }
 }
@@ -74,6 +97,7 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
     fn compute_concrete_opaque_types(
         &mut self,
         opaque_types: &[(OpaqueTypeKey<'tcx>, OpaqueHiddenType<'tcx>)],
+        first_pass: bool,
     ) {
         let tcx = self.tcx;
         let TypingMode::Analysis { defining_opaque_types_and_generators } = self.typing_mode()
@@ -94,12 +118,22 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
                     continue;
                 }
 
-                usage_kind.merge(self.consider_opaque_type_use(opaque_type_key, hidden_type));
+                usage_kind.merge(self.consider_opaque_type_use(
+                    opaque_type_key,
+                    hidden_type,
+                    first_pass,
+                ));
                 if let UsageKind::HasDefiningUse = usage_kind {
                     break;
                 }
             }
 
+            // If this the first pass (`try_handle_opaque_type_uses_next`),
+            // then do not report any errors.
+            if first_pass {
+                continue;
+            }
+
             let guar = match usage_kind {
                 UsageKind::None => {
                     if let Some(guar) = self.tainted_by_errors() {
@@ -152,6 +186,7 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
         &mut self,
         opaque_type_key: OpaqueTypeKey<'tcx>,
         hidden_type: OpaqueHiddenType<'tcx>,
+        first_pass: bool,
     ) -> UsageKind<'tcx> {
         if let Err(err) = opaque_type_has_defining_use_args(
             &self,
@@ -199,7 +234,13 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
             .borrow_mut()
             .concrete_opaque_types
             .insert(opaque_type_key.def_id, hidden_type);
-        assert!(prev.is_none());
+
+        // We do want to insert opaque types the first pass, because we want to
+        // equate them. So, the second pass (where we report errors) will have
+        // a hidden type inserted.
+        if first_pass {
+            assert!(prev.is_none());
+        }
         UsageKind::HasDefiningUse
     }
 
@@ -209,11 +250,14 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
     ) {
         let tcx = self.tcx;
         for &(key, hidden_type) in opaque_types {
-            let expected =
-                *self.typeck_results.borrow_mut().concrete_opaque_types.get(&key.def_id).unwrap();
-
-            let expected = EarlyBinder::bind(expected.ty).instantiate(tcx, key.args);
-            self.demand_eqtype(hidden_type.span, expected, hidden_type.ty);
+            // On the first pass to this function, some opaque types may not
+            // have a hidden type assigned.
+            if let Some(expected) =
+                self.typeck_results.borrow_mut().concrete_opaque_types.get(&key.def_id)
+            {
+                let expected = EarlyBinder::bind(expected.ty).instantiate(tcx, key.args);
+                self.demand_eqtype(hidden_type.span, expected, hidden_type.ty);
+            }
         }
     }