transpile: expand --translate-const-macros conservative to a lot more CExprKinds

We do this by recursively checking whether an expression is `const`.
This is generally done in a conservative manner,
modulo the `ExplicitCast` bug (#853), non-`const` `sizeof(VLA)`s,
and `f128`'s non-`const` methods (#1262).

Statements are not handled yet.

Author: kkysen

c2rust-transpile/src/c_ast/mod.rs

@@ -601,7 +601,7 @@ impl TypedAstContext {
         }
     }
 
-    // Pessimistically try to check if an expression doesn't return. If it does, or we can't tell
+    /// Pessimistically try to check if an expression doesn't return. If it does, or we can't tell
     /// that it doesn't, return `false`.
     pub fn expr_diverges(&self, expr_id: CExprId) -> bool {
         let func_id = match self.index(expr_id).kind {
@@ -624,6 +624,70 @@ impl TypedAstContext {
         }
     }
 
+    /// Pessimistically try to check if an expression is `const`.
+    /// If it's not, or we can't tell if it is, return `false`.
+    pub fn is_const_expr(&self, expr: CExprId) -> bool {
+        use CExprKind::*;
+        let is_const = |expr| self.is_const_expr(expr);
+        match self[expr].kind {
+            // A literal is always `const`.
+            Literal(_, _) => true,
+            // Unary ops should be `const`.
+            // TODO handle `f128` or use the primitive type.
+            Unary(_, _, expr, _) => is_const(expr),
+            // Not sure what a `None` `CExprId` means here
+            // or how to detect a `sizeof` of a VLA, which is non-`const`.
+            UnaryType(_, _, _, _) => true,
+            // Not sure what a `OffsetOfKind::Variable` means.
+            OffsetOf(_, _) => true,
+            // `ptr::offset` (ptr `BinOp::Add`) was `const` stabilized in `1.61.0`.
+            // `ptr::offset_from` (ptr `BinOp::Subtract`) was `const` stabilized in `1.65.0`.
+            // TODO `f128` is not yet handled, as we should eventually
+            // switch to the (currently unstable) `f128` primitive type (#1262).
+            Binary(_, _, lhs, rhs, _, _) => is_const(lhs) && is_const(rhs),
+            // `as` casts are always `const`.
+            ImplicitCast(_, _, _, _, _) => true,
+            // `as` casts are always `const`.
+            // TODO This is `const`, although there's a bug #853.
+            ExplicitCast(_, _, _, _, _) => true,
+            // This is used in `const` locations like `match` patterns and array lengths, so it must be `const`.
+            ConstantExpr(_, _, _) => true,
+            // A reference in an already otherwise `const` context should be `const` itself.
+            DeclRef(_, _, _) => true,
+            Call(_, fn_expr, ref args) => {
+                let is_const_fn = false; // TODO detect which `fn`s are `const`.
+                is_const(fn_expr) && args.iter().copied().all(is_const) && is_const_fn
+            }
+            Member(_, expr, _, _, _) => is_const(expr),
+            ArraySubscript(_, array, index, _) => is_const(array) && is_const(index),
+            Conditional(_, cond, if_true, if_false) => {
+                is_const(cond) && is_const(if_true) && is_const(if_false)
+            }
+            BinaryConditional(_, cond, if_false) => is_const(cond) && is_const(if_false),
+            InitList(_, ref inits, _, _) => inits.iter().copied().all(is_const),
+            ImplicitValueInit(_) => true,
+            Paren(_, expr) => is_const(expr),
+            CompoundLiteral(_, expr) => is_const(expr),
+            Predefined(_, expr) => is_const(expr),
+            Statements(_, stmt) => self.is_const_stmt(stmt),
+            VAArg(_, expr) => is_const(expr),
+            // SIMD is not yet `const` in Rust.
+            ShuffleVector(_, _) | ConvertVector(_, _) => false,
+            DesignatedInitExpr(_, _, expr) => is_const(expr),
+            Choose(_, cond, if_true, if_false, _) => {
+                is_const(cond) && is_const(if_true) && is_const(if_false)
+            }
+            // Atomics are not yet `const` in Rust.
+            Atomic { .. } => false,
+            BadExpr => false,
+        }
+    }
+
+    pub fn is_const_stmt(&self, _stmt: CStmtId) -> bool {
+        // TODO
+        false
+    }
+
     pub fn prune_unwanted_decls(&mut self, want_unused_functions: bool) {
         // Starting from a set of root declarations, walk each one to find declarations it
         // depends on. Then walk each of those, recursively.
@@ -1186,6 +1250,9 @@ pub enum OffsetOfKind {
 
 /// Represents an expression in C (6.5 Expressions)
 ///
+/// This is modeled on Clang's APIs, so where documentation
+/// is lacking here, look at Clang.
+///
 /// We've kept a qualified type on every node since Clang has this information available, and since
 /// the semantics of translations of certain constructs often depend on the type of the things they
 /// are given.

c2rust-transpile/src/translator/mod.rs

@@ -2163,15 +2163,16 @@ impl<'c> Translation<'c> {
 
     /// Determine if we're able to convert this const macro expansion.
     fn can_convert_const_macro_expansion(&self, expr_id: CExprId) -> TranslationResult<()> {
-        let kind = &self.ast_context[expr_id].kind;
         match self.tcfg.translate_const_macros {
             TranslateMacros::None => Err(format_err!("translate_const_macros is None"))?,
-            TranslateMacros::Conservative => match *kind {
-                CExprKind::Literal(..) => Ok(()), // Literals are leaf expressions, so they should always be const-compatible.
-                _ => Err(format_err!(
-                    "conservative const macros don't yet allow {kind:?}"
-                ))?,
-            },
+            TranslateMacros::Conservative => {
+                // TODO We still allow `CExprKind::ExplicitCast`s
+                // even though they're broken (see #853).
+                if !self.ast_context.is_const_expr(expr_id) {
+                    Err(format_err!("non-const expr {expr_id:?}"))?;
+                }
+                Ok(())
+            }
             TranslateMacros::Experimental => Ok(()),
         }
     }

c2rust-transpile/tests/snapshots/macros.c

@@ -282,7 +282,9 @@ struct fn_ptrs {
 
 typedef int (*fn_ptr_ty)(char);
 
-const struct fn_ptrs fns = {NULL, NULL, NULL};
+// TODO Skip for now since it uses `libc`, which we don't test in snapshots.
+// const struct fn_ptrs fns = {NULL, NULL, NULL};
+const struct fn_ptrs fns = {};
 
 // Make sure we can't refer to globals in a const macro
 #define GLOBAL_REF &fns