Don't let thte diagnostic leak the inner types of opaque types

Author: bit-aloo

compiler/rustc_trait_selection/src/solve/fulfill/derive_errors.rs

@@ -1,8 +1,8 @@
 use std::ops::ControlFlow;
 
-use rustc_hir::LangItem;
+use rustc_hir::{self as hir, LangItem};
 use rustc_infer::infer::InferCtxt;
-use rustc_infer::traits::solve::{CandidateSource, GoalSource, MaybeCause};
+use rustc_infer::traits::solve::{BuiltinImplSource, CandidateSource, GoalSource, MaybeCause};
 use rustc_infer::traits::{
     self, MismatchedProjectionTypes, Obligation, ObligationCause, ObligationCauseCode,
     PredicateObligation, SelectionError,
@@ -248,6 +248,55 @@ impl<'tcx> BestObligation<'tcx> {
         candidates
     }
 
+    fn is_opaque_auto_trait_candidate(
+        &self,
+        tcx: TyCtxt<'tcx>,
+        candidate: &inspect::InspectCandidate<'_, 'tcx>,
+        pred: ty::Predicate<'tcx>,
+    ) -> bool {
+        self.is_builtin_misc_trait_candidate(candidate)
+            && self.is_positive_auto_trait_predicate_with_opaque_self(tcx, pred)
+    }
+
+    fn is_builtin_misc_trait_candidate(
+        &self,
+        candidate: &inspect::InspectCandidate<'_, 'tcx>,
+    ) -> bool {
+        matches!(
+            candidate.kind(),
+            inspect::ProbeKind::TraitCandidate {
+                source: CandidateSource::BuiltinImpl(BuiltinImplSource::Misc),
+                result: _,
+            }
+        )
+    }
+
+    fn is_positive_auto_trait_predicate_with_opaque_self(
+        &self,
+        tcx: TyCtxt<'tcx>,
+        pred: ty::Predicate<'tcx>,
+    ) -> bool {
+        let ty::PredicateKind::Clause(ty::ClauseKind::Trait(trait_pred)) =
+            pred.kind().skip_binder()
+        else {
+            return false;
+        };
+
+        if trait_pred.polarity != ty::PredicatePolarity::Positive
+            || !tcx.trait_is_auto(trait_pred.def_id())
+        {
+            return false;
+        }
+
+        let ty::Alias(_, ty::AliasTy { kind: ty::Opaque { def_id, .. }, .. }) =
+            trait_pred.self_ty().kind()
+        else {
+            return false;
+        };
+
+        !matches!(tcx.opaque_ty_origin(*def_id), hir::OpaqueTyOrigin::AsyncFn { .. })
+    }
+
     /// HACK: We walk the nested obligations for a well-formed arg manually,
     /// since there's nontrivial logic in `wf.rs` to set up an obligation cause.
     /// Ideally we'd be able to track this better.
@@ -447,6 +496,13 @@ impl<'tcx> ProofTreeVisitor<'tcx> for BestObligation<'tcx> {
             return ControlFlow::Break(self.obligation.clone());
         }
 
+        // Don't walk into opaque auto trait candidates, as doing so would expose
+        // the opaque's hidden type in diagnostics outside of its defining scope.
+        if self.is_opaque_auto_trait_candidate(tcx, candidate, pred) {
+            trace!("opaque auto trait candidate -> exit");
+            return ControlFlow::Break(self.obligation.clone());
+        }
+
         // FIXME: Also, what about considering >1 layer up the stack? May be necessary
         // for normalizes-to.
         let child_mode = match pred.kind().skip_binder() {

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

@@ -23,7 +23,7 @@ where
     // Proving `impl Sized: Unpin` must not constrain `NameMe<T>`
     // to the foreign closure hidden inside `define`.
     let opaque = require_auto(define::<T>());
-    //~^ ERROR type annotations needed
+    //~^ ERROR `impl Sized` cannot be unpinned
     let closure;
     loop {}
     return closure;

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

@@ -1,12 +1,13 @@
-error[E0283]: type annotations needed: cannot satisfy `impl Sized: Unpin`
+error[E0277]: `impl Sized` cannot be unpinned
   --> $DIR/opaque-hidden-ty-inference.rs:25:31
    |
 LL |     let opaque = require_auto(define::<T>());
-   |                  ------------ ^^^^^^^^^^^^^
+   |                  ------------ ^^^^^^^^^^^^^ the trait `Unpin` is not implemented for `impl Sized`
    |                  |
    |                  required by a bound introduced by this call
    |
-   = note: cannot satisfy `impl Sized: Unpin`
+   = note: consider using the `pin!` macro
+           consider using `Box::pin` if you need to access the pinned value outside of the current scope
 note: required by a bound in `require_auto`
   --> $DIR/opaque-hidden-ty-inference.rs:12:20
    |
@@ -15,4 +16,4 @@ LL | fn require_auto<T: Unpin>(x: T) -> T {
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0283`.
+For more information about this error, try `rustc --explain E0277`.