Fix array reference

Author: lucic71

cpp2rust/converter/models/converter_refcount.cpp

@@ -496,12 +496,19 @@ ConverterRefCount::MaterializeTemp(const std::string &binding_name,
                                    clang::QualType param_type,
                                    clang::Expr *expr) {
   auto pointee = param_type.getNonReferenceType();
-  auto value = ConvertFreshRValue(expr, pointee);
-  auto type_str = ToStringBase(pointee);
   const auto *decl = in_const_initializer_ ? keyword::kStatic : keyword::kLet;
-
-  auto binding = std::format("{} {} : Value<{}> = Rc::new(RefCell::new({}));",
-                             decl, binding_name, type_str, value);
+  std::string binding;
+  if (pointee->isConstantArrayType()) {
+    PushConversionKind push(*this, ConversionKind::FullRefCount);
+    binding = std::format("{} {} : {} = {};", decl, binding_name,
+                          ToString(pointee),
+                          BoxValue(ConvertVarInitValue(pointee, expr)));
+  } else {
+    auto value = ConvertFreshRValue(expr, pointee);
+    auto type_str = ToStringBase(pointee);
+    binding = std::format("{} {} : Value<{}> = Rc::new(RefCell::new({}));",
+                          decl, binding_name, type_str, value);
+  }
   auto ref =
       in_const_initializer_ ? ".with(Value::as_pointer)" : ".as_pointer()";
   return {binding, binding_name + ref};
@@ -1499,6 +1506,10 @@ bool ConverterRefCount::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) {
                          ToString(sub_expr->IgnoreParens())));
       computed_expr_type_ = ComputedExprType::FreshPointer;
       return false;
+    } else if (auto ptr = ConvertArrayPointerDeref(sub_expr); !ptr.empty()) {
+      StrCat(ptr);
+      computed_expr_type_ = ComputedExprType::FreshPointer;
+      return false;
     } else {
       // we need to write (var.as_pointer as Ptr<T>) because Rust isn't
       // smart enough to pick the right specialization
@@ -2569,6 +2580,9 @@ std::string ConverterRefCount::ConvertVarInitValue(clang::QualType qual_type,
         return std::format("Ptr::<{}>::from_string_literal({})", code_unit,
                            ToString(expr->IgnoreParens()->IgnoreImplicit()));
       }
+      if (auto ptr = ConvertArrayPointerDeref(expr); !ptr.empty()) {
+        return ptr;
+      }
     }
     return ConvertFreshPointer(expr, qual_type);
   }
@@ -3185,6 +3199,18 @@ bool ConverterRefCount::DerefReadsValue(clang::QualType pointee_type) {
   return pointee_type.isPODType(ctx_) && !pointee_type->isRecordType();
 }
 
+std::string ConverterRefCount::ConvertArrayPointerDeref(clang::Expr *expr) {
+  auto *op =
+      clang::dyn_cast<clang::UnaryOperator>(expr->IgnoreParenNoopCasts(ctx_));
+  if (!op || op->getOpcode() != clang::UO_Deref ||
+      !op->getType()->isArrayType()) {
+    return {};
+  }
+  PushConversionKind push(*this, ConversionKind::Unboxed);
+  return std::format("({}{}.as_pointer())", ConvertRValue(op->getSubExpr()),
+                     GetPointerDerefSuffix(op->getType()));
+}
+
 const char *
 ConverterRefCount::GetPointerDerefSuffix(clang::QualType pointee_type) {
   return DerefReadsValue(pointee_type) ? ".read()" : ".upgrade().deref()";

cpp2rust/converter/models/converter_refcount.h

@@ -348,6 +348,8 @@ class ConverterRefCount final : public Converter {
   // returns a copy of the pointee, rather than a borrow of it.
   bool DerefReadsValue(clang::QualType pointee_type);
   const char *GetPointerDerefSuffix(clang::QualType pointee_type);
+
+  std::string ConvertArrayPointerDeref(clang::Expr *expr);
   // Sets the freshness of the dereference of a pointer to pointee_type: a
   // copy read with .read() is fresh.
   void SetDerefFreshness(clang::QualType pointee_type);

tests/unit/array_reference.cpp

@@ -65,6 +65,7 @@ int main() {
   assert(len(buf) == 4);
   int arr[3] = {1, 2, 3};
   assert(sum(arr) == 6);
+  assert(sum({1, 2, 3}) == 6);
   fill(arr, 7);
   assert(sum(arr) == 21);
   assert(sum_twice(arr) == 42);
@@ -88,5 +89,14 @@ int main() {
 
   const char *names[2] = {"ab", "cde"};
   assert(total_len(names) == 5);
+
+  int rows[2][3] = {{1, 2, 3}, {4, 5, 6}};
+  int (*p)[3] = rows;
+  ++p;
+  assert(*p == &rows[1][0]);
+  int (&r)[3] = *p;
+  assert(r[0] == 4);
+  assert(sum(r) == 15);
+  assert(sum(*p) == 15);
   return 0;
 }