Translate static assert to rust const assert

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -1268,7 +1268,22 @@ bool Converter::VisitTypeAliasTemplateDecl(clang::TypeAliasTemplateDecl *) {
   return false;
 }
 
-bool Converter::VisitStaticAssertDecl(clang::StaticAssertDecl *) {
+bool Converter::VisitStaticAssertDecl(clang::StaticAssertDecl *decl) {
+  auto *assert_expr = decl->getAssertExpr();
+  if (assert_expr->isValueDependent()) {
+    return false;
+  }
+  std::string condition;
+  if (assert_expr->getType()->isBooleanType() &&
+      IsRustConstEvaluableExpr(assert_expr)) {
+    condition = ToString(assert_expr);
+  } else {
+    bool value = false;
+    ENSURE(assert_expr->EvaluateAsBooleanCondition(value, ctx_));
+    condition = value ? keyword::kTrue : keyword::kFalse;
+  }
+  StrCat(std::format("const _: () = assert!({}{});", condition,
+                     GetAssertMessageAsString(assert_expr, ctx_)));
   return false;
 }
 
@@ -2273,30 +2288,6 @@ bool Converter::VisitCharacterLiteral(clang::CharacterLiteral *expr) {
   return false;
 }
 
-std::string Converter::GetEscapedCharLiteral(char character) const {
-  switch (character) {
-  case '"':
-    return "\\\"";
-  case '\'':
-    return "\\'";
-  case '\\':
-    return "\\\\";
-  case '\n':
-    return "\\n";
-  case '\r':
-    return "\\r";
-  case '\t':
-    return "\\t";
-  case '\0':
-    return "\\0";
-  }
-  auto uc = static_cast<unsigned char>(character);
-  if (uc < 0x20 || uc >= 0x7F) {
-    return std::format("\\x{:02x}", uc);
-  }
-  return std::string(1, character);
-}
-
 std::string Converter::GetEscapedUTF8CharLiteral(clang::Expr *expr) const {
   auto char_expr =
       clang::dyn_cast<clang::CharacterLiteral>(expr->IgnoreCasts());

cpp2rust/converter/converter.h

@@ -354,7 +354,6 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual bool VisitCharacterLiteral(clang::CharacterLiteral *expr);
 
-  std::string GetEscapedCharLiteral(char character) const;
   std::string GetCodeUnitArrayLiteral(const clang::StringLiteral *expr);
   bool IsArrayInitContext() const;
 

cpp2rust/converter/converter_lib.cpp

@@ -5,9 +5,11 @@
 
 #include <clang/AST/DeclTemplate.h>
 #include <clang/AST/ExprCXX.h>
+#include <clang/AST/ExprConcepts.h>
 #include <clang/AST/Mangle.h>
 #include <clang/AST/ParentMapContext.h>
 #include <clang/Basic/SourceManager.h>
+#include <clang/Lex/Lexer.h>
 #include <llvm/Support/Path.h>
 #include <llvm/Support/raw_ostream.h>
 
@@ -108,6 +110,67 @@ bool IsBuiltinConstantP(const clang::Expr *expr) {
   return false;
 }
 
+bool IsRustConstEvaluableExpr(const clang::Expr *expr) {
+  expr = expr->IgnoreParenImpCasts();
+  if (clang::isa<clang::IntegerLiteral, clang::ConceptSpecializationExpr>(
+          expr)) {
+    return true;
+  }
+  if (auto *trait = clang::dyn_cast<clang::UnaryExprOrTypeTraitExpr>(expr)) {
+    return trait->getKind() == clang::UnaryExprOrTypeTrait::UETT_SizeOf;
+  }
+  if (auto *unary = clang::dyn_cast<clang::UnaryOperator>(expr)) {
+    return unary->getOpcode() == clang::UO_LNot &&
+           IsRustConstEvaluableExpr(unary->getSubExpr());
+  }
+  if (auto *binary = clang::dyn_cast<clang::BinaryOperator>(expr)) {
+    return (binary->isEqualityOp() || binary->isRelationalOp()) &&
+           IsRustConstEvaluableExpr(binary->getLHS()) &&
+           IsRustConstEvaluableExpr(binary->getRHS());
+  }
+  return false;
+}
+
+std::string GetEscapedCharLiteral(char character) {
+  switch (character) {
+  case '"':
+    return "\\\"";
+  case '\'':
+    return "\\'";
+  case '\\':
+    return "\\\\";
+  case '\n':
+    return "\\n";
+  case '\r':
+    return "\\r";
+  case '\t':
+    return "\\t";
+  case '\0':
+    return "\\0";
+  }
+  auto uc = static_cast<unsigned char>(character);
+  if (uc < 0x20 || uc >= 0x7F) {
+    return std::format("\\x{:02x}", uc);
+  }
+  return std::string(1, character);
+}
+
+std::string GetAssertMessageAsString(const clang::Expr *expr,
+                                     const clang::ASTContext &ctx) {
+  auto text = clang::Lexer::getSourceText(
+      clang::CharSourceRange::getTokenRange(expr->getSourceRange()),
+      ctx.getSourceManager(), ctx.getLangOpts());
+  std::string message = R"(, ")";
+  for (char c : text) {
+    // Doubled so that assert! does not read them as a format placeholder.
+    if (c == '{' || c == '}') {
+      message += c;
+    }
+    message += GetEscapedCharLiteral(c);
+  }
+  return message + '"';
+}
+
 bool IsComparisonWithNullOp(const clang::BinaryOperator *expr) {
   if (!expr->isComparisonOp()) {
     return false;

cpp2rust/converter/converter_lib.h

@@ -38,6 +38,13 @@ bool IsGlobalVar(const clang::VarDecl *decl);
 
 bool IsGlobalVar(const clang::Expr *expr);
 
+bool IsRustConstEvaluableExpr(const clang::Expr *expr);
+
+std::string GetEscapedCharLiteral(char character);
+
+std::string GetAssertMessageAsString(const clang::Expr *expr,
+                                     const clang::ASTContext &ctx);
+
 bool IsComparisonWithNullOp(const clang::BinaryOperator *expr);
 
 bool IsInMainFile(const clang::Decl *decl);

tests/unit/concepts.cpp

@@ -6,6 +6,7 @@ template <typename T>
 concept Small = sizeof(T) <= 4;
 
 static_assert(Small<int>);
+static_assert(sizeof(int) == 4);
 
 template <typename T>
 concept HasSize = requires(T t) {

tests/unit/out/refcount/concepts.rs

@@ -6,6 +6,11 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
+const _: () = assert!(true, "Small<int>");
+const _: () = assert!(
+    (::std::mem::size_of::<i32>() == 4_usize),
+    "sizeof(int) == 4"
+);
 #[derive(Clone, ByteRepr, Default)]
 pub struct Sized {}
 pub fn is_small_0() -> bool {
@@ -46,6 +51,7 @@ pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
+    const _: () = assert!(!(false), "!Small<long>");;
     assert!(({ is_small_0() }));
     assert!(!({ is_small_1() }));
     assert!(true);

tests/unit/out/unsafe/concepts.rs

@@ -6,6 +6,11 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
+const _: () = assert!(true, "Small<int>");
+const _: () = assert!(
+    ((::std::mem::size_of::<i32>()) == (4_usize)),
+    "sizeof(int) == 4"
+);
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct Sized {}
@@ -51,6 +56,7 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
+    const _: () = assert!(!(false), "!Small<long>");;
     assert!((unsafe { is_small_0() }));
     assert!(!(unsafe { is_small_1() }));
     assert!(true);