From 7f9df00e1d01c808abe7cb701a2ba1ce52beefa0 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 28 Sep 2026 20:11:27 +0100 Subject: [PATCH 1/6] Move builtin rules in rules/ --- cpp2rust/converter/converter.cpp | 59 +---- cpp2rust/converter/mapper.cpp | 110 +-------- .../converter/models/converter_refcount.cpp | 4 + rules/builtin_types/cxxflags | 1 + rules/builtin_types/src.cpp | 58 +++++ rules/builtin_types/tgt_refcount.rs | 132 +++++++++++ rules/builtin_types/tgt_unsafe.rs | 214 ++++++++++++++++++ rules/cstddef/src.cpp | 9 + rules/cstddef/tgt_refcount.rs | 20 ++ rules/cstddef/tgt_unsafe.rs | 28 +++ rules/string/src.cpp | 1 + rules/string/tgt_unsafe.rs | 4 + 12 files changed, 480 insertions(+), 160 deletions(-) create mode 100644 rules/builtin_types/cxxflags create mode 100644 rules/builtin_types/src.cpp create mode 100644 rules/builtin_types/tgt_refcount.rs create mode 100644 rules/builtin_types/tgt_unsafe.rs create mode 100644 rules/cstddef/tgt_refcount.rs diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp index e43208d8e..227b995bd 100644 --- a/cpp2rust/converter/converter.cpp +++ b/cpp2rust/converter/converter.cpp @@ -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; } diff --git a/cpp2rust/converter/mapper.cpp b/cpp2rust/converter/mapper.cpp index 0a1a7a57d..0464976ce 100644 --- a/cpp2rust/converter/mapper.cpp +++ b/cpp2rust/converter/mapper.cpp @@ -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 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 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( - 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_); @@ -862,7 +758,10 @@ std::string ToString(clang::QualType qual_type, ScalarSugar sugar) { } else if (const auto *ptr = t->getAs()) { auto pointee = ptr->getPointeeType(); auto canonical = pointee.getCanonicalType().getDesugaredType(*ctx_); - if (Map(pointee) == Map(canonical)) { + bool builtin_alias = canonical->isBuiltinType() && + (pointee->getAs() || + pointee->getAs()); + if (!builtin_alias && Map(pointee) == Map(canonical)) { pointee = canonical; } std::string out; @@ -1123,7 +1022,6 @@ void LoadTranslationRules(Model model, clang::ASTContext &ctx, } translation_rules_loaded_ = true; - addBuiltinTypes(model); addRulesFromDirectory(rules_dir, model); #if 0 diff --git a/cpp2rust/converter/models/converter_refcount.cpp b/cpp2rust/converter/models/converter_refcount.cpp index 99b4a5d08..0c3855be3 100644 --- a/cpp2rust/converter/models/converter_refcount.cpp +++ b/cpp2rust/converter/models/converter_refcount.cpp @@ -2089,6 +2089,10 @@ ConverterRefCount::GetArrayDefaultAsString(clang::QualType qual_type) { } std::string ConverterRefCount::GetDefaultAsString(clang::QualType qual_type) { + if (qual_type->isVoidType()) { + return "()"; + } + if (IsVaListType(qual_type)) { computed_expr_type_ = ComputedExprType::FreshValue; return BoxValue("VaList::default()"); diff --git a/rules/builtin_types/cxxflags b/rules/builtin_types/cxxflags new file mode 100644 index 000000000..e23b2aef6 --- /dev/null +++ b/rules/builtin_types/cxxflags @@ -0,0 +1 @@ +-std=c++20 diff --git a/rules/builtin_types/src.cpp b/rules/builtin_types/src.cpp new file mode 100644 index 000000000..b995e80cb --- /dev/null +++ b/rules/builtin_types/src.cpp @@ -0,0 +1,58 @@ +// Copyright (c) 2022-present INESC-ID. +// Distributed under the MIT license that can be found in the LICENSE file. + +#include + +typedef bool t1; +typedef bool *t2; +typedef const bool *t3; +typedef float t4; +typedef float *t5; +typedef const float *t6; +typedef double t7; +typedef double *t8; +typedef const double *t9; +typedef char t10; +typedef char *t11; +typedef const char *t12; +typedef signed char t13; +typedef signed char *t14; +typedef const signed char *t15; +typedef unsigned char t16; +typedef unsigned char *t17; +typedef const unsigned char *t18; +typedef short t19; +typedef short *t20; +typedef const short *t21; +typedef unsigned short t22; +typedef unsigned short *t23; +typedef const unsigned short *t24; +typedef int t25; +typedef int *t26; +typedef const int *t27; +typedef unsigned int t28; +typedef unsigned int *t29; +typedef const unsigned int *t30; +typedef long t31; +typedef long *t32; +typedef const long *t33; +typedef unsigned long t34; +typedef unsigned long *t35; +typedef const unsigned long *t36; +typedef long long t37; +typedef long long *t38; +typedef const long long *t39; +typedef unsigned long long t40; +typedef unsigned long long *t41; +typedef const unsigned long long *t42; +typedef void *t43; +typedef const void *t44; +typedef decltype(nullptr) t45; +typedef void t46; +typedef long double t47; +typedef wchar_t t48; +typedef char8_t t49; +typedef char16_t t50; +typedef char32_t t51; +typedef __int128 t52; +typedef unsigned __int128 t53; diff --git a/rules/builtin_types/tgt_refcount.rs b/rules/builtin_types/tgt_refcount.rs new file mode 100644 index 000000000..133e3d474 --- /dev/null +++ b/rules/builtin_types/tgt_refcount.rs @@ -0,0 +1,132 @@ +// Copyright (c) 2022-present INESC-ID. +// Distributed under the MIT license that can be found in the LICENSE file. + +use libcc2rs::*; + +fn t2() -> Ptr:: { + Ptr::::null() +} + +fn t3() -> Ptr:: { + Ptr::::null() +} + +fn t5() -> Ptr:: { + Ptr::::null() +} + +fn t6() -> Ptr:: { + Ptr::::null() +} + +fn t8() -> Ptr:: { + Ptr::::null() +} + +fn t9() -> Ptr:: { + Ptr::::null() +} + +fn t10() -> u8 { + 0_u8 +} + +fn t11() -> Ptr:: { + Ptr::::null() +} + +fn t12() -> Ptr:: { + Ptr::::null() +} + +fn t14() -> Ptr:: { + Ptr::::null() +} + +fn t15() -> Ptr:: { + Ptr::::null() +} + +fn t17() -> Ptr:: { + Ptr::::null() +} + +fn t18() -> Ptr:: { + Ptr::::null() +} + +fn t20() -> Ptr:: { + Ptr::::null() +} + +fn t21() -> Ptr:: { + Ptr::::null() +} + +fn t23() -> Ptr:: { + Ptr::::null() +} + +fn t24() -> Ptr:: { + Ptr::::null() +} + +fn t26() -> Ptr:: { + Ptr::::null() +} + +fn t27() -> Ptr:: { + Ptr::::null() +} + +fn t29() -> Ptr:: { + Ptr::::null() +} + +fn t30() -> Ptr:: { + Ptr::::null() +} + +fn t32() -> Ptr:: { + Ptr::::null() +} + +fn t33() -> Ptr:: { + Ptr::::null() +} + +fn t35() -> Ptr:: { + Ptr::::null() +} + +fn t36() -> Ptr:: { + Ptr::::null() +} + +fn t38() -> Ptr:: { + Ptr::::null() +} + +fn t39() -> Ptr:: { + Ptr::::null() +} + +fn t41() -> Ptr:: { + Ptr::::null() +} + +fn t42() -> Ptr:: { + Ptr::::null() +} + +fn t43() -> AnyPtr { + AnyPtr::default() +} + +fn t44() -> AnyPtr { + AnyPtr::default() +} + +fn t45() -> AnyPtr { + AnyPtr::default() +} diff --git a/rules/builtin_types/tgt_unsafe.rs b/rules/builtin_types/tgt_unsafe.rs new file mode 100644 index 000000000..d7df7c517 --- /dev/null +++ b/rules/builtin_types/tgt_unsafe.rs @@ -0,0 +1,214 @@ +// Copyright (c) 2022-present INESC-ID. +// Distributed under the MIT license that can be found in the LICENSE file. + +fn t1() -> bool { + false +} + +fn t2() -> *mut bool { + std::ptr::null_mut() +} + +fn t3() -> *const bool { + std::ptr::null() +} + +fn t4() -> f32 { + 0.0_f32 +} + +fn t5() -> *mut f32 { + std::ptr::null_mut() +} + +fn t6() -> *const f32 { + std::ptr::null() +} + +fn t7() -> f64 { + 0.0_f64 +} + +fn t8() -> *mut f64 { + std::ptr::null_mut() +} + +fn t9() -> *const f64 { + std::ptr::null() +} + +fn t10() -> libc::c_char { + (0 as libc::c_char) +} + +fn t11() -> *mut libc::c_char { + std::ptr::null_mut() +} + +fn t12() -> *const libc::c_char { + std::ptr::null() +} + +fn t13() -> i8 { + 0_i8 +} + +fn t14() -> *mut i8 { + std::ptr::null_mut() +} + +fn t15() -> *const i8 { + std::ptr::null() +} + +fn t16() -> u8 { + 0_u8 +} + +fn t17() -> *mut u8 { + std::ptr::null_mut() +} + +fn t18() -> *const u8 { + std::ptr::null() +} + +fn t19() -> i16 { + 0_i16 +} + +fn t20() -> *mut i16 { + std::ptr::null_mut() +} + +fn t21() -> *const i16 { + std::ptr::null() +} + +fn t22() -> u16 { + 0_u16 +} + +fn t23() -> *mut u16 { + std::ptr::null_mut() +} + +fn t24() -> *const u16 { + std::ptr::null() +} + +fn t25() -> i32 { + 0_i32 +} + +fn t26() -> *mut i32 { + std::ptr::null_mut() +} + +fn t27() -> *const i32 { + std::ptr::null() +} + +fn t28() -> u32 { + 0_u32 +} + +fn t29() -> *mut u32 { + std::ptr::null_mut() +} + +fn t30() -> *const u32 { + std::ptr::null() +} + +fn t31() -> i64 { + 0_i64 +} + +fn t32() -> *mut i64 { + std::ptr::null_mut() +} + +fn t33() -> *const i64 { + std::ptr::null() +} + +fn t34() -> u64 { + 0_u64 +} + +fn t35() -> *mut u64 { + std::ptr::null_mut() +} + +fn t36() -> *const u64 { + std::ptr::null() +} + +fn t37() -> i64 { + 0_i64 +} + +fn t38() -> *mut i64 { + std::ptr::null_mut() +} + +fn t39() -> *const i64 { + std::ptr::null() +} + +fn t40() -> u64 { + 0_u64 +} + +fn t41() -> *mut u64 { + std::ptr::null_mut() +} + +fn t42() -> *const u64 { + std::ptr::null() +} + +fn t43() -> *mut ::libc::c_void { + std::ptr::null_mut() +} + +fn t44() -> *const ::libc::c_void { + std::ptr::null() +} + +fn t45() -> *mut ::libc::c_void { + std::ptr::null_mut::<::libc::c_void>() +} + +fn t46() -> ::libc::c_void { + unreachable!() +} + +fn t47() -> f64 { + 0.0_f64 +} + +fn t48() -> i32 { + 0_i32 +} + +fn t49() -> u8 { + 0_u8 +} + +fn t50() -> u16 { + 0_u16 +} + +fn t51() -> u32 { + 0_u32 +} + +fn t52() -> i128 { + 0_i128 +} + +fn t53() -> u128 { + 0_u128 +} diff --git a/rules/cstddef/src.cpp b/rules/cstddef/src.cpp index 9ae81ccd7..b53725844 100644 --- a/rules/cstddef/src.cpp +++ b/rules/cstddef/src.cpp @@ -2,9 +2,18 @@ // Distributed under the MIT license that can be found in the LICENSE file. #include +#include using t1 = std::byte; +typedef size_t t2; +typedef size_t *t3; +typedef const size_t *t4; +typedef decltype(sizeof(0)) t5; +typedef ssize_t t6; +typedef ssize_t *t7; +typedef const ssize_t *t8; + std::byte f1(const std::byte &a0, unsigned a1) { return operator<<(a0, a1); } std::byte f2(const std::byte &a0, unsigned a1) { return operator>>(a0, a1); } diff --git a/rules/cstddef/tgt_refcount.rs b/rules/cstddef/tgt_refcount.rs new file mode 100644 index 000000000..8a68ba2c6 --- /dev/null +++ b/rules/cstddef/tgt_refcount.rs @@ -0,0 +1,20 @@ +// Copyright (c) 2022-present INESC-ID. +// Distributed under the MIT license that can be found in the LICENSE file. + +use libcc2rs::*; + +fn t3() -> Ptr:: { + Ptr::::null() +} + +fn t4() -> Ptr:: { + Ptr::::null() +} + +fn t7() -> Ptr:: { + Ptr::::null() +} + +fn t8() -> Ptr:: { + Ptr::::null() +} diff --git a/rules/cstddef/tgt_unsafe.rs b/rules/cstddef/tgt_unsafe.rs index d40e1d1c2..25a660e66 100644 --- a/rules/cstddef/tgt_unsafe.rs +++ b/rules/cstddef/tgt_unsafe.rs @@ -5,6 +5,34 @@ fn t1() -> u8 { Default::default() } +fn t2() -> usize { + 0_usize +} + +fn t3() -> *mut usize { + std::ptr::null_mut() +} + +fn t4() -> *const usize { + std::ptr::null() +} + +fn t5() -> usize { + 0_usize +} + +fn t6() -> isize { + 0_isize +} + +fn t7() -> *mut isize { + std::ptr::null_mut() +} + +fn t8() -> *const isize { + std::ptr::null() +} + fn f1(a0: &mut u8, a1: u32) -> u8 { *a0 << a1 } diff --git a/rules/string/src.cpp b/rules/string/src.cpp index 0a3581e8c..276962df8 100644 --- a/rules/string/src.cpp +++ b/rules/string/src.cpp @@ -7,6 +7,7 @@ using t1 = std::string; using t2 = std::string::iterator; +typedef std::string::size_type t3; std::string f1(const std::string &s, std::size_t pos, std::size_t count) { return s.substr(pos, count); diff --git a/rules/string/tgt_unsafe.rs b/rules/string/tgt_unsafe.rs index e2c2bd91c..4a9bb6ff2 100644 --- a/rules/string/tgt_unsafe.rs +++ b/rules/string/tgt_unsafe.rs @@ -9,6 +9,10 @@ fn t2() -> *mut libc::c_char { ::std::ptr::null_mut() } +fn t3() -> usize { + 0_usize +} + unsafe fn f1(a0: Vec, a1: usize, a2: usize) -> Vec { let mut __tmp1 = a0[(a1) as usize..::std::cmp::min((a1 + a2) as usize, a0.len() - 1)].to_vec(); __tmp1.push(0); From be6709201be09a3b5a8041317833a3f669f41d37 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 28 Sep 2026 20:15:33 +0100 Subject: [PATCH 2/6] Fix rule for float --- rules/builtin_types/tgt_unsafe.rs | 6 +++--- .../unit/out/refcount/scalar_builtin_construct_destruct.rs | 2 +- tests/unit/out/refcount/static_local.rs | 2 +- tests/unit/out/refcount/types.rs | 4 ++-- tests/unit/out/refcount/vector_with_allocator.rs | 2 +- tests/unit/out/unsafe/scalar_builtin_construct_destruct.rs | 2 +- tests/unit/out/unsafe/static_local.rs | 3 +-- tests/unit/out/unsafe/types.rs | 2 +- tests/unit/out/unsafe/vector_with_allocator.rs | 2 +- 9 files changed, 12 insertions(+), 13 deletions(-) diff --git a/rules/builtin_types/tgt_unsafe.rs b/rules/builtin_types/tgt_unsafe.rs index d7df7c517..e4b0b0085 100644 --- a/rules/builtin_types/tgt_unsafe.rs +++ b/rules/builtin_types/tgt_unsafe.rs @@ -14,7 +14,7 @@ fn t3() -> *const bool { } fn t4() -> f32 { - 0.0_f32 + 0_f32 } fn t5() -> *mut f32 { @@ -26,7 +26,7 @@ fn t6() -> *const f32 { } fn t7() -> f64 { - 0.0_f64 + 0_f64 } fn t8() -> *mut f64 { @@ -186,7 +186,7 @@ fn t46() -> ::libc::c_void { } fn t47() -> f64 { - 0.0_f64 + 0_f64 } fn t48() -> i32 { diff --git a/tests/unit/out/refcount/scalar_builtin_construct_destruct.rs b/tests/unit/out/refcount/scalar_builtin_construct_destruct.rs index eadea9b3c..33afac2a2 100644 --- a/tests/unit/out/refcount/scalar_builtin_construct_destruct.rs +++ b/tests/unit/out/refcount/scalar_builtin_construct_destruct.rs @@ -50,7 +50,7 @@ pub fn main() { } fn main_0() -> i32 { let i: Value = Rc::new(RefCell::new(0_i32)); - let d: Value = Rc::new(RefCell::new(0.0_f64)); + let d: Value = Rc::new(RefCell::new(0_f64)); let p: Value> = Rc::new(RefCell::new(({ zero_0() }))); assert!(((*i.borrow()) == 0)); assert!(((*d.borrow()) == 0.0E+0)); diff --git a/tests/unit/out/refcount/static_local.rs b/tests/unit/out/refcount/static_local.rs index e362558b0..6ab3118ee 100644 --- a/tests/unit/out/refcount/static_local.rs +++ b/tests/unit/out/refcount/static_local.rs @@ -11,7 +11,7 @@ pub fn foo_0() -> i32 { static static_i_1: Value = Rc::new(RefCell::new(0_i32)); ); thread_local!( - static static_f_2: Value = Rc::new(RefCell::new(0.0_f32)); + static static_f_2: Value = Rc::new(RefCell::new(0_f32)); ); thread_local!( static static_b_3: Value = Rc::new(RefCell::new(false)); diff --git a/tests/unit/out/refcount/types.rs b/tests/unit/out/refcount/types.rs index bc5a9226e..b969aa8bc 100644 --- a/tests/unit/out/refcount/types.rs +++ b/tests/unit/out/refcount/types.rs @@ -27,7 +27,7 @@ fn main_0() -> i32 { let xc8: Value = Rc::new(RefCell::new(66_u8)); let xc16: Value = Rc::new(RefCell::new(67_u16)); let xc32: Value = Rc::new(RefCell::new(68_u32)); - let xnp: Value> = Rc::new(RefCell::new(Default::default())); + let xnp: Value = Rc::new(RefCell::new(Default::default())); assert!( (((((((((((((*xu8.borrow()) as i32) + ((*xu16.borrow()) as i32)) as u32) .wrapping_add((*xu32.borrow()))) as u64) @@ -46,7 +46,7 @@ fn main_0() -> i32 { .wrapping_add((*xc32.borrow())) == 266_u32) ); - assert!((::default()).is_null()); + assert!((AnyPtr::default()).is_null()); return 0; } pub fn __cpp2rust_init_globals() {} diff --git a/tests/unit/out/refcount/vector_with_allocator.rs b/tests/unit/out/refcount/vector_with_allocator.rs index 2e3911a62..fb6d06506 100644 --- a/tests/unit/out/refcount/vector_with_allocator.rs +++ b/tests/unit/out/refcount/vector_with_allocator.rs @@ -315,7 +315,7 @@ pub trait TestAllocator_double_Impl { impl TestAllocator_double_Impl for Ptr { fn allocate(&self, n: usize) -> Ptr { let n: Value = Rc::new(RefCell::new(n)); - return Ptr::alloc_array((0..(*n.borrow())).map(|_| 0.0_f64).collect::>()); + return Ptr::alloc_array((0..(*n.borrow())).map(|_| 0_f64).collect::>()); } fn deallocate(&self, p: Ptr, _a1: usize) { let p: Value> = Rc::new(RefCell::new(p)); diff --git a/tests/unit/out/unsafe/scalar_builtin_construct_destruct.rs b/tests/unit/out/unsafe/scalar_builtin_construct_destruct.rs index 148fec472..03987f846 100644 --- a/tests/unit/out/unsafe/scalar_builtin_construct_destruct.rs +++ b/tests/unit/out/unsafe/scalar_builtin_construct_destruct.rs @@ -27,7 +27,7 @@ pub fn main() { } unsafe fn main_0() -> i32 { let mut i: i32 = 0_i32; - let mut d: f64 = 0.0_f64; + let mut d: f64 = 0_f64; let mut p: *mut i32 = (unsafe { zero_0() }); assert!(((i) == (0))); assert!(((d) == (0.0E+0))); diff --git a/tests/unit/out/unsafe/static_local.rs b/tests/unit/out/unsafe/static_local.rs index 58e4d479f..f57a670b3 100644 --- a/tests/unit/out/unsafe/static_local.rs +++ b/tests/unit/out/unsafe/static_local.rs @@ -8,8 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; use std::rc::Rc; pub unsafe fn foo_0() -> i32 { static mut static_i_1: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0_i32 });; - static mut static_f_2: std::cell::LazyCell = - std::cell::LazyCell::new(|| unsafe { 0.0_f32 });; + static mut static_f_2: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0_f32 });; static mut static_b_3: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { false });; static mut kX1_4: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 1 });; diff --git a/tests/unit/out/unsafe/types.rs b/tests/unit/out/unsafe/types.rs index 1d6da6bb0..f57d5c384 100644 --- a/tests/unit/out/unsafe/types.rs +++ b/tests/unit/out/unsafe/types.rs @@ -43,7 +43,7 @@ unsafe fn main_0() -> i32 { ); assert!((((xld) * (2_f64)) == (3_f64))); assert!(((((((xwc) + (xc8 as i32)) + (xc16 as i32)) as u32).wrapping_add(xc32)) == (266_u32))); - assert!((<*mut ::libc::c_void>::default()).is_null()); + assert!((std::ptr::null_mut::<::libc::c_void>()).is_null()); return 0; } pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/unit/out/unsafe/vector_with_allocator.rs b/tests/unit/out/unsafe/vector_with_allocator.rs index b019d5ef7..c12c8fb2b 100644 --- a/tests/unit/out/unsafe/vector_with_allocator.rs +++ b/tests/unit/out/unsafe/vector_with_allocator.rs @@ -25,7 +25,7 @@ impl TestAllocator_int_ { pub struct TestAllocator_double_ {} impl TestAllocator_double_ { pub unsafe fn allocate(&mut self, mut n: usize) -> *mut f64 { - return Box::leak((0..n).map(|_| 0.0_f64).collect::>()).as_mut_ptr(); + return Box::leak((0..n).map(|_| 0_f64).collect::>()).as_mut_ptr(); } pub unsafe fn deallocate(&mut self, mut p: *mut f64, mut _a1: usize) { ::std::mem::drop(Box::from_raw(::std::slice::from_raw_parts_mut( From 29d10faa6ee2bc8410de5630c9b9d3b88490c6f5 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 28 Sep 2026 20:35:15 +0100 Subject: [PATCH 3/6] Reorder builtin rules --- rules/builtin_types/src.cpp | 86 +++---- rules/builtin_types/tgt_refcount.rs | 306 ++++++++++++++++++++--- rules/builtin_types/tgt_unsafe.rs | 362 +++++++++++++++++++++++----- 3 files changed, 599 insertions(+), 155 deletions(-) diff --git a/rules/builtin_types/src.cpp b/rules/builtin_types/src.cpp index b995e80cb..ee504e213 100644 --- a/rules/builtin_types/src.cpp +++ b/rules/builtin_types/src.cpp @@ -3,56 +3,36 @@ #include -typedef bool t1; -typedef bool *t2; -typedef const bool *t3; -typedef float t4; -typedef float *t5; -typedef const float *t6; -typedef double t7; -typedef double *t8; -typedef const double *t9; -typedef char t10; -typedef char *t11; -typedef const char *t12; -typedef signed char t13; -typedef signed char *t14; -typedef const signed char *t15; -typedef unsigned char t16; -typedef unsigned char *t17; -typedef const unsigned char *t18; -typedef short t19; -typedef short *t20; -typedef const short *t21; -typedef unsigned short t22; -typedef unsigned short *t23; -typedef const unsigned short *t24; -typedef int t25; -typedef int *t26; -typedef const int *t27; -typedef unsigned int t28; -typedef unsigned int *t29; -typedef const unsigned int *t30; -typedef long t31; -typedef long *t32; -typedef const long *t33; -typedef unsigned long t34; -typedef unsigned long *t35; -typedef const unsigned long *t36; -typedef long long t37; -typedef long long *t38; -typedef const long long *t39; -typedef unsigned long long t40; -typedef unsigned long long *t41; -typedef const unsigned long long *t42; -typedef void *t43; -typedef const void *t44; -typedef decltype(nullptr) t45; -typedef void t46; -typedef long double t47; -typedef wchar_t t48; -typedef char8_t t49; -typedef char16_t t50; -typedef char32_t t51; -typedef __int128 t52; -typedef unsigned __int128 t53; +#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 diff --git a/rules/builtin_types/tgt_refcount.rs b/rules/builtin_types/tgt_refcount.rs index 133e3d474..5e6a84de8 100644 --- a/rules/builtin_types/tgt_refcount.rs +++ b/rules/builtin_types/tgt_refcount.rs @@ -3,130 +3,362 @@ use libcc2rs::*; -fn t2() -> Ptr:: { +fn t0() -> AnyPtr { + AnyPtr::default() +} + +fn t11() -> Ptr:: { Ptr::::null() } -fn t3() -> Ptr:: { +fn t12() -> Ptr:: { Ptr::::null() } -fn t5() -> Ptr:: { - Ptr::::null() +fn t13() -> Ptr:: { + Ptr::::null() } -fn t6() -> Ptr:: { - Ptr::::null() +fn t14() -> Ptr:: { + Ptr::::null() } -fn t8() -> Ptr:: { - Ptr::::null() +fn t20() -> u8 { + 0_u8 } -fn t9() -> Ptr:: { - Ptr::::null() +fn t21() -> Ptr:: { + Ptr::::null() } -fn t10() -> u8 { - 0_u8 +fn t22() -> Ptr:: { + Ptr::::null() } -fn t11() -> Ptr:: { +fn t23() -> Ptr:: { Ptr::::null() } -fn t12() -> Ptr:: { +fn t24() -> Ptr:: { Ptr::::null() } -fn t14() -> Ptr:: { +fn t31() -> Ptr:: { + Ptr::::null() +} + +fn t32() -> Ptr:: { Ptr::::null() } -fn t15() -> Ptr:: { +fn t33() -> Ptr:: { Ptr::::null() } -fn t17() -> Ptr:: { +fn t34() -> Ptr:: { + Ptr::::null() +} + +fn t41() -> Ptr:: { + Ptr::::null() +} + +fn t42() -> Ptr:: { Ptr::::null() } -fn t18() -> Ptr:: { +fn t43() -> Ptr:: { Ptr::::null() } -fn t20() -> Ptr:: { +fn t44() -> Ptr:: { + Ptr::::null() +} + +fn t51() -> Ptr:: { + Ptr::::null() +} + +fn t52() -> Ptr:: { + Ptr::::null() +} + +fn t53() -> Ptr:: { + Ptr::::null() +} + +fn t54() -> Ptr:: { + Ptr::::null() +} + +fn t61() -> Ptr:: { Ptr::::null() } -fn t21() -> Ptr:: { +fn t62() -> Ptr:: { Ptr::::null() } -fn t23() -> Ptr:: { +fn t63() -> Ptr:: { + Ptr::::null() +} + +fn t64() -> Ptr:: { + Ptr::::null() +} + +fn t71() -> Ptr:: { + Ptr::::null() +} + +fn t72() -> Ptr:: { + Ptr::::null() +} + +fn t73() -> Ptr:: { + Ptr::::null() +} + +fn t74() -> Ptr:: { + Ptr::::null() +} + +fn t81() -> Ptr:: { Ptr::::null() } -fn t24() -> Ptr:: { +fn t82() -> Ptr:: { Ptr::::null() } -fn t26() -> Ptr:: { +fn t83() -> Ptr:: { + Ptr::::null() +} + +fn t84() -> Ptr:: { + Ptr::::null() +} + +fn t91() -> Ptr:: { + Ptr::::null() +} + +fn t92() -> Ptr:: { + Ptr::::null() +} + +fn t93() -> Ptr:: { + Ptr::::null() +} + +fn t94() -> Ptr:: { + Ptr::::null() +} + +fn t101() -> Ptr:: { + Ptr::::null() +} + +fn t102() -> Ptr:: { + Ptr::::null() +} + +fn t103() -> Ptr:: { + Ptr::::null() +} + +fn t104() -> Ptr:: { + Ptr::::null() +} + +fn t111() -> Ptr:: { + Ptr::::null() +} + +fn t112() -> Ptr:: { Ptr::::null() } -fn t27() -> Ptr:: { +fn t113() -> Ptr:: { Ptr::::null() } -fn t29() -> Ptr:: { +fn t114() -> Ptr:: { + Ptr::::null() +} + +fn t121() -> Ptr:: { + Ptr::::null() +} + +fn t122() -> Ptr:: { Ptr::::null() } -fn t30() -> Ptr:: { +fn t123() -> Ptr:: { Ptr::::null() } -fn t32() -> Ptr:: { +fn t124() -> Ptr:: { + Ptr::::null() +} + +fn t131() -> Ptr:: { + Ptr::::null() +} + +fn t132() -> Ptr:: { + Ptr::::null() +} + +fn t133() -> Ptr:: { + Ptr::::null() +} + +fn t134() -> Ptr:: { + Ptr::::null() +} + +fn t141() -> Ptr:: { + Ptr::::null() +} + +fn t142() -> Ptr:: { + Ptr::::null() +} + +fn t143() -> Ptr:: { Ptr::::null() } -fn t33() -> Ptr:: { +fn t144() -> Ptr:: { Ptr::::null() } -fn t35() -> Ptr:: { +fn t151() -> Ptr:: { + Ptr::::null() +} + +fn t152() -> Ptr:: { + Ptr::::null() +} + +fn t153() -> Ptr:: { Ptr::::null() } -fn t36() -> Ptr:: { +fn t154() -> Ptr:: { Ptr::::null() } -fn t38() -> Ptr:: { +fn t161() -> Ptr:: { Ptr::::null() } -fn t39() -> Ptr:: { +fn t162() -> Ptr:: { Ptr::::null() } -fn t41() -> Ptr:: { +fn t163() -> Ptr:: { + Ptr::::null() +} + +fn t164() -> Ptr:: { + Ptr::::null() +} + +fn t171() -> Ptr:: { + Ptr::::null() +} + +fn t172() -> Ptr:: { + Ptr::::null() +} + +fn t173() -> Ptr:: { Ptr::::null() } -fn t42() -> Ptr:: { +fn t174() -> Ptr:: { Ptr::::null() } -fn t43() -> AnyPtr { +fn t181() -> Ptr:: { + Ptr::::null() +} + +fn t182() -> Ptr:: { + Ptr::::null() +} + +fn t183() -> Ptr:: { + Ptr::::null() +} + +fn t184() -> Ptr:: { + Ptr::::null() +} + +fn t191() -> Ptr:: { + Ptr::::null() +} + +fn t192() -> Ptr:: { + Ptr::::null() +} + +fn t193() -> Ptr:: { + Ptr::::null() +} + +fn t194() -> Ptr:: { + Ptr::::null() +} + +fn t201() -> Ptr:: { + Ptr::::null() +} + +fn t202() -> Ptr:: { + Ptr::::null() +} + +fn t203() -> Ptr:: { + Ptr::::null() +} + +fn t204() -> Ptr:: { + Ptr::::null() +} + +fn t211() -> Ptr:: { + Ptr::::null() +} + +fn t212() -> Ptr:: { + Ptr::::null() +} + +fn t213() -> Ptr:: { + Ptr::::null() +} + +fn t214() -> Ptr:: { + Ptr::::null() +} + +fn t221() -> AnyPtr { + AnyPtr::default() +} + +fn t222() -> AnyPtr { AnyPtr::default() } -fn t44() -> AnyPtr { +fn t223() -> AnyPtr { AnyPtr::default() } -fn t45() -> AnyPtr { +fn t224() -> AnyPtr { AnyPtr::default() } diff --git a/rules/builtin_types/tgt_unsafe.rs b/rules/builtin_types/tgt_unsafe.rs index e4b0b0085..a31f3a375 100644 --- a/rules/builtin_types/tgt_unsafe.rs +++ b/rules/builtin_types/tgt_unsafe.rs @@ -1,214 +1,446 @@ // Copyright (c) 2022-present INESC-ID. // Distributed under the MIT license that can be found in the LICENSE file. -fn t1() -> bool { +fn t0() -> *mut ::libc::c_void { + std::ptr::null_mut::<::libc::c_void>() +} + +fn t10() -> bool { false } -fn t2() -> *mut bool { +fn t11() -> *mut bool { std::ptr::null_mut() } -fn t3() -> *const bool { +fn t12() -> *const bool { std::ptr::null() } -fn t4() -> f32 { - 0_f32 -} - -fn t5() -> *mut f32 { +fn t13() -> *mut bool { std::ptr::null_mut() } -fn t6() -> *const f32 { +fn t14() -> *const bool { std::ptr::null() } -fn t7() -> f64 { - 0_f64 +fn t20() -> libc::c_char { + (0 as libc::c_char) } -fn t8() -> *mut f64 { +fn t21() -> *mut libc::c_char { std::ptr::null_mut() } -fn t9() -> *const f64 { +fn t22() -> *const libc::c_char { std::ptr::null() } -fn t10() -> libc::c_char { - (0 as libc::c_char) +fn t23() -> *mut libc::c_char { + std::ptr::null_mut() +} + +fn t24() -> *const libc::c_char { + std::ptr::null() } -fn t11() -> *mut libc::c_char { +fn t30() -> i8 { + 0_i8 +} + +fn t31() -> *mut i8 { std::ptr::null_mut() } -fn t12() -> *const libc::c_char { +fn t32() -> *const i8 { std::ptr::null() } -fn t13() -> i8 { - 0_i8 +fn t33() -> *mut i8 { + std::ptr::null_mut() +} + +fn t34() -> *const i8 { + std::ptr::null() +} + +fn t40() -> u8 { + 0_u8 } -fn t14() -> *mut i8 { +fn t41() -> *mut u8 { std::ptr::null_mut() } -fn t15() -> *const i8 { +fn t42() -> *const u8 { std::ptr::null() } -fn t16() -> u8 { +fn t43() -> *mut u8 { + std::ptr::null_mut() +} + +fn t44() -> *const u8 { + std::ptr::null() +} + +fn t50() -> u8 { 0_u8 } -fn t17() -> *mut u8 { +fn t51() -> *mut u8 { + std::ptr::null_mut() +} + +fn t52() -> *const u8 { + std::ptr::null() +} + +fn t53() -> *mut u8 { std::ptr::null_mut() } -fn t18() -> *const u8 { +fn t54() -> *const u8 { std::ptr::null() } -fn t19() -> i16 { +fn t60() -> i16 { 0_i16 } -fn t20() -> *mut i16 { +fn t61() -> *mut i16 { + std::ptr::null_mut() +} + +fn t62() -> *const i16 { + std::ptr::null() +} + +fn t63() -> *mut i16 { + std::ptr::null_mut() +} + +fn t64() -> *const i16 { + std::ptr::null() +} + +fn t70() -> u16 { + 0_u16 +} + +fn t71() -> *mut u16 { std::ptr::null_mut() } -fn t21() -> *const i16 { +fn t72() -> *const u16 { std::ptr::null() } -fn t22() -> u16 { +fn t73() -> *mut u16 { + std::ptr::null_mut() +} + +fn t74() -> *const u16 { + std::ptr::null() +} + +fn t80() -> u16 { 0_u16 } -fn t23() -> *mut u16 { +fn t81() -> *mut u16 { std::ptr::null_mut() } -fn t24() -> *const u16 { +fn t82() -> *const u16 { std::ptr::null() } -fn t25() -> i32 { +fn t83() -> *mut u16 { + std::ptr::null_mut() +} + +fn t84() -> *const u16 { + std::ptr::null() +} + +fn t90() -> i32 { 0_i32 } -fn t26() -> *mut i32 { +fn t91() -> *mut i32 { + std::ptr::null_mut() +} + +fn t92() -> *const i32 { + std::ptr::null() +} + +fn t93() -> *mut i32 { + std::ptr::null_mut() +} + +fn t94() -> *const i32 { + std::ptr::null() +} + +fn t100() -> u32 { + 0_u32 +} + +fn t101() -> *mut u32 { + std::ptr::null_mut() +} + +fn t102() -> *const u32 { + std::ptr::null() +} + +fn t103() -> *mut u32 { + std::ptr::null_mut() +} + +fn t104() -> *const u32 { + std::ptr::null() +} + +fn t110() -> i32 { + 0_i32 +} + +fn t111() -> *mut i32 { + std::ptr::null_mut() +} + +fn t112() -> *const i32 { + std::ptr::null() +} + +fn t113() -> *mut i32 { std::ptr::null_mut() } -fn t27() -> *const i32 { +fn t114() -> *const i32 { std::ptr::null() } -fn t28() -> u32 { +fn t120() -> u32 { 0_u32 } -fn t29() -> *mut u32 { +fn t121() -> *mut u32 { + std::ptr::null_mut() +} + +fn t122() -> *const u32 { + std::ptr::null() +} + +fn t123() -> *mut u32 { std::ptr::null_mut() } -fn t30() -> *const u32 { +fn t124() -> *const u32 { std::ptr::null() } -fn t31() -> i64 { +fn t130() -> f32 { + 0_f32 +} + +fn t131() -> *mut f32 { + std::ptr::null_mut() +} + +fn t132() -> *const f32 { + std::ptr::null() +} + +fn t133() -> *mut f32 { + std::ptr::null_mut() +} + +fn t134() -> *const f32 { + std::ptr::null() +} + +fn t140() -> i64 { 0_i64 } -fn t32() -> *mut i64 { +fn t141() -> *mut i64 { std::ptr::null_mut() } -fn t33() -> *const i64 { +fn t142() -> *const i64 { std::ptr::null() } -fn t34() -> u64 { +fn t143() -> *mut i64 { + std::ptr::null_mut() +} + +fn t144() -> *const i64 { + std::ptr::null() +} + +fn t150() -> u64 { 0_u64 } -fn t35() -> *mut u64 { +fn t151() -> *mut u64 { + std::ptr::null_mut() +} + +fn t152() -> *const u64 { + std::ptr::null() +} + +fn t153() -> *mut u64 { std::ptr::null_mut() } -fn t36() -> *const u64 { +fn t154() -> *const u64 { std::ptr::null() } -fn t37() -> i64 { +fn t160() -> i64 { 0_i64 } -fn t38() -> *mut i64 { +fn t161() -> *mut i64 { + std::ptr::null_mut() +} + +fn t162() -> *const i64 { + std::ptr::null() +} + +fn t163() -> *mut i64 { std::ptr::null_mut() } -fn t39() -> *const i64 { +fn t164() -> *const i64 { std::ptr::null() } -fn t40() -> u64 { +fn t170() -> u64 { 0_u64 } -fn t41() -> *mut u64 { +fn t171() -> *mut u64 { std::ptr::null_mut() } -fn t42() -> *const u64 { +fn t172() -> *const u64 { std::ptr::null() } -fn t43() -> *mut ::libc::c_void { +fn t173() -> *mut u64 { std::ptr::null_mut() } -fn t44() -> *const ::libc::c_void { +fn t174() -> *const u64 { std::ptr::null() } -fn t45() -> *mut ::libc::c_void { - std::ptr::null_mut::<::libc::c_void>() +fn t180() -> f64 { + 0_f64 +} + +fn t181() -> *mut f64 { + std::ptr::null_mut() +} + +fn t182() -> *const f64 { + std::ptr::null() +} + +fn t183() -> *mut f64 { + std::ptr::null_mut() } -fn t46() -> ::libc::c_void { - unreachable!() +fn t184() -> *const f64 { + std::ptr::null() } -fn t47() -> f64 { +fn t190() -> f64 { 0_f64 } -fn t48() -> i32 { - 0_i32 +fn t191() -> *mut f64 { + std::ptr::null_mut() } -fn t49() -> u8 { - 0_u8 +fn t192() -> *const f64 { + std::ptr::null() } -fn t50() -> u16 { - 0_u16 +fn t193() -> *mut f64 { + std::ptr::null_mut() } -fn t51() -> u32 { - 0_u32 +fn t194() -> *const f64 { + std::ptr::null() } -fn t52() -> i128 { +fn t200() -> i128 { 0_i128 } -fn t53() -> u128 { +fn t201() -> *mut i128 { + std::ptr::null_mut() +} + +fn t202() -> *const i128 { + std::ptr::null() +} + +fn t203() -> *mut i128 { + std::ptr::null_mut() +} + +fn t204() -> *const i128 { + std::ptr::null() +} + +fn t210() -> u128 { 0_u128 } + +fn t211() -> *mut u128 { + std::ptr::null_mut() +} + +fn t212() -> *const u128 { + std::ptr::null() +} + +fn t213() -> *mut u128 { + std::ptr::null_mut() +} + +fn t214() -> *const u128 { + std::ptr::null() +} + +fn t220() -> () { + () +} + +fn t221() -> *mut ::libc::c_void { + std::ptr::null_mut() +} + +fn t222() -> *const ::libc::c_void { + std::ptr::null() +} + +fn t223() -> *mut ::libc::c_void { + std::ptr::null_mut() +} + +fn t224() -> *const ::libc::c_void { + std::ptr::null() +} From ef2f1a480d394e03f378f688df0d700f8222cc50 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 28 Sep 2026 20:35:50 +0100 Subject: [PATCH 4/6] Remove hardcoded default values --- cpp2rust/converter/converter.cpp | 16 ------------- .../converter/models/converter_refcount.cpp | 24 ++----------------- 2 files changed, 2 insertions(+), 38 deletions(-) diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp index 227b995bd..573889013 100644 --- a/cpp2rust/converter/converter.cpp +++ b/cpp2rust/converter/converter.cpp @@ -3985,10 +3985,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()"; @@ -4021,18 +4017,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_)) { diff --git a/cpp2rust/converter/models/converter_refcount.cpp b/cpp2rust/converter/models/converter_refcount.cpp index 0c3855be3..130120a57 100644 --- a/cpp2rust/converter/models/converter_refcount.cpp +++ b/cpp2rust/converter/models/converter_refcount.cpp @@ -2089,10 +2089,6 @@ ConverterRefCount::GetArrayDefaultAsString(clang::QualType qual_type) { } std::string ConverterRefCount::GetDefaultAsString(clang::QualType qual_type) { - if (qual_type->isVoidType()) { - return "()"; - } - if (IsVaListType(qual_type)) { computed_expr_type_ = ComputedExprType::FreshValue; return BoxValue("VaList::default()"); @@ -2117,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); @@ -2133,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)); } From 8ded40536858da39d4181cda37bbc39a1bcfaeed Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 28 Sep 2026 20:40:40 +0100 Subject: [PATCH 5/6] Drop intermediate cast --- cpp2rust/converter/converter.cpp | 5 -- .../out/unsafe/defaulted_move_cross_tu.rs | 6 +- tests/ub/out/unsafe/fd_use_after_close.rs | 2 +- tests/unit/out/unsafe/bsearch_ptr_cmp.rs | 6 +- tests/unit/out/unsafe/copy_move_defaulted.rs | 14 ++--- tests/unit/out/unsafe/cstring.rs | 56 ++++++++---------- tests/unit/out/unsafe/errno.rs | 2 +- tests/unit/out/unsafe/fcntl.rs | 2 +- tests/unit/out/unsafe/fd_io.rs | 10 ++-- tests/unit/out/unsafe/fn_ptr.rs | 2 +- tests/unit/out/unsafe/fn_ptr_cast.rs | 8 +-- .../unit/out/unsafe/fn_ptr_stdlib_compare.rs | 24 ++++---- tests/unit/out/unsafe/fn_ptr_vtable.rs | 2 +- tests/unit/out/unsafe/fstat.rs | 2 +- tests/unit/out/unsafe/ifaddrs.rs | 12 ++-- tests/unit/out/unsafe/inet_pton_ntop.rs | 16 +++--- tests/unit/out/unsafe/lseek_ftruncate.rs | 8 +-- tests/unit/out/unsafe/malloc_realloc_free.rs | 20 +++---- tests/unit/out/unsafe/memcpy_overlap.rs | 6 +- tests/unit/out/unsafe/memcpy_struct_bytes.rs | 12 ++-- tests/unit/out/unsafe/memcpy_struct_struct.rs | 6 +- tests/unit/out/unsafe/memset.rs | 4 +- tests/unit/out/unsafe/netdb.rs | 28 +++++---- tests/unit/out/unsafe/new_alloc_array.rs | 4 +- tests/unit/out/unsafe/operator_new_delete.rs | 4 +- tests/unit/out/unsafe/pipe_io.rs | 10 ++-- tests/unit/out/unsafe/poll.rs | 4 +- tests/unit/out/unsafe/ptr_cast_init.rs | 3 +- tests/unit/out/unsafe/qsort_bsearch.rs | 10 ++-- .../out/unsafe/reinterpret_cast_ptr_cmp.rs | 4 +- tests/unit/out/unsafe/select.rs | 7 +-- tests/unit/out/unsafe/sockopt.rs | 6 +- tests/unit/out/unsafe/stdio_nofd.rs | 36 +++++------- tests/unit/out/unsafe/stdlib_h.rs | 2 +- tests/unit/out/unsafe/strdup.rs | 10 ++-- tests/unit/out/unsafe/string_h.rs | 57 ++++++++----------- .../out/unsafe/string_literal_ptr_init.rs | 4 +- tests/unit/out/unsafe/unconst.rs | 4 +- .../unit/out/unsafe/union_addrof_external.rs | 7 +-- tests/unit/out/unsafe/union_cross_arm_cast.rs | 5 +- .../out/unsafe/union_flex_array_member.rs | 2 +- tests/unit/out/unsafe/union_memset_memcpy.rs | 18 +++--- tests/unit/out/unsafe/union_nested.rs | 4 +- .../unit/out/unsafe/union_struct_dual_use.rs | 4 +- .../unit/out/unsafe/union_tagged_many_arms.rs | 8 +-- tests/unit/out/unsafe/union_tagged_simple.rs | 10 ++-- .../out/unsafe/union_void_ptr_sized_deref.rs | 6 +- tests/unit/out/unsafe/unistd.rs | 41 +++++-------- tests/unit/out/unsafe/va_arg_fn_ptr.rs | 6 +- .../unsafe/void_ptr_implicit_conversion.rs | 3 +- tests/unit/out/unsafe/z_bit_cast.rs | 14 ++--- 51 files changed, 238 insertions(+), 308 deletions(-) diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp index 573889013..81c9f4d3c 100644 --- a/cpp2rust/converter/converter.cpp +++ b/cpp2rust/converter/converter.cpp @@ -2458,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; diff --git a/tests/multi-file/defaulted_move_cross_tu/out/unsafe/defaulted_move_cross_tu.rs b/tests/multi-file/defaulted_move_cross_tu/out/unsafe/defaulted_move_cross_tu.rs index b6d26a9ac..21474db01 100644 --- a/tests/multi-file/defaulted_move_cross_tu/out/unsafe/defaulted_move_cross_tu.rs +++ b/tests/multi-file/defaulted_move_cross_tu/out/unsafe/defaulted_move_cross_tu.rs @@ -32,12 +32,12 @@ impl S { { if 8_usize != 0 { ::std::ptr::copy_nonoverlapping( - ((&mut (*_a0).n as *mut [i32; 2]) as *const [i32; 2] as *const ::libc::c_void), - ((&mut self.n as *mut [i32; 2]) as *mut [i32; 2] as *mut ::libc::c_void), + ((&mut (*_a0).n as *mut [i32; 2]) as *const ::libc::c_void), + ((&mut self.n as *mut [i32; 2]) as *mut ::libc::c_void), 8_usize as usize, ) } - ((&mut self.n as *mut [i32; 2]) as *mut [i32; 2] as *mut ::libc::c_void) + ((&mut self.n as *mut [i32; 2]) as *mut ::libc::c_void) }; return &mut (*(self as *mut S)); } diff --git a/tests/ub/out/unsafe/fd_use_after_close.rs b/tests/ub/out/unsafe/fd_use_after_close.rs index e1e9e65ac..faeb35962 100644 --- a/tests/ub/out/unsafe/fd_use_after_close.rs +++ b/tests/ub/out/unsafe/fd_use_after_close.rs @@ -23,7 +23,7 @@ unsafe fn main_0() -> i32 { let mut buf: [libc::c_char; 4] = [(0 as libc::c_char); 4]; let mut n: isize = libc::read( fd, - (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void), + (buf.as_mut_ptr() as *mut ::libc::c_void), ::std::mem::size_of::<[libc::c_char; 4]>(), ); return if ((((n) == (-1_i32 as isize)) as i32) != 0) { diff --git a/tests/unit/out/unsafe/bsearch_ptr_cmp.rs b/tests/unit/out/unsafe/bsearch_ptr_cmp.rs index d4aa67285..34e244705 100644 --- a/tests/unit/out/unsafe/bsearch_ptr_cmp.rs +++ b/tests/unit/out/unsafe/bsearch_ptr_cmp.rs @@ -18,8 +18,8 @@ pub fn main() { unsafe fn main_0() -> i32 { let mut a1: [i32; 3] = [1, 2, 3]; let mut vptr1: *mut ::libc::c_void = libc::bsearch( - ((&mut a1[(0) as usize] as *mut i32) as *const i32 as *const ::libc::c_void), - (a1.as_mut_ptr() as *const i32 as *const ::libc::c_void), + ((&mut a1[(0) as usize] as *mut i32) as *const ::libc::c_void), + (a1.as_mut_ptr() as *const ::libc::c_void), 1_usize, ::std::mem::size_of::(), Some(std::mem::transmute::< @@ -30,7 +30,7 @@ unsafe fn main_0() -> i32 { as *const (), )), ); - assert!(((vptr1) == ((&mut a1[(0) as usize] as *mut i32) as *mut i32 as *mut ::libc::c_void))); + assert!(((vptr1) == ((&mut a1[(0) as usize] as *mut i32) as *mut ::libc::c_void))); return 0; } pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/unit/out/unsafe/copy_move_defaulted.rs b/tests/unit/out/unsafe/copy_move_defaulted.rs index c41d85182..dbb365151 100644 --- a/tests/unit/out/unsafe/copy_move_defaulted.rs +++ b/tests/unit/out/unsafe/copy_move_defaulted.rs @@ -150,13 +150,12 @@ impl Buffer { { if 8_usize != 0 { ::std::ptr::copy_nonoverlapping( - ((&mut (*_a0).arr as *mut [i32; 2]) as *const [i32; 2] - as *const ::libc::c_void), - ((&mut self.arr as *mut [i32; 2]) as *mut [i32; 2] as *mut ::libc::c_void), + ((&mut (*_a0).arr as *mut [i32; 2]) as *const ::libc::c_void), + ((&mut self.arr as *mut [i32; 2]) as *mut ::libc::c_void), 8_usize as usize, ) } - ((&mut self.arr as *mut [i32; 2]) as *mut [i32; 2] as *mut ::libc::c_void) + ((&mut self.arr as *mut [i32; 2]) as *mut ::libc::c_void) }; return &mut (*(self as *mut Buffer)); } @@ -195,13 +194,12 @@ impl Owner { { if 8_usize != 0 { ::std::ptr::copy_nonoverlapping( - ((&mut (*_a0).arr as *mut [i32; 2]) as *const [i32; 2] - as *const ::libc::c_void), - ((&mut self.arr as *mut [i32; 2]) as *mut [i32; 2] as *mut ::libc::c_void), + ((&mut (*_a0).arr as *mut [i32; 2]) as *const ::libc::c_void), + ((&mut self.arr as *mut [i32; 2]) as *mut ::libc::c_void), 8_usize as usize, ) } - ((&mut self.arr as *mut [i32; 2]) as *mut [i32; 2] as *mut ::libc::c_void) + ((&mut self.arr as *mut [i32; 2]) as *mut ::libc::c_void) }; self.p = (*_a0).p.take(); return &mut (*(self as *mut Owner)); diff --git a/tests/unit/out/unsafe/cstring.rs b/tests/unit/out/unsafe/cstring.rs index ea810293d..9cb598085 100644 --- a/tests/unit/out/unsafe/cstring.rs +++ b/tests/unit/out/unsafe/cstring.rs @@ -19,14 +19,14 @@ pub unsafe fn test_memcpy_0() { let mut r: *mut ::libc::c_void = { if 6_usize != 0 { ::std::ptr::copy_nonoverlapping( - (src.as_ptr() as *const libc::c_char as *const ::libc::c_void), - (dst.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void), + (src.as_ptr() as *const ::libc::c_void), + (dst.as_mut_ptr() as *mut ::libc::c_void), 6_usize as usize, ) } - (dst.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) + (dst.as_mut_ptr() as *mut ::libc::c_void) }; - assert!(((r) == (dst.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void))); + assert!(((r) == (dst.as_mut_ptr() as *mut ::libc::c_void))); assert!( (((dst[(0) as usize] as i32) == (('h' as libc::c_char) as i32)) && ((dst[(1) as usize] as i32) == (('e' as libc::c_char) as i32))) @@ -41,13 +41,13 @@ pub unsafe fn test_memcpy_0() { pub unsafe fn test_memset_1() { let mut buf: [libc::c_char; 4] = [(0 as libc::c_char); 4]; let mut r: *mut ::libc::c_void = { - let byte_0 = (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) as *mut u8; + let byte_0 = (buf.as_mut_ptr() as *mut ::libc::c_void) as *mut u8; for offset in 0..4_usize { *byte_0.offset(offset as isize) = (('x' as libc::c_char) as i32) as u8; } - (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) + (buf.as_mut_ptr() as *mut ::libc::c_void) }; - assert!(((r) == (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void))); + assert!(((r) == (buf.as_mut_ptr() as *mut ::libc::c_void))); assert!( ((((buf[(0) as usize] as i32) == (('x' as libc::c_char) as i32)) && ((buf[(1) as usize] as i32) == (('x' as libc::c_char) as i32))) @@ -77,11 +77,11 @@ pub unsafe fn test_memcmp_2() { assert!( (({ let sa = core::slice::from_raw_parts( - (a.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8, + (a.as_ptr() as *const ::libc::c_void) as *const u8, 4_usize as usize, ); let sb = core::slice::from_raw_parts( - (b.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8, + (b.as_ptr() as *const ::libc::c_void) as *const u8, 4_usize as usize, ); let mut diff = 0_i32; @@ -97,11 +97,11 @@ pub unsafe fn test_memcmp_2() { assert!( (({ let sa = core::slice::from_raw_parts( - (a.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8, + (a.as_ptr() as *const ::libc::c_void) as *const u8, 4_usize as usize, ); let sb = core::slice::from_raw_parts( - (c.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8, + (c.as_ptr() as *const ::libc::c_void) as *const u8, 4_usize as usize, ); let mut diff = 0_i32; @@ -117,11 +117,11 @@ pub unsafe fn test_memcmp_2() { assert!( (({ let sa = core::slice::from_raw_parts( - (c.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8, + (c.as_ptr() as *const ::libc::c_void) as *const u8, 4_usize as usize, ); let sb = core::slice::from_raw_parts( - (a.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8, + (a.as_ptr() as *const ::libc::c_void) as *const u8, 4_usize as usize, ); let mut diff = 0_i32; @@ -147,17 +147,14 @@ pub unsafe fn test_memmove_3() { let mut r: *mut ::libc::c_void = { if 4_usize != 0 { ::std::ptr::copy_nonoverlapping( - (buf.as_mut_ptr() as *const libc::c_char as *const ::libc::c_void), - (buf.as_mut_ptr().offset((1) as isize) as *mut libc::c_char as *mut ::libc::c_void), + (buf.as_mut_ptr() as *const ::libc::c_void), + (buf.as_mut_ptr().offset((1) as isize) as *mut ::libc::c_void), 4_usize as usize, ) } - (buf.as_mut_ptr().offset((1) as isize) as *mut libc::c_char as *mut ::libc::c_void) + (buf.as_mut_ptr().offset((1) as isize) as *mut ::libc::c_void) }; - assert!( - ((r) == (buf.as_mut_ptr().offset((1) as isize) as *mut libc::c_char - as *mut ::libc::c_void)) - ); + assert!(((r) == (buf.as_mut_ptr().offset((1) as isize) as *mut ::libc::c_void))); assert!( (((buf[(0) as usize] as i32) == (('a' as libc::c_char) as i32)) && ((buf[(1) as usize] as i32) == (('a' as libc::c_char) as i32))) @@ -226,25 +223,20 @@ pub unsafe fn test_memchr_8() { (64 as libc::c_char), ]; let mut r: *const ::libc::c_void = libc::memchr( - (data.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const ::libc::c_void, + (data.as_ptr() as *const ::libc::c_void) as *const ::libc::c_void, 48, 4_usize as usize, ) as *const ::libc::c_void; - assert!( - ((r) == ((&data[(2) as usize] as *const libc::c_char) as *const libc::c_char - as *const ::libc::c_void)) - ); + assert!(((r) == ((&data[(2) as usize] as *const libc::c_char) as *const ::libc::c_void))); assert!( (libc::memchr( - (data.as_ptr() as *const libc::c_char as *const ::libc::c_void) - as *const ::libc::c_void, + (data.as_ptr() as *const ::libc::c_void) as *const ::libc::c_void, 153, 4_usize as usize ) as *const ::libc::c_void) .is_null() ); - let mut p: *const ::libc::c_void = - (data.as_ptr() as *const libc::c_char as *const ::libc::c_void); + let mut p: *const ::libc::c_void = (data.as_ptr() as *const ::libc::c_void); let mut n: usize = 4_usize; assert!( ((libc::memchr(p as *const ::libc::c_void, 16, n as usize) as *const ::libc::c_void) @@ -274,7 +266,7 @@ pub unsafe fn test_strdup_10() { let mut d: *mut libc::c_char = libcc2rs::strdup_unsafe(c"hello".as_ptr()); assert!(!((d).is_null())); assert!(((libc::strcmp((d).cast_const(), c"hello".as_ptr())) == (0))); - libcc2rs::free_unsafe((d as *mut libc::c_char as *mut ::libc::c_void)); + libcc2rs::free_unsafe((d as *mut ::libc::c_void)); let mut p: *const libc::c_char = c"world".as_ptr(); let mut buf: [libc::c_char; 4] = [ ('a' as libc::c_char), @@ -285,11 +277,11 @@ pub unsafe fn test_strdup_10() { let mut d2: *mut libc::c_char = libcc2rs::strdup_unsafe(p); assert!(!((d2).is_null())); assert!(((libc::strcmp((d2).cast_const(), p)) == (0))); - libcc2rs::free_unsafe((d2 as *mut libc::c_char as *mut ::libc::c_void)); + libcc2rs::free_unsafe((d2 as *mut ::libc::c_void)); let mut d3: *mut libc::c_char = libcc2rs::strdup_unsafe((buf.as_mut_ptr()).cast_const()); assert!(!((d3).is_null())); assert!(((libc::strcmp((d3).cast_const(), (buf.as_mut_ptr()).cast_const())) == (0))); - libcc2rs::free_unsafe((d3 as *mut libc::c_char as *mut ::libc::c_void)); + libcc2rs::free_unsafe((d3 as *mut ::libc::c_void)); } pub unsafe fn test_strcspn_11() { assert!(((libc::strcspn(c"hello".as_ptr(), c"el".as_ptr())) == (1_usize))); diff --git a/tests/unit/out/unsafe/errno.rs b/tests/unit/out/unsafe/errno.rs index 1668c216d..a465779af 100644 --- a/tests/unit/out/unsafe/errno.rs +++ b/tests/unit/out/unsafe/errno.rs @@ -21,7 +21,7 @@ pub unsafe fn test_errno_preserved_across_strdup_1() { libcc2rs::strdup_unsafe((c"hello".as_ptr().cast_mut()).cast_const()); assert!((((!((d).is_null())) as i32) != 0)); assert!(((((*libcc2rs::cpp2rust_errno_unsafe()) == (99)) as i32) != 0)); - libcc2rs::free_unsafe((d as *mut libc::c_char as *mut ::libc::c_void)); + libcc2rs::free_unsafe((d as *mut ::libc::c_void)); (*libcc2rs::cpp2rust_errno_unsafe()) = 0; } pub unsafe fn test_errno_from_fseek_2() { diff --git a/tests/unit/out/unsafe/fcntl.rs b/tests/unit/out/unsafe/fcntl.rs index d76ec44c6..7f67f512e 100644 --- a/tests/unit/out/unsafe/fcntl.rs +++ b/tests/unit/out/unsafe/fcntl.rs @@ -34,7 +34,7 @@ unsafe fn main_0() -> i32 { assert!( ((((libc::read( fds[(0) as usize], - ((&mut b as *mut libc::c_char) as *mut libc::c_char as *mut ::libc::c_void), + ((&mut b as *mut libc::c_char) as *mut ::libc::c_void), 1_usize )) == (-1_i32 as isize)) as i32) != 0) diff --git a/tests/unit/out/unsafe/fd_io.rs b/tests/unit/out/unsafe/fd_io.rs index ce16c3f1a..e4c3fb974 100644 --- a/tests/unit/out/unsafe/fd_io.rs +++ b/tests/unit/out/unsafe/fd_io.rs @@ -26,7 +26,7 @@ unsafe fn main_0() -> i32 { assert!( ((((libc::write( fd, - (c"hello world".as_ptr().cast_mut() as *const libc::c_char as *const ::libc::c_void), + (c"hello world".as_ptr().cast_mut() as *const ::libc::c_void), 11_usize )) == (11_isize)) as i32) != 0) @@ -36,16 +36,16 @@ unsafe fn main_0() -> i32 { assert!(((((fd) >= (0)) as i32) != 0)); let mut buf: [libc::c_char; 16] = [(0 as libc::c_char); 16]; { - let byte_0 = (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) as *mut u8; + let byte_0 = (buf.as_mut_ptr() as *mut ::libc::c_void) as *mut u8; for offset in 0..::std::mem::size_of::<[libc::c_char; 16]>() { *byte_0.offset(offset as isize) = 0 as u8; } - (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) + (buf.as_mut_ptr() as *mut ::libc::c_void) }; assert!( ((((libc::read( fd, - (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void), + (buf.as_mut_ptr() as *mut ::libc::c_void), ::std::mem::size_of::<[libc::c_char; 16]>() )) == (11_isize)) as i32) != 0) @@ -60,7 +60,7 @@ unsafe fn main_0() -> i32 { assert!( ((((libc::read( fd, - (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void), + (buf.as_mut_ptr() as *mut ::libc::c_void), ::std::mem::size_of::<[libc::c_char; 16]>() )) == (0_isize)) as i32) != 0) diff --git a/tests/unit/out/unsafe/fn_ptr.rs b/tests/unit/out/unsafe/fn_ptr.rs index 97acea7ee..8dae6e50e 100644 --- a/tests/unit/out/unsafe/fn_ptr.rs +++ b/tests/unit/out/unsafe/fn_ptr.rs @@ -13,7 +13,7 @@ pub unsafe fn foo_1( mut fn_: Option i32>, mut pi: *mut i32, ) -> i32 { - return (unsafe { (fn_).unwrap()((pi as *mut i32 as *mut ::libc::c_void)) }); + return (unsafe { (fn_).unwrap()((pi as *mut ::libc::c_void)) }); } pub fn main() { unsafe { diff --git a/tests/unit/out/unsafe/fn_ptr_cast.rs b/tests/unit/out/unsafe/fn_ptr_cast.rs index 7138271f4..62fdeff05 100644 --- a/tests/unit/out/unsafe/fn_ptr_cast.rs +++ b/tests/unit/out/unsafe/fn_ptr_cast.rs @@ -52,12 +52,8 @@ pub unsafe fn test_call_through_cast_5() { Option i32>, >(Some(add_offset_4)); let mut val: i32 = 100; - let mut result: i32 = (unsafe { - (gfn).unwrap()( - ((&mut val as *mut i32) as *mut i32 as *mut ::libc::c_void), - 42, - ) - }); + let mut result: i32 = + (unsafe { (gfn).unwrap()(((&mut val as *mut i32) as *mut ::libc::c_void), 42) }); assert!(((result) == (142))); } pub fn main() { diff --git a/tests/unit/out/unsafe/fn_ptr_stdlib_compare.rs b/tests/unit/out/unsafe/fn_ptr_stdlib_compare.rs index 3d9a40802..ca6a58fb3 100644 --- a/tests/unit/out/unsafe/fn_ptr_stdlib_compare.rs +++ b/tests/unit/out/unsafe/fn_ptr_stdlib_compare.rs @@ -61,14 +61,14 @@ unsafe fn main_0() -> i32 { assert!(!((stream).is_null())); let mut buf: [libc::c_char; 16] = [(0 as libc::c_char); 16]; { - let byte_0 = (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) as *mut u8; + let byte_0 = (buf.as_mut_ptr() as *mut ::libc::c_void) as *mut u8; for offset in 0..::std::mem::size_of::<[libc::c_char; 16]>() { *byte_0.offset(offset as isize) = (('X' as libc::c_char) as i32) as u8; } - (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) + (buf.as_mut_ptr() as *mut ::libc::c_void) }; let mut n: usize = libcc2rs::fread_unsafe( - (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void), + (buf.as_mut_ptr() as *mut ::libc::c_void), 1_usize, 10_usize, stream, @@ -93,15 +93,15 @@ unsafe fn main_0() -> i32 { assert!(!((stream).is_null())); let mut buf: [libc::c_char; 16] = [(0 as libc::c_char); 16]; { - let byte_0 = (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) as *mut u8; + let byte_0 = (buf.as_mut_ptr() as *mut ::libc::c_void) as *mut u8; for offset in 0..::std::mem::size_of::<[libc::c_char; 16]>() { *byte_0.offset(offset as isize) = (('X' as libc::c_char) as i32) as u8; } - (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) + (buf.as_mut_ptr() as *mut ::libc::c_void) }; let mut n: usize = (unsafe { (fn1).unwrap()( - (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void), + (buf.as_mut_ptr() as *mut ::libc::c_void), 1_usize, 10_usize, stream, @@ -154,14 +154,14 @@ unsafe fn main_0() -> i32 { assert!(!((stream).is_null())); let mut buf: [libc::c_char; 10] = [(0 as libc::c_char); 10]; { - let byte_0 = (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) as *mut u8; + let byte_0 = (buf.as_mut_ptr() as *mut ::libc::c_void) as *mut u8; for offset in 0..::std::mem::size_of::<[libc::c_char; 10]>() { *byte_0.offset(offset as isize) = (('Y' as libc::c_char) as i32) as u8; } - (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) + (buf.as_mut_ptr() as *mut ::libc::c_void) }; let mut n: usize = libcc2rs::fwrite_unsafe( - (buf.as_mut_ptr() as *const libc::c_char as *const ::libc::c_void), + (buf.as_mut_ptr() as *const ::libc::c_void), 1_usize, 10_usize, stream, @@ -176,15 +176,15 @@ unsafe fn main_0() -> i32 { assert!(!((stream).is_null())); let mut buf: [libc::c_char; 10] = [(0 as libc::c_char); 10]; { - let byte_0 = (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) as *mut u8; + let byte_0 = (buf.as_mut_ptr() as *mut ::libc::c_void) as *mut u8; for offset in 0..::std::mem::size_of::<[libc::c_char; 10]>() { *byte_0.offset(offset as isize) = (('Y' as libc::c_char) as i32) as u8; } - (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) + (buf.as_mut_ptr() as *mut ::libc::c_void) }; let mut n: usize = (unsafe { (gn1).unwrap()( - (buf.as_mut_ptr() as *const libc::c_char as *const ::libc::c_void), + (buf.as_mut_ptr() as *const ::libc::c_void), 1_usize, 10_usize, stream, diff --git a/tests/unit/out/unsafe/fn_ptr_vtable.rs b/tests/unit/out/unsafe/fn_ptr_vtable.rs index b83719c1d..c2ae95ad9 100644 --- a/tests/unit/out/unsafe/fn_ptr_vtable.rs +++ b/tests/unit/out/unsafe/fn_ptr_vtable.rs @@ -26,7 +26,7 @@ pub static mut storage_0: std::cell::LazyCell = std::cell::LazyCell::new(|| pub unsafe fn int_create_1(mut val: i32) -> *mut ::libc::c_void { (*std::cell::LazyCell::force_mut(&mut *&raw mut storage_0)) = val; return ((&raw mut (*std::cell::LazyCell::force_mut(&mut *&raw mut storage_0)) as *mut i32) - as *mut i32 as *mut ::libc::c_void); + as *mut ::libc::c_void); } pub unsafe fn int_get_2(mut p: *mut ::libc::c_void) -> i32 { return (*(p as *mut i32)); diff --git a/tests/unit/out/unsafe/fstat.rs b/tests/unit/out/unsafe/fstat.rs index d45adbc22..c66a04f0e 100644 --- a/tests/unit/out/unsafe/fstat.rs +++ b/tests/unit/out/unsafe/fstat.rs @@ -26,7 +26,7 @@ unsafe fn main_0() -> i32 { assert!( ((((libc::write( fd, - (c"hello".as_ptr().cast_mut() as *const libc::c_char as *const ::libc::c_void), + (c"hello".as_ptr().cast_mut() as *const ::libc::c_void), 5_usize )) == (5_isize)) as i32) != 0) diff --git a/tests/unit/out/unsafe/ifaddrs.rs b/tests/unit/out/unsafe/ifaddrs.rs index c5bd3e03f..2eea6c9d4 100644 --- a/tests/unit/out/unsafe/ifaddrs.rs +++ b/tests/unit/out/unsafe/ifaddrs.rs @@ -33,12 +33,12 @@ unsafe fn main_0() -> i32 { let mut lo_be: [u8; 4] = [127_u8, 0_u8, 0_u8, 1_u8]; if (((({ let sa = core::slice::from_raw_parts( - ((&mut (*sin).sin_addr as *mut ::libc::in_addr) as *const ::libc::in_addr - as *const ::libc::c_void) as *const u8, + ((&mut (*sin).sin_addr as *mut ::libc::in_addr) as *const ::libc::c_void) + as *const u8, 4_usize as usize, ); let sb = core::slice::from_raw_parts( - (lo_be.as_mut_ptr() as *const u8 as *const ::libc::c_void) as *const u8, + (lo_be.as_mut_ptr() as *const ::libc::c_void) as *const u8, 4_usize as usize, ); let mut diff = 0_i32; @@ -61,12 +61,12 @@ unsafe fn main_0() -> i32 { assert!( (((({ let sa = core::slice::from_raw_parts( - ((&mut (*mask).sin_addr as *mut ::libc::in_addr) as *const ::libc::in_addr - as *const ::libc::c_void) as *const u8, + ((&mut (*mask).sin_addr as *mut ::libc::in_addr) as *const ::libc::c_void) + as *const u8, 4_usize as usize, ); let sb = core::slice::from_raw_parts( - (mask_be.as_mut_ptr() as *const u8 as *const ::libc::c_void) as *const u8, + (mask_be.as_mut_ptr() as *const ::libc::c_void) as *const u8, 4_usize as usize, ); let mut diff = 0_i32; diff --git a/tests/unit/out/unsafe/inet_pton_ntop.rs b/tests/unit/out/unsafe/inet_pton_ntop.rs index a6429ab5a..4bfb80f17 100644 --- a/tests/unit/out/unsafe/inet_pton_ntop.rs +++ b/tests/unit/out/unsafe/inet_pton_ntop.rs @@ -22,7 +22,7 @@ unsafe fn main_0() -> i32 { inet_pton( libc::AF_INET, (c"1.2.3.4".as_ptr().cast_mut()).cast_const(), - (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void), + (buf.as_mut_ptr() as *mut ::libc::c_void), ) }) == (1)) as i32) != 0) @@ -44,7 +44,7 @@ unsafe fn main_0() -> i32 { inet_pton( libc::AF_INET, (c"999.1.1.1".as_ptr().cast_mut()).cast_const(), - (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void), + (buf.as_mut_ptr() as *mut ::libc::c_void), ) }) == (0)) as i32) != 0) @@ -57,7 +57,7 @@ unsafe fn main_0() -> i32 { inet_pton( libc::AF_INET, (c"not an ip".as_ptr().cast_mut()).cast_const(), - (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void), + (buf.as_mut_ptr() as *mut ::libc::c_void), ) }) == (0)) as i32) != 0) @@ -70,7 +70,7 @@ unsafe fn main_0() -> i32 { inet_pton( libc::AF_INET6, (c"::1".as_ptr().cast_mut()).cast_const(), - (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void), + (buf.as_mut_ptr() as *mut ::libc::c_void), ) }) == (1)) as i32) != 0) @@ -88,7 +88,7 @@ unsafe fn main_0() -> i32 { inet_pton( libc::AF_INET6, (c"2001:db8::5".as_ptr().cast_mut()).cast_const(), - (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void), + (buf.as_mut_ptr() as *mut ::libc::c_void), ) }) == (1)) as i32) != 0) @@ -115,7 +115,7 @@ unsafe fn main_0() -> i32 { } inet_ntop( libc::AF_INET, - (four.as_mut_ptr() as *const u8 as *const ::libc::c_void), + (four.as_mut_ptr() as *const ::libc::c_void), text.as_mut_ptr(), (::std::mem::size_of::<[libc::c_char; 64]>() as u32), ) @@ -142,7 +142,7 @@ unsafe fn main_0() -> i32 { } inet_ntop( libc::AF_INET6, - (sixteen.as_mut_ptr() as *const u8 as *const ::libc::c_void), + (sixteen.as_mut_ptr() as *const ::libc::c_void), text.as_mut_ptr(), (::std::mem::size_of::<[libc::c_char; 64]>() as u32), ) @@ -163,7 +163,7 @@ unsafe fn main_0() -> i32 { } inet_ntop( libc::AF_INET, - (four.as_mut_ptr() as *const u8 as *const ::libc::c_void), + (four.as_mut_ptr() as *const ::libc::c_void), text.as_mut_ptr(), 4_u32, ) diff --git a/tests/unit/out/unsafe/lseek_ftruncate.rs b/tests/unit/out/unsafe/lseek_ftruncate.rs index 8aa4f8d2c..68a850c46 100644 --- a/tests/unit/out/unsafe/lseek_ftruncate.rs +++ b/tests/unit/out/unsafe/lseek_ftruncate.rs @@ -26,7 +26,7 @@ unsafe fn main_0() -> i32 { assert!( ((((libc::write( fd, - (c"hello world".as_ptr().cast_mut() as *const libc::c_char as *const ::libc::c_void), + (c"hello world".as_ptr().cast_mut() as *const ::libc::c_void), 11_usize )) == (11_isize)) as i32) != 0) @@ -35,16 +35,16 @@ unsafe fn main_0() -> i32 { assert!(((((libc::lseek(fd, 6_i64, ::libc::SEEK_SET)) == (6_i64)) as i32) != 0)); let mut buf: [libc::c_char; 16] = [(0 as libc::c_char); 16]; { - let byte_0 = (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) as *mut u8; + let byte_0 = (buf.as_mut_ptr() as *mut ::libc::c_void) as *mut u8; for offset in 0..::std::mem::size_of::<[libc::c_char; 16]>() { *byte_0.offset(offset as isize) = 0 as u8; } - (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) + (buf.as_mut_ptr() as *mut ::libc::c_void) }; assert!( ((((libc::read( fd, - (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void), + (buf.as_mut_ptr() as *mut ::libc::c_void), ::std::mem::size_of::<[libc::c_char; 16]>() )) == (5_isize)) as i32) != 0) diff --git a/tests/unit/out/unsafe/malloc_realloc_free.rs b/tests/unit/out/unsafe/malloc_realloc_free.rs index f0e8c6da8..d00feb602 100644 --- a/tests/unit/out/unsafe/malloc_realloc_free.rs +++ b/tests/unit/out/unsafe/malloc_realloc_free.rs @@ -19,7 +19,7 @@ unsafe fn main_0() -> i32 { let mut p: *mut i32 = (libcc2rs::malloc_unsafe(::std::mem::size_of::()) as *mut i32); (*p) = 42; assert!(((((*p) == (42)) as i32) != 0)); - libcc2rs::free_unsafe((p as *mut i32 as *mut ::libc::c_void)); + libcc2rs::free_unsafe((p as *mut ::libc::c_void)); let mut arr: *mut i32 = (libcc2rs::malloc_unsafe( (4_usize).wrapping_mul((::std::mem::size_of::() as usize)), ) as *mut i32); @@ -30,14 +30,14 @@ unsafe fn main_0() -> i32 { } assert!(((((*arr.offset((0) as isize)) == (0)) as i32) != 0)); assert!(((((*arr.offset((3) as isize)) == (30)) as i32) != 0)); - libcc2rs::free_unsafe((arr as *mut i32 as *mut ::libc::c_void)); + libcc2rs::free_unsafe((arr as *mut ::libc::c_void)); let mut grow: *mut i32 = (libcc2rs::malloc_unsafe( (2_usize).wrapping_mul((::std::mem::size_of::() as usize)), ) as *mut i32); (*grow.offset((0) as isize)) = 1; (*grow.offset((1) as isize)) = 2; grow = (libcc2rs::realloc_unsafe( - (grow as *mut i32 as *mut ::libc::c_void), + (grow as *mut ::libc::c_void), (4_usize).wrapping_mul((::std::mem::size_of::() as usize)), ) as *mut i32); (*grow.offset((2) as isize)) = 3; @@ -46,7 +46,7 @@ unsafe fn main_0() -> i32 { assert!(((((*grow.offset((1) as isize)) == (2)) as i32) != 0)); assert!(((((*grow.offset((2) as isize)) == (3)) as i32) != 0)); assert!(((((*grow.offset((3) as isize)) == (4)) as i32) != 0)); - libcc2rs::free_unsafe((grow as *mut i32 as *mut ::libc::c_void)); + libcc2rs::free_unsafe((grow as *mut ::libc::c_void)); let mut zeros: *mut i32 = (libcc2rs::calloc_unsafe(4_usize, ::std::mem::size_of::()) as *mut i32); let mut i: i32 = 0; @@ -54,7 +54,7 @@ unsafe fn main_0() -> i32 { assert!(((((*zeros.offset((i) as isize)) == (0)) as i32) != 0)); i.postfix_inc(); } - libcc2rs::free_unsafe((zeros as *mut i32 as *mut ::libc::c_void)); + libcc2rs::free_unsafe((zeros as *mut ::libc::c_void)); } let mut pmalloc: Option *mut ::libc::c_void> = Some(libcc2rs::malloc_unsafe); @@ -70,7 +70,7 @@ unsafe fn main_0() -> i32 { ((unsafe { (pmalloc).unwrap()(::std::mem::size_of::()) }) as *mut i32); (*p) = 42; assert!(((((*p) == (42)) as i32) != 0)); - (unsafe { (pfree).unwrap()((p as *mut i32 as *mut ::libc::c_void)) }); + (unsafe { (pfree).unwrap()((p as *mut ::libc::c_void)) }); let mut arr: *mut i32 = ((unsafe { (pmalloc).unwrap()((4_usize).wrapping_mul((::std::mem::size_of::() as usize))) }) as *mut i32); @@ -81,7 +81,7 @@ unsafe fn main_0() -> i32 { } assert!(((((*arr.offset((0) as isize)) == (0)) as i32) != 0)); assert!(((((*arr.offset((3) as isize)) == (30)) as i32) != 0)); - (unsafe { (pfree).unwrap()((arr as *mut i32 as *mut ::libc::c_void)) }); + (unsafe { (pfree).unwrap()((arr as *mut ::libc::c_void)) }); let mut grow: *mut i32 = ((unsafe { (pmalloc).unwrap()((2_usize).wrapping_mul((::std::mem::size_of::() as usize))) }) as *mut i32); @@ -89,7 +89,7 @@ unsafe fn main_0() -> i32 { (*grow.offset((1) as isize)) = 2; grow = ((unsafe { (prealloc).unwrap()( - (grow as *mut i32 as *mut ::libc::c_void), + (grow as *mut ::libc::c_void), (4_usize).wrapping_mul((::std::mem::size_of::() as usize)), ) }) as *mut i32); @@ -99,7 +99,7 @@ unsafe fn main_0() -> i32 { assert!(((((*grow.offset((1) as isize)) == (2)) as i32) != 0)); assert!(((((*grow.offset((2) as isize)) == (3)) as i32) != 0)); assert!(((((*grow.offset((3) as isize)) == (4)) as i32) != 0)); - (unsafe { (pfree).unwrap()((grow as *mut i32 as *mut ::libc::c_void)) }); + (unsafe { (pfree).unwrap()((grow as *mut ::libc::c_void)) }); let mut zeros: *mut i32 = ((unsafe { (pcalloc).unwrap()(4_usize, ::std::mem::size_of::()) }) as *mut i32); let mut i: i32 = 0; @@ -107,7 +107,7 @@ unsafe fn main_0() -> i32 { assert!(((((*zeros.offset((i) as isize)) == (0)) as i32) != 0)); i.postfix_inc(); } - (unsafe { (pfree).unwrap()((zeros as *mut i32 as *mut ::libc::c_void)) }); + (unsafe { (pfree).unwrap()((zeros as *mut ::libc::c_void)) }); } return 0; } diff --git a/tests/unit/out/unsafe/memcpy_overlap.rs b/tests/unit/out/unsafe/memcpy_overlap.rs index 369351d2a..15d2e43ee 100644 --- a/tests/unit/out/unsafe/memcpy_overlap.rs +++ b/tests/unit/out/unsafe/memcpy_overlap.rs @@ -24,12 +24,12 @@ unsafe fn main_0() -> i32 { { if 4_usize != 0 { ::std::ptr::copy_nonoverlapping( - (buf.as_mut_ptr() as *const libc::c_char as *const ::libc::c_void), - (buf.as_mut_ptr().offset((2) as isize) as *mut libc::c_char as *mut ::libc::c_void), + (buf.as_mut_ptr() as *const ::libc::c_void), + (buf.as_mut_ptr().offset((2) as isize) as *mut ::libc::c_void), 4_usize as usize, ) } - (buf.as_mut_ptr().offset((2) as isize) as *mut libc::c_char as *mut ::libc::c_void) + (buf.as_mut_ptr().offset((2) as isize) as *mut ::libc::c_void) }; assert!(((buf[(0) as usize] as i32) == (1))); assert!(((buf[(1) as usize] as i32) == (2))); diff --git a/tests/unit/out/unsafe/memcpy_struct_bytes.rs b/tests/unit/out/unsafe/memcpy_struct_bytes.rs index da7900c3f..c5ae26c19 100644 --- a/tests/unit/out/unsafe/memcpy_struct_bytes.rs +++ b/tests/unit/out/unsafe/memcpy_struct_bytes.rs @@ -24,23 +24,23 @@ unsafe fn main_0() -> i32 { { if ::std::mem::size_of::<[u8; 8]>() != 0 { ::std::ptr::copy_nonoverlapping( - ((&mut src as *mut point) as *const point as *const ::libc::c_void), - (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void), + ((&mut src as *mut point) as *const ::libc::c_void), + (buf.as_mut_ptr() as *mut ::libc::c_void), ::std::mem::size_of::<[u8; 8]>() as usize, ) } - (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void) + (buf.as_mut_ptr() as *mut ::libc::c_void) }; let mut dst: point = ::default(); { if ::std::mem::size_of::() != 0 { ::std::ptr::copy_nonoverlapping( - (buf.as_mut_ptr() as *const u8 as *const ::libc::c_void), - ((&mut dst as *mut point) as *mut point as *mut ::libc::c_void), + (buf.as_mut_ptr() as *const ::libc::c_void), + ((&mut dst as *mut point) as *mut ::libc::c_void), ::std::mem::size_of::() as usize, ) } - ((&mut dst as *mut point) as *mut point as *mut ::libc::c_void) + ((&mut dst as *mut point) as *mut ::libc::c_void) }; assert!(((((dst.x) == (3)) as i32) != 0)); assert!(((((dst.y) == (7)) as i32) != 0)); diff --git a/tests/unit/out/unsafe/memcpy_struct_struct.rs b/tests/unit/out/unsafe/memcpy_struct_struct.rs index d0238477e..80d31fde3 100644 --- a/tests/unit/out/unsafe/memcpy_struct_struct.rs +++ b/tests/unit/out/unsafe/memcpy_struct_struct.rs @@ -58,13 +58,13 @@ unsafe fn main_0() -> i32 { if ((table_size as u64).wrapping_mul((::std::mem::size_of::() as u64)) as usize) != 0 { ::std::ptr::copy_nonoverlapping( - ((&mut table[(0) as usize] as *mut Entry) as *const Entry as *const ::libc::c_void), - ((&mut table[(table_size)] as *mut Entry) as *mut Entry as *mut ::libc::c_void), + ((&mut table[(0) as usize] as *mut Entry) as *const ::libc::c_void), + ((&mut table[(table_size)] as *mut Entry) as *mut ::libc::c_void), ((table_size as u64).wrapping_mul((::std::mem::size_of::() as u64)) as usize) as usize, ) } - ((&mut table[(table_size)] as *mut Entry) as *mut Entry as *mut ::libc::c_void) + ((&mut table[(table_size)] as *mut Entry) as *mut ::libc::c_void) }; assert!( ((table[(4) as usize].bits as i32) == (1)) diff --git a/tests/unit/out/unsafe/memset.rs b/tests/unit/out/unsafe/memset.rs index 22eb64526..d662dad32 100644 --- a/tests/unit/out/unsafe/memset.rs +++ b/tests/unit/out/unsafe/memset.rs @@ -17,11 +17,11 @@ unsafe fn main_0() -> i32 { let mut arr: *mut i32 = Box::leak((0..(N as usize)).map(|_| 0_i32).collect::>()).as_mut_ptr(); { - let byte_0 = (arr as *mut i32 as *mut ::libc::c_void) as *mut u8; + let byte_0 = (arr as *mut ::libc::c_void) as *mut u8; for offset in 0..(::std::mem::size_of::() as usize).wrapping_mul((N as usize)) { *byte_0.offset(offset as isize) = 1 as u8; } - (arr as *mut i32 as *mut ::libc::c_void) + (arr as *mut ::libc::c_void) }; let mut sum: i32 = 0; let mut i: i32 = 0; diff --git a/tests/unit/out/unsafe/netdb.rs b/tests/unit/out/unsafe/netdb.rs index cdabe0275..98dafb3b1 100644 --- a/tests/unit/out/unsafe/netdb.rs +++ b/tests/unit/out/unsafe/netdb.rs @@ -40,12 +40,11 @@ pub unsafe fn test_ipv4_literal_0() { assert!( (((({ let sa = core::slice::from_raw_parts( - ((&mut (*sin).sin_port as *mut u16) as *const u16 as *const ::libc::c_void) - as *const u8, + ((&mut (*sin).sin_port as *mut u16) as *const ::libc::c_void) as *const u8, 2_usize as usize, ); let sb = core::slice::from_raw_parts( - (port_be.as_mut_ptr() as *const u8 as *const ::libc::c_void) as *const u8, + (port_be.as_mut_ptr() as *const ::libc::c_void) as *const u8, 2_usize as usize, ); let mut diff = 0_i32; @@ -63,12 +62,12 @@ pub unsafe fn test_ipv4_literal_0() { assert!( (((({ let sa = core::slice::from_raw_parts( - ((&mut (*sin).sin_addr as *mut ::libc::in_addr) as *const ::libc::in_addr - as *const ::libc::c_void) as *const u8, + ((&mut (*sin).sin_addr as *mut ::libc::in_addr) as *const ::libc::c_void) + as *const u8, 4_usize as usize, ); let sb = core::slice::from_raw_parts( - (addr_be.as_mut_ptr() as *const u8 as *const ::libc::c_void) as *const u8, + (addr_be.as_mut_ptr() as *const ::libc::c_void) as *const u8, 4_usize as usize, ); let mut diff = 0_i32; @@ -118,12 +117,11 @@ pub unsafe fn test_ipv6_literal_1() { assert!( (((({ let sa = core::slice::from_raw_parts( - ((&mut (*sin6).sin6_port as *mut u16) as *const u16 as *const ::libc::c_void) - as *const u8, + ((&mut (*sin6).sin6_port as *mut u16) as *const ::libc::c_void) as *const u8, 2_usize as usize, ); let sb = core::slice::from_raw_parts( - (port_be.as_mut_ptr() as *const u8 as *const ::libc::c_void) as *const u8, + (port_be.as_mut_ptr() as *const ::libc::c_void) as *const u8, 2_usize as usize, ); let mut diff = 0_i32; @@ -144,12 +142,12 @@ pub unsafe fn test_ipv6_literal_1() { assert!( (((({ let sa = core::slice::from_raw_parts( - ((&mut (*sin6).sin6_addr as *mut ::libc::in6_addr) as *const ::libc::in6_addr - as *const ::libc::c_void) as *const u8, + ((&mut (*sin6).sin6_addr as *mut ::libc::in6_addr) as *const ::libc::c_void) + as *const u8, 16_usize as usize, ); let sb = core::slice::from_raw_parts( - (addr_be.as_mut_ptr() as *const u8 as *const ::libc::c_void) as *const u8, + (addr_be.as_mut_ptr() as *const ::libc::c_void) as *const u8, 16_usize as usize, ); let mut diff = 0_i32; @@ -183,12 +181,12 @@ pub unsafe fn test_null_hints_2() { assert!( (((({ let sa = core::slice::from_raw_parts( - ((&mut (*sin).sin_addr as *mut ::libc::in_addr) as *const ::libc::in_addr - as *const ::libc::c_void) as *const u8, + ((&mut (*sin).sin_addr as *mut ::libc::in_addr) as *const ::libc::c_void) + as *const u8, 4_usize as usize, ); let sb = core::slice::from_raw_parts( - (addr_be.as_mut_ptr() as *const u8 as *const ::libc::c_void) as *const u8, + (addr_be.as_mut_ptr() as *const ::libc::c_void) as *const u8, 4_usize as usize, ); let mut diff = 0_i32; diff --git a/tests/unit/out/unsafe/new_alloc_array.rs b/tests/unit/out/unsafe/new_alloc_array.rs index 80788cd88..ba153f66b 100644 --- a/tests/unit/out/unsafe/new_alloc_array.rs +++ b/tests/unit/out/unsafe/new_alloc_array.rs @@ -16,11 +16,11 @@ unsafe fn main_0() -> i32 { let mut array: *mut i32 = Box::leak((0..100_usize).map(|_| 0_i32).collect::>()).as_mut_ptr(); { - let byte_0 = (array as *mut i32 as *mut ::libc::c_void) as *mut u8; + let byte_0 = (array as *mut ::libc::c_void) as *mut u8; for offset in 0..(::std::mem::size_of::() as usize).wrapping_mul(100_usize) { *byte_0.offset(offset as isize) = 0 as u8; } - (array as *mut i32 as *mut ::libc::c_void) + (array as *mut ::libc::c_void) }; (*array.offset((99) as isize)) = -1_i32; let mut p1: *mut i32 = array; diff --git a/tests/unit/out/unsafe/operator_new_delete.rs b/tests/unit/out/unsafe/operator_new_delete.rs index 05006ca0f..bb440c43d 100644 --- a/tests/unit/out/unsafe/operator_new_delete.rs +++ b/tests/unit/out/unsafe/operator_new_delete.rs @@ -16,14 +16,14 @@ unsafe fn main_0() -> i32 { let mut a: *mut i32 = (libcc2rs::malloc_unsafe(::std::mem::size_of::()) as *mut i32); (*a) = 42; assert!(((*a) == (42))); - libcc2rs::free_unsafe((a as *mut i32 as *mut ::libc::c_void)); + libcc2rs::free_unsafe((a as *mut ::libc::c_void)); let mut arr: *mut i32 = (libcc2rs::malloc_unsafe((::std::mem::size_of::() as usize).wrapping_mul(2_usize)) as *mut i32); (*arr.offset((0) as isize)) = 0; (*arr.offset((1) as isize)) = 1; assert!((((*arr.offset((0) as isize)) + (*arr.offset((1) as isize))) == (1))); - libcc2rs::free_unsafe((arr as *mut i32 as *mut ::libc::c_void)); + libcc2rs::free_unsafe((arr as *mut ::libc::c_void)); return 0; } pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/unit/out/unsafe/pipe_io.rs b/tests/unit/out/unsafe/pipe_io.rs index 0f3f06e98..1e378e91c 100644 --- a/tests/unit/out/unsafe/pipe_io.rs +++ b/tests/unit/out/unsafe/pipe_io.rs @@ -18,23 +18,23 @@ unsafe fn main_0() -> i32 { assert!( ((((libc::write( fds[(1) as usize], - (c"ab".as_ptr().cast_mut() as *const libc::c_char as *const ::libc::c_void), + (c"ab".as_ptr().cast_mut() as *const ::libc::c_void), 2_usize )) == (2_isize)) as i32) != 0) ); let mut buf: [libc::c_char; 4] = [(0 as libc::c_char); 4]; { - let byte_0 = (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) as *mut u8; + let byte_0 = (buf.as_mut_ptr() as *mut ::libc::c_void) as *mut u8; for offset in 0..::std::mem::size_of::<[libc::c_char; 4]>() { *byte_0.offset(offset as isize) = 0 as u8; } - (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) + (buf.as_mut_ptr() as *mut ::libc::c_void) }; assert!( ((((libc::read( fds[(0) as usize], - (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void), + (buf.as_mut_ptr() as *mut ::libc::c_void), ::std::mem::size_of::<[libc::c_char; 4]>() )) == (2_isize)) as i32) != 0) @@ -50,7 +50,7 @@ unsafe fn main_0() -> i32 { assert!( ((((libc::read( fds[(0) as usize], - (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void), + (buf.as_mut_ptr() as *mut ::libc::c_void), ::std::mem::size_of::<[libc::c_char; 4]>() )) == (0_isize)) as i32) != 0) diff --git a/tests/unit/out/unsafe/poll.rs b/tests/unit/out/unsafe/poll.rs index 86c205704..b7c0cbb54 100644 --- a/tests/unit/out/unsafe/poll.rs +++ b/tests/unit/out/unsafe/poll.rs @@ -18,7 +18,7 @@ unsafe fn main_0() -> i32 { assert!( ((((libc::write( fds[(1) as usize], - (c"x".as_ptr().cast_mut() as *const libc::c_char as *const ::libc::c_void), + (c"x".as_ptr().cast_mut() as *const ::libc::c_void), 1_usize )) == (1_isize)) as i32) != 0) @@ -41,7 +41,7 @@ unsafe fn main_0() -> i32 { assert!( ((((libc::read( fds[(0) as usize], - ((&mut ch as *mut libc::c_char) as *mut libc::c_char as *mut ::libc::c_void), + ((&mut ch as *mut libc::c_char) as *mut ::libc::c_void), 1_usize )) == (1_isize)) as i32) != 0) diff --git a/tests/unit/out/unsafe/ptr_cast_init.rs b/tests/unit/out/unsafe/ptr_cast_init.rs index c4bee41a8..d2df72491 100644 --- a/tests/unit/out/unsafe/ptr_cast_init.rs +++ b/tests/unit/out/unsafe/ptr_cast_init.rs @@ -34,8 +34,7 @@ unsafe fn main_0() -> i32 { let mut v: *mut view = (hp as *mut view); assert!((((((*v).tag) == (7)) as i32) != 0)); let mut data: [libc::c_char; 3] = std::mem::transmute(*b"hi\0"); - let mut vp: *mut ::libc::c_void = - (data.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void); + let mut vp: *mut ::libc::c_void = (data.as_mut_ptr() as *mut ::libc::c_void); let mut n: i32 = 2; let mut sel: *mut libc::c_char = (if ((((n) < (100)) as i32) != 0) { vp diff --git a/tests/unit/out/unsafe/qsort_bsearch.rs b/tests/unit/out/unsafe/qsort_bsearch.rs index f66904286..6a0a3a84a 100644 --- a/tests/unit/out/unsafe/qsort_bsearch.rs +++ b/tests/unit/out/unsafe/qsort_bsearch.rs @@ -20,7 +20,7 @@ pub fn main() { unsafe fn main_0() -> i32 { let mut arr: [i32; 8] = [5, 2, 9, 1, 7, 3, 8, 4]; libc::qsort( - (arr.as_mut_ptr() as *mut i32 as *mut ::libc::c_void), + (arr.as_mut_ptr() as *mut ::libc::c_void), 8_usize, ::std::mem::size_of::(), Some(std::mem::transmute::< @@ -38,8 +38,8 @@ unsafe fn main_0() -> i32 { } let mut key: i32 = 7; let mut hit: *mut i32 = (libc::bsearch( - ((&mut key as *mut i32) as *const i32 as *const ::libc::c_void), - (arr.as_mut_ptr() as *const i32 as *const ::libc::c_void), + ((&mut key as *mut i32) as *const ::libc::c_void), + (arr.as_mut_ptr() as *const ::libc::c_void), 8_usize, ::std::mem::size_of::(), Some(std::mem::transmute::< @@ -54,8 +54,8 @@ unsafe fn main_0() -> i32 { assert!(((((*hit) == (7)) as i32) != 0)); let mut miss_key: i32 = 42; let mut miss: *mut i32 = (libc::bsearch( - ((&mut miss_key as *mut i32) as *const i32 as *const ::libc::c_void), - (arr.as_mut_ptr() as *const i32 as *const ::libc::c_void), + ((&mut miss_key as *mut i32) as *const ::libc::c_void), + (arr.as_mut_ptr() as *const ::libc::c_void), 8_usize, ::std::mem::size_of::(), Some(std::mem::transmute::< diff --git a/tests/unit/out/unsafe/reinterpret_cast_ptr_cmp.rs b/tests/unit/out/unsafe/reinterpret_cast_ptr_cmp.rs index d53847662..71973a7fe 100644 --- a/tests/unit/out/unsafe/reinterpret_cast_ptr_cmp.rs +++ b/tests/unit/out/unsafe/reinterpret_cast_ptr_cmp.rs @@ -16,8 +16,8 @@ unsafe fn main_0() -> i32 { let mut i1: i32 = 42; let mut ptr1: *mut i32 = (&mut i1 as *mut i32); let mut ptr2: *mut libc::c_char = ((&mut i1 as *mut i32) as *mut libc::c_char); - let mut vptr1: *mut ::libc::c_void = (ptr1 as *mut i32 as *mut ::libc::c_void); - let mut vptr2: *mut ::libc::c_void = (ptr2 as *mut libc::c_char as *mut ::libc::c_void); + let mut vptr1: *mut ::libc::c_void = (ptr1 as *mut ::libc::c_void); + let mut vptr2: *mut ::libc::c_void = (ptr2 as *mut ::libc::c_void); assert!(((vptr1) == (vptr2))); return 0; } diff --git a/tests/unit/out/unsafe/select.rs b/tests/unit/out/unsafe/select.rs index 049eb563f..549f9b9a0 100644 --- a/tests/unit/out/unsafe/select.rs +++ b/tests/unit/out/unsafe/select.rs @@ -20,12 +20,11 @@ unsafe fn main_0() -> i32 { libc::FD_SET(fds[(0) as usize], (&mut rset as *mut ::libc::fd_set)); let mut tv: ::libc::timeval = unsafe { std::mem::zeroed() }; { - let byte_0 = ((&mut tv as *mut ::libc::timeval) as *mut ::libc::timeval - as *mut ::libc::c_void) as *mut u8; + let byte_0 = ((&mut tv as *mut ::libc::timeval) as *mut ::libc::c_void) as *mut u8; for offset in 0..::std::mem::size_of::<::libc::timeval>() { *byte_0.offset(offset as isize) = 0 as u8; } - ((&mut tv as *mut ::libc::timeval) as *mut ::libc::timeval as *mut ::libc::c_void) + ((&mut tv as *mut ::libc::timeval) as *mut ::libc::c_void) }; tv.tv_sec = 0_i64; assert!( @@ -49,7 +48,7 @@ unsafe fn main_0() -> i32 { assert!( ((((libc::write( fds[(1) as usize], - (c"x".as_ptr().cast_mut() as *const libc::c_char as *const ::libc::c_void), + (c"x".as_ptr().cast_mut() as *const ::libc::c_void), 1_usize )) == (1_isize)) as i32) != 0) diff --git a/tests/unit/out/unsafe/sockopt.rs b/tests/unit/out/unsafe/sockopt.rs index 884f9d06f..2ed618ad8 100644 --- a/tests/unit/out/unsafe/sockopt.rs +++ b/tests/unit/out/unsafe/sockopt.rs @@ -21,7 +21,7 @@ unsafe fn main_0() -> i32 { s, libc::SOL_SOCKET, libc::SO_KEEPALIVE, - ((&mut on as *mut i32) as *const i32 as *const ::libc::c_void), + ((&mut on as *mut i32) as *const ::libc::c_void), (::std::mem::size_of::() as u32) )) == (0)) as i32) != 0) @@ -31,7 +31,7 @@ unsafe fn main_0() -> i32 { s, libc::IPPROTO_TCP, libc::TCP_NODELAY, - ((&mut on as *mut i32) as *const i32 as *const ::libc::c_void), + ((&mut on as *mut i32) as *const ::libc::c_void), (::std::mem::size_of::() as u32) )) == (0)) as i32) != 0) @@ -43,7 +43,7 @@ unsafe fn main_0() -> i32 { s, libc::SOL_SOCKET, libc::SO_ERROR, - ((&mut err as *mut i32) as *mut i32 as *mut ::libc::c_void), + ((&mut err as *mut i32) as *mut ::libc::c_void), (&mut len as *mut u32) )) == (0)) as i32) != 0) diff --git a/tests/unit/out/unsafe/stdio_nofd.rs b/tests/unit/out/unsafe/stdio_nofd.rs index 59f6a758b..8559abe37 100644 --- a/tests/unit/out/unsafe/stdio_nofd.rs +++ b/tests/unit/out/unsafe/stdio_nofd.rs @@ -38,7 +38,7 @@ pub unsafe fn test_fputc_fputs_0() { ]; assert!( ((((libcc2rs::fread_unsafe( - (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void), + (buf.as_mut_ptr() as *mut ::libc::c_void), 1_usize, 16_usize, fp @@ -48,12 +48,11 @@ pub unsafe fn test_fputc_fputs_0() { assert!( (((({ let sa = core::slice::from_raw_parts( - (buf.as_mut_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8, + (buf.as_mut_ptr() as *const ::libc::c_void) as *const u8, 5_usize as usize, ); let sb = core::slice::from_raw_parts( - (c"ABCD\n".as_ptr().cast_mut() as *const libc::c_char as *const ::libc::c_void) - as *const u8, + (c"ABCD\n".as_ptr().cast_mut() as *const ::libc::c_void) as *const u8, 5_usize as usize, ); let mut diff = 0_i32; @@ -93,12 +92,11 @@ pub unsafe fn test_fgets_getc_2() { assert!( (((({ let sa = core::slice::from_raw_parts( - (buf.as_mut_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8, + (buf.as_mut_ptr() as *const ::libc::c_void) as *const u8, 7_usize as usize, ); let sb = core::slice::from_raw_parts( - (c"line1\n".as_ptr().cast_mut() as *const libc::c_char as *const ::libc::c_void) - as *const u8, + (c"line1\n".as_ptr().cast_mut() as *const ::libc::c_void) as *const u8, 7_usize as usize, ); let mut diff = 0_i32; @@ -117,12 +115,11 @@ pub unsafe fn test_fgets_getc_2() { assert!( (((({ let sa = core::slice::from_raw_parts( - (buf.as_mut_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8, + (buf.as_mut_ptr() as *const ::libc::c_void) as *const u8, 4_usize as usize, ); let sb = core::slice::from_raw_parts( - (c"ine".as_ptr().cast_mut() as *const libc::c_char as *const ::libc::c_void) - as *const u8, + (c"ine".as_ptr().cast_mut() as *const ::libc::c_void) as *const u8, 4_usize as usize, ); let mut diff = 0_i32; @@ -140,12 +137,11 @@ pub unsafe fn test_fgets_getc_2() { assert!( (((({ let sa = core::slice::from_raw_parts( - (buf.as_mut_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8, + (buf.as_mut_ptr() as *const ::libc::c_void) as *const u8, 3_usize as usize, ); let sb = core::slice::from_raw_parts( - (c"2\n".as_ptr().cast_mut() as *const libc::c_char as *const ::libc::c_void) - as *const u8, + (c"2\n".as_ptr().cast_mut() as *const ::libc::c_void) as *const u8, 3_usize as usize, ); let mut diff = 0_i32; @@ -187,7 +183,7 @@ pub unsafe fn test_freopen_3() { ]; assert!( ((((libcc2rs::fread_unsafe( - (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void), + (buf.as_mut_ptr() as *mut ::libc::c_void), 1_usize, 8_usize, fp2 @@ -197,12 +193,11 @@ pub unsafe fn test_freopen_3() { assert!( (((({ let sa = core::slice::from_raw_parts( - (buf.as_mut_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8, + (buf.as_mut_ptr() as *const ::libc::c_void) as *const u8, 5_usize as usize, ); let sb = core::slice::from_raw_parts( - (c"hello".as_ptr().cast_mut() as *const libc::c_char as *const ::libc::c_void) - as *const u8, + (c"hello".as_ptr().cast_mut() as *const ::libc::c_void) as *const u8, 5_usize as usize, ); let mut diff = 0_i32; @@ -244,7 +239,7 @@ pub unsafe fn test_fseeko_4() { ]; assert!( ((((libcc2rs::fread_unsafe( - (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void), + (buf.as_mut_ptr() as *mut ::libc::c_void), 1_usize, 5_usize, fp @@ -254,12 +249,11 @@ pub unsafe fn test_fseeko_4() { assert!( (((({ let sa = core::slice::from_raw_parts( - (buf.as_mut_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8, + (buf.as_mut_ptr() as *const ::libc::c_void) as *const u8, 5_usize as usize, ); let sb = core::slice::from_raw_parts( - (c"world".as_ptr().cast_mut() as *const libc::c_char as *const ::libc::c_void) - as *const u8, + (c"world".as_ptr().cast_mut() as *const ::libc::c_void) as *const u8, 5_usize as usize, ); let mut diff = 0_i32; diff --git a/tests/unit/out/unsafe/stdlib_h.rs b/tests/unit/out/unsafe/stdlib_h.rs index 7beb16be4..5087bf4a3 100644 --- a/tests/unit/out/unsafe/stdlib_h.rs +++ b/tests/unit/out/unsafe/stdlib_h.rs @@ -60,7 +60,7 @@ pub unsafe fn test_realpath_1() { as i32) != 0) ); - libcc2rs::free_unsafe((p as *mut libc::c_char as *mut ::libc::c_void)); + libcc2rs::free_unsafe((p as *mut ::libc::c_void)); (*libcc2rs::cpp2rust_errno_unsafe()) = 0; assert!( ((((libc::realpath( diff --git a/tests/unit/out/unsafe/strdup.rs b/tests/unit/out/unsafe/strdup.rs index 41b0bade3..216ebc40f 100644 --- a/tests/unit/out/unsafe/strdup.rs +++ b/tests/unit/out/unsafe/strdup.rs @@ -28,7 +28,7 @@ unsafe fn main_0() -> i32 { )) == (0)) as i32) != 0) ); - libcc2rs::free_unsafe((d as *mut libc::c_char as *mut ::libc::c_void)); + libcc2rs::free_unsafe((d as *mut ::libc::c_void)); let mut p: *const libc::c_char = (c"world".as_ptr().cast_mut()).cast_const(); let mut buf: [libc::c_char; 4] = [ (('a' as i32) as libc::c_char), @@ -39,18 +39,18 @@ unsafe fn main_0() -> i32 { let mut d2: *mut libc::c_char = libcc2rs::strdup_unsafe(p); assert!((((!((d2).is_null())) as i32) != 0)); assert!(((((libc::strcmp((d2).cast_const(), p)) == (0)) as i32) != 0)); - libcc2rs::free_unsafe((d2 as *mut libc::c_char as *mut ::libc::c_void)); + libcc2rs::free_unsafe((d2 as *mut ::libc::c_void)); let mut d3: *mut libc::c_char = libcc2rs::strdup_unsafe((buf.as_mut_ptr()).cast_const()); assert!((((!((d3).is_null())) as i32) != 0)); assert!( ((((libc::strcmp((d3).cast_const(), (buf.as_mut_ptr()).cast_const())) == (0)) as i32) != 0) ); - libcc2rs::free_unsafe((d3 as *mut libc::c_char as *mut ::libc::c_void)); + libcc2rs::free_unsafe((d3 as *mut ::libc::c_void)); let mut d4: *mut libc::c_char = std::ptr::null_mut(); d4 = libcc2rs::strdup_unsafe(p); assert!((((!((d4).is_null())) as i32) != 0)); assert!(((((libc::strcmp((d4).cast_const(), p)) == (0)) as i32) != 0)); - libcc2rs::free_unsafe((d4 as *mut libc::c_char as *mut ::libc::c_void)); + libcc2rs::free_unsafe((d4 as *mut ::libc::c_void)); let mut rec: record = record { name: std::ptr::null_mut(), }; @@ -58,7 +58,7 @@ unsafe fn main_0() -> i32 { (*r).name = libcc2rs::strdup_unsafe(p); assert!((((!(((*r).name).is_null())) as i32) != 0)); assert!(((((libc::strcmp(((*r).name).cast_const(), p)) == (0)) as i32) != 0)); - libcc2rs::free_unsafe(((*r).name as *mut libc::c_char as *mut ::libc::c_void)); + libcc2rs::free_unsafe(((*r).name as *mut ::libc::c_void)); return 0; } pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/unit/out/unsafe/string_h.rs b/tests/unit/out/unsafe/string_h.rs index 8360ab292..33dd57f04 100644 --- a/tests/unit/out/unsafe/string_h.rs +++ b/tests/unit/out/unsafe/string_h.rs @@ -19,16 +19,14 @@ pub unsafe fn test_memcpy_0() { let mut r: *mut ::libc::c_void = { if 6_usize != 0 { ::std::ptr::copy_nonoverlapping( - (src.as_ptr() as *const libc::c_char as *const ::libc::c_void), - (dst.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void), + (src.as_ptr() as *const ::libc::c_void), + (dst.as_mut_ptr() as *mut ::libc::c_void), 6_usize as usize, ) } - (dst.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) + (dst.as_mut_ptr() as *mut ::libc::c_void) }; - assert!( - ((((r) == (dst.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void)) as i32) != 0) - ); + assert!(((((r) == (dst.as_mut_ptr() as *mut ::libc::c_void)) as i32) != 0)); assert!( ((((((((((dst[(0) as usize] as i32) == ('h' as i32)) as i32) != 0) && ((((dst[(1) as usize] as i32) == ('e' as i32)) as i32) != 0)) as i32) @@ -47,15 +45,13 @@ pub unsafe fn test_memcpy_0() { pub unsafe fn test_memset_1() { let mut buf: [libc::c_char; 4] = [(0 as libc::c_char); 4]; let mut r: *mut ::libc::c_void = { - let byte_0 = (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) as *mut u8; + let byte_0 = (buf.as_mut_ptr() as *mut ::libc::c_void) as *mut u8; for offset in 0..4_usize { *byte_0.offset(offset as isize) = ('x' as i32) as u8; } - (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) + (buf.as_mut_ptr() as *mut ::libc::c_void) }; - assert!( - ((((r) == (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void)) as i32) != 0) - ); + assert!(((((r) == (buf.as_mut_ptr() as *mut ::libc::c_void)) as i32) != 0)); assert!( (((((((((((((buf[(0) as usize] as i32) == ('x' as i32)) as i32) != 0) && ((((buf[(1) as usize] as i32) == ('x' as i32)) as i32) != 0)) @@ -89,11 +85,11 @@ pub unsafe fn test_memcmp_2() { assert!( (((({ let sa = core::slice::from_raw_parts( - (a.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8, + (a.as_ptr() as *const ::libc::c_void) as *const u8, 4_usize as usize, ); let sb = core::slice::from_raw_parts( - (b.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8, + (b.as_ptr() as *const ::libc::c_void) as *const u8, 4_usize as usize, ); let mut diff = 0_i32; @@ -110,11 +106,11 @@ pub unsafe fn test_memcmp_2() { assert!( (((({ let sa = core::slice::from_raw_parts( - (a.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8, + (a.as_ptr() as *const ::libc::c_void) as *const u8, 4_usize as usize, ); let sb = core::slice::from_raw_parts( - (c.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8, + (c.as_ptr() as *const ::libc::c_void) as *const u8, 4_usize as usize, ); let mut diff = 0_i32; @@ -131,11 +127,11 @@ pub unsafe fn test_memcmp_2() { assert!( (((({ let sa = core::slice::from_raw_parts( - (c.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8, + (c.as_ptr() as *const ::libc::c_void) as *const u8, 4_usize as usize, ); let sb = core::slice::from_raw_parts( - (a.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8, + (a.as_ptr() as *const ::libc::c_void) as *const u8, 4_usize as usize, ); let mut diff = 0_i32; @@ -162,18 +158,15 @@ pub unsafe fn test_memmove_3() { let mut r: *mut ::libc::c_void = { if 4_usize != 0 { ::std::ptr::copy_nonoverlapping( - (buf.as_mut_ptr() as *const libc::c_char as *const ::libc::c_void), - (buf.as_mut_ptr().offset((1) as isize) as *mut libc::c_char as *mut ::libc::c_void), + (buf.as_mut_ptr() as *const ::libc::c_void), + (buf.as_mut_ptr().offset((1) as isize) as *mut ::libc::c_void), 4_usize as usize, ) } - (buf.as_mut_ptr().offset((1) as isize) as *mut libc::c_char as *mut ::libc::c_void) + (buf.as_mut_ptr().offset((1) as isize) as *mut ::libc::c_void) }; assert!( - ((((r) - == (buf.as_mut_ptr().offset((1) as isize) as *mut libc::c_char as *mut ::libc::c_void)) - as i32) - != 0) + ((((r) == (buf.as_mut_ptr().offset((1) as isize) as *mut ::libc::c_void)) as i32) != 0) ); assert!( ((((((((((buf[(0) as usize] as i32) == ('a' as i32)) as i32) != 0) @@ -310,32 +303,28 @@ pub unsafe fn test_memchr_8() { (64 as libc::c_char), ]; let mut r: *mut ::libc::c_void = libc::memchr( - (data.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const ::libc::c_void, + (data.as_ptr() as *const ::libc::c_void) as *const ::libc::c_void, 48, 4_usize as usize, ); assert!( - ((((r) - == ((&data[(2) as usize] as *const libc::c_char) as *mut libc::c_char - as *mut ::libc::c_void)) as i32) + ((((r) == ((&data[(2) as usize] as *const libc::c_char) as *mut ::libc::c_void)) as i32) != 0) ); assert!( ((((libc::memchr( - (data.as_ptr() as *const libc::c_char as *const ::libc::c_void) - as *const ::libc::c_void, + (data.as_ptr() as *const ::libc::c_void) as *const ::libc::c_void, 153, 4_usize as usize )) .is_null()) as i32) != 0) ); - let mut p: *const ::libc::c_void = - (data.as_ptr() as *const libc::c_char as *const ::libc::c_void); + let mut p: *const ::libc::c_void = (data.as_ptr() as *const ::libc::c_void); let mut n: usize = 4_usize; assert!( - ((((libc::memchr(p as *const ::libc::c_void, 16, n as usize)) - == (p as *mut ::libc::c_void as *mut ::libc::c_void)) as i32) + ((((libc::memchr(p as *const ::libc::c_void, 16, n as usize)) == (p as *mut ::libc::c_void)) + as i32) != 0) ); } diff --git a/tests/unit/out/unsafe/string_literal_ptr_init.rs b/tests/unit/out/unsafe/string_literal_ptr_init.rs index 507a5c1c4..158debef2 100644 --- a/tests/unit/out/unsafe/string_literal_ptr_init.rs +++ b/tests/unit/out/unsafe/string_literal_ptr_init.rs @@ -100,7 +100,7 @@ unsafe fn main_0() -> i32 { ((*std::cell::LazyCell::force_mut(&mut *&raw mut table_1))[(0) as usize].name as *mut ::libc::c_void) } else { - (c"".as_ptr().cast_mut() as *mut libc::c_char as *mut ::libc::c_void) + (c"".as_ptr().cast_mut() as *mut ::libc::c_void) }; assert!( (((((*(p as *const libc::c_char).offset((0) as isize)) as i32) == ('\0' as i32)) as i32) @@ -111,7 +111,7 @@ unsafe fn main_0() -> i32 { ((*std::cell::LazyCell::force_mut(&mut *&raw mut table_1))[(0) as usize].name as *mut ::libc::c_void) } else { - (c"".as_ptr().cast_mut() as *mut libc::c_char as *mut ::libc::c_void) + (c"".as_ptr().cast_mut() as *mut ::libc::c_void) }; assert!( (((((*(p as *const libc::c_char).offset((0) as isize)) as i32) == ('f' as i32)) as i32) diff --git a/tests/unit/out/unsafe/unconst.rs b/tests/unit/out/unsafe/unconst.rs index 7d914b094..a4511edcb 100644 --- a/tests/unit/out/unsafe/unconst.rs +++ b/tests/unit/out/unsafe/unconst.rs @@ -15,8 +15,8 @@ pub fn main() { unsafe fn main_0() -> i32 { let a: i32 = 1; let mut p: *const i32 = (&a as *const i32); - let mut q: *mut i32 = (((((p) as *const i32 as *const ::libc::c_void) as u64) - as *mut ::libc::c_void) as *mut i32); + let mut q: *mut i32 = + (((((p) as *const ::libc::c_void) as u64) as *mut ::libc::c_void) as *mut i32); assert!(((p) == ((q).cast_const()))); return 0; } diff --git a/tests/unit/out/unsafe/union_addrof_external.rs b/tests/unit/out/unsafe/union_addrof_external.rs index 830617b75..8bf37c256 100644 --- a/tests/unit/out/unsafe/union_addrof_external.rs +++ b/tests/unit/out/unsafe/union_addrof_external.rs @@ -61,7 +61,7 @@ pub unsafe fn fill_1(mut out: *mut ::libc::c_void, mut cap: usize) { { if n != 0 { ::std::ptr::copy_nonoverlapping( - (src.as_mut_ptr() as *const u8 as *const ::libc::c_void), + (src.as_mut_ptr() as *const ::libc::c_void), out, n as usize, ) @@ -78,12 +78,11 @@ pub fn main() { unsafe fn main_0() -> i32 { let mut c: Container = ::default(); { - let byte_0 = - ((&mut c as *mut Container) as *mut Container as *mut ::libc::c_void) as *mut u8; + let byte_0 = ((&mut c as *mut Container) as *mut ::libc::c_void) as *mut u8; for offset in 0..::std::mem::size_of::() { *byte_0.offset(offset as isize) = 0 as u8; } - ((&mut c as *mut Container) as *mut Container as *mut ::libc::c_void) + ((&mut c as *mut Container) as *mut ::libc::c_void) }; (unsafe { let _out: *mut ::libc::c_void = ((&mut c.view as *mut anon_0) as *mut ::libc::c_void); diff --git a/tests/unit/out/unsafe/union_cross_arm_cast.rs b/tests/unit/out/unsafe/union_cross_arm_cast.rs index 35e1b665a..fe98da097 100644 --- a/tests/unit/out/unsafe/union_cross_arm_cast.rs +++ b/tests/unit/out/unsafe/union_cross_arm_cast.rs @@ -67,12 +67,11 @@ pub fn main() { unsafe fn main_0() -> i32 { let mut c: Container = ::default(); { - let byte_0 = - ((&mut c as *mut Container) as *mut Container as *mut ::libc::c_void) as *mut u8; + let byte_0 = ((&mut c as *mut Container) as *mut ::libc::c_void) as *mut u8; for offset in 0..::std::mem::size_of::() { *byte_0.offset(offset as isize) = 0 as u8; } - ((&mut c as *mut Container) as *mut Container as *mut ::libc::c_void) + ((&mut c as *mut Container) as *mut ::libc::c_void) }; c.u.a.code = 10_u16; c.len = (::std::mem::size_of::() as u32); diff --git a/tests/unit/out/unsafe/union_flex_array_member.rs b/tests/unit/out/unsafe/union_flex_array_member.rs index e13a8cd12..4432e3ee9 100644 --- a/tests/unit/out/unsafe/union_flex_array_member.rs +++ b/tests/unit/out/unsafe/union_flex_array_member.rs @@ -59,7 +59,7 @@ unsafe fn main_0() -> i32 { assert!((((((*q) as i32) == (20)) as i32) != 0)); (*q) = 187_u8; assert!((((((*q) as i32) == (187)) as i32) != 0)); - libcc2rs::free_unsafe((n as *mut node as *mut ::libc::c_void)); + libcc2rs::free_unsafe((n as *mut ::libc::c_void)); return 0; } pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/unit/out/unsafe/union_memset_memcpy.rs b/tests/unit/out/unsafe/union_memset_memcpy.rs index b8c6dac03..373f70f38 100644 --- a/tests/unit/out/unsafe/union_memset_memcpy.rs +++ b/tests/unit/out/unsafe/union_memset_memcpy.rs @@ -64,12 +64,11 @@ pub fn main() { unsafe fn main_0() -> i32 { let mut c: Container = ::default(); { - let byte_0 = - ((&mut c as *mut Container) as *mut Container as *mut ::libc::c_void) as *mut u8; + let byte_0 = ((&mut c as *mut Container) as *mut ::libc::c_void) as *mut u8; for offset in 0..::std::mem::size_of::() { *byte_0.offset(offset as isize) = 0 as u8; } - ((&mut c as *mut Container) as *mut Container as *mut ::libc::c_void) + ((&mut c as *mut Container) as *mut ::libc::c_void) }; assert!(((((c.view.a.code as i32) == (0)) as i32) != 0)); assert!(((((c.view.b.lo as i32) == (0)) as i32) != 0)); @@ -91,14 +90,12 @@ unsafe fn main_0() -> i32 { { if len != 0 { ::std::ptr::copy_nonoverlapping( - (src.as_mut_ptr() as *const u8 as *const ::libc::c_void), - ((&mut c.view.raw_ as *mut [libc::c_char; 256]) as *mut [libc::c_char; 256] - as *mut ::libc::c_void), + (src.as_mut_ptr() as *const ::libc::c_void), + ((&mut c.view.raw_ as *mut [libc::c_char; 256]) as *mut ::libc::c_void), len as usize, ) } - ((&mut c.view.raw_ as *mut [libc::c_char; 256]) as *mut [libc::c_char; 256] - as *mut ::libc::c_void) + ((&mut c.view.raw_ as *mut [libc::c_char; 256]) as *mut ::libc::c_void) }; assert!(((((c.view.b.code as i32) == (2)) as i32) != 0)); assert!( @@ -107,12 +104,11 @@ unsafe fn main_0() -> i32 { != 0) ); { - let byte_0 = - ((&mut c as *mut Container) as *mut Container as *mut ::libc::c_void) as *mut u8; + let byte_0 = ((&mut c as *mut Container) as *mut ::libc::c_void) as *mut u8; for offset in 0..::std::mem::size_of::() { *byte_0.offset(offset as isize) = 0 as u8; } - ((&mut c as *mut Container) as *mut Container as *mut ::libc::c_void) + ((&mut c as *mut Container) as *mut ::libc::c_void) }; assert!(((((c.view.b.code as i32) == (0)) as i32) != 0)); return 0; diff --git a/tests/unit/out/unsafe/union_nested.rs b/tests/unit/out/unsafe/union_nested.rs index 0e59f04cf..14481281e 100644 --- a/tests/unit/out/unsafe/union_nested.rs +++ b/tests/unit/out/unsafe/union_nested.rs @@ -65,11 +65,11 @@ pub fn main() { unsafe fn main_0() -> i32 { let mut ex: Outer = ::default(); { - let byte_0 = ((&mut ex as *mut Outer) as *mut Outer as *mut ::libc::c_void) as *mut u8; + let byte_0 = ((&mut ex as *mut Outer) as *mut ::libc::c_void) as *mut u8; for offset in 0..::std::mem::size_of::() { *byte_0.offset(offset as isize) = 0 as u8; } - ((&mut ex as *mut Outer) as *mut Outer as *mut ::libc::c_void) + ((&mut ex as *mut Outer) as *mut ::libc::c_void) }; ex.kind = 2; ex.level = 1; diff --git a/tests/unit/out/unsafe/union_struct_dual_use.rs b/tests/unit/out/unsafe/union_struct_dual_use.rs index 27a8df55c..a5171c872 100644 --- a/tests/unit/out/unsafe/union_struct_dual_use.rs +++ b/tests/unit/out/unsafe/union_struct_dual_use.rs @@ -44,11 +44,11 @@ unsafe fn main_0() -> i32 { assert!(((((unsafe { sum_inner_0((&mut standalone as *mut Inner),) }) == (7)) as i32) != 0)); let mut outer: Outer = ::default(); { - let byte_0 = ((&mut outer as *mut Outer) as *mut Outer as *mut ::libc::c_void) as *mut u8; + let byte_0 = ((&mut outer as *mut Outer) as *mut ::libc::c_void) as *mut u8; for offset in 0..::std::mem::size_of::() { *byte_0.offset(offset as isize) = 0 as u8; } - ((&mut outer as *mut Outer) as *mut Outer as *mut ::libc::c_void) + ((&mut outer as *mut Outer) as *mut ::libc::c_void) }; outer.u.inner.a = 3; outer.u.inner.b = 4; diff --git a/tests/unit/out/unsafe/union_tagged_many_arms.rs b/tests/unit/out/unsafe/union_tagged_many_arms.rs index ca262ab1c..fb880a648 100644 --- a/tests/unit/out/unsafe/union_tagged_many_arms.rs +++ b/tests/unit/out/unsafe/union_tagged_many_arms.rs @@ -58,12 +58,8 @@ unsafe fn main_0() -> i32 { let mut x: i32 = 0; let mut e: Slot = ::default(); e.tag = Tag_enum_T_REF; - e.payload.handle = ((&mut x as *mut i32) as *mut i32 as *mut ::libc::c_void); - assert!( - ((((e.payload.handle) == ((&mut x as *mut i32) as *mut i32 as *mut ::libc::c_void)) - as i32) - != 0) - ); + e.payload.handle = ((&mut x as *mut i32) as *mut ::libc::c_void); + assert!(((((e.payload.handle) == ((&mut x as *mut i32) as *mut ::libc::c_void)) as i32) != 0)); return 0; } pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/unit/out/unsafe/union_tagged_simple.rs b/tests/unit/out/unsafe/union_tagged_simple.rs index f3713395d..21de983a3 100644 --- a/tests/unit/out/unsafe/union_tagged_simple.rs +++ b/tests/unit/out/unsafe/union_tagged_simple.rs @@ -37,18 +37,16 @@ unsafe fn main_0() -> i32 { let mut dummy: i32 = 0; let mut m1: Event = ::default(); m1.kind = Kind_enum_KIND_DONE; - m1.handle = ((&mut dummy as *mut i32) as *mut i32 as *mut ::libc::c_void); + m1.handle = ((&mut dummy as *mut i32) as *mut ::libc::c_void); m1.payload.code = 42; assert!(((((m1.kind as u32) == ((Kind_enum_KIND_DONE as i32) as u32)) as i32) != 0)); assert!(((((m1.payload.code) == (42)) as i32) != 0)); let mut m2: Event = ::default(); m2.kind = Kind_enum_KIND_NONE; - m2.handle = ((&mut dummy as *mut i32) as *mut i32 as *mut ::libc::c_void); - m2.payload.obj = ((&mut dummy as *mut i32) as *mut i32 as *mut ::libc::c_void); + m2.handle = ((&mut dummy as *mut i32) as *mut ::libc::c_void); + m2.payload.obj = ((&mut dummy as *mut i32) as *mut ::libc::c_void); assert!( - ((((m2.payload.obj) == ((&mut dummy as *mut i32) as *mut i32 as *mut ::libc::c_void)) - as i32) - != 0) + ((((m2.payload.obj) == ((&mut dummy as *mut i32) as *mut ::libc::c_void)) as i32) != 0) ); return 0; } diff --git a/tests/unit/out/unsafe/union_void_ptr_sized_deref.rs b/tests/unit/out/unsafe/union_void_ptr_sized_deref.rs index c29a85870..28a14022b 100644 --- a/tests/unit/out/unsafe/union_void_ptr_sized_deref.rs +++ b/tests/unit/out/unsafe/union_void_ptr_sized_deref.rs @@ -61,15 +61,15 @@ unsafe fn main_0() -> i32 { let mut buf16: i16 = 0_i16; let mut s: Sink = ::default(); s.width = Width_enum_W_64; - s.out.handle = ((&mut buf64 as *mut i64) as *mut i64 as *mut ::libc::c_void); + s.out.handle = ((&mut buf64 as *mut i64) as *mut ::libc::c_void); (unsafe { write_count_1((&mut s as *mut Sink), 1234605616436508552_i64) }); assert!(((((buf64) == (1234605616436508552_i64)) as i32) != 0)); s.width = Width_enum_W_32; - s.out.handle = ((&mut buf32 as *mut i32) as *mut i32 as *mut ::libc::c_void); + s.out.handle = ((&mut buf32 as *mut i32) as *mut ::libc::c_void); (unsafe { write_count_1((&mut s as *mut Sink), 305419896_i64) }); assert!(((((buf32) == (305419896)) as i32) != 0)); s.width = Width_enum_W_16; - s.out.handle = ((&mut buf16 as *mut i16) as *mut i16 as *mut ::libc::c_void); + s.out.handle = ((&mut buf16 as *mut i16) as *mut ::libc::c_void); (unsafe { write_count_1((&mut s as *mut Sink), 4660_i64) }); assert!(((((buf16 as i32) == (4660)) as i32) != 0)); return 0; diff --git a/tests/unit/out/unsafe/unistd.rs b/tests/unit/out/unsafe/unistd.rs index 298535d2c..73b3dab8e 100644 --- a/tests/unit/out/unsafe/unistd.rs +++ b/tests/unit/out/unsafe/unistd.rs @@ -14,7 +14,7 @@ pub unsafe fn test_close_0() { assert!( ((((libc::read( fds[(0) as usize], - (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void), + (buf.as_mut_ptr() as *mut ::libc::c_void), 1_usize )) == (-1_i32 as isize)) as i32) != 0) @@ -44,22 +44,18 @@ pub unsafe fn test_lseek_1() { (0 as libc::c_char), ]; assert!( - ((((libc::read( - fd, - (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void), - 5_usize - )) == (5_isize)) as i32) + ((((libc::read(fd, (buf.as_mut_ptr() as *mut ::libc::c_void), 5_usize)) == (5_isize)) + as i32) != 0) ); assert!( (((({ let sa = core::slice::from_raw_parts( - (buf.as_mut_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8, + (buf.as_mut_ptr() as *const ::libc::c_void) as *const u8, 5_usize as usize, ); let sb = core::slice::from_raw_parts( - (c"world".as_ptr().cast_mut() as *const libc::c_char as *const ::libc::c_void) - as *const u8, + (c"world".as_ptr().cast_mut() as *const ::libc::c_void) as *const u8, 5_usize as usize, ); let mut diff = 0_i32; @@ -105,22 +101,18 @@ pub unsafe fn test_read_2() { (0 as libc::c_char), ]; assert!( - ((((libc::read( - fd, - (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void), - 16_usize - )) == (11_isize)) as i32) + ((((libc::read(fd, (buf.as_mut_ptr() as *mut ::libc::c_void), 16_usize)) == (11_isize)) + as i32) != 0) ); assert!( (((({ let sa = core::slice::from_raw_parts( - (buf.as_mut_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8, + (buf.as_mut_ptr() as *const ::libc::c_void) as *const u8, 11_usize as usize, ); let sb = core::slice::from_raw_parts( - (c"hello world".as_ptr().cast_mut() as *const libc::c_char as *const ::libc::c_void) - as *const u8, + (c"hello world".as_ptr().cast_mut() as *const ::libc::c_void) as *const u8, 11_usize as usize, ); let mut diff = 0_i32; @@ -151,11 +143,8 @@ pub unsafe fn test_pipe_4() { assert!(((((libc::pipe(fds.as_mut_ptr())) == (0)) as i32) != 0)); let mut msg: *const libc::c_char = (c"world".as_ptr().cast_mut()).cast_const(); assert!( - ((((libc::write( - fds[(1) as usize], - (msg as *const libc::c_char as *const ::libc::c_void), - 5_usize - )) == (5_isize)) as i32) + ((((libc::write(fds[(1) as usize], (msg as *const ::libc::c_void), 5_usize)) == (5_isize)) + as i32) != 0) ); let mut buf: [libc::c_char; 8] = [ @@ -171,7 +160,7 @@ pub unsafe fn test_pipe_4() { assert!( ((((libc::read( fds[(0) as usize], - (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void), + (buf.as_mut_ptr() as *mut ::libc::c_void), 8_usize )) == (5_isize)) as i32) != 0) @@ -179,11 +168,11 @@ pub unsafe fn test_pipe_4() { assert!( (((({ let sa = core::slice::from_raw_parts( - (buf.as_mut_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8, + (buf.as_mut_ptr() as *const ::libc::c_void) as *const u8, 5_usize as usize, ); let sb = core::slice::from_raw_parts( - (msg as *const libc::c_char as *const ::libc::c_void) as *const u8, + (msg as *const ::libc::c_void) as *const u8, 5_usize as usize, ); let mut diff = 0_i32; @@ -201,7 +190,7 @@ pub unsafe fn test_pipe_4() { assert!( ((((libc::read( fds[(0) as usize], - (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void), + (buf.as_mut_ptr() as *mut ::libc::c_void), 8_usize )) == (0_isize)) as i32) != 0) diff --git a/tests/unit/out/unsafe/va_arg_fn_ptr.rs b/tests/unit/out/unsafe/va_arg_fn_ptr.rs index 7c749c4c7..67ae7edc1 100644 --- a/tests/unit/out/unsafe/va_arg_fn_ptr.rs +++ b/tests/unit/out/unsafe/va_arg_fn_ptr.rs @@ -92,10 +92,8 @@ unsafe fn main_0() -> i32 { let mut dummy: i32 = 0; assert!( ((((unsafe { - let _ctx: *mut ::libc::c_void = - ((&mut dummy as *mut i32) as *mut i32 as *mut ::libc::c_void); - let _extra: *mut ::libc::c_void = - ((&mut dummy as *mut i32) as *mut i32 as *mut ::libc::c_void); + let _ctx: *mut ::libc::c_void = ((&mut dummy as *mut i32) as *mut ::libc::c_void); + let _extra: *mut ::libc::c_void = ((&mut dummy as *mut i32) as *mut ::libc::c_void); not_supported_5(_ctx, Some(square_0), _extra) }) == (-3_i32)) as i32) != 0) diff --git a/tests/unit/out/unsafe/void_ptr_implicit_conversion.rs b/tests/unit/out/unsafe/void_ptr_implicit_conversion.rs index c798f66f3..96f60a39b 100644 --- a/tests/unit/out/unsafe/void_ptr_implicit_conversion.rs +++ b/tests/unit/out/unsafe/void_ptr_implicit_conversion.rs @@ -19,8 +19,7 @@ pub fn main() { } unsafe fn main_0() -> i32 { let mut value: i32 = 41; - let mut opaque: *mut ::libc::c_void = - ((&mut value as *mut i32) as *mut i32 as *mut ::libc::c_void); + let mut opaque: *mut ::libc::c_void = ((&mut value as *mut i32) as *mut ::libc::c_void); let mut typed: *mut i32 = (opaque as *mut i32); assert!(((((unsafe { bump_0(opaque,) }) == (42)) as i32) != 0)); assert!(((((*typed) == (42)) as i32) != 0)); diff --git a/tests/unit/out/unsafe/z_bit_cast.rs b/tests/unit/out/unsafe/z_bit_cast.rs index f23abe306..fb2e20932 100644 --- a/tests/unit/out/unsafe/z_bit_cast.rs +++ b/tests/unit/out/unsafe/z_bit_cast.rs @@ -18,15 +18,11 @@ unsafe fn main_0() -> i32 { let mut a1: [u32; 3] = [1_u32, 2_u32, 3_u32]; (unsafe { decay_cast_0(a1.as_mut_ptr()) }); (unsafe { decay_cast_0((&mut a1[(0) as usize] as *mut u32)) }); - (unsafe { bit_cast_1((a1.as_mut_ptr() as *const u32 as *const ::libc::c_void)) }); - (unsafe { - bit_cast_1(((&mut a1[(0) as usize] as *mut u32) as *const u32 as *const ::libc::c_void)) - }); - (unsafe { - bit_cast_1(((&mut a1 as *mut [u32; 3]) as *const [u32; 3] as *const ::libc::c_void)) - }); - let mut ptr: *mut ::libc::c_void = (a1.as_mut_ptr() as *mut u32 as *mut ::libc::c_void); - assert!(((ptr) == (a1.as_mut_ptr() as *mut u32 as *mut ::libc::c_void))); + (unsafe { bit_cast_1((a1.as_mut_ptr() as *const ::libc::c_void)) }); + (unsafe { bit_cast_1(((&mut a1[(0) as usize] as *mut u32) as *const ::libc::c_void)) }); + (unsafe { bit_cast_1(((&mut a1 as *mut [u32; 3]) as *const ::libc::c_void)) }); + let mut ptr: *mut ::libc::c_void = (a1.as_mut_ptr() as *mut ::libc::c_void); + assert!(((ptr) == (a1.as_mut_ptr() as *mut ::libc::c_void))); assert!(((*(ptr as *mut u32).offset((0) as isize)) == (a1[(0) as usize]))); return 0; } From 9131013095b1b17681217dbf1828f8e873951454 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 28 Sep 2026 20:53:15 +0100 Subject: [PATCH 6/6] Return poitners instead of reference from rule --- rules/string/tgt_unsafe.rs | 2 +- rules/vector/tgt_unsafe.rs | 4 ++-- tests/unit/out/unsafe/implicit_autoref.rs | 2 +- tests/unit/out/unsafe/nested_vector.rs | 2 +- tests/unit/out/unsafe/vector.rs | 15 ++++++++------- tests/unit/out/unsafe/vector_with_allocator.rs | 15 ++++++++------- 6 files changed, 21 insertions(+), 19 deletions(-) diff --git a/rules/string/tgt_unsafe.rs b/rules/string/tgt_unsafe.rs index 4a9bb6ff2..e50722ace 100644 --- a/rules/string/tgt_unsafe.rs +++ b/rules/string/tgt_unsafe.rs @@ -165,7 +165,7 @@ unsafe fn f26(a0: &mut Vec, a1: usize) -> *mut libc::c_char { if a1 as usize >= a0.len() - 1 { panic!("out of bounds access") } else { - &mut a0[a1 as usize] + (&mut a0[a1 as usize] as *mut libc::c_char) } } diff --git a/rules/vector/tgt_unsafe.rs b/rules/vector/tgt_unsafe.rs index 81b22c8f7..c63add853 100644 --- a/rules/vector/tgt_unsafe.rs +++ b/rules/vector/tgt_unsafe.rs @@ -54,7 +54,7 @@ unsafe fn f6(a0: &mut Vec) -> *mut T1 { a0.as_mut_ptr() } unsafe fn f7(a0: &mut Vec, a1: usize) -> *mut T1 { - &mut (a0)[a1 as usize] + (&mut (a0)[a1 as usize] as *mut T1) } unsafe fn f8(a0: usize) -> Vec { (0..(a0) as usize) @@ -281,7 +281,7 @@ unsafe fn f65(a0: &mut Vec) -> *mut T1 { } unsafe fn f66(a0: &mut Vec, a1: usize) -> *mut T1 { - &mut (a0)[a1 as usize] + (&mut (a0)[a1 as usize] as *mut T1) } unsafe fn f67(a0: usize) -> Vec { diff --git a/tests/unit/out/unsafe/implicit_autoref.rs b/tests/unit/out/unsafe/implicit_autoref.rs index 77a7038fa..af5d489fc 100644 --- a/tests/unit/out/unsafe/implicit_autoref.rs +++ b/tests/unit/out/unsafe/implicit_autoref.rs @@ -37,7 +37,7 @@ unsafe fn main_0() -> i32 { assert!((((&mut (*p))[(1_usize)]) == (30))); assert!(((b) == (40))); assert!((((&mut (*hp)).v[(1_usize)]) == (60))); - (unsafe { write_through_0((&mut (&mut (*p))[0_usize as usize])) }); + (unsafe { write_through_0((&mut (&mut (*p))[0_usize as usize] as *mut i32)) }); assert!((((&mut (*p))[(0_usize)]) == (42))); return 0; } diff --git a/tests/unit/out/unsafe/nested_vector.rs b/tests/unit/out/unsafe/nested_vector.rs index d00b032f6..7468956df 100644 --- a/tests/unit/out/unsafe/nested_vector.rs +++ b/tests/unit/out/unsafe/nested_vector.rs @@ -16,7 +16,7 @@ unsafe fn main_0() -> i32 { let mut v1: Vec> = Vec::new(); let mut v2: Vec = vec![1]; v1.push(v2.clone()); - assert!(((*&mut (*((v1).last_mut().unwrap()))[0_usize as usize]) == (1))); + assert!(((*(&mut (*((v1).last_mut().unwrap()))[0_usize as usize] as *mut i32)) == (1))); return 0; } pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/unit/out/unsafe/vector.rs b/tests/unit/out/unsafe/vector.rs index 559c9d14c..da4824ea8 100644 --- a/tests/unit/out/unsafe/vector.rs +++ b/tests/unit/out/unsafe/vector.rs @@ -150,17 +150,18 @@ unsafe fn main_0() -> i32 { x0 = 6.0E+0; assert!(((*((v6).last_mut().unwrap())) == (5.0E+0))); let mut idx: i32 = 0; - assert!(((*&mut (v6)[(idx as usize) as usize]) == (2.0E+0))); - assert!(((*&mut (v6)[(s2).wrapping_sub(1_usize) as usize]) == (5.0E+0))); - let ref1: *mut f64 = &mut (v6)[(s2).wrapping_sub(1_usize) as usize]; + assert!(((*(&mut (v6)[(idx as usize) as usize] as *mut f64)) == (2.0E+0))); + assert!(((*(&mut (v6)[(s2).wrapping_sub(1_usize) as usize] as *mut f64)) == (5.0E+0))); + let ref1: *mut f64 = (&mut (v6)[(s2).wrapping_sub(1_usize) as usize] as *mut f64); (*ref1) += 1.5E+0; - assert!(((*&mut (v6)[(s2).wrapping_sub(1_usize) as usize]) == (6.5E+0))); - let mut x1: f64 = (*&mut (v6)[(s2).wrapping_sub(1_usize) as usize]); + assert!(((*(&mut (v6)[(s2).wrapping_sub(1_usize) as usize] as *mut f64)) == (6.5E+0))); + let mut x1: f64 = (*(&mut (v6)[(s2).wrapping_sub(1_usize) as usize] as *mut f64)); assert!(((x1) == (6.5E+0))); x1 -= 1.5E+0; - assert!(((*&mut (v6)[(s2).wrapping_sub(1_usize) as usize]) == (6.5E+0))); + assert!(((*(&mut (v6)[(s2).wrapping_sub(1_usize) as usize] as *mut f64)) == (6.5E+0))); assert!( - ((((s1).wrapping_add(s2)).wrapping_add(((*&mut (v2)[0_usize as usize]) as usize))) + ((((s1).wrapping_add(s2)) + .wrapping_add(((*(&mut (v2)[0_usize as usize] as *mut i32)) as usize))) == (103_usize)) ); return 0; diff --git a/tests/unit/out/unsafe/vector_with_allocator.rs b/tests/unit/out/unsafe/vector_with_allocator.rs index c12c8fb2b..332dd9a84 100644 --- a/tests/unit/out/unsafe/vector_with_allocator.rs +++ b/tests/unit/out/unsafe/vector_with_allocator.rs @@ -170,15 +170,15 @@ unsafe fn main_0() -> i32 { x0 = 6.0E+0; assert!(((*((v6).last_mut().unwrap())) == (5.0E+0))); let mut idx: i32 = 0; - assert!(((*&mut (v6)[(idx as usize) as usize]) == (2.0E+0))); - assert!(((*&mut (v6)[(s2).wrapping_sub(1_usize) as usize]) == (5.0E+0))); - let ref1: *mut f64 = &mut (v6)[(s2).wrapping_sub(1_usize) as usize]; + assert!(((*(&mut (v6)[(idx as usize) as usize] as *mut f64)) == (2.0E+0))); + assert!(((*(&mut (v6)[(s2).wrapping_sub(1_usize) as usize] as *mut f64)) == (5.0E+0))); + let ref1: *mut f64 = (&mut (v6)[(s2).wrapping_sub(1_usize) as usize] as *mut f64); (*ref1) += 1.5E+0; - assert!(((*&mut (v6)[(s2).wrapping_sub(1_usize) as usize]) == (6.5E+0))); - let mut x1: f64 = (*&mut (v6)[(s2).wrapping_sub(1_usize) as usize]); + assert!(((*(&mut (v6)[(s2).wrapping_sub(1_usize) as usize] as *mut f64)) == (6.5E+0))); + let mut x1: f64 = (*(&mut (v6)[(s2).wrapping_sub(1_usize) as usize] as *mut f64)); assert!(((x1) == (6.5E+0))); x1 -= 1.5E+0; - assert!(((*&mut (v6)[(s2).wrapping_sub(1_usize) as usize]) == (6.5E+0))); + assert!(((*(&mut (v6)[(s2).wrapping_sub(1_usize) as usize] as *mut f64)) == (6.5E+0))); let mut v7: Vec = Vec::new(); let mut v8: Vec = Vec::new(); v7.push(4); @@ -243,7 +243,8 @@ unsafe fn main_0() -> i32 { assert!(((v13.len()) == (5_usize))); assert!(((v13[(0_usize)] as i32) == (10)) && ((v13[(4_usize)] as i32) == (50))); assert!( - ((((s1).wrapping_add(s2)).wrapping_add(((*&mut (v2)[0_usize as usize]) as usize))) + ((((s1).wrapping_add(s2)) + .wrapping_add(((*(&mut (v2)[0_usize as usize] as *mut i32)) as usize))) == (103_usize)) ); return 0;