handle unevaluated consts after monomophize

Author: lcnr

src/librustc_codegen_ssa/mir/constant.rs

@@ -40,31 +40,36 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         &mut self,
         constant: &mir::Constant<'tcx>,
     ) -> Result<ConstValue<'tcx>, ErrorHandled> {
-        match constant.literal.val {
+        let const_ = match constant.literal.val {
             ty::ConstKind::Unevaluated(def_id, substs, promoted) => {
                 let substs = self.monomorphize(&substs);
-                self.cx
-                    .tcx()
-                    .const_eval_resolve(ty::ParamEnv::reveal_all(), def_id, substs, promoted, None)
-                    .map_err(|err| {
-                        if promoted.is_none() {
-                            self.cx
-                                .tcx()
-                                .sess
-                                .span_err(constant.span, "erroneous constant encountered");
-                        }
-                        err
-                    })
+                ty::ConstKind::Unevaluated(def_id, substs, promoted)
             }
+            ty::ConstKind::Value(value) => ty::ConstKind::Value(value),
+            ty::ConstKind::Param(_) => self.monomorphize(&constant.literal).val,
+            _ => span_bug!(constant.span, "encountered bad Const in codegen: {:?}", constant),
+        };
+
+        match const_ {
+            ty::ConstKind::Unevaluated(def_id, substs, promoted) => self
+                .cx
+                .tcx()
+                .const_eval_resolve(ty::ParamEnv::reveal_all(), def_id, substs, promoted, None)
+                .map_err(|err| {
+                    if promoted.is_none() {
+                        self.cx
+                            .tcx()
+                            .sess
+                            .span_err(constant.span, "erroneous constant encountered");
+                    }
+                    err
+                }),
             ty::ConstKind::Value(value) => Ok(value),
-            _ => {
-                let const_ = self.monomorphize(&constant.literal);
-                if let ty::ConstKind::Value(value) = const_.val {
-                    Ok(value)
-                } else {
-                    span_bug!(constant.span, "encountered bad ConstKind in codegen: {:?}", const_);
-                }
-            }
+            _ => span_bug!(
+                constant.span,
+                "encountered bad ConstKind after monomorphizing: {:?}",
+                const_
+            ),
         }
     }
 

src/test/ui/const-generics/issues/issue-70125.rs

@@ -0,0 +1,19 @@
+// run-pass
+#![feature(const_generics)]
+//~^ WARN the feature `const_generics` is incomplete and may cause the compiler to crash
+
+const L: usize = 4;
+
+pub trait Print<const N: usize> {
+    fn print(&self) -> usize {
+        N
+    }
+}
+
+pub struct Printer;
+impl Print<L> for Printer {}
+
+fn main() {
+    let p = Printer;
+    assert_eq!(p.print(), 4);
+}

src/test/ui/const-generics/issues/issue-70125.stderr

@@ -0,0 +1,8 @@
+warning: the feature `const_generics` is incomplete and may cause the compiler to crash
+  --> $DIR/issue-70125.rs:2:12
+   |
+LL | #![feature(const_generics)]
+   |            ^^^^^^^^^^^^^^
+   |
+   = note: `#[warn(incomplete_features)]` on by default
+

src/test/ui/const-generics/normalization_failure.rs

@@ -0,0 +1,16 @@
+// run-pass
+
+#![feature(const_generics)]
+//~^ WARN the feature `const_generics` is incomplete and may cause the compiler to crash
+
+fn main() {
+    <()>::foo();
+}
+
+trait Foo<const X: usize> {
+    fn foo() -> usize {
+        X
+    }
+}
+
+impl Foo<{3}> for () {}

src/test/ui/const-generics/normalization_failure.stderr

@@ -0,0 +1,8 @@
+warning: the feature `const_generics` is incomplete and may cause the compiler to crash
+  --> $DIR/normalization_failure.rs:3:12
+   |
+LL | #![feature(const_generics)]
+   |            ^^^^^^^^^^^^^^
+   |
+   = note: `#[warn(incomplete_features)]` on by default
+