Translate reference to array (#357)

Reference to array is translated as `Ptr<Box<[T]>>` in refcount and
`*const/mut [T; N]` in unsafe.

I added a new ConversionKind called Pointee to translate reference to
array in refcount. The semantics are:
* `FullRefCount`: `Value<Pointee>`
* `Pointee`: the object itself
* `Unboxed`: same as `Pointee`, except arrays which are `[T; N]` intead
`Box<[T]>`

I also added `Ptr::from_string_literal_array` which is similar to
`Ptr::from_string_literal`, the only difference is that that the new
function returns `Ptr<Box<[u8]>>` instead of `Ptr<u8>`.

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -2186,8 +2186,11 @@ std::string Converter::GetEscapedStringLiteral(clang::Expr *expr,
 }
 
 bool Converter::VisitStringLiteral(clang::StringLiteral *expr) {
-  if (!curr_init_type_.empty() && curr_init_type_.back()->isArrayType()) {
-    if (auto *arr_ty = ctx_.getAsConstantArrayType(curr_init_type_.back())) {
+  auto init_type = curr_init_type_.empty()
+                       ? clang::QualType()
+                       : curr_init_type_.back().getNonReferenceType();
+  if (!init_type.isNull() && init_type->isArrayType()) {
+    if (auto *arr_ty = ctx_.getAsConstantArrayType(init_type)) {
       uint64_t arr_size = arr_ty->getSize().getZExtValue();
       if (expr->getString().empty()) {
         StrCat(std::format("[0 as libc::c_char; {}]", arr_size));

cpp2rust/converter/models/converter_refcount.cpp

@@ -129,6 +129,7 @@ bool ConverterRefCount::NeedsMut(const clang::VarDecl *decl,
 std::string ConverterRefCount::BoxType(std::string &&str) const {
   switch (getConversionKind()) {
   case ConversionKind::Unboxed:
+  case ConversionKind::Pointee:
   case ConversionKind::Ptr:
     return std::move(str);
   case ConversionKind::FullRefCount:
@@ -140,6 +141,7 @@ std::string ConverterRefCount::BoxType(std::string &&str) const {
 std::string ConverterRefCount::BoxValue(std::string &&str) const {
   switch (getConversionKind()) {
   case ConversionKind::Unboxed:
+  case ConversionKind::Pointee:
   case ConversionKind::Ptr:
     return std::move(str);
   case ConversionKind::FullRefCount:
@@ -178,7 +180,7 @@ bool ConverterRefCount::VisitIncompleteArrayType(
 }
 
 bool ConverterRefCount::VisitReferenceType(clang::ReferenceType *type) {
-  PushConversionKind push(*this, ConversionKind::Unboxed);
+  PushConversionKind push(*this, ConversionKind::Pointee);
   StrCat("Ptr<");
   Convert(type->getPointeeType());
   StrCat(token::kGt);
@@ -297,6 +299,7 @@ bool ConverterRefCount::VisitConstantArrayType(clang::ConstantArrayType *type) {
   case ConversionKind::Ptr:
     Convert(type->getElementType());
     break;
+  case ConversionKind::Pointee:
   case ConversionKind::FullRefCount:
     StrCat("Box<[");
     Convert(type->getElementType());
@@ -396,7 +399,9 @@ bool ConverterRefCount::VisitArraySubscriptExpr(
     clang::ArraySubscriptExpr *expr) {
   auto *base = expr->getBase();
   if (base->IgnoreCasts()->getType()->isPointerType() ||
-      IsUnionArrayMember(base)) {
+      IsUnionArrayMember(base) ||
+      (IsReferenceType(base) &&
+       base->IgnoreCasts()->getType()->isArrayType())) {
     ConvertPointerSubscript(expr);
   } else {
     if (!base->IgnoreCasts()->getType()->isArrayType()) {
@@ -846,7 +851,8 @@ bool ConverterRefCount::VisitDeclRefExpr(clang::DeclRefExpr *expr) {
     // std::vector<T>& gets converted to Ptr<vec<T>>
     // So we need to make a pointer to the vector itself
     if (isObject()) {
-      if (IsBoxedType(ref->getPointeeType())) {
+      if (IsBoxedType(ref->getPointeeType()) ||
+          ref->getPointeeType()->isArrayType()) {
         StrCat(str, ".to_strong().as_pointer()");
         computed_expr_type_ = ComputedExprType::FreshPointer;
         return false;
@@ -1227,7 +1233,9 @@ bool ConverterRefCount::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) {
       // smart enough to pick the right specialization
       PushConversionKind push(*this, ConversionKind::Unboxed);
       PushParen paren(*this);
-      StrCat(ConvertPointer(sub_expr), keyword::kAs, ToString(expr->getType()));
+      StrCat(IsReferenceType(sub_expr) ? ConvertObject(sub_expr)
+                                       : ConvertPointer(sub_expr),
+             keyword::kAs, ToString(expr->getType()));
       return false;
     }
   }
@@ -1590,6 +1598,7 @@ bool ConverterRefCount::VisitInitListExpr(clang::InitListExpr *expr) {
   case ConversionKind::Ptr:
     Converter::VisitInitListExpr(expr);
     break;
+  case ConversionKind::Pointee:
   case ConversionKind::FullRefCount:
     StrCat("Box::new(");
     Converter::VisitInitListExpr(expr);
@@ -2078,6 +2087,14 @@ std::string ConverterRefCount::ConvertVarInitValue(clang::QualType qual_type,
     if (llvm::isa<clang::MaterializeTemporaryExpr>(expr->IgnoreImpCasts())) {
       return EmitMaterializedTempBinding(qual_type, expr);
     }
+    if (qual_type.getNonReferenceType()->isArrayType()) {
+      if (IsStringLiteralExpr(expr)) {
+        return std::format("Ptr::from_string_literal_array({})",
+                           ToString(expr->IgnoreParens()->IgnoreImplicit()));
+      }
+      return std::format("({} as {})", ConvertFreshPointer(expr),
+                         ToString(qual_type));
+    }
     return ConvertFreshPointer(expr);
   }
   return ConvertFreshRValue(expr, qual_type);
@@ -2449,7 +2466,7 @@ void ConverterRefCount::ConvertDeref(clang::Expr *expr) {
   }
 
   if (isObject()) {
-    if (IsBoxedType(pointee_type)) {
+    if (IsBoxedType(pointee_type) || pointee_type->isArrayType()) {
       StrCat(".to_strong().as_pointer()");
       computed_expr_type_ = ComputedExprType::FreshPointer;
     }

cpp2rust/converter/models/converter_refcount.h

@@ -285,6 +285,7 @@ class ConverterRefCount final : public Converter {
   /// The kind of conversion that should be performed.
   enum class ConversionKind : uint8_t {
     Unboxed,
+    Pointee,
     Ptr,
     FullRefCount,
   };
@@ -293,6 +294,8 @@ class ConverterRefCount final : public Converter {
     switch (k) {
     case ConversionKind::Unboxed:
       return "Unboxed";
+    case ConversionKind::Pointee:
+      return "Pointee";
     case ConversionKind::Ptr:
       return "Ptr";
     case ConversionKind::FullRefCount:

libcc2rs/src/cstr.rs

@@ -7,7 +7,7 @@ use std::fmt;
 use std::rc::Rc;
 
 use crate::CStringIterator;
-use crate::rc::{Ptr, PtrKind};
+use crate::rc::{AsPointer, Ptr, PtrKind};
 
 impl fmt::Display for Ptr<u8> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -27,12 +27,32 @@ impl fmt::Display for Ptr<u8> {
     }
 }
 
-type StringLiteralMap = HashMap<&'static [u8], Rc<RefCell<Vec<u8>>>>;
+type StringLiteralMap = HashMap<&'static [u8], Rc<RefCell<Box<[u8]>>>>;
 
 thread_local! {
     static STRING_LITERALS: RefCell<StringLiteralMap> = RefCell::new(HashMap::new());
 }
 
+impl Ptr<Box<[u8]>> {
+    #[inline]
+    pub fn from_string_literal_array(s: &'static [u8]) -> Self {
+        STRING_LITERALS.with(|literals| {
+            let mut literals = literals.borrow_mut();
+            let weak = Rc::downgrade(literals.entry(s).or_insert_with(|| {
+                Rc::new(RefCell::new({
+                    let mut v = s.to_vec();
+                    v.push(0);
+                    v.into_boxed_slice()
+                }))
+            }));
+            Ptr {
+                offset: 0,
+                kind: PtrKind::StackSingle(weak),
+            }
+        })
+    }
+}
+
 impl Ptr<u8> {
     #[allow(clippy::explicit_counter_loop)]
     pub fn memcpy(&self, src: &Self, len: usize) {
@@ -86,20 +106,9 @@ impl Ptr<u8> {
 
     #[inline]
     pub fn from_string_literal(s: &'static [u8]) -> Self {
-        STRING_LITERALS.with(|literals| {
-            let mut literals = literals.borrow_mut();
-            let weak = Rc::downgrade(literals.entry(s).or_insert_with(|| {
-                Rc::new(RefCell::new({
-                    let mut v = s.to_vec();
-                    v.push(0);
-                    v
-                }))
-            }));
-            Ptr {
-                offset: 0,
-                kind: PtrKind::Vec(weak),
-            }
-        })
+        Ptr::<Box<[u8]>>::from_string_literal_array(s)
+            .to_strong()
+            .as_pointer()
     }
 
     pub fn to_c_string_iterator(&self) -> CStringIterator {

tests/unit/array_reference.cpp

@@ -0,0 +1,80 @@
+#include <cassert>
+
+int len(const char (&s)[5]) {
+  int n = 0;
+  while (s[n] != '\0') {
+    ++n;
+  }
+  return n;
+}
+
+int len5(const char *s) {
+  int n = 0;
+  while (s[n] != '\0') {
+    ++n;
+  }
+  return n;
+}
+
+int sum(const int (&a)[3]) { return a[0] + a[1] + a[2]; }
+
+void fill(int (&a)[3], int v) {
+  for (int i = 0; i < 3; ++i) {
+    a[i] = v;
+  }
+}
+
+int sum_twice(const int (&a)[3]) { return sum(a) + sum(a); }
+
+void fill_and_sum(int (&a)[3], int v, int &out) {
+  fill(a, v);
+  out = sum_twice(a);
+}
+
+const char (&pick(const char (&s)[5]))[5] { return s; }
+
+struct Point {
+  int x;
+  int y;
+};
+
+int sum_points(const Point (&p)[2]) {
+  return p[0].x + p[0].y + p[1].x + p[1].y;
+}
+
+void shift_points(Point (&p)[2], int d) {
+  p[0].x += d;
+  p[1].y += d;
+}
+
+int total_len(const char *(&names)[2]) {
+  return len5(names[0]) + len5(names[1]);
+}
+
+int main() {
+  assert(len("beta") == 4);
+  char buf[5] = "abcd";
+  assert(len(buf) == 4);
+  int arr[3] = {1, 2, 3};
+  assert(sum(arr) == 6);
+  fill(arr, 7);
+  assert(sum(arr) == 21);
+  assert(sum_twice(arr) == 42);
+  int out = 0;
+  fill_and_sum(arr, 2, out);
+  assert(out == 12);
+  assert(arr[0] == 2);
+  const char (&lit)[5] = "beta";
+  assert(len(lit) == 4);
+  assert(pick("beta")[0] == 'b');
+  assert(len(pick(buf)) == 4);
+  Point pts[2] = {{1, 2}, {3, 4}};
+  assert(sum_points(pts) == 10);
+  shift_points(pts, 10);
+  assert(pts[0].x == 11);
+  assert(pts[1].y == 14);
+  assert(sum_points(pts) == 30);
+  const char *names[2] = {"ab", "cde"};
+  assert(total_len(names) == 5);
+  return 0;
+}