Add support for __auto_type (#1782)

Fixes #1779

Author: ahomescu

c2rust-ast-exporter/src/AstExporter.cpp

@@ -674,6 +674,22 @@ class TypeEncoder final : public TypeVisitor<TypeEncoder> {
 
         VisitQualType(t);
     }
+
+    void VisitAutoType(const AutoType *T) {
+        if (!T->isGNUAutoType()) {
+            printDiag(Context, DiagnosticsEngine::Warning,
+                      "Encountered unexpected auto type",
+                      src_loc, src_range);
+            return;
+        }
+
+        auto t = T->desugar();
+        auto qt = encodeQualType(t);
+        encodeType(T, TagAutoType,
+                   [qt](CborEncoder *local) { cbor_encode_uint(local, qt); });
+
+        VisitQualType(t);
+    }
 };
 
 class TranslateASTVisitor final

c2rust-ast-exporter/src/ast_tags.hpp

@@ -152,6 +152,8 @@ enum TypeTag {
 
     TagFloat128,
     TagAtomicType,
+
+    TagAutoType,
 };
 
 enum StringTypeTag {

c2rust-transpile/src/c_ast/conversion.rs

@@ -947,6 +947,16 @@ impl ConversionContext {
                     self.processed_nodes.insert(new_id, OTHER_TYPE);
                 }
 
+                TypeTag::TagAutoType if expected_ty & TYPE != 0 => {
+                    let auto_id =
+                        from_value(ty_node.extras[0].clone()).expect("Auto type child not found");
+                    let auto = self.visit_type(auto_id);
+
+                    let auto_ty = CTypeKind::Auto(auto);
+                    self.add_type(new_id, not_located(auto_ty));
+                    self.processed_nodes.insert(new_id, TYPE);
+                }
+
                 t => panic!(
                     "Type conversion not implemented for {:?} expecting {:?}",
                     t, expected_ty

c2rust-transpile/src/c_ast/iterators.rs

@@ -294,6 +294,7 @@ fn immediate_type_children(kind: &CTypeKind) -> Vec<SomeId> {
         Decayed(ctype)
         | Paren(ctype)
         | TypeOf(ctype)
+        | Auto(ctype)
         | Complex(ctype)
         | ConstantArray(ctype, _)
         | IncompleteArray(ctype) => intos![ctype],

c2rust-transpile/src/c_ast/mod.rs

@@ -760,6 +760,7 @@ impl TypedAstContext {
                 CDeclKind::Typedef { typ: ty, .. } => ty.ctype,
                 _ => panic!("Typedef decl did not point to a typedef"),
             },
+            Auto(ty) => ty,
             _ => return typ,
         };
         self.resolve_type_id(ty)
@@ -778,6 +779,7 @@ impl TypedAstContext {
             Decayed(ty) => ty,
             TypeOf(ty) => ty,
             Paren(ty) => ty,
+            Auto(ty) => ty,
             _ => return typ,
         };
         self.resolve_type_id_no_typedef(ty)
@@ -2549,6 +2551,9 @@ pub enum CTypeKind {
     SSize,
     PtrDiff,
     WChar,
+
+    // `__auto_type` with its deduced actual type.
+    Auto(CTypeId),
 }
 
 impl CTypeKind {
@@ -2678,6 +2683,8 @@ impl CTypeKind {
             Float128 => false,
 
             // Non-scalars.
+            // TODO: we should investigate if all of these are dead code,
+            // and replace them with panics in that case.
             Complex(_) => false,
             Pointer(_) => false,
             Reference(_) => false,
@@ -2700,6 +2707,7 @@ impl CTypeKind {
             Vector(_, _) => false,
             UnhandledSveType => false,
             Atomic(_) => false,
+            Auto(_) => false,
         }
     }
 
@@ -2787,6 +2795,7 @@ impl CTypeKind {
             SSize => false,
             PtrDiff => false,
             WChar => false,
+            Auto(_) => false,
         }
     }
 }

c2rust-transpile/src/convert_type.rs

@@ -329,6 +329,7 @@ impl TypeConverter {
             }
 
             CTypeKind::TypeOf(ty) => self.convert(ctxt, ty),
+            CTypeKind::Auto(ty) => self.convert(ctxt, ty),
 
             ref t => Err(format_err!("Unsupported type {:?}", t).into()),
         }

c2rust-transpile/src/translator/mod.rs

@@ -4243,6 +4243,7 @@ impl<'c> Translation<'c> {
             | Reference(CQualTypeId { ctype, .. })
             | BlockPointer(CQualTypeId { ctype, .. })
             | TypeOf(ctype)
+            | Auto(ctype)
             | Complex(ctype) => imports.extend(self.imports_for_type(*ctype)),
             Enum(decl_id) | Typedef(decl_id) | Union(decl_id) | Struct(decl_id) => {
                 let mut decl_id = *decl_id;

c2rust-transpile/tests/snapshots.rs

@@ -314,6 +314,11 @@ fn test_atomics() {
     transpile("atomics.c").run();
 }
 
+#[test]
+fn test_auto_type() {
+    transpile("auto_type.c").run();
+}
+
 #[test]
 fn test_bitfields() {
     transpile("bitfields.c").expect_compile_error(true).run();

c2rust-transpile/tests/snapshots/auto_type.c

@@ -0,0 +1,11 @@
+struct bar {
+  int x;
+};
+
+int foo() {
+  __auto_type x = 42;
+  __auto_type px = &x;
+  __auto_type sx = sizeof(x);
+  __auto_type y = (struct bar) { .x = x };
+  return y.x;
+}

c2rust-transpile/tests/snapshots/snapshots__transpile@auto_type.c.2021.snap

@@ -0,0 +1,30 @@
+---
+source: c2rust-transpile/tests/snapshots.rs
+expression: cat tests/snapshots/auto_type.2021.rs
+---
+#![allow(
+    clippy::missing_safety_doc,
+    dead_code,
+    non_camel_case_types,
+    non_snake_case,
+    non_upper_case_globals,
+    unused_assignments,
+    unused_mut
+)]
+#![feature(raw_ref_op)]
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct bar {
+    pub x: ::core::ffi::c_int,
+}
+#[no_mangle]
+pub unsafe extern "C" fn foo() -> ::core::ffi::c_int {
+    let mut x: ::core::ffi::c_int = 42 as ::core::ffi::c_int;
+    let mut px: *mut ::core::ffi::c_int = &raw mut x;
+    let mut sx: ::core::ffi::c_ulong =
+        ::core::mem::size_of::<::core::ffi::c_int>() as ::core::ffi::c_ulong;
+    let mut y: bar = bar {
+        x: x as ::core::ffi::c_int,
+    } as bar;
+    return y.x;
+}