Handle both dereference and subscript

Author: lucic71

cpp2rust/converter/models/converter_refcount.cpp

@@ -1506,10 +1506,6 @@ 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
@@ -2580,9 +2576,6 @@ 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);
   }
@@ -3046,6 +3039,9 @@ void ConverterRefCount::ConvertPointerSubscript(
     ConvertPointerElem(base, idx);
   } else {
     ConvertPointerOffset(base, idx);
+    if (expr->getType()->isArrayType()) {
+      StrCat(GetPointerDerefSuffix(expr->getType()), ".as_pointer()");
+    }
   }
   if (deref) {
     StrCat(GetPointerDerefSuffix(expr->getType()));
@@ -3127,6 +3123,11 @@ void ConverterRefCount::ConvertDeref(clang::Expr *expr) {
     str = std::move(buf).str();
   }
 
+  if (isAddrOf() && pointee_type->isArrayType()) {
+    str = std::format("({}){}.as_pointer()", std::move(str),
+                      GetPointerDerefSuffix(pointee_type));
+  }
+
   if (isObject() && WantsElementPtr() &&
       (IsBoxedType(ctx_, pointee_type) || pointee_type->isArrayType())) {
     StrCat(std::format("Ptr::<{}>::decay(&({}))", ToString(pointee_type),
@@ -3199,18 +3200,6 @@ 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,8 +348,6 @@ 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

@@ -98,5 +98,8 @@ int main() {
   assert(r[0] == 4);
   assert(sum(r) == 15);
   assert(sum(*p) == 15);
+  int (*q)[3] = rows;
+  assert(sum(q[1]) == 15);
+  assert(q[1] == &rows[1][0]);
   return 0;
 }

tests/unit/out/refcount/array_reference.rs

@@ -143,18 +143,29 @@ fn main_0() -> i32 {
     let mut p: Ptr<Value<Box<[i32]>>> = (rows.as_pointer() as Ptr<Value<Box<[i32]>>>);
     p.prefix_inc();
     assert!(
-        ({ (p.read().as_pointer()) } == {
+        ({ ((p).read().as_pointer() as Ptr::<i32>).clone() } == {
             ((((rows.as_pointer() as Ptr<Value<Box<[i32]>>>)
                 .offset(1)
                 .read()
                 .as_pointer()) as Ptr<i32>)
                 .offset(0))
         })
     );
-    let r: Ptr<i32> = (p.read().as_pointer());
+    let r: Ptr<i32> = ((p).read().as_pointer()).clone();
     assert!(((elem!((r), 0).read()) == 4));
     assert!((({ sum_2((r).clone(),) }) == 15));
-    assert!((({ sum_2((p.read().as_pointer()),) }) == 15));
+    assert!((({ sum_2(((p).read().as_pointer()).clone(),) }) == 15));
+    let mut q: Ptr<Value<Box<[i32]>>> = (rows.as_pointer() as Ptr<Value<Box<[i32]>>>);
+    assert!((({ sum_2(q.offset((1) as isize).read().as_pointer(),) }) == 15));
+    assert!(
+        ({ (q.offset((1) as isize).read().as_pointer() as Ptr::<i32>) } == {
+            ((((rows.as_pointer() as Ptr<Value<Box<[i32]>>>)
+                .offset(1)
+                .read()
+                .as_pointer()) as Ptr<i32>)
+                .offset(0))
+        })
+    );
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/array_reference.rs

@@ -125,6 +125,12 @@ unsafe fn main_0() -> i32 {
     assert!((((*r)[(0) as usize]) == (4)));
     assert!(((unsafe { sum_2(r,) }) == (15)));
     assert!(((unsafe { sum_2(&(*p),) }) == (15)));
+    let mut q: *mut [i32; 3] = rows.as_mut_ptr();
+    assert!(((unsafe { sum_2(&(*q.offset((1) as isize)),) }) == (15)));
+    assert!(
+        (((*q.offset((1) as isize)).as_mut_ptr())
+            == (&mut rows[(1) as usize][(0) as usize] as *mut i32))
+    );
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}