transpile: add synthetic CTypeKinds for sized types

these CTypeKinds do not correspond to Clang type kinds, but it is useful to create them when we process the C AST so we can recognize the type aliases that define them and reify them into the appropriate types on the Rust side, which do exist at a language level there (such as u8)

Author: fw-immunant

c2rust-transpile/src/c_ast/iterators.rs

@@ -285,7 +285,9 @@ fn immediate_type_children(kind: &CTypeKind) -> Vec<SomeId> {
         TypeOfExpr(e) => intos![e],
         Void | Bool | Short | Int | Long | LongLong | UShort | UInt | ULong | ULongLong | SChar
         | UChar | Char | Double | LongDouble | Float | Int128 | UInt128 | BuiltinFn | Half
-        | BFloat16 | UnhandledSveType | Float128 => {
+        | BFloat16 | UnhandledSveType | Float128 | Int8 | Int16 | Int32 | Int64 | IntPtr
+        | UInt8 | UInt16 | UInt32 | UInt64 | UIntPtr | IntMax | UIntMax | Size | SSize
+        | PtrDiff | WChar => {
             vec![]
         }
 

c2rust-transpile/src/c_ast/mod.rs

@@ -1711,9 +1711,35 @@ pub enum CTypeKind {
     Float128,
     // Atomic types (6.7.2.4)
     Atomic(CQualTypeId),
+
+    // Rust sized types, pullback'd into C so that we can treat uint16_t, etc. as real types.
+    Int8,
+    Int16,
+    Int32,
+    Int64,
+    IntPtr,
+    UInt8,
+    UInt16,
+    UInt32,
+    UInt64,
+    UIntPtr,
+    IntMax,
+    UIntMax,
+    Size,
+    SSize,
+    PtrDiff,
+    WChar,
 }
 
 impl CTypeKind {
+    pub const PULLBACK_KINDS: [CTypeKind; 16] = {
+        use CTypeKind::*;
+        [
+            Int8, Int16, Int32, Int64, IntPtr, UInt8, UInt16, UInt32, UInt64, UIntPtr, IntMax,
+            UIntMax, Size, SSize, PtrDiff, WChar,
+        ]
+    };
+
     pub fn as_str(&self) -> &'static str {
         use CTypeKind::*;
         match self {
@@ -1738,6 +1764,24 @@ impl CTypeKind {
             Half => "half",
             BFloat16 => "bfloat16",
             Float128 => "__float128",
+
+            Int8 => "int8_t",
+            Int16 => "int16_t",
+            Int32 => "int32_t",
+            Int64 => "int64_t",
+            IntPtr => "intptr_t",
+            UInt8 => "uint8_t",
+            UInt16 => "uint16_t",
+            UInt32 => "uint32_t",
+            UInt64 => "uint64_t",
+            UIntPtr => "uintptr_t",
+            IntMax => "intmax_t",
+            UIntMax => "uintmax_t",
+            Size => "size_t",
+            SSize => "ssize_t",
+            PtrDiff => "ptrdiff_t",
+            WChar => "wchar_t",
+
             _ => unimplemented!("Printer::print_type({:?})", self),
         }
     }
@@ -1803,14 +1847,43 @@ impl CTypeKind {
         use CTypeKind::*;
         matches!(
             self,
-            Bool | UChar | UInt | UShort | ULong | ULongLong | UInt128
+            Bool | UChar
+                | UInt
+                | UShort
+                | ULong
+                | ULongLong
+                | UInt128
+                | UInt8
+                | UInt16
+                | UInt32
+                | UInt64
+                | UIntPtr
+                | UIntMax
+                | Size
+                | WChar
         )
     }
 
     pub fn is_signed_integral_type(&self) -> bool {
         use CTypeKind::*;
         // `Char` is true on the platforms we handle
-        matches!(self, Char | SChar | Int | Short | Long | LongLong | Int128)
+        matches!(
+            self,
+            Char | SChar
+                | Int
+                | Short
+                | Long
+                | LongLong
+                | Int128
+                | Int8
+                | Int16
+                | Int32
+                | Int64
+                | IntPtr
+                | IntMax
+                | SSize
+                | PtrDiff
+        )
     }
 
     pub fn is_floating_type(&self) -> bool {

c2rust-transpile/src/convert_type.rs

@@ -333,6 +333,23 @@ impl TypeConverter {
             CTypeKind::UInt128 => Ok(mk().path_ty(mk().path(vec!["u128"]))),
             CTypeKind::BFloat16 => Ok(mk().path_ty(mk().path(vec!["bf16"]))),
 
+            CTypeKind::Int8 => Ok(mk().path_ty(mk().path(vec!["i8"]))),
+            CTypeKind::Int16 => Ok(mk().path_ty(mk().path(vec!["i16"]))),
+            CTypeKind::Int32 => Ok(mk().path_ty(mk().path(vec!["i32"]))),
+            CTypeKind::Int64 => Ok(mk().path_ty(mk().path(vec!["i64"]))),
+            CTypeKind::IntPtr => Ok(mk().path_ty(mk().path(vec!["isize"]))),
+            CTypeKind::UInt8 => Ok(mk().path_ty(mk().path(vec!["u8"]))),
+            CTypeKind::UInt16 => Ok(mk().path_ty(mk().path(vec!["u16"]))),
+            CTypeKind::UInt32 => Ok(mk().path_ty(mk().path(vec!["u32"]))),
+            CTypeKind::UInt64 => Ok(mk().path_ty(mk().path(vec!["u64"]))),
+            CTypeKind::UIntPtr => Ok(mk().path_ty(mk().path(vec!["usize"]))),
+            CTypeKind::IntMax => Ok(mk().path_ty(mk().path(vec!["libc", "intmax_t"]))),
+            CTypeKind::UIntMax => Ok(mk().path_ty(mk().path(vec!["libc", "uintmax_t"]))),
+            CTypeKind::Size => Ok(mk().path_ty(mk().path(vec!["usize"]))),
+            CTypeKind::SSize => Ok(mk().path_ty(mk().path(vec!["isize"]))),
+            CTypeKind::PtrDiff => Ok(mk().path_ty(mk().path(vec!["isize"]))),
+            CTypeKind::WChar => Ok(mk().path_ty(mk().path(vec!["libc", "wchar_t"]))),
+
             CTypeKind::Pointer(qtype) => self.convert_pointer(ctxt, qtype),
 
             CTypeKind::Elaborated(ref ctype) => self.convert(ctxt, *ctype),

c2rust-transpile/src/translator/mod.rs

@@ -4988,6 +4988,11 @@ impl<'c> Translation<'c> {
             Void | Char | SChar | UChar | Short | UShort | Int | UInt | Long | ULong | LongLong
             | ULongLong | Int128 | UInt128 | Half | BFloat16 | Float | Double | LongDouble
             | Float128 => {}
+            // other libc types
+            WChar | IntMax | UIntMax => {}
+            // Built-in Rust sized types
+            Int8 | Int16 | Int32 | Int64 | IntPtr | UInt8 | UInt16 | UInt32 | UInt64 | UIntPtr
+            | Size | SSize | PtrDiff => {}
             // Bool uses the bool type, so no dependency on libc
             Bool => {}
             Paren(ctype)