Translate SourceLocExpr (#468)

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -2406,6 +2406,37 @@ Converter::GetCodeUnitArrayLiteral(const clang::StringLiteral *expr) {
   return out;
 }
 
+std::string Converter::GetSourceFileAsString(clang::QualType type) {
+  return std::format("concat!(file!(), \"\\0\").as_ptr() as {}",
+                     ToString(type));
+}
+
+bool Converter::VisitSourceLocExpr(clang::SourceLocExpr *expr) {
+  switch (expr->getIdentKind()) {
+  case clang::SourceLocIdentKind::Line:
+    StrCat(std::format("line!() as {}", ToString(expr->getType())));
+    computed_expr_type_ = ComputedExprType::FreshValue;
+    return false;
+  case clang::SourceLocIdentKind::File:
+    StrCat(GetSourceFileAsString(expr->getType()));
+    computed_expr_type_ = ComputedExprType::FreshPointer;
+    return false;
+  case clang::SourceLocIdentKind::Function: {
+    auto value = expr->EvaluateInContext(ctx_, nullptr);
+    auto *str = clang::cast<clang::StringLiteral>(
+        value.getLValueBase().get<const clang::Expr *>());
+    Convert(clang::ImplicitCastExpr::Create(
+        ctx_, expr->getType(), clang::CK_ArrayToPointerDecay,
+        const_cast<clang::StringLiteral *>(str), nullptr, clang::VK_PRValue,
+        clang::FPOptionsOverride()));
+    return false;
+  }
+  default:
+    assert(0 && "unsupported SourceLocExpr");
+    return false;
+  }
+}
+
 bool Converter::VisitStringLiteral(clang::StringLiteral *expr) {
   if (IsCodeUnitStringLiteral(expr)) {
     StrCat(GetCodeUnitArrayLiteral(expr));

cpp2rust/converter/converter.h

@@ -382,6 +382,10 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
                                       uint64_t pad_nulls = 0) const;
   virtual bool VisitStringLiteral(clang::StringLiteral *expr);
 
+  bool VisitSourceLocExpr(clang::SourceLocExpr *expr);
+
+  virtual std::string GetSourceFileAsString(clang::QualType type);
+
   virtual bool VisitCXXBoolLiteralExpr(clang::CXXBoolLiteralExpr *expr);
 
   bool VisitCXXNoexceptExpr(clang::CXXNoexceptExpr *expr);

cpp2rust/converter/models/converter_refcount.cpp

@@ -1365,6 +1365,11 @@ bool ConverterRefCount::VisitCallExpr(clang::CallExpr *expr) {
   return false;
 }
 
+std::string ConverterRefCount::GetSourceFileAsString(clang::QualType type) {
+  return std::format("Ptr::<{}>::from_string_literal(file!().as_bytes())",
+                     ToStringBase(type->getPointeeType().getUnqualifiedType()));
+}
+
 bool ConverterRefCount::VisitStringLiteral(clang::StringLiteral *expr) {
   if (IsCodeUnitStringLiteral(expr)) {
     auto arr = GetCodeUnitArrayLiteral(expr);

cpp2rust/converter/models/converter_refcount.h

@@ -137,6 +137,8 @@ class ConverterRefCount final : public Converter {
 
   bool VisitStringLiteral(clang::StringLiteral *expr) override;
 
+  std::string GetSourceFileAsString(clang::QualType type) override;
+
   bool VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) override;
 
   bool VisitFunctionPointerCast(clang::ExplicitCastExpr *expr);

tests/unit/macros.cpp

@@ -1,11 +1,26 @@
+#include <assert.h>
 #include <stdio.h>
+#include <string.h>
+
+const char *base_name(const char *path) {
+  const char *slash = strrchr(path, '/');
+  return slash ? slash + 1 : path;
+}
 
 void log(const char *file, int line, const char *func) {
   printf("%s %d %s\n", file, line, func);
 }
 
+int line() { return __builtin_LINE(); }
+
+const char *function() { return __builtin_FUNCTION(); }
+
 int main() {
   printf("%s %d %s\n", __FILE__, __LINE__, __FUNCTION__);
   log(__FILE__, __LINE__, __FUNCTION__);
+  assert(__builtin_LINE() > 0);
+  assert(base_name(__builtin_FILE())[0] != '\0');
+  assert(line() > 0);
+  printf("%s\n", function());
   return 0;
 }

tests/unit/out/refcount/macros.rs

@@ -6,9 +6,41 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
-pub fn log_0(mut file: Ptr<i8>, mut line: i32, mut func: Ptr<i8>) {
+pub fn base_name_0(mut path: Ptr<i8>) -> Ptr<i8> {
+    let mut slash: Ptr<i8> = {
+        let __s = (path).clone();
+        let __t = (('/' as i8) as i32) as i8;
+        match __s
+            .to_c_string_iterator()
+            .enumerate()
+            .filter(|__e| __e.1 == __t)
+            .last()
+        {
+            Some((__i, _)) => __s.offset(__i),
+            None => {
+                if __t == 0 {
+                    __s.offset(__s.to_c_string_iterator().count())
+                } else {
+                    Ptr::null()
+                }
+            }
+        }
+    };
+    return if !(slash).is_null() {
+        slash.offset((1) as isize)
+    } else {
+        path
+    };
+}
+pub fn log_1(mut file: Ptr<i8>, mut line: i32, mut func: Ptr<i8>) {
     println!("{} {} {}", file, line, func);
 }
+pub fn line_2() -> i32 {
+    return (line!() as u32 as i32);
+}
+pub fn function_3() -> Ptr<i8> {
+    return Ptr::<i8>::from_string_literal(b"function");
+}
 pub fn main() {
     __cpp2rust_init_globals();
     std::process::exit(main_0());
@@ -17,16 +49,27 @@ fn main_0() -> i32 {
     println!(
         "{} {} {}",
         Ptr::<i8>::from_string_literal(b"macros.cpp"),
-        8,
+        19,
         Ptr::<i8>::from_string_literal(b"main")
     );
     ({
-        log_0(
+        log_1(
             Ptr::<i8>::from_string_literal(b"macros.cpp"),
-            9,
+            20,
             Ptr::<i8>::from_string_literal(b"main"),
         )
     });
+    assert!((line!() as u32 > 0_u32));
+    assert!(
+        (((elem!(
+            ({ base_name_0(Ptr::<i8>::from_string_literal(file!().as_bytes()),) }),
+            0
+        )
+        .read()) as i32)
+            != (('\0' as i8) as i32))
+    );
+    assert!((({ line_2() }) > 0));
+    println!("{}", ({ function_3() }));
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/macros.rs

@@ -6,9 +6,24 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub unsafe fn log_0(mut file: *const libc::c_char, mut line: i32, mut func: *const libc::c_char) {
+pub unsafe fn base_name_0(mut path: *const libc::c_char) -> *const libc::c_char {
+    let mut slash: *const libc::c_char =
+        (libc::strrchr(path, (('/' as libc::c_char) as i32)) as *const libc::c_char);
+    return if !(slash).is_null() {
+        slash.offset((1) as isize)
+    } else {
+        path
+    };
+}
+pub unsafe fn log_1(mut file: *const libc::c_char, mut line: i32, mut func: *const libc::c_char) {
     printf(c"%s %d %s\n".as_ptr() as *const i8, file, line, func);
 }
+pub unsafe fn line_2() -> i32 {
+    return (line!() as u32 as i32);
+}
+pub unsafe fn function_3() -> *const libc::c_char {
+    return c"function".as_ptr();
+}
 pub fn main() {
     unsafe {
         __cpp2rust_init_globals();
@@ -19,10 +34,18 @@ unsafe fn main_0() -> i32 {
     printf(
         c"%s %d %s\n".as_ptr() as *const i8,
         c"macros.cpp".as_ptr(),
-        8,
+        19,
         c"main".as_ptr(),
     );
-    (unsafe { log_0(c"macros.cpp".as_ptr(), 9, c"main".as_ptr()) });
+    (unsafe { log_1(c"macros.cpp".as_ptr(), 20, c"main".as_ptr()) });
+    assert!(((line!() as u32) > (0_u32)));
+    assert!(
+        (((*(unsafe { base_name_0(concat!(file!(), "\0").as_ptr() as *const libc::c_char,) })
+            .offset((0) as isize)) as i32)
+            != (('\0' as libc::c_char) as i32))
+    );
+    assert!(((unsafe { line_2() }) > (0)));
+    printf(c"%s\n".as_ptr() as *const i8, (unsafe { function_3() }));
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}