transpile: convert typedefs of target-dependent macros to their synthetic CTypeKinds

e.g., `typedef __SIZE_TYPE__ size_t;` -> `typedef <CTypeKind::Size> size_t`

Author: fw-immunant

c2rust-ast-exporter/src/AstExporter.cpp

@@ -1,8 +1,10 @@
 #include <algorithm>
+#include <clang/AST/Type.h>
 #include <cstdlib>
 #include <fstream>
 #include <iostream>
 #include <iterator>
+#include <optional>
 #include <set>
 #include <unordered_map>
 #include <unordered_set>
@@ -98,7 +100,6 @@ Optional<APSInt> getIntegerConstantExpr(const Expr &E, const ASTContext &Ctx) {
 #endif // CLANG_VERSION_MAJOR
 }
 #else
-#include <optional>
 std::optional<APSInt> getIntegerConstantExpr(const Expr &E,
                                              const ASTContext &Ctx) {
     return E.getIntegerConstantExpr(Ctx);
@@ -2225,6 +2226,36 @@ class TranslateASTVisitor final
 
     bool VisitTypedefNameDecl(TypedefNameDecl *D) {
         auto typeForDecl = D->getUnderlyingType();
+        // If this typedef is to a compiler-builtin macro with target-dependent definition, note the
+        // macro's name so we can map to the appropriate target-independent name (e.g. `size_t`).
+        auto targetDependentMacro = [&]() -> std::optional<std::string> {
+            TypeSourceInfo *TSI = D->getTypeSourceInfo();
+            if (!TSI)
+                return {};
+
+            TypeLoc typeLoc = TSI->getTypeLoc();
+            SourceLocation loc = typeLoc.getBeginLoc();
+
+            if (loc.isInvalid())
+                return {};
+
+            // Check if the location is from a macro expansion
+            if (!loc.isMacroID()) {
+                return {};
+            }
+
+            auto macroName = Lexer::getImmediateMacroName(loc, Context->getSourceManager(), Context->getLangOpts());
+            // Double-underscore indicates that name is reserved for the implementation,
+            // so this should not interfere with user code.
+#if CLANG_VERSION_MAJOR >= 18
+            if (!macroName.starts_with("__")) {
+#else
+            if (!macroName.startswith("__")) {
+#endif // CLANG_VERSION_MAJOR
+                return {};
+            }
+            return std::make_optional(std::string(macroName));
+        }();
         if (!D->isCanonicalDecl()) {
             // Emit non-canonical decl so we have a placeholder to attach comments to
             std::vector<void *> childIds = {D->getCanonicalDecl()};
@@ -2235,11 +2266,17 @@ class TranslateASTVisitor final
 
         std::vector<void *> childIds;
         encode_entry(D, TagTypedefDecl, childIds, typeForDecl,
-                     [D](CborEncoder *array) {
+                     [D, targetDependentMacro](CborEncoder *array) {
                          auto name = D->getNameAsString();
                          cbor_encode_string(array, name);
 
                          cbor_encode_boolean(array, D->isImplicit());
+
+                         if (!targetDependentMacro) {
+                             cbor_encode_null(array);
+                         } else {
+                             cbor_encode_string(array, targetDependentMacro->data());
+                         }
                      });
 
         typeEncoder.VisitQualType(typeForDecl);

c2rust-transpile/src/c_ast/conversion.rs

@@ -1884,12 +1884,53 @@ impl ConversionContext {
                     let typ_old = node
                         .type_id
                         .expect("Expected to find type on typedef declaration");
-                    let typ = self.visit_qualified_type(typ_old);
+                    let mut typ = self.visit_qualified_type(typ_old);
+
+                    // Clang injects definitions of the form `#define SOME_MACRO unsigned int` into
+                    // compilation units based on the target. (See lib/Frontend/InitPreprocessor.cpp
+                    // in Clang).
+                    //
+                    // Later, headers contain defns like: `typedef SOME_MACRO standard_t;`
+                    //
+                    // We detect these typedefs and replace the type referred to by `SOME_MACRO`
+                    // with a synthetic, portable `CTypeKind` chosen based on the macro's name.
+                    //
+                    // This allows us to generate platform-independent Rust types like u64 or usize
+                    // despite the C side internally working with a target-specific type.
+                    let target_dependent_macro: Option<String> = from_value(node.extras[2].clone())
+                        .expect("Expected to find optional target-dependent macro name");
+
+                    typ = target_dependent_macro
+                        .as_deref()
+                        .and_then(|macro_name| {
+                            let kind = match macro_name {
+                                // Match names in the order Clang defines them.
+                                "__INTMAX_TYPE__" => CTypeKind::IntMax,
+                                "__UINTMAX_TYPE__" => CTypeKind::UIntMax,
+                                "__PTRDIFF_TYPE__" => CTypeKind::PtrDiff,
+                                "__INTPTR_TYPE__" => CTypeKind::IntPtr,
+                                "__SIZE_TYPE__" => CTypeKind::Size,
+                                "__WCHAR_TYPE__" => CTypeKind::WChar,
+                                // __WINT_TYPE__ is defined by Clang but has no obvious translation
+                                // __CHARn_TYPE__ for n ∈ {8, 16, 32} also lack obvious translation
+                                "__UINTPTR_TYPE__" => CTypeKind::UIntPtr,
+                                _ => {
+                                    log::debug!("Unknown target-dependent macro {macro_name}!");
+                                    return None;
+                                }
+                            };
+                            log::trace!("Selected kind {kind} for typedef {name}");
+                            Some(CQualTypeId::new(
+                                self.typed_context.type_for_kind(kind).unwrap(),
+                            ))
+                        })
+                        .unwrap_or(typ);
 
                     let typdef_decl = CDeclKind::Typedef {
                         name,
                         typ,
                         is_implicit,
+                        target_dependent_macro,
                     };
 
                     self.add_decl(new_id, located(node, typdef_decl));

c2rust-transpile/src/c_ast/mod.rs

@@ -951,6 +951,7 @@ pub enum CDeclKind {
         name: String,
         typ: CQualTypeId,
         is_implicit: bool,
+        target_dependent_macro: Option<String>,
     },
 
     // Struct

c2rust-transpile/src/translator/mod.rs

@@ -1955,9 +1955,9 @@ impl<'c> Translation<'c> {
                     &mut self.type_converter.borrow_mut().translate_valist,
                     false,
                 );
+
                 let ty = self.convert_type(typ.ctype)?;
                 self.type_converter.borrow_mut().translate_valist = translate_valist;
-
                 Ok(ConvertedDecl::Item(
                     mk().span(span).pub_().type_item(new_name, ty),
                 ))