Auto merge of rust-lang#134126 - c410-f3r:hocus-pocus, r=<try>

[`generic_assert`] Avoid constant environments

cc rust-lang#44838

This PR is a work in progress. Requesting an early perf run to evaluate possible impacts.

The `generic_assert` feature captures variables for printing purposes.

```rust
fn foo() {
  let elem = 1i32;
  assert!(&elem);
}

// Expansion
fn foo() {
  let elem = 1i32;
  {
    use ::core::asserting::{TryCaptureGeneric, TryCapturePrintable};
    let mut __capture0 = ::core::asserting::Capture::new();
    let __local_bind0 = &elem;
    if (!&*__local_bind0) {
        (&::core::asserting::Wrapper(__local_bind0)).try_capture(&mut __capture0);
        {
          ::std::rt::panic_fmt(format_args!("Assertion failed: &elem\nWith captures:\n  elem = {0:?}\n", __capture0));
        }
      }
  };
}
```

The problem is that such a thing is complicated in constant environments. At the current time only strings are allowed and a full support parity with non-constant environments is, as far as I can tell, not feasible in the foreseen future.

```rust
fn foo() {
  // !!! ERROR !!!
  const {
    let elem = 1i32;
    assert!(&elem);
  }
}
```

Therefore, `generic_assert` will not be triggered in constant environment through an `is_in_const_env` variable flag originated in the `rustc_parse` crate.

Author: bors

compiler/rustc_ast/src/ast.rs

@@ -1718,6 +1718,7 @@ pub enum ClosureBinder {
 /// is being invoked, and the `args` are arguments passed to it.
 #[derive(Clone, Encodable, Decodable, Debug)]
 pub struct MacCall {
+    pub is_in_const_env: bool,
     pub path: Path,
     pub args: P<DelimArgs>,
 }

compiler/rustc_ast/src/mut_visit.rs

@@ -711,7 +711,7 @@ fn walk_attribute<T: MutVisitor>(vis: &mut T, attr: &mut Attribute) {
 }
 
 fn walk_mac<T: MutVisitor>(vis: &mut T, mac: &mut MacCall) {
-    let MacCall { path, args } = mac;
+    let MacCall { is_in_const_env: _, path, args } = mac;
     vis.visit_path(path);
     visit_delim_args(vis, args);
 }

compiler/rustc_ast/src/visit.rs

@@ -1008,7 +1008,7 @@ pub fn walk_stmt<'a, V: Visitor<'a>>(visitor: &mut V, statement: &'a Stmt) -> V:
 }
 
 pub fn walk_mac<'a, V: Visitor<'a>>(visitor: &mut V, mac: &'a MacCall) -> V::Result {
-    let MacCall { path, args: _ } = mac;
+    let MacCall { is_in_const_env: _, path, args: _ } = mac;
     visitor.visit_path(path, DUMMY_NODE_ID)
 }
 

compiler/rustc_builtin_macros/src/asm.rs

@@ -814,6 +814,7 @@ fn expand_preparsed_asm(
 
 pub(super) fn expand_asm<'cx>(
     ecx: &'cx mut ExtCtxt<'_>,
+    _is_in_const_env: bool,
     sp: Span,
     tts: TokenStream,
 ) -> MacroExpanderResult<'cx> {
@@ -843,6 +844,7 @@ pub(super) fn expand_asm<'cx>(
 
 pub(super) fn expand_naked_asm<'cx>(
     ecx: &'cx mut ExtCtxt<'_>,
+    _is_in_const_env: bool,
     sp: Span,
     tts: TokenStream,
 ) -> MacroExpanderResult<'cx> {
@@ -873,6 +875,7 @@ pub(super) fn expand_naked_asm<'cx>(
 
 pub(super) fn expand_global_asm<'cx>(
     ecx: &'cx mut ExtCtxt<'_>,
+    _is_in_const_env: bool,
     sp: Span,
     tts: TokenStream,
 ) -> MacroExpanderResult<'cx> {

compiler/rustc_builtin_macros/src/assert.rs

@@ -17,6 +17,7 @@ use crate::errors;
 
 pub(crate) fn expand_assert<'cx>(
     cx: &'cx mut ExtCtxt<'_>,
+    is_in_const_env: bool,
     span: Span,
     tts: TokenStream,
 ) -> MacroExpanderResult<'cx> {
