Do not assert that a change in global cache only happens when concurrent

Author: jackh726

compiler/rustc_middle/src/ty/context.rs

@@ -207,8 +207,9 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         from_entry(entry)
     }
 
-    fn evaluation_is_concurrent(&self) -> bool {
-        self.sess.threads() > 1
+    fn assert_evaluation_is_concurrent(&self) {
+        // Turns out, the assumption for this function isn't perfect.
+        // See trait-system-refactor-initiative#234.
     }
 
     fn expand_abstract_consts<T: TypeFoldable<TyCtxt<'tcx>>>(self, t: T) -> T {

compiler/rustc_type_ir/src/interner.rs

@@ -185,7 +185,9 @@ pub trait Interner:
         from_entry: impl FnOnce(&CanonicalParamEnvCacheEntry<Self>) -> R,
     ) -> R;
 
-    fn evaluation_is_concurrent(&self) -> bool;
+    // Useful for testing. If a cache entry is replaced, this should
+    // (in theory) only happen when concurrent.
+    fn assert_evaluation_is_concurrent(&self);
 
     fn expand_abstract_consts<T: TypeFoldable<Self>>(self, t: T) -> T;
 
@@ -569,7 +571,7 @@ impl<I: Interner> search_graph::Cx for I {
     fn with_global_cache<R>(self, f: impl FnOnce(&mut search_graph::GlobalCache<Self>) -> R) -> R {
         I::with_global_cache(self, f)
     }
-    fn evaluation_is_concurrent(&self) -> bool {
-        self.evaluation_is_concurrent()
+    fn assert_evaluation_is_concurrent(&self) {
+        self.assert_evaluation_is_concurrent()
     }
 }

compiler/rustc_type_ir/src/search_graph/global_cache.rs

@@ -56,13 +56,13 @@ impl<X: Cx> GlobalCache<X> {
             let with_overflow = WithOverflow { nested_goals, result };
             let prev = entry.with_overflow.insert(required_depth, with_overflow);
             if let Some(prev) = &prev {
-                assert!(cx.evaluation_is_concurrent());
+                cx.assert_evaluation_is_concurrent();
                 assert_eq!(cx.get_tracked(&prev.result), evaluation_result.result);
             }
         } else {
             let prev = entry.success.replace(Success { required_depth, nested_goals, result });
             if let Some(prev) = &prev {
-                assert!(cx.evaluation_is_concurrent());
+                cx.assert_evaluation_is_concurrent();
                 assert_eq!(cx.get_tracked(&prev.result), evaluation_result.result);
             }
         }

compiler/rustc_type_ir/src/search_graph/mod.rs

@@ -53,7 +53,7 @@ pub trait Cx: Copy {
 
     fn with_global_cache<R>(self, f: impl FnOnce(&mut GlobalCache<Self>) -> R) -> R;
 
-    fn evaluation_is_concurrent(&self) -> bool;
+    fn assert_evaluation_is_concurrent(&self);
 }
 
 pub trait Delegate: Sized {

tests/ui/traits/next-solver/fn-delegation-opaque-cycle.current.stderr

@@ -0,0 +1,22 @@
+error[E0391]: cycle detected when computing type of `opaque::<impl at $DIR/fn-delegation-opaque-cycle.rs:25:5: 25:24>::opaque_ret::{anon_assoc#0}`
+  --> $DIR/fn-delegation-opaque-cycle.rs:26:25
+   |
+LL |         reuse to_reuse::opaque_ret;
+   |                         ^^^^^^^^^^
+   |
+note: ...which requires comparing an impl and trait method signature, inferring any hidden `impl Trait` types in the process...
+  --> $DIR/fn-delegation-opaque-cycle.rs:26:25
+   |
+LL |         reuse to_reuse::opaque_ret;
+   |                         ^^^^^^^^^^
+   = note: ...which again requires computing type of `opaque::<impl at $DIR/fn-delegation-opaque-cycle.rs:25:5: 25:24>::opaque_ret::{anon_assoc#0}`, completing the cycle
+note: cycle used when checking assoc item `opaque::<impl at $DIR/fn-delegation-opaque-cycle.rs:25:5: 25:24>::opaque_ret` is compatible with trait definition
+  --> $DIR/fn-delegation-opaque-cycle.rs:26:25
+   |
+LL |         reuse to_reuse::opaque_ret;
+   |                         ^^^^^^^^^^
+   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0391`.

tests/ui/traits/next-solver/fn-delegation-opaque-cycle.next.stderr

@@ -0,0 +1,18 @@
+error[E0391]: cycle detected when computing type of `opaque::<impl at $DIR/fn-delegation-opaque-cycle.rs:25:5: 25:24>::opaque_ret::{anon_assoc#0}`
+  --> $DIR/fn-delegation-opaque-cycle.rs:26:25
+   |
+LL |         reuse to_reuse::opaque_ret;
+   |                         ^^^^^^^^^^
+   |
+note: ...which requires comparing an impl and trait method signature, inferring any hidden `impl Trait` types in the process...
+  --> $DIR/fn-delegation-opaque-cycle.rs:26:25
+   |
+LL |         reuse to_reuse::opaque_ret;
+   |                         ^^^^^^^^^^
+   = note: ...which again requires computing type of `opaque::<impl at $DIR/fn-delegation-opaque-cycle.rs:25:5: 25:24>::opaque_ret::{anon_assoc#0}`, completing the cycle
+   = note: cycle used when computing implied outlives bounds for `<u8 as opaque::ToReuse>::opaque_ret::{anon_assoc#0}` (hack disabled = false)
+   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0391`.

tests/ui/traits/next-solver/fn-delegation-opaque-cycle.rs

@@ -0,0 +1,30 @@
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+//@ check-fail
+
+// Regression test for trait-system-refactor-initiative#234. If we end up in a
+// query cycle, it should be okay as long as results are the same.
+
+#![feature(fn_delegation)]
+#![allow(incomplete_features)]
+
+mod opaque {
+    trait Trait {}
+    impl Trait for () {}
+
+    mod to_reuse {
+        use super::Trait;
+        pub fn opaque_ret() -> impl Trait { () }
+    }
+
+    trait ToReuse {
+        fn opaque_ret() -> impl Trait { () }
+    }
+
+    impl ToReuse for u8 {
+        reuse to_reuse::opaque_ret; //~ ERROR cycle detected when computing type
+    }
+}
+
+fn main() {}