Contraint the var_values to not contain type and const inference variable during PostTypeckUntilBorrowck for auto trait opaque ty

Author: bit-aloo

compiler/rustc_next_trait_solver/src/solve/trait_goals.rs

@@ -5,7 +5,7 @@ use rustc_type_ir::fast_reject::DeepRejectCtxt;
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::lang_items::SolverTraitLangItem;
 use rustc_type_ir::solve::{
-    AliasBoundKind, CandidatePreferenceMode, CanonicalResponse, MaybeInfo,
+    AliasBoundKind, CandidatePreferenceMode, CanonicalResponse, ExternalConstraintsData, MaybeInfo,
     NoSolutionOrRerunNonErased, OpaqueTypesJank, QueryResultOrRerunNonErased, RerunNonErased,
     RerunReason, RerunResultExt, SizedTraitKind,
 };
@@ -1286,9 +1286,6 @@ where
     ) -> Result<Candidate<I>, NoSolutionOrRerunNonErased> {
         let cx = self.cx();
         let source = CandidateSource::BuiltinImpl(BuiltinImplSource::Misc);
-        if self.opaque_accesses.might_rerun() {
-            match self.opaque_accesses.rerun_always(RerunReason::AutoTraitLeakage)? {}
-        }
 
         for item_bound in cx.item_self_bounds(def_id.into()).skip_binder() {
             if item_bound.as_trait_clause().is_some_and(|b| b.def_id() == goal.predicate.def_id()) {
@@ -1303,25 +1300,49 @@ where
                 goal.with(cx, goal.predicate.with_replaced_self_ty(cx, hidden_ty)),
             )?;
             ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
-        });
+        })?;
 
-        let opaque_types_may_leak = match self.typing_mode() {
-            TypingMode::PostTypeckUntilBorrowck { .. } => false,
-            TypingMode::Coherence
-            | TypingMode::Typeck { .. }
-            | TypingMode::PostBorrowck { .. }
-            | TypingMode::Reflection
-            | TypingMode::PostAnalysis
-            | TypingMode::Codegen
-            | TypingMode::ErasedNotCoherence(MayBeErased) => true,
-        };
+        // Proving an auto trait for the hidden type must not constrain inference
+        // variables, as that would leak the hidden type itself.
+        if !candidate.result.value.var_values.is_identity_modulo_regions() {
+            return self.forced_ambiguity(MaybeInfo::AMBIGUOUS);
+        }
 
-        match candidate {
-            Ok(candidate) if has_only_region_constraints(candidate.result) => Ok(candidate),
-            Ok(candidate) if !opaque_types_may_leak => Ok(candidate),
-            Ok(_) => self.forced_ambiguity(MaybeInfo::AMBIGUOUS),
-            Err(err) => Err(err),
+        let ExternalConstraintsData {
+            region_constraints: _,
+            ref opaque_types,
+            ref normalization_nested_goals,
+        } = *candidate.result.value.external_constraints;
+        debug_assert!(normalization_nested_goals.is_empty());
+
+        // New defining uses may leak an opaque's hidden type into the caller's
+        // inference state. This is safe after typeck, where hidden types are already
+        // fixed and only regions are inferred, but not during typeck while hidden
+        // types may still contain inference variables.
+        if !opaque_types.is_empty() {
+            match self.typing_mode() {
+                // We're inferring regions of opaque types, but
+                // the type itself is already fully known, no way
+                // to leak the hidden type.
+                TypingMode::PostTypeckUntilBorrowck { .. } => {}
+                // We're inferring the hidden type of opaques, could
+                // leak types through it.
+                TypingMode::Typeck { .. } => {
+                    return self.forced_ambiguity(MaybeInfo::AMBIGUOUS);
+                }
+                // we never add new uses to the opaque type storage
+                TypingMode::Coherence
+                | TypingMode::PostBorrowck { .. }
+                | TypingMode::Reflection
+                | TypingMode::PostAnalysis
+                | TypingMode::Codegen
+                | TypingMode::ErasedNotCoherence(MayBeErased) => {
+                    return self.forced_ambiguity(MaybeInfo::AMBIGUOUS);
+                }
+            }
         }
+
+        Ok(candidate)
     }
 
     // Return `Some` if there is an impl (built-in or user provided) that may

tests/ui/impl-trait/auto-trait-leakage/auxiliary/opaque-auto-trait-leakage.rs

@@ -1,3 +1,9 @@
+// External crate for `opaque-hidden-ty-inference.rs`.
+//
+// `define` returns `WaddupGamers<T, closure>`. Its `Unpin` impl only holds if
+// `<T as Leak>::Assoc` is that closure. The test's caller says `Assoc` is its
+// own opaque type instead, so checking `Unpin` would try to set that opaque
+// type to this closure.
 pub struct WaddupGamers<T, U>(Option<T>, U);
 
 impl<T: Leak<Assoc = U>, U> Unpin for WaddupGamers<T, U> {}

tests/ui/impl-trait/auto-trait-leakage/opaque-hidden-ty-inference.stderr

@@ -6,7 +6,7 @@ LL |     let opaque = require_auto(define::<T>());
    |                  |
    |                  required by a bound introduced by this call
    |
-  ::: $DIR/auxiliary/opaque-auto-trait-leakage.rs:14:29
+  ::: $DIR/auxiliary/opaque-auto-trait-leakage.rs:20:29
    |
 LL |     WaddupGamers(None::<T>, || ())
    |                             -- the expected closure
@@ -15,7 +15,7 @@ LL |     WaddupGamers(None::<T>, || ())
                  found type `!`
    = note: required for `WaddupGamers<T, {closure@dep::define<T>::{closure#0}}>` to implement `Unpin`
 note: required because it appears within the type `impl Sized`
-  --> $DIR/auxiliary/opaque-auto-trait-leakage.rs:13:23
+  --> $DIR/auxiliary/opaque-auto-trait-leakage.rs:19:23
    |
 LL | pub fn define<T>() -> impl Sized {
    |                       ^^^^^^^^^^