@@ -56,6 +57,7 @@ pub(crate) fn expand_assert<'cx>(
         let then = cx.expr(
             call_site_span,
             ExprKind::MacCall(P(MacCall {
+                is_in_const_env,
                 path: panic_path(),
                 args: P(DelimArgs {
                     dspan: DelimSpan::from_single(call_site_span),
@@ -69,8 +71,8 @@ pub(crate) fn expand_assert<'cx>(
     // If `generic_assert` is enabled, generates rich captured outputs
     //
     // FIXME(c410-f3r) See https://github.com/rust-lang/rust/issues/96949
-    else if cx.ecfg.features.generic_assert() {
-        context::Context::new(cx, call_site_span).build(cond_expr, panic_path())
+    else if cx.ecfg.features.generic_assert() && !is_in_const_env {
+        context::Context::new(cx, call_site_span).build(cond_expr, is_in_const_env, panic_path())
     }
     // If `generic_assert` is not enabled, only outputs a literal "assertion failed: ..."
     // string

compiler/rustc_builtin_macros/src/assert/context.rs

@@ -71,11 +71,16 @@ impl<'cx, 'a> Context<'cx, 'a> {
     ///   }
     /// }
     /// ```
-    pub(super) fn build(mut self, mut cond_expr: P<Expr>, panic_path: Path) -> P<Expr> {
+    pub(super) fn build(
+        mut self,
+        mut cond_expr: P<Expr>,
+        is_in_const_env: bool,
+        panic_path: Path,
+    ) -> P<Expr> {
         let expr_str = pprust::expr_to_string(&cond_expr);
         self.manage_cond_expr(&mut cond_expr);
         let initial_imports = self.build_initial_imports();
-        let panic = self.build_panic(&expr_str, panic_path);
+        let panic = self.build_panic(&expr_str, is_in_const_env, panic_path);
         let cond_expr_with_unlikely = self.build_unlikely(cond_expr);
 
         let Self { best_case_captures, capture_decls, cx, local_bind_decls, span, .. } = self;
@@ -147,7 +152,7 @@ impl<'cx, 'a> Context<'cx, 'a> {
     ///     __capture0,
     ///     ...
     /// );
-    fn build_panic(&self, expr_str: &str, panic_path: Path) -> P<Expr> {
+    fn build_panic(&self, expr_str: &str, is_in_const_env: bool, panic_path: Path) -> P<Expr> {
         let escaped_expr_str = escape_to_fmt(expr_str);
         let initial = [
             TokenTree::token_joint(
@@ -179,6 +184,7 @@ impl<'cx, 'a> Context<'cx, 'a> {
         self.cx.expr(
             self.span,
             ExprKind::MacCall(P(MacCall {
+                is_in_const_env,
                 path: panic_path,
                 args: P(DelimArgs {
                     dspan: DelimSpan::from_single(self.span),

compiler/rustc_builtin_macros/src/cfg.rs

@@ -13,6 +13,7 @@ use crate::errors;
 
 pub(crate) fn expand_cfg(
     cx: &mut ExtCtxt<'_>,
+    _is_in_const_env: bool,
     sp: Span,
     tts: TokenStream,
 ) -> MacroExpanderResult<'static> {

compiler/rustc_builtin_macros/src/compile_error.rs

@@ -8,6 +8,7 @@ use crate::util::get_single_str_from_tts;
 
 pub(crate) fn expand_compile_error<'cx>(
     cx: &'cx mut ExtCtxt<'_>,
+    _is_in_const_env: bool,
     sp: Span,
     tts: TokenStream,
 ) -> MacroExpanderResult<'cx> {

compiler/rustc_builtin_macros/src/concat.rs

@@ -9,6 +9,7 @@ use crate::util::get_exprs_from_tts;
 
 pub(crate) fn expand_concat(
     cx: &mut ExtCtxt<'_>,
+    _is_in_const_env: bool,
     sp: rustc_span::Span,
     tts: TokenStream,
 ) -> MacroExpanderResult<'static> {

compiler/rustc_builtin_macros/src/concat_bytes.rs

@@ -112,6 +112,7 @@ fn handle_array_element(
 
 pub(crate) fn expand_concat_bytes(
     cx: &mut ExtCtxt<'_>,
+    _is_in_const_env: bool,
     sp: Span,
     tts: TokenStream,
 ) -> MacroExpanderResult<'static> {