[const-prop] Fix ICE due to underflow when calculating enum discriminant

src/librustc_mir/interpret/place.rs

@@ -1082,17 +1082,21 @@ where
                 }
                 if variant_index != dataful_variant {
                     let variants_start = niche_variants.start().as_u32();
-                    let variant_index_relative = variant_index.as_u32()
-                        .checked_sub(variants_start)
-                        .expect("overflow computing relative variant idx");
+
+                    let (variant_index_relative, op) = if variant_index.as_u32() >= variants_start {
+                        (variant_index.as_u32() - variants_start, mir::BinOp::Add)
+                    } else {
+                        (variants_start - variant_index.as_u32(), mir::BinOp::Sub)
+                    };
+
                     // We need to use machine arithmetic when taking into account `niche_start`:
                     // discr_val = variant_index_relative + niche_start_val
                     let discr_layout = self.layout_of(discr_layout.value.to_int_ty(*self.tcx))?;
                     let niche_start_val = ImmTy::from_uint(niche_start, discr_layout);
                     let variant_index_relative_val =
                         ImmTy::from_uint(variant_index_relative, discr_layout);
                     let discr_val = self.binary_op(
-                        mir::BinOp::Add,
+                        op,
                         variant_index_relative_val,
                         niche_start_val,
                     )?;

src/test/ui/consts/issue-66787.rs

@@ -0,0 +1,39 @@
+// build-pass
+// compile-flags: --crate-type lib
+
+// Regression test for ICE which occurred when const propagating an enum whose discriminant
+// niche triggered an integer underflow conmupting a delta.
+
+pub enum ApiError {}
+#[allow(dead_code)]
+pub struct TokioError {
+    b: bool,
+}
+pub enum Error {
+    Api {
+        source: ApiError,
+    },
+    Ethereum,
+    Tokio {
+        source: TokioError,
+    },
+}
+struct Api;
+impl IntoError<Error> for Api
+{
+    type Source = ApiError;
+    fn into_error(self, error: Self::Source) -> Error {
+        Error::Api {
+            source: (|v| v)(error),
+        }
+    }
+}
+
+pub trait IntoError<E>
+{
+    /// The underlying error
+    type Source;
+
+    /// Combine the information to produce the error
+    fn into_error(self, source: Self::Source) -> E;
+}