Actually prevent cycle errors

Author: oli-obk

compiler/rustc_hir_analysis/src/collect/type_of.rs

@@ -4,6 +4,7 @@ use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::intravisit;
 use rustc_hir::intravisit::Visitor;
 use rustc_hir::{HirId, Node};
+use rustc_infer::infer::opaque_types::may_define_opaque_type;
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::print::with_forced_trimmed_paths;
 use rustc_middle::ty::subst::InternalSubsts;
@@ -589,6 +590,12 @@ fn find_opaque_ty_constraints_for_tait(tcx: TyCtxt<'_>, def_id: LocalDefId) -> T
                 debug!("no constraint: no typeck results");
                 return;
             }
+
+            if !may_define_opaque_type(self.tcx, item_def_id, self.def_id) {
+                debug!("no constraint: does not have TAIT in signature");
+                return;
+            }
+
             // Calling `mir_borrowck` can lead to cycle errors through
             // const-checking, avoid calling it if we don't have to.
             // ```rust

compiler/rustc_infer/src/infer/opaque_types.rs

@@ -638,11 +638,19 @@ impl<'tcx> InferCtxt<'tcx> {
 /// and `opaque_hir_id` is the `HirId` of the definition of the opaque type `Baz`.
 /// For the above example, this function returns `true` for `f1` and `false` for `f2`.
 #[instrument(skip(tcx), level = "trace", ret)]
-fn may_define_opaque_type<'tcx>(
+pub fn may_define_opaque_type<'tcx>(
     tcx: TyCtxt<'tcx>,
     def_id: LocalDefId,
     opaque_def_id: LocalDefId,
 ) -> bool {
+    if tcx.is_closure(def_id.to_def_id()) {
+        return may_define_opaque_type(
+            tcx,
+            tcx.parent(def_id.to_def_id()).expect_local(),
+            opaque_def_id,
+        );
+    }
+
     let param_env = tcx.param_env(def_id);
     let opaque_hir_id = tcx.hir().local_def_id_to_hir_id(opaque_def_id);
     let mut hir_id = tcx.hir().local_def_id_to_hir_id(def_id);

tests/ui/type-alias-impl-trait/auto-trait-leakage3.rs

@@ -1,11 +1,10 @@
 #![feature(type_alias_impl_trait)]
 #![allow(dead_code)]
 
-// FIXME This should compile, but it currently doesn't
+// check-pass
 
 mod m {
     type Foo = impl std::fmt::Debug;
-    //~^ ERROR: cycle detected when computing type of `m::Foo::{opaque#0}` [E0391]
 
     pub fn foo() -> Foo {
         22_u32

tests/ui/type-alias-impl-trait/auto-trait-leakage3.stderr

@@ -1,10 +1,11 @@
 #![feature(type_alias_impl_trait)]
 
+// check-pass
+
 // Check that, even within the defining scope, we can get the
 // `Send` or `Sync` bound of a TAIT, as long as the current function
 // doesn't mention those TAITs in the signature
 type Foo = impl std::fmt::Debug;
-//~^ ERROR cycle detected
 
 fn is_send<T: Send>() {}
 

tests/ui/type-alias-impl-trait/defining-scopes-cycle-prevention.rs

@@ -7,6 +7,8 @@ type DropType<T> = ();
 //~^ ERROR type parameter `T` is unused
 
 type Foo = impl std::fmt::Debug;
+//~^ ERROR unconstrained opaque type
+
 // Check that, even though `Foo` is not part
 // of the actual type, we do allow this to be a defining scope
 fn g() -> DropType<Foo> {

tests/ui/type-alias-impl-trait/defining-scopes-cycle-prevention.stderr

@@ -4,8 +4,16 @@ error[E0091]: type parameter `T` is unused
 LL | type DropType<T> = ();
    |               ^ unused type parameter
 
+error: unconstrained opaque type
+  --> $DIR/defining-scopes-syntactic.rs:9:12
+   |
+LL | type Foo = impl std::fmt::Debug;
+   |            ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `Foo` must be used in combination with a concrete type within the same module
+
 error[E0308]: mismatched types
-  --> $DIR/defining-scopes-syntactic.rs:13:18
+  --> $DIR/defining-scopes-syntactic.rs:15:18
    |
 LL | type Foo = impl std::fmt::Debug;
    |            -------------------- the expected opaque type
@@ -18,7 +26,7 @@ LL |     let _: Foo = 42;
    = note: expected opaque type `Foo`
                      found type `{integer}`
 
-error: aborting due to 2 previous errors
+error: aborting due to 3 previous errors
 
 Some errors have detailed explanations: E0091, E0308.
 For more information about an error, try `rustc --explain E0091`.

tests/ui/type-alias-impl-trait/defining-scopes-syntactic.rs

@@ -3,17 +3,20 @@
 use std::fmt::Debug;
 
 type Foo = impl Debug;
-pub trait Yay { }
-impl Yay for Foo { }
+pub trait Yay {}
+impl Yay for Foo {}
 
-fn foo() {
-    is_yay::<u32>();   //~ ERROR: the trait bound `u32: Yay` is not satisfied
+fn foo()
+where
+    Foo: Debug,
+{
+    is_yay::<u32>(); //~ ERROR: the trait bound `u32: Yay` is not satisfied
     is_debug::<u32>(); // OK
-    is_yay::<Foo>();   // OK
+    is_yay::<Foo>(); // OK
     is_debug::<Foo>(); // OK
 }
 
-fn is_yay<T: Yay>() { }
-fn is_debug<T: Debug>() { }
+fn is_yay<T: Yay>() {}
+fn is_debug<T: Debug>() {}
 
 fn main() {}