Don't probe InferConst in fold_const if self.infcx is None

Author: ShE3py

compiler/rustc_infer/src/infer/canonical/canonicalizer.rs

@@ -456,17 +456,32 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
     fn fold_const(&mut self, mut ct: ty::Const<'tcx>) -> ty::Const<'tcx> {
         match ct.kind() {
             ty::ConstKind::Infer(InferConst::Var(mut vid)) => {
+                let Some(infcx) = self.infcx else {
+                    // FIXME(with_negative_coherence): the infcx has constraints from equating
+                    // the impl headers in `impl_intersection_has_negative_obligation`.
+                    // We should use these constraints as assumptions.
+                    assert!(self.tcx.features().with_negative_coherence);
+                    debug!("canonicalizing `ConstKind::Infer` without an `infcx`?");
+                    assert!(!self.canonicalize_mode.preserve_universes());
+                    return self.canonicalize_const_var(
+                        CanonicalVarInfo {
+                            kind: CanonicalVarKind::Const(ty::UniverseIndex::ROOT, ct.ty()),
+                        },
+                        ct,
+                    );
+                };
+
                 // We need to canonicalize the *root* of our const var.
                 // This is so that our canonical response correctly reflects
                 // any equated inference vars correctly!
-                let root_vid = self.infcx.unwrap().root_const_var(vid);
+                let root_vid = infcx.root_const_var(vid);
                 if root_vid != vid {
                     ct = ty::Const::new_var(self.tcx, root_vid, ct.ty());
                     vid = root_vid;
                 }
 
                 debug!("canonical: const var found with vid {:?}", vid);
-                match self.infcx.unwrap().probe_const_var(vid) {
+                match infcx.probe_const_var(vid) {
                     Ok(c) => {
                         debug!("(resolved to {:?})", c);
                         return self.fold_const(c);
@@ -487,7 +502,19 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
                 }
             }
             ty::ConstKind::Infer(InferConst::EffectVar(vid)) => {
-                match self.infcx.unwrap().probe_effect_var(vid) {
+                let Some(infcx) = self.infcx else {
+                    // FIXME(with_negative_coherence): the infcx has constraints from equating
+                    // the impl headers in `impl_intersection_has_negative_obligation`.
+                    // We should use these constraints as assumptions.
+                    assert!(self.tcx.features().with_negative_coherence);
+                    debug!("canonicalizing `ConstKind::Infer` without an `infcx`?");
+                    return self.canonicalize_const_var(
+                        CanonicalVarInfo { kind: CanonicalVarKind::Effect },
+                        ct,
+                    );
+                };
+
+                match infcx.probe_effect_var(vid) {
                     Some(value) => return self.fold_const(value),
                     None => {
                         return self.canonicalize_const_var(

src/tools/compiletest/src/runtest.rs

@@ -381,7 +381,7 @@ impl<'test> TestCx<'test> {
         // if a test does not crash, consider it an error
         if proc_res.status.success() || matches!(proc_res.status.code(), Some(1 | 0)) {
             self.fatal(&format!(
-                "test no longer crashes/triggers ICE! Please give it a mearningful name, \
+                "test no longer crashes/triggers ICE! Please give it a meaningful name, \
             add a doc-comment to the start of the test explaining why it exists and \
             move it to tests/ui or wherever you see fit."
             ));

tests/crashes/119381.rs

@@ -0,0 +1,11 @@
+//! Issue #119381: encountering `ty::ConstKind::Infer(InferConst::Var(_))` inside a `ParamEnv`
+
+#![feature(with_negative_coherence)]
+trait Trait {}
+impl<const N: u8> Trait for [(); N] {}
+impl<const N: i8> Trait for [(); N] {}
+//~^ conflicting implementations of trait `Trait` for type `[(); _]`
+//~| mismatched types
+//~^^^^ mismatched types
+
+fn main() {}

tests/ui/inference/infer-const-in-param-env.rs

@@ -0,0 +1,24 @@
+error[E0119]: conflicting implementations of trait `Trait` for type `[(); _]`
+  --> $DIR/infer-const-in-param-env.rs:6:1
+   |
+LL | impl<const N: u8> Trait for [(); N] {}
+   | ----------------------------------- first implementation here
+LL | impl<const N: i8> Trait for [(); N] {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `[(); _]`
+
+error[E0308]: mismatched types
+  --> $DIR/infer-const-in-param-env.rs:5:34
+   |
+LL | impl<const N: u8> Trait for [(); N] {}
+   |                                  ^ expected `usize`, found `u8`
+
+error[E0308]: mismatched types
+  --> $DIR/infer-const-in-param-env.rs:6:34
+   |
+LL | impl<const N: i8> Trait for [(); N] {}
+   |                                  ^ expected `usize`, found `i8`
+
+error: aborting due to 3 previous errors
+
+Some errors have detailed explanations: E0119, E0308.
+For more information about an error, try `rustc --explain E0119`.