Skip to content

Move builtin types in rules/ #429

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
nunoplopes merged 6 commits into from
Sep 28, 2026
Merged

Move builtin types in rules/ #429

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
7f9df00
Move builtin rules in rules/
lucic71 Sep 28, 2026
be67092
Fix rule for float
lucic71 Sep 28, 2026
29d10fa
Reorder builtin rules
lucic71 Sep 28, 2026
ef2f1a4
Remove hardcoded default values
lucic71 Sep 28, 2026
8ded405
Drop intermediate cast
lucic71 Sep 28, 2026
9131013
Return poitners instead of reference from rule
lucic71 Sep 28, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
80 changes: 5 additions & 75 deletions cpp2rust/converter/converter.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -151,61 +151,12 @@ std::string Converter::ConvertPointeeType(clang::QualType ptr_type) {
}

bool Converter::VisitBuiltinType(clang::BuiltinType *type) {
switch (type->getKind()) {
case clang::BuiltinType::Bool:
StrCat("bool");
break;
case clang::BuiltinType::Float:
StrCat("f32");
break;
case clang::BuiltinType::Double:
case clang::BuiltinType::LongDouble:
StrCat("f64");
break;
case clang::BuiltinType::Char_S:
case clang::BuiltinType::Char_U:
StrCat(CharRustType());
break;
case clang::BuiltinType::SChar:
StrCat("i8");
break;
case clang::BuiltinType::UChar:
StrCat("u8");
break;
case clang::BuiltinType::UShort:
case clang::BuiltinType::UInt:
case clang::BuiltinType::ULong:
case clang::BuiltinType::ULongLong:
case clang::BuiltinType::Short:
case clang::BuiltinType::Int:
case clang::BuiltinType::Long:
case clang::BuiltinType::LongLong:
case clang::BuiltinType::WChar_S:
case clang::BuiltinType::WChar_U:
case clang::BuiltinType::Char8:
case clang::BuiltinType::Char16:
case clang::BuiltinType::Char32:
StrCat(std::format("{}{}", type->isSignedInteger() ? 'i' : 'u',
ctx_.getTypeSize(type)));
break;
case clang::BuiltinType::Void:
StrCat("::libc::c_void");
break;
case clang::BuiltinType::UInt128:
StrCat("u128");
break;
case clang::BuiltinType::Int128:
StrCat("i128");
break;
case clang::BuiltinType::NullPtr:
Convert(ctx_.VoidPtrTy);
break;
default:
llvm::errs() << "unsupported builtin type: "
<< type->getName(ctx_.getPrintingPolicy()) << '\n';
assert(0 && "unsupported builtin type\n");
break;
auto mapped = Mapper::Map(clang::QualType(type, 0));
if (mapped.empty()) {
llvm::report_fatal_error(llvm::Twine("no type rule for builtin type: ") +
type->getName(ctx_.getPrintingPolicy()));
}
StrCat(mapped);
return false;
}

Expand Down Expand Up @@ -2507,11 +2458,6 @@ bool Converter::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) {
case clang::CastKind::CK_BitCast: {
PushParen paren(*this);
Convert(sub_expr);
if (type->isVoidPointerType()) {
StrCat(keyword::kAs,
type->getPointeeType().isConstQualified() ? "*const" : "*mut");
StrCat(ConvertPointeeType(sub_expr->getType()));
}
ConvertCast(type);
SetFreshType(type);
break;
Expand Down Expand Up @@ -4034,10 +3980,6 @@ std::string Converter::GetArrayDefaultAsString(clang::QualType qual_type) {
}

std::string Converter::GetDefaultAsString(clang::QualType qual_type) {
if (qual_type->isVoidType()) {
return "()";
}

if (IsVaListType(qual_type)) {
computed_expr_type_ = ComputedExprType::FreshValue;
return "VaList::default()";
Expand Down Expand Up @@ -4070,18 +4012,6 @@ std::string Converter::GetDefaultAsString(clang::QualType qual_type) {
std::string Converter::GetDefaultAsStringFallback(clang::QualType qual_type) {
qual_type = qual_type.getUnqualifiedType().getCanonicalType();

if (qual_type->isBooleanType()) {
return "false";
}

if (qual_type->isIntegerType() && !qual_type->isEnumeralType()) {
return getTypedLiteral("0", ToString(qual_type));
}

if (qual_type->isFloatingType()) {
return getTypedLiteral("0.0", ToString(qual_type));
}

if (auto record = qual_type->getAsRecordDecl()) {
if (ctx_.getSourceManager().isInSystemHeader(record->getLocation()) &&
qual_type.isPODType(ctx_)) {
Expand Down
110 changes: 4 additions & 106 deletions cpp2rust/converter/mapper.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -458,110 +458,6 @@ void addRulesFromDirectory(const std::filesystem::path &dir, Model model) {
}
}

void addBuiltinTypes(Model model) {
assert(ctx_);

auto add_scalar_rule = [&](const std::string &cxx, const std::string &rust,
const std::string &initializer = {}) {
auto plain = TranslationRule::TypeRule::Plain(rust);
plain.initializer = initializer;
std::vector<std::string> derives = {"Copy", "Clone", "Default",
"Debug", "PartialEq", "PartialOrd"};
if (!(rust == "f32" || rust == "f64")) {
derives.insert(derives.end(), {"Eq", "Ord", "Hash"});
}
plain.type_info.derives = std::move(derives);
AddTypeRule(cxx, TranslationRule::TypeRule(plain));
AddTypeRule("const " + cxx, std::move(plain));

switch (model) {
case Model::kUnsafe:
AddTypeRule(cxx + " *",
TranslationRule::TypeRule::UnsafePtr("*mut " + rust));
AddTypeRule("const " + cxx + " *",
TranslationRule::TypeRule::UnsafePtr("*const " + rust));
break;
case Model::kRefCount:
AddTypeRule(cxx + " *", TranslationRule::TypeRule::RefcountPtr(
"Ptr::<" + rust + ">"));
AddTypeRule("const " + cxx + " *", TranslationRule::TypeRule::RefcountPtr(
"Ptr::<" + rust + ">"));
break;
}
};

auto add_builtin_rule = [&](clang::QualType qt, const std::string &rust) {
add_scalar_rule(ToString(qt), rust);
};

auto add_size_rules = [&](clang::QualType size_type,
std::initializer_list<const char *> aliases,
const std::string &rust) {
auto initializer = "0_" + rust;
for (const char *alias : aliases) {
add_scalar_rule(alias, rust, initializer);
}
if (const auto *predef = clang::dyn_cast<clang::PredefinedSugarType>(
size_type.getTypePtr())) {
add_scalar_rule(predef->getIdentifier()->getName().str(), rust,
initializer);
}
};

auto build_rust_type = [&](clang::QualType qt) {
unsigned bits = ctx_->getTypeSize(qt);
char sign = qt->isSignedIntegerType() ? 'i' : 'u';
return std::format("{}{}", sign, bits);
};

// Misc
add_builtin_rule(ctx_->BoolTy, "bool");
add_builtin_rule(ctx_->FloatTy, "f32");
add_builtin_rule(ctx_->DoubleTy, "f64");

switch (model) {
case Model::kUnsafe:
AddTypeRule(ToString(ctx_->VoidTy) + " *",
TranslationRule::TypeRule::UnsafePtr("*mut ::libc::c_void"));
AddTypeRule("const " + ToString(ctx_->VoidTy) + " *",
TranslationRule::TypeRule::UnsafePtr("*const ::libc::c_void"));
break;
case Model::kRefCount:
AddTypeRule(ToString(ctx_->VoidTy) + " *",
TranslationRule::TypeRule::RefcountPtr("AnyPtr"));
AddTypeRule("const " + ToString(ctx_->VoidTy) + " *",
TranslationRule::TypeRule::RefcountPtr("AnyPtr"));
break;
}

// Char
switch (model) {
case Model::kUnsafe:
add_builtin_rule(ctx_->CharTy, "libc::c_char");
break;
case Model::kRefCount:
add_builtin_rule(ctx_->CharTy, "u8");
break;
}
add_builtin_rule(ctx_->SignedCharTy, "i8");
add_builtin_rule(ctx_->UnsignedCharTy, "u8");

// Integers
add_builtin_rule(ctx_->ShortTy, build_rust_type(ctx_->ShortTy));
add_builtin_rule(ctx_->UnsignedShortTy,
build_rust_type(ctx_->UnsignedShortTy));
add_builtin_rule(ctx_->IntTy, build_rust_type(ctx_->IntTy));
add_builtin_rule(ctx_->UnsignedIntTy, build_rust_type(ctx_->UnsignedIntTy));
add_builtin_rule(ctx_->LongTy, build_rust_type(ctx_->LongTy));
add_builtin_rule(ctx_->UnsignedLongTy, build_rust_type(ctx_->UnsignedLongTy));
add_builtin_rule(ctx_->LongLongTy, build_rust_type(ctx_->LongLongTy));
add_builtin_rule(ctx_->UnsignedLongLongTy,
build_rust_type(ctx_->UnsignedLongLongTy));

add_size_rules(ctx_->getSizeType(), {"size_t", "size_type"}, "usize");
add_size_rules(ctx_->getSignedSizeType(), {"ssize_t"}, "isize");
}

clang::QualType normalizeQualType(clang::QualType qual_type) {
assert(ctx_);

Expand Down Expand Up @@ -862,7 +758,10 @@ std::string ToString(clang::QualType qual_type, ScalarSugar sugar) {
} else if (const auto *ptr = t->getAs<clang::PointerType>()) {
auto pointee = ptr->getPointeeType();
auto canonical = pointee.getCanonicalType().getDesugaredType(*ctx_);
if (Map(pointee) == Map(canonical)) {
bool builtin_alias = canonical->isBuiltinType() &&
(pointee->getAs<clang::TypedefType>() ||
pointee->getAs<clang::PredefinedSugarType>());
if (!builtin_alias && Map(pointee) == Map(canonical)) {
pointee = canonical;
}
std::string out;
Expand Down Expand Up @@ -1123,7 +1022,6 @@ void LoadTranslationRules(Model model, clang::ASTContext &ctx,
}
translation_rules_loaded_ = true;

addBuiltinTypes(model);
addRulesFromDirectory(rules_dir, model);

#if 0
Expand Down
20 changes: 2 additions & 18 deletions cpp2rust/converter/models/converter_refcount.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2113,12 +2113,8 @@ std::string ConverterRefCount::GetDefaultAsString(clang::QualType qual_type) {
ret =
std::format("FnPtr::<{}>::null()", ConvertFunctionPointerType(proto));
} else {
if (pointee_type->isVoidType()) {
ret = "AnyPtr::default()";
} else {
PushConversionKind push(*this, ConversionKind::Unboxed);
ret = std::format("Ptr::<{}>::null()", ConvertPointeeType(qual_type));
}
PushConversionKind push(*this, ConversionKind::Unboxed);
ret = std::format("Ptr::<{}>::null()", ConvertPointeeType(qual_type));
}
} else {
return Converter::GetDefaultAsString(qual_type);
Expand All @@ -2129,18 +2125,6 @@ std::string ConverterRefCount::GetDefaultAsString(clang::QualType qual_type) {

std::string
ConverterRefCount::GetDefaultAsStringFallback(clang::QualType qual_type) {
auto canonical = qual_type.getUnqualifiedType().getCanonicalType();
if (canonical->isBooleanType() ||
(canonical->isIntegerType() && !canonical->isEnumeralType()) ||
canonical->isFloatingType()) {
std::string unboxed;
{
PushConversionKind push(*this, ConversionKind::Unboxed);
unboxed = Converter::GetDefaultAsStringFallback(qual_type);
}
return BoxValue(std::move(unboxed));
}

return std::format("<{}>::default()", ToString(qual_type));
}

Expand Down
1 change: 1 addition & 0 deletions rules/builtin_types/cxxflags
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1 @@
-std=c++20
38 changes: 38 additions & 0 deletions rules/builtin_types/src.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,38 @@
// Copyright (c) 2022-present INESC-ID.
// Distributed under the MIT license that can be found in the LICENSE file.

#include <cstddef>

#define BUILTIN_TYPE(N, T) \
typedef T t##N##0; \
typedef T *t##N##1; \
typedef const T *t##N##2; \
typedef volatile T *t##N##3; \
typedef const volatile T *t##N##4;

typedef decltype(nullptr) t0;

BUILTIN_TYPE(1, bool)
BUILTIN_TYPE(2, char)
BUILTIN_TYPE(3, signed char)
BUILTIN_TYPE(4, unsigned char)
BUILTIN_TYPE(5, char8_t)
BUILTIN_TYPE(6, short)
BUILTIN_TYPE(7, unsigned short)
BUILTIN_TYPE(8, char16_t)
BUILTIN_TYPE(9, int)
BUILTIN_TYPE(10, unsigned int)
BUILTIN_TYPE(11, wchar_t)
BUILTIN_TYPE(12, char32_t)
BUILTIN_TYPE(13, float)
BUILTIN_TYPE(14, long)
BUILTIN_TYPE(15, unsigned long)
BUILTIN_TYPE(16, long long)
BUILTIN_TYPE(17, unsigned long long)
BUILTIN_TYPE(18, double)
BUILTIN_TYPE(19, long double)
BUILTIN_TYPE(20, __int128)
BUILTIN_TYPE(21, unsigned __int128)
BUILTIN_TYPE(22, void)

#undef BUILTIN_TYPE
Loading
Loading