Translate C99 flexible array member (#473)

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -268,7 +268,7 @@ bool Converter::VisitConstantArrayType(clang::ConstantArrayType *type) {
 bool Converter::VisitIncompleteArrayType(clang::IncompleteArrayType *type) {
   StrCat('[');
   Convert(type->getElementType());
-  StrCat(']');
+  StrCat("; 0]");
   return false;
 }
 
@@ -4129,9 +4129,8 @@ std::string Converter::GetArrayDefaultAsString(clang::QualType qual_type) {
     return std::format("[{}; {}]", element_type_as_string,
                        size_as_string.c_str());
   }
-  if (auto *array_type =
-          clang::dyn_cast<clang::IncompleteArrayType>(qual_type)) {
-    return GetDefaultAsString(array_type->getElementType());
+  if (clang::isa<clang::IncompleteArrayType>(qual_type)) {
+    return "[]";
   }
   if (Printer::ToString(ctx_, qual_type).contains("std::array")) {
     assert(GetTemplateArgs(qual_type).has_value());

cpp2rust/converter/models/converter_refcount.cpp

@@ -75,7 +75,8 @@ static bool NeedsMutAccess(clang::ASTContext &ctx,
 static bool IsValueField(clang::ASTContext &ctx,
                          const clang::FieldDecl *field) {
   auto type = field->getType();
-  return type->isConstantArrayType() || IsBoxedType(ctx, type);
+  return type->isConstantArrayType() || type->isIncompleteArrayType() ||
+         IsBoxedType(ctx, type);
 }
 
 // Whether `expr` is an array field whose elements are accessed through
@@ -2449,6 +2450,12 @@ bool ConverterRefCount::VisitCXXDefaultArgExpr(clang::CXXDefaultArgExpr *expr) {
 
 std::string
 ConverterRefCount::GetArrayDefaultAsString(clang::QualType qual_type) {
+  if (auto *array_type =
+          clang::dyn_cast<clang::IncompleteArrayType>(qual_type)) {
+    PushConversionKind push(*this, ConversionKind::Unboxed);
+    return std::format("Box::<[{}]>::default()",
+                       ToString(array_type->getElementType()));
+  }
   if (auto *array_type = clang::dyn_cast<clang::ConstantArrayType>(qual_type)) {
     const auto &size = array_type->getSize();
     auto size_as_string = GetNumAsString(size);

tests/unit/flex_array_member_incomplete.c

@@ -0,0 +1,28 @@
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct F {
+  int n;
+  char tail[];
+};
+
+int main(void) {
+  assert(sizeof(struct F) == sizeof(int));
+  struct F *f = malloc(sizeof(struct F) + 4);
+  assert(f != NULL);
+  f->n = 4;
+  memcpy(f->tail, "xyz", 4);
+  assert(f->n == 4);
+  assert(strcmp(f->tail, "xyz") == 0);
+  assert(f->tail[1] == 'y');
+  free(f);
+  struct F *g = malloc(sizeof(struct F) + 8);
+  assert(g != NULL);
+  g->n = 8;
+  memcpy(g->tail, "abcdefg", 8);
+  assert(g->tail[6] == 'g');
+  assert(g->tail[7] == '\0');
+  free(g);
+  return 0;
+}

tests/unit/out/refcount/flex_array_member_incomplete.rs

@@ -0,0 +1,95 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+#[derive(DeepClone, Record, ByteRepr, VaArg, FnPtrArg)]
+#[byte_size(4)]
+pub struct F {
+    #[offset(0)]
+    pub n: i32,
+    #[offset(4)]
+    #[byte_size(0)]
+    pub tail: Value<Box<[i8]>>,
+}
+impl Default for F {
+    fn default() -> Self {
+        F {
+            n: 0_i32,
+            tail: Rc::new(RefCell::new(Box::<[i8]>::default())),
+        }
+    }
+}
+pub fn main() {
+    __cpp2rust_init_globals();
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    assert!((((4usize == ::std::mem::size_of::<i32>()) as i32) != 0));
+    let mut f: Ptr<F> =
+        libcc2rs::malloc_refcount((4usize as usize).wrapping_add(4_usize)).reinterpret_cast::<F>();
+    assert!((((!((f).is_null())) as i32) != 0));
+    field!(f, n).write(4);
+    {
+        ((array_field_ptr!(f, tail) as Ptr<i8>) as Ptr<i8>)
+            .to_any()
+            .memcpy(
+                &Ptr::<i8>::from_string_literal(b"xyz").to_any(),
+                4_usize as usize,
+            );
+        ((array_field_ptr!(f, tail) as Ptr<i8>) as Ptr<i8>).to_any()
+    };
+    assert!((((f.with(|__s| __s.n) == 4) as i32) != 0));
+    assert!(
+        ((({
+            let mut __it1 = (array_field_ptr!(f, tail) as Ptr<i8>).to_c_string_iterator();
+            let mut __it2 = Ptr::<i8>::from_string_literal(b"xyz").to_c_string_iterator();
+            loop {
+                let __c1 = __it1.next();
+                let __c2 = __it2.next();
+                if __c1 != __c2 {
+                    break (__c1.unwrap_or(0) as u8 as i32) - (__c2.unwrap_or(0) as u8 as i32);
+                }
+                if __c1.is_none() {
+                    break 0;
+                }
+            }
+        } == 0) as i32)
+            != 0)
+    );
+    assert!(
+        (((((elem!((array_field_ptr!(f, tail) as Ptr::<i8>), 1).read()) as i32) == ('y' as i32))
+            as i32)
+            != 0)
+    );
+    libcc2rs::free_refcount((f).to_any());
+    let mut g: Ptr<F> =
+        libcc2rs::malloc_refcount((4usize as usize).wrapping_add(8_usize)).reinterpret_cast::<F>();
+    assert!((((!((g).is_null())) as i32) != 0));
+    field!(g, n).write(8);
+    {
+        ((array_field_ptr!(g, tail) as Ptr<i8>) as Ptr<i8>)
+            .to_any()
+            .memcpy(
+                &Ptr::<i8>::from_string_literal(b"abcdefg").to_any(),
+                8_usize as usize,
+            );
+        ((array_field_ptr!(g, tail) as Ptr<i8>) as Ptr<i8>).to_any()
+    };
+    assert!(
+        (((((elem!((array_field_ptr!(g, tail) as Ptr::<i8>), 6).read()) as i32) == ('g' as i32))
+            as i32)
+            != 0)
+    );
+    assert!(
+        (((((elem!((array_field_ptr!(g, tail) as Ptr::<i8>), 7).read()) as i32) == ('\0' as i32))
+            as i32)
+            != 0)
+    );
+    libcc2rs::free_refcount((g).to_any());
+    return 0;
+}
+pub fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/flex_array_member_incomplete.rs

@@ -0,0 +1,75 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::{Read, Seek, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+#[repr(C)]
+#[derive(Copy, Clone, VaArg, FnPtrArg)]
+pub struct F {
+    pub n: i32,
+    pub tail: [libc::c_char; 0],
+}
+impl Default for F {
+    fn default() -> Self {
+        F { n: 0_i32, tail: [] }
+    }
+}
+pub fn main() {
+    unsafe {
+        __cpp2rust_init_globals();
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    assert!(((((::std::mem::size_of::<F>()) == (::std::mem::size_of::<i32>())) as i32) != 0));
+    let mut f: *mut F =
+        (libcc2rs::malloc_unsafe((::std::mem::size_of::<F>() as usize).wrapping_add(4_usize))
+            as *mut F);
+    assert!((((!((f).is_null())) as i32) != 0));
+    (*f).n = 4;
+    {
+        if 4_usize != 0 {
+            ::std::ptr::copy_nonoverlapping(
+                (c"xyz".as_ptr().cast_mut() as *const ::libc::c_void),
+                ((*f).tail.as_mut_ptr() as *mut ::libc::c_void),
+                4_usize as usize,
+            )
+        }
+        ((*f).tail.as_mut_ptr() as *mut ::libc::c_void)
+    };
+    assert!((((((*f).n) == (4)) as i32) != 0));
+    assert!(
+        ((((libc::strcmp(
+            ((*f).tail.as_mut_ptr()).cast_const(),
+            (c"xyz".as_ptr().cast_mut()).cast_const()
+        )) == (0)) as i32)
+            != 0)
+    );
+    assert!((((((*(*f).tail.as_mut_ptr().add((1) as usize)) as i32) == ('y' as i32)) as i32) != 0));
+    libcc2rs::free_unsafe((f as *mut ::libc::c_void));
+    let mut g: *mut F =
+        (libcc2rs::malloc_unsafe((::std::mem::size_of::<F>() as usize).wrapping_add(8_usize))
+            as *mut F);
+    assert!((((!((g).is_null())) as i32) != 0));
+    (*g).n = 8;
+    {
+        if 8_usize != 0 {
+            ::std::ptr::copy_nonoverlapping(
+                (c"abcdefg".as_ptr().cast_mut() as *const ::libc::c_void),
+                ((*g).tail.as_mut_ptr() as *mut ::libc::c_void),
+                8_usize as usize,
+            )
+        }
+        ((*g).tail.as_mut_ptr() as *mut ::libc::c_void)
+    };
+    assert!((((((*(*g).tail.as_mut_ptr().add((6) as usize)) as i32) == ('g' as i32)) as i32) != 0));
+    assert!(
+        (((((*(*g).tail.as_mut_ptr().add((7) as usize)) as i32) == ('\0' as i32)) as i32) != 0)
+    );
+    libcc2rs::free_unsafe((g as *mut ::libc::c_void));
+    return 0;
+}
+pub unsafe fn __cpp2rust_init_globals() {}