Fix ICE when passing DefId-creating args to legacy_const_generics.

Author: veluca93

compiler/rustc_ast_lowering/messages.ftl

@@ -103,6 +103,8 @@ ast_lowering_invalid_asm_template_modifier_reg_class =
 ast_lowering_invalid_asm_template_modifier_sym =
     asm template modifiers are not allowed for `sym` arguments
 
+ast_lowering_invalid_legacy_const_generic_arg =
+    invalid argument to a legacy const generic: cannot have const blocks, closures, async blocks or items
 ast_lowering_invalid_register =
     invalid register `{$reg}`: {$error}
 

compiler/rustc_ast_lowering/src/errors.rs

@@ -451,3 +451,10 @@ pub(crate) struct YieldInClosure {
     #[suggestion(code = "#[coroutine] ", applicability = "maybe-incorrect", style = "verbose")]
     pub suggestion: Option<Span>,
 }
+
+#[derive(Diagnostic)]
+#[diag(ast_lowering_invalid_legacy_const_generic_arg)]
+pub(crate) struct InvalidLegacyConstGenericArg {
+    #[primary_span]
+    pub span: Span,
+}

compiler/rustc_ast_lowering/src/expr.rs

@@ -1,4 +1,5 @@
 use std::assert_matches::assert_matches;
+use std::ops::ControlFlow;
 
 use rustc_ast::ptr::P as AstP;
 use rustc_ast::*;
@@ -12,6 +13,7 @@ use rustc_span::source_map::{respan, Spanned};
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
 use rustc_span::{DesugaringKind, Span, DUMMY_SP};
 use thin_vec::{thin_vec, ThinVec};
+use visit::{walk_expr, Visitor};
 
 use super::errors::{
     AsyncCoroutinesNotSupported, AwaitOnlyInAsyncFnAndBlocks, BaseExpressionDoubleDot,
@@ -22,9 +24,32 @@ use super::errors::{
 use super::{
     GenericArgsMode, ImplTraitContext, LoweringContext, ParamMode, ResolverAstLoweringExt,
 };
-use crate::errors::YieldInClosure;
+use crate::errors::{InvalidLegacyConstGenericArg, YieldInClosure};
 use crate::{fluent_generated, FnDeclKind, ImplTraitPosition};
 
+struct WillCreateDefIdsVisitor {}
+
+impl<'v> rustc_ast::visit::Visitor<'v> for WillCreateDefIdsVisitor {
+    type Result = ControlFlow<Span>;
+
+    fn visit_anon_const(&mut self, c: &'v AnonConst) -> Self::Result {
+        ControlFlow::Break(c.value.span)
+    }
+
+    fn visit_item(&mut self, item: &'v Item) -> Self::Result {
+        ControlFlow::Break(item.span)
+    }
+
+    fn visit_expr(&mut self, ex: &'v Expr) -> Self::Result {
+        match ex.kind {
+            ExprKind::Gen(..) | ExprKind::ConstBlock(..) | ExprKind::Closure(..) => {
+                ControlFlow::Break(ex.span)
+            }
+            _ => walk_expr(self, ex),
+        }
+    }
+}
+
 impl<'hir> LoweringContext<'_, 'hir> {
     fn lower_exprs(&mut self, exprs: &[AstP<Expr>]) -> &'hir [hir::Expr<'hir>] {
         self.arena.alloc_from_iter(exprs.iter().map(|x| self.lower_expr_mut(x)))
@@ -392,7 +417,22 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     self.create_def(parent_def_id, node_id, kw::Empty, DefKind::AnonConst, f.span);
                 }
 
-                let anon_const = AnonConst { id: node_id, value: arg };
+                let mut visitor = WillCreateDefIdsVisitor {};
+                let const_value = if let ControlFlow::Break(span) = visitor.visit_expr(&arg) {
+                    AstP(Expr {
+                        id: self.next_node_id(),
+                        kind: ExprKind::Err(
+                            self.tcx.dcx().emit_err(InvalidLegacyConstGenericArg { span }),
+                        ),
+                        span: f.span,
+                        attrs: [].into(),
+                        tokens: None,
+                    })
+                } else {
+                    arg
+                };
+
+                let anon_const = AnonConst { id: node_id, value: const_value };
                 generic_args.push(AngleBracketedArg::Arg(GenericArg::Const(anon_const)));
             } else {
                 real_args.push(arg);

tests/crashes/123077-2.rs

@@ -0,0 +1,20 @@
+const fn foo<const U: i32>() -> i32 {
+    U
+}
+
+fn main() {
+    std::arch::x86_64::_mm_blend_ps(loop {}, loop {}, || ());
+    //~^ invalid argument to a legacy const generic
+
+    std::arch::x86_64::_mm_blend_ps(loop {}, loop {}, 5 + || ());
+    //~^ invalid argument to a legacy const generic
+
+    std::arch::x86_64::_mm_blend_ps(loop {}, loop {}, foo::<{ 1 + 2 }>());
+    //~^ invalid argument to a legacy const generic
+
+    std::arch::x86_64::_mm_blend_ps(loop {}, loop {}, foo::<3>());
+    //~^ invalid argument to a legacy const generic
+
+    std::arch::x86_64::_mm_blend_ps(loop {}, loop {}, &const {});
+    //~^ invalid argument to a legacy const generic
+}

tests/crashes/129150.rs

@@ -0,0 +1,32 @@
+error: invalid argument to a legacy const generic: cannot have const blocks, closures, async blocks or items
+  --> $DIR/invalid-rustc_legacy_const_generics-issue-123077.rs:6:55
+   |
+LL |     std::arch::x86_64::_mm_blend_ps(loop {}, loop {}, || ());
+   |                                                       ^^^^^
+
+error: invalid argument to a legacy const generic: cannot have const blocks, closures, async blocks or items
+  --> $DIR/invalid-rustc_legacy_const_generics-issue-123077.rs:9:59
+   |
+LL |     std::arch::x86_64::_mm_blend_ps(loop {}, loop {}, 5 + || ());
+   |                                                           ^^^^^
+
+error: invalid argument to a legacy const generic: cannot have const blocks, closures, async blocks or items
+  --> $DIR/invalid-rustc_legacy_const_generics-issue-123077.rs:12:61
+   |
+LL |     std::arch::x86_64::_mm_blend_ps(loop {}, loop {}, foo::<{ 1 + 2 }>());
+   |                                                             ^^^^^^^^^
+
+error: invalid argument to a legacy const generic: cannot have const blocks, closures, async blocks or items
+  --> $DIR/invalid-rustc_legacy_const_generics-issue-123077.rs:15:61
+   |
+LL |     std::arch::x86_64::_mm_blend_ps(loop {}, loop {}, foo::<3>());
+   |                                                             ^
+
+error: invalid argument to a legacy const generic: cannot have const blocks, closures, async blocks or items
+  --> $DIR/invalid-rustc_legacy_const_generics-issue-123077.rs:18:56
+   |
+LL |     std::arch::x86_64::_mm_blend_ps(loop {}, loop {}, &const {});
+   |                                                        ^^^^^^^^
+
+error: aborting due to 5 previous errors
+