Key rules through explicit and implicit casts

Author: lucic71

cpp2rust/converter/rules/rules_loader.cpp

@@ -473,7 +473,13 @@ std::string DeclKey(const clang::NamedDecl *decl) {
 }
 
 std::string ExprKey(clang::ASTContext &ctx, const clang::Expr *expr) {
-  expr = expr->IgnoreParenImpCasts();
+  for (auto inner = expr->IgnoreParens()->IgnoreImplicit(); inner != expr;
+       inner = expr->IgnoreParens()->IgnoreImplicit()) {
+    expr = inner;
+  }
+  if (auto cast = llvm::dyn_cast<clang::ExplicitCastExpr>(expr)) {
+    return ExprKey(ctx, cast->getSubExpr());
+  }
   if (llvm::isa<clang::IntegerLiteral>(expr) &&
       expr->getBeginLoc().isMacroID()) {
     return clang::Lexer::getImmediateMacroName(

rules/chrono/src_cxx20.cpp

@@ -0,0 +1,10 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include <chrono>
+
+using t1 = std::chrono::day;
+
+std::chrono::day f1(unsigned a0) { return std::chrono::day(a0); }
+
+unsigned f2(const std::chrono::day &a0) { return static_cast<unsigned>(a0); }

rules/chrono/tgt_unsafe.rs

@@ -0,0 +1,14 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+fn t1() -> u32 {
+    0_u32
+}
+
+unsafe fn f1(a0: u32) -> u32 {
+    a0
+}
+
+unsafe fn f2(a0: u32) -> u32 {
+    a0
+}

rules/fs_path/src_cxx17.cpp

@@ -0,0 +1,13 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include <filesystem>
+#include <string>
+
+using t1 = std::filesystem::path;
+
+std::filesystem::path f1(const char *a0) { return std::filesystem::path(a0); }
+
+std::string f2(const std::filesystem::path &a0) {
+  return static_cast<std::string>(a0);
+}

rules/fs_path/tgt_refcount.rs

@@ -0,0 +1,19 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use libcc2rs::*;
+
+fn t1() -> Vec<i8> {
+    vec![0]
+}
+
+fn f1(a0: Ptr<i8>) -> Vec<i8> {
+    let mut __v = Vec::new();
+    a0.with_c_str(|__s| __v.extend_from_slice(__s));
+    __v.push(0);
+    __v
+}
+
+fn f2(a0: Vec<i8>) -> Vec<i8> {
+    a0
+}

rules/fs_path/tgt_unsafe.rs

@@ -0,0 +1,20 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+fn t1() -> Vec<libc::c_char> {
+    vec![0]
+}
+
+unsafe fn f1(a0: *const libc::c_char) -> Vec<libc::c_char> {
+    let mut __v = ::std::ffi::CStr::from_ptr(a0)
+        .to_bytes()
+        .iter()
+        .map(|&__b| __b as libc::c_char)
+        .collect::<Vec<libc::c_char>>();
+    __v.push(0);
+    __v
+}
+
+unsafe fn f2(a0: Vec<libc::c_char>) -> Vec<libc::c_char> {
+    a0
+}

tests/unit/chrono_day_conversion.cpp

@@ -0,0 +1,10 @@
+// ADDITIONAL_COMPILE_FLAGS: -std=c++20
+#include <assert.h>
+#include <chrono>
+
+int main() {
+  unsigned n = 17;
+  std::chrono::day d(n);
+  assert(static_cast<unsigned>(d) == 17);
+  return 0;
+}

tests/unit/fs_path_string_conversion.cpp

@@ -0,0 +1,13 @@
+// ADDITIONAL_COMPILE_FLAGS: -std=c++17
+#include <assert.h>
+#include <filesystem>
+#include <string>
+
+int main() {
+  const char *name = "dir/file.txt";
+  std::filesystem::path p(name);
+  std::string s = static_cast<std::string>(p);
+  assert(s.size() == 12);
+  assert(s == "dir/file.txt");
+  return 0;
+}