Unrolled build for #165497 in rollup 165510

Rollup merge of #165497 - WaffleLapkin:_, r=BoxyUwU

fix unsoundness when compiling `[diverging_const; _]`

Follow up to #165416, because I [missed a case](#165416 (comment)). r? @BoxyUwU

Author: bors

compiler/rustc_hir_typeck/src/expr.rs

@@ -31,7 +31,7 @@ use rustc_infer::traits::WellFormedLoc;
 use rustc_infer::traits::query::NoSolution;
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AllowTwoPhase};
 use rustc_middle::ty::error::{ExpectedFound, TypeError};
-use rustc_middle::ty::{self, AdtKind, GenericArgs, Ty, TypeVisitableExt, Unnormalized};
+use rustc_middle::ty::{self, AdtKind, ConstKind, GenericArgs, Ty, TypeVisitableExt, Unnormalized};
 use rustc_session::diagnostics::feature_err;
 use rustc_span::edit_distance::find_best_match_for_name;
 use rustc_span::hygiene::DesugaringKind;
@@ -1774,17 +1774,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             ),
         );
 
-        let count_is_zero = {
-            if let Ok(count) = tcx.try_normalize_erasing_regions(
-                self.typing_env(self.param_env),
-                Unnormalized::new_wip(count),
-            ) {
-                count.try_to_value().and_then(|c| c.try_to_target_usize(tcx)) == Some(0)
-            } else {
-                false
-            }
-        };
-
         let uty = match expected {
             ExpectHasType(uty) => uty.builtin_index(),
             _ => None,
@@ -1811,6 +1800,28 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // This is a problem, because it means if `CONST` is `const { panic!() }`, the side effect
         // of panic / failing compilation never happens. In such cases we need to ignore divergence
         // from the `CONST`, as otherwise we can end up executing code that was assumed unreachable.
+        let count_is_zero = match count.kind() {
+            // This is the exact check that mir building does
+            ConstKind::Value(v) => v.try_to_target_usize(tcx) == Some(0),
+
+            // An infer const can get inferred to 0.
+            //
+            // We could check the expectation here to do ad-hoc inference, but that feels quite
+            // error prone and annoying.
+            ConstKind::Infer(_) => true,
+
+            // While const generic params can be substituted with 0, mir building specifically
+            // checks for value 0 before monomorphization, so they (alongside aliases, etc) cannot
+            // trigger the bug.
+            ConstKind::Param(_)
+            | ConstKind::Placeholder(_)
+            | ConstKind::Alias(..)
+            | ConstKind::Error(_)
+            | ConstKind::Expr(_) => false,
+
+            ConstKind::Bound(..) => bug!(),
+        };
+
         if count_is_zero && element.is_constant_for_zero_repeat() {
             self.diverges.set(old_diverges);
         }

tests/ui/repeat-expr/zero_assoc_diverging_consts.rs

@@ -0,0 +1,29 @@
+// Check that repeating a diverging constant 0 times doesn't lead to unsoundness.
+//
+// This specific test checks that using an associated const that evaluates to 0, rather than just
+// plain literal 0, doesn't allow the unsoundness either.
+//
+// Issue: <https://github.com/rust-lang/rust/issues/165323>
+//
+//@ build-fail
+#![feature(generic_const_exprs)]
+
+trait Trait {
+    const ZERO: usize;
+}
+
+impl Trait for () {
+    const ZERO: usize = 0;
+}
+
+fn ex_nihilo<T: Trait>() -> u32
+where
+    [(); T::ZERO]:,
+{
+    [const { panic!() } as !; T::ZERO];
+    //~^ error: evaluation panicked: explicit panic
+}
+
+fn main() {
+    dbg!(ex_nihilo::<()>());
+}

tests/ui/repeat-expr/zero_assoc_diverging_consts.stderr

@@ -0,0 +1,23 @@
+error[E0080]: evaluation panicked: explicit panic
+  --> $DIR/zero_assoc_diverging_consts.rs:23:14
+   |
+LL | fn ex_nihilo<T: Trait>() -> u32
+...
+LL |     [const { panic!() } as !; T::ZERO];
+   |              ^^^^^^^^ evaluation of `ex_nihilo::<()>::{constant#1}` failed here
+
+note: erroneous constant encountered
+  --> $DIR/zero_assoc_diverging_consts.rs:23:6
+   |
+LL |     [const { panic!() } as !; T::ZERO];
+   |      ^^^^^^^^^^^^^^^^^^
+
+note: the above error was encountered while instantiating `fn ex_nihilo::<()>`
+  --> $DIR/zero_assoc_diverging_consts.rs:28:10
+   |
+LL |     dbg!(ex_nihilo::<()>());
+   |          ^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0080`.

…diverging_type_relative_consts_consts.rs …r/zero_diverging_type_relative_consts.rstests/ui/repeat-expr/zero_diverging_type_relative_consts_consts.rs renamed to tests/ui/repeat-expr/zero_diverging_type_relative_consts.rs tests/ui/repeat-expr/zero_diverging_type_relative_consts_consts.rs renamed to tests/ui/repeat-expr/zero_diverging_type_relative_consts.rs

@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/zero_diverging_type_relative_consts_consts.rs:14:19
+  --> $DIR/zero_diverging_type_relative_consts.rs:14:19
    |
 LL | fn ex_nihilo() -> u32 {
    |    ---------      ^^^ expected `u32`, found `()`

…rging_type_relative_consts_consts.stderr …ro_diverging_type_relative_consts.stderrtests/ui/repeat-expr/zero_diverging_type_relative_consts_consts.stderr renamed to tests/ui/repeat-expr/zero_diverging_type_relative_consts.stderr tests/ui/repeat-expr/zero_diverging_type_relative_consts_consts.stderr renamed to tests/ui/repeat-expr/zero_diverging_type_relative_consts.stderr

@@ -0,0 +1,20 @@
+// Check that repeating a diverging constant 0 times (inferred via `_`)
+// doesn't lead to unsoundness.
+//
+// Issue: <https://github.com/rust-lang/rust/issues/165323>
+
+fn ex_nihilo() -> u32 {
+    //~^ error: mismatched types
+    let _: [_; 0] = [const { panic!() } as !; _];
+}
+
+fn ex_nihilo2() -> u32 {
+    //~^ error: mismatched types
+    let a = [const { panic!() } as !; _];
+    let _: [_; 0] = a;
+}
+
+fn main() {
+    dbg!(ex_nihilo());
+    dbg!(ex_nihilo2());
+}

tests/ui/repeat-expr/zero_infer_diverging_consts.rs

@@ -0,0 +1,19 @@
+error[E0308]: mismatched types
+  --> $DIR/zero_infer_diverging_consts.rs:6:19
+   |
+LL | fn ex_nihilo() -> u32 {
+   |    ---------      ^^^ expected `u32`, found `()`
+   |    |
+   |    implicitly returns `()` as its body has no tail or `return` expression
+
+error[E0308]: mismatched types
+  --> $DIR/zero_infer_diverging_consts.rs:11:20
+   |
+LL | fn ex_nihilo2() -> u32 {
+   |    ----------      ^^^ expected `u32`, found `()`
+   |    |
+   |    implicitly returns `()` as its body has no tail or `return` expression
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0308`.

tests/ui/repeat-expr/zero_infer_diverging_consts.stderr

@@ -0,0 +1,17 @@
+// Check that repeating a diverging constant 0 times doesn't lead to unsoundness.
+//
+// This specific test checks that using a generic const argument that is substited with 0, rather
+// than just plain literal 0, doesn't allow the unsoundness either.
+//
+// Issue: <https://github.com/rust-lang/rust/issues/165323>
+//
+//@ build-fail
+
+fn ex_nihilo<const N: usize>() -> u32 {
+    [const { panic!() } as !; N];
+    //~^ error: evaluation panicked: explicit panic
+}
+
+fn main() {
+    dbg!(ex_nihilo::<0>());
+}

tests/ui/repeat-expr/zero_param_diverging_consts.rs

@@ -0,0 +1,22 @@
+error[E0080]: evaluation panicked: explicit panic
+  --> $DIR/zero_param_diverging_consts.rs:11:14
+   |
+LL | fn ex_nihilo<const N: usize>() -> u32 {
+LL |     [const { panic!() } as !; N];
+   |              ^^^^^^^^ evaluation of `ex_nihilo::<0>::{constant#0}` failed here
+
+note: erroneous constant encountered
+  --> $DIR/zero_param_diverging_consts.rs:11:6
+   |
+LL |     [const { panic!() } as !; N];
+   |      ^^^^^^^^^^^^^^^^^^
+
+note: the above error was encountered while instantiating `fn ex_nihilo::<0>`
+  --> $DIR/zero_param_diverging_consts.rs:16:10
+   |
+LL |     dbg!(ex_nihilo::<0>());
+   |          ^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0080`.