Translate C boolean expressions (#12)

In C, as opposed to C++, clang does not generate IntegerToBoolean
implicit casts. To fix this, create an artificial implicit cast so that
C and C++ code can be handled uniformly.

As a side effect of this PR, C unit tests are now translated in C
instead of C++.

Author: lucic71

.github/workflows/format.yml

@@ -23,7 +23,7 @@ jobs:
           echo "$HOME/.cargo/bin" >> $GITHUB_PATH
 
       - name: Check C++ formatting
-        run: find cpp2rust tests -name '*.cpp' -o -name '*.h' | xargs clang-format --dry-run --Werror
+        run: find cpp2rust tests -name '*.cpp' -o -name '*.h' -o -name '*.c' | xargs clang-format --dry-run --Werror
 
       - name: Check Rust formatting
         run: |

CMakeLists.txt

@@ -93,7 +93,7 @@ add_subdirectory(tests)
 find_program(CLANG_FORMAT NAMES clang-format-22 clang-format)
 
 file(GLOB_RECURSE ALL_CXX_SOURCES
-     cpp2rust/*.cpp cpp2rust/*.h tests/*.cpp)
+     cpp2rust/*.cpp cpp2rust/*.h tests/*.cpp tests/*.c)
 
 add_custom_target("format"
                   COMMAND ${CLANG_FORMAT} -i ${ALL_CXX_SOURCES}

cpp2rust/CMakeLists.txt

@@ -13,7 +13,8 @@ target_link_libraries(cpp2rust PRIVATE
 target_include_directories(cpp2rust PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
 target_include_directories(cpp2rust PUBLIC SYSTEM ${CLANG_INCLUDE_DIRS} ${LLVM_INCLUDE_DIRS})
 target_compile_definitions(cpp2rust PUBLIC ${LLVM_DEFINITIONS})
-target_compile_definitions(cpp2rust PUBLIC "-DCLANG_EXECUTABLE=\"${CMAKE_CXX_COMPILER}\"")
+target_compile_definitions(cpp2rust PUBLIC "-DCLANG_C_COMPILER=\"${CMAKE_C_COMPILER}\"")
+target_compile_definitions(cpp2rust PUBLIC "-DCLANG_CXX_COMPILER=\"${CMAKE_CXX_COMPILER}\"")
 target_compile_definitions(cpp2rust PUBLIC "-DCLANG_RESOURCE_DIR=\"${LLVM_LIBRARY_DIR}/clang/${LLVM_VERSION_MAJOR}\"")
 target_compile_definitions(cpp2rust PUBLIC "-DCOMPAT_INCLUDE_DIR=\"${CMAKE_CURRENT_SOURCE_DIR}/compat\"")
 

cpp2rust/converter/converter.cpp

@@ -916,9 +916,18 @@ bool Converter::VisitReturnStmt(clang::ReturnStmt *stmt) {
   return false;
 }
 
+void Converter::ConvertCondition(clang::Expr *cond) {
+  if (!cond->getType()->isBooleanType()) {
+    PushExprKind push(*this, ExprKind::RValue);
+    Convert(CreateConversionToBool(cond, ctx_));
+    return;
+  }
+  Convert(cond);
+}
+
 bool Converter::VisitIfStmt(clang::IfStmt *stmt) {
   StrCat(keyword::kIf);
-  Convert(stmt->getCond());
+  ConvertCondition(stmt->getCond());
   StrCat(token::kOpenCurlyBracket);
   Convert(stmt->getThen());
   StrCat(token::kCloseCurlyBracket);
@@ -938,7 +947,7 @@ bool Converter::VisitIfStmt(clang::IfStmt *stmt) {
 bool Converter::VisitWhileStmt(clang::WhileStmt *stmt) {
   StrCat("'loop_:");
   StrCat(keyword::kWhile);
-  Convert(stmt->getCond());
+  ConvertCondition(stmt->getCond());
   StrCat(token::kOpenCurlyBracket);
   curr_for_inc_.emplace(nullptr);
   Convert(stmt->getBody());
@@ -954,7 +963,7 @@ bool Converter::VisitDoStmt(clang::DoStmt *stmt) {
   Convert(stmt->getBody());
   curr_for_inc_.pop();
   StrCat(keyword::kIf, token::kNot, token::kOpenParen);
-  Convert(stmt->getCond());
+  ConvertCondition(stmt->getCond());
   StrCat(token::kCloseParen, token::kOpenCurlyBracket, keyword::kBreak,
          token::kSemiColon, token::kCloseCurlyBracket,
          token::kCloseCurlyBracket);
@@ -968,7 +977,7 @@ bool Converter::VisitForStmt(clang::ForStmt *stmt) {
   if (stmt->getCond() == nullptr) {
     StrCat("true");
   } else {
-    Convert(stmt->getCond());
+    ConvertCondition(stmt->getCond());
   }
   StrCat(token::kOpenCurlyBracket);
   curr_for_inc_.emplace(stmt->getInc());
@@ -1546,7 +1555,8 @@ bool Converter::VisitFloatingLiteral(clang::FloatingLiteral *expr) {
 bool Converter::VisitCharacterLiteral(clang::CharacterLiteral *expr) {
   std::string ch = GetEscapedCharLiteral(expr->getValue());
   ch = "'" + std::move(ch) + "'";
-  StrCat(token::kOpenParen, ch, keyword::kAs, "u8", token::kCloseParen);
+  StrCat(token::kOpenParen, ch, keyword::kAs, ToStringBase(expr->getType()),
+         token::kCloseParen);
   computed_expr_type_ = ComputedExprType::FreshValue;
   return false;
 }
@@ -1664,6 +1674,15 @@ bool Converter::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) {
     Convert(sub_expr);
     break;
   case clang::CastKind::CK_IntegralToBoolean:
+    if (auto binop = clang::dyn_cast<clang::BinaryOperator>(
+            sub_expr->IgnoreParenImpCasts())) {
+      // This already produces bool, no need for != 0
+      if (binop->isComparisonOp()) {
+        Convert(sub_expr);
+        break;
+      }
+    }
+
     StrCat(token::kOpenParen);
     Convert(sub_expr);
     StrCat(token::kDiff, token::kZero, token::kCloseParen);
@@ -2875,12 +2894,12 @@ void Converter::ConvertAssignment(clang::Expr *lhs, clang::Expr *rhs,
   curr_init_type_.pop();
   auto rhs_as_string = ConvertFreshRValue(rhs);
 
-  if (isRValue()) {
+  if (!isVoid()) {
     StrCat(token::kOpenCurlyBracket);
   }
 
   StrCat(lhs_as_string, assign_operator, rhs_as_string);
-  if (isRValue()) {
+  if (!isVoid()) {
     StrCat(token::kSemiColon, ConvertRValue(lhs), token::kCloseCurlyBracket);
   }
 }

cpp2rust/converter/converter.h

@@ -112,6 +112,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual bool VisitReturnStmt(clang::ReturnStmt *stmt);
 
+  void ConvertCondition(clang::Expr *cond);
+
   virtual bool VisitIfStmt(clang::IfStmt *stmt);
 
   virtual bool VisitWhileStmt(clang::WhileStmt *stmt);

cpp2rust/converter/converter_lib.cpp

@@ -654,4 +654,10 @@ bool ContainsVAArgExpr(const clang::Stmt *stmt) {
   return false;
 }
 
+clang::Expr *CreateConversionToBool(clang::Expr *expr, clang::ASTContext &ctx) {
+  return clang::ImplicitCastExpr::Create(
+      ctx, ctx.BoolTy, clang::CK_IntegralToBoolean, expr,
+      /*BasePath=*/nullptr, clang::VK_PRValue, clang::FPOptionsOverride());
+}
+
 } // namespace cpp2rust

cpp2rust/converter/converter_lib.h

@@ -152,4 +152,6 @@ bool IsBuiltinVaCopy(const clang::CallExpr *expr);
 
 bool ContainsVAArgExpr(const clang::Stmt *stmt);
 
+clang::Expr *CreateConversionToBool(clang::Expr *expr, clang::ASTContext &ctx);
+
 } // namespace cpp2rust

cpp2rust/converter/models/converter_refcount.cpp

@@ -188,7 +188,7 @@ bool ConverterRefCount::VisitPointerType(clang::PointerType *type) {
   PushConversionKind push2(*this, ConversionKind::FullRefCount,
                            pointee_type->isArrayType());
   if (pointee_type->isRecordType() &&
-      abstract_structs_.contains(GetID(pointee_type->getAsCXXRecordDecl()))) {
+      abstract_structs_.contains(GetID(pointee_type->getAsRecordDecl()))) {
     StrCat("PtrDyn<dyn");
   } else {
     StrCat("Ptr<");

cpp2rust/cpp2rust.cpp

@@ -150,7 +150,7 @@ int main(int argc, char *argv[]) {
 
   auto rs_code =
       BuildDir.empty()
-          ? cpp2rust::TranspileSrc(cc_code, model, cxx_flags, RulesDir)
+          ? cpp2rust::TranspileSrc(cc_code, model, cxx_flags, RulesDir, CcFile)
           : cpp2rust::TranspileDir(BuildDir, model, RulesDir);
 
   if (rs_code.empty()) {

cpp2rust/cpp2rust_lib.cpp

@@ -13,15 +13,17 @@
 namespace cpp2rust {
 std::string TranspileSrc(std::string_view cc_code, Model model,
                          const std::vector<std::string_view> &cxx_flags,
-                         const std::string &rules_dir) {
+                         const std::string &rules_dir,
+                         std::string_view filename) {
   auto tool_args = getPlatformClangFlags();
   tool_args.push_back("-fparse-all-comments");
   tool_args.insert(tool_args.end(), cxx_flags.begin(), cxx_flags.end());
 
   std::string rs_code;
   clang::tooling::runToolOnCodeWithArgs(
       std::make_unique<FrontendAction>(rs_code, model, true, rules_dir),
-      cc_code, tool_args, "input.cpp", CLANG_EXECUTABLE);
+      cc_code, tool_args, filename.ends_with(".c") ? "input.c" : "input.cpp",
+      filename.ends_with(".c") ? CLANG_C_COMPILER : CLANG_CXX_COMPILER);
   return rs_code;
 }