From 5b88a35ffe4ca54a9671be783235f9f078f698ad Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 19 Oct 2026 15:15:26 +0100 Subject: [PATCH 1/7] Remove per-type special loops --- cpp2rust/converter/converter.cpp | 116 +++--------------- cpp2rust/converter/converter.h | 14 --- cpp2rust/converter/converter_lib.cpp | 8 +- cpp2rust/converter/converter_lib.h | 4 +- .../converter/models/converter_refcount.cpp | 80 ------------ .../converter/models/converter_refcount.h | 9 -- tests/unit/out/refcount/auto.rs | 11 +- tests/unit/out/refcount/foreach.rs | 11 +- .../refcount/foreach_disjoint_field_borrow.rs | 12 +- tests/unit/out/refcount/foreach_double.rs | 102 +++++++++++++-- tests/unit/out/refcount/foreach_map.rs | 52 ++++++-- tests/unit/out/refcount/foreach_mut.rs | 86 ++++++++++--- tests/unit/out/refcount/iterators.rs | 30 ++++- tests/unit/out/refcount/map-reallocation.rs | 13 +- tests/unit/out/refcount/map.rs | 13 +- tests/unit/out/refcount/map_key_identity.rs | 29 ++++- tests/unit/out/refcount/unboxed_locals.rs | 11 +- tests/unit/out/refcount/vector3.rs | 65 ++++++++-- tests/unit/out/unsafe/auto.rs | 9 +- tests/unit/out/unsafe/foreach.rs | 9 +- .../unsafe/foreach_disjoint_field_borrow.rs | 9 +- tests/unit/out/unsafe/foreach_double.rs | 90 +++++++++++--- tests/unit/out/unsafe/foreach_map.rs | 20 ++- tests/unit/out/unsafe/foreach_mut.rs | 72 ++++++++--- tests/unit/out/unsafe/iterators.rs | 30 +++-- tests/unit/out/unsafe/map-reallocation.rs | 5 +- tests/unit/out/unsafe/map.rs | 5 +- tests/unit/out/unsafe/map_key_identity.rs | 12 +- tests/unit/out/unsafe/unboxed_locals.rs | 9 +- tests/unit/out/unsafe/vector3.rs | 54 ++++++-- 30 files changed, 636 insertions(+), 354 deletions(-) diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp index e78230bf0..b3ec88d24 100644 --- a/cpp2rust/converter/converter.cpp +++ b/cpp2rust/converter/converter.cpp @@ -1488,112 +1488,27 @@ bool Converter::VisitForStmt(clang::ForStmt *stmt) { return false; } -void Converter::ConvertLoopVariable(clang::VarDecl *decl, - clang::Expr *range_init) { - auto loop_var_type = decl->getType(); - auto loop_var_name = GetNamedDeclAsString(decl); - - if (loop_var_type->isReferenceType()) { - auto pointee_type = loop_var_type->getPointeeType(); - Convert(range_init); - if (pointee_type.isConstQualified()) { - StrCat(std::format(".as_ptr().add({})", loop_var_name)); - } else { - StrCat(std::format(".as_mut_ptr().add({})", loop_var_name)); - } - } else { - { - PushExplicitAutoref autoref(*this, /*is_mut=*/false); - Convert(range_init); - } - StrCat(std::format("[{}]", loop_var_name)); - StrCat(".clone()"); - } -} - -void Converter::ConvertForRangeBody(clang::CXXForRangeStmt *stmt) { - PushBreakTarget push(break_target_, BreakTarget::Loop); - curr_for_inc_.emplace_back(nullptr); - ConvertBodyStmts(stmt->getBody()); - curr_for_inc_.pop_back(); -} - bool Converter::VisitCXXForRangeStmt(clang::CXXForRangeStmt *stmt) { - auto range_init_type = stmt->getRangeInit()->getType(); - - if (!Mapper::Contains(ctx_, range_init_type.getUnqualifiedType())) { - // FIXME: improve error handling - log() << "for range stmts only for types in std namespace\n"; - } - - log() << "GetClassName: " << GetClassName(range_init_type) << '\n'; - - if (GetClassName(range_init_type) == "std::map") { - return VisitCXXForRangeStmtMap(stmt); - } - if (GetClassName(range_init_type) == "std::basic_string") { - return VisitCXXForRangeStmtString(stmt); + PushBreakTarget push(break_target_, BreakTarget::Loop); + Convert(stmt->getInit()); + if (!IsAliasOfInit(ctx_, clang::cast( + stmt->getRangeStmt()->getSingleDecl()))) { + Convert(stmt->getRangeStmt()); } - return VisitCXXForRangeStmtVector(stmt); -} - -bool Converter::VisitCXXForRangeStmtMap(clang::CXXForRangeStmt *stmt) { - auto begin = - llvm::cast(stmt->getBeginStmt()->getSingleDecl()); - + Convert(stmt->getBeginStmt()); + Convert(stmt->getEndStmt()); StrCat("'loop_:"); - auto map_type = Mapper::Map(*this, stmt->getRangeInit()->getType()); - StrCat(keyword::kFor, GetNamedDeclAsString(begin), keyword::kIn, - "UnsafeMap::range(&"); - Convert(stmt->getRangeInit()); - StrCat(std::format(" as *const {})", map_type)); + StrCat(keyword::kWhile); + ConvertCondition(stmt->getCond()); { PushBrace brace(*this); + curr_for_inc_.emplace_back(stmt->getInc()); Convert(stmt->getLoopVarStmt()); - ConvertForRangeBody(stmt); - } - - return false; -} - -bool Converter::VisitCXXForRangeStmtString(clang::CXXForRangeStmt *stmt) { - return VisitCXXForRangeStmtIndexBased(stmt, "len()-1"); -} - -bool Converter::VisitCXXForRangeStmtVector(clang::CXXForRangeStmt *stmt) { - return VisitCXXForRangeStmtIndexBased(stmt, "len()"); -} - -bool Converter::VisitCXXForRangeStmtIndexBased(clang::CXXForRangeStmt *stmt, - const char *len_suffix) { - auto *loop_var = stmt->getLoopVariable(); - auto loop_var_name = GetNamedDeclAsString(loop_var); - - StrCat("'loop_:"); - StrCat(keyword::kFor, loop_var_name, keyword::kIn, "0.."); - { - PushParen range(*this); - Convert(stmt->getRangeInit()); - StrCat(token::kDot, len_suffix); - } - { - PushBrace body(*this); - StrCat(keyword::kLet); - - auto loop_var_type = loop_var->getType(); - if (!loop_var_type.isConstQualified()) { - StrCat(keyword_mut_); - } - - StrCat(loop_var_name); - StrCat(token::kAssign); - - ConvertLoopVariable(loop_var, stmt->getRangeInit()); - + ConvertBodyStmts(stmt->getBody()); + curr_for_inc_.pop_back(); + Convert(stmt->getInc()); StrCat(token::kSemiColon); - ConvertForRangeBody(stmt); } - return false; } @@ -3269,6 +3184,11 @@ bool Converter::VisitDeclRefExpr(clang::DeclRefExpr *expr) { Convert(init); return false; } + if (auto var = clang::dyn_cast(expr->getDecl()); + var && IsAliasOfInit(ctx_, var)) { + Convert(var->getInit()); + return false; + } ConvertDeclRefValue(expr, expr->getDecl()); return false; } diff --git a/cpp2rust/converter/converter.h b/cpp2rust/converter/converter.h index 79022d26e..cd07a0ec8 100644 --- a/cpp2rust/converter/converter.h +++ b/cpp2rust/converter/converter.h @@ -223,17 +223,6 @@ class Converter : public clang::RecursiveASTVisitor { virtual bool VisitCXXForRangeStmt(clang::CXXForRangeStmt *stmt); - virtual bool VisitCXXForRangeStmtMap(clang::CXXForRangeStmt *stmt); - - virtual bool VisitCXXForRangeStmtVector(clang::CXXForRangeStmt *stmt); - - virtual bool VisitCXXForRangeStmtString(clang::CXXForRangeStmt *stmt); - - bool VisitCXXForRangeStmtIndexBased(clang::CXXForRangeStmt *stmt, - const char *len_suffix); - - void ConvertForRangeBody(clang::CXXForRangeStmt *stmt); - virtual bool VisitBreakStmt(clang::BreakStmt *stmt); virtual bool VisitContinueStmt(clang::ContinueStmt *stmt); @@ -750,9 +739,6 @@ class Converter : public clang::RecursiveASTVisitor { virtual void ConvertCast(clang::QualType qual_type, int line = __builtin_LINE()); - virtual void ConvertLoopVariable(clang::VarDecl *decl, - clang::Expr *range_init); - virtual bool ConvertCXXOperatorCallExpr(clang::CXXOperatorCallExpr *expr); std::string GetMappedAsString(clang::Expr *expr, clang::Expr **args = nullptr, diff --git a/cpp2rust/converter/converter_lib.cpp b/cpp2rust/converter/converter_lib.cpp index c516fefe5..b71740ce4 100644 --- a/cpp2rust/converter/converter_lib.cpp +++ b/cpp2rust/converter/converter_lib.cpp @@ -1920,10 +1920,10 @@ std::optional GetParamImplicitConvertTarget(clang::Expr *expr, return fn->getParamDecl(param_idx)->getType().getNonReferenceType(); } -std::string GetClassName(clang::QualType type) { - if (auto *record = type->getAsCXXRecordDecl()) - return record->getQualifiedNameAsString(); - return {}; +bool IsAliasOfInit(clang::ASTContext &ctx, const clang::VarDecl *var) { + auto *init = var->getInit(); + return var->isImplicit() && var->getType()->isReferenceType() && init && + init->isGLValue() && !init->HasSideEffects(ctx); } bool IsVaListType(clang::QualType type) { diff --git a/cpp2rust/converter/converter_lib.h b/cpp2rust/converter/converter_lib.h index f8511750d..18b02a8b2 100644 --- a/cpp2rust/converter/converter_lib.h +++ b/cpp2rust/converter/converter_lib.h @@ -321,10 +321,10 @@ clang::Expr *BuildInitExpr(clang::Sema &sema, clang::QualType type, llvm::ArrayRef args, clang::SourceLocation loc); -std::string GetClassName(clang::QualType type); - bool IsVaListType(clang::QualType type); +bool IsAliasOfInit(clang::ASTContext &ctx, const clang::VarDecl *var); + bool NeedsImplicitScalarCast(clang::ASTContext &ctx, clang::QualType from, clang::QualType to); diff --git a/cpp2rust/converter/models/converter_refcount.cpp b/cpp2rust/converter/models/converter_refcount.cpp index df5ef3a5d..42ea9d1fd 100644 --- a/cpp2rust/converter/models/converter_refcount.cpp +++ b/cpp2rust/converter/models/converter_refcount.cpp @@ -2258,86 +2258,6 @@ bool ConverterRefCount::VisitCXXDeleteExpr(clang::CXXDeleteExpr *expr) { return false; } -void ConverterRefCount::EmitByValueShadow(const clang::VarDecl *loop_var, - std::string box_expr, - const std::string &type_override) { - auto type = loop_var->getType(); - if (!type->isReferenceType()) { - bool unboxed = IsUnboxedVar(loop_var); - PushConversionKind push(*this, VarConversionKind(loop_var)); - auto type_str = type_override.empty() ? ToString(type) : type_override; - StrCat(keyword::kLet, unboxed ? keyword::kMut : "", - GetNamedDeclAsString(loop_var), token::kColon, type_str, - token::kAssign); - StrCat(BoxValue(std::move(box_expr)), token::kSemiColon); - } -} - -bool ConverterRefCount::VisitCXXForRangeStmtMap(clang::CXXForRangeStmt *stmt) { - auto begin = - llvm::cast(stmt->getBeginStmt()->getSingleDecl()); - auto begin_name = GetNamedDeclAsString(begin); - - StrCat("'loop_:"); - StrCat(keyword::kFor, begin_name, keyword::kIn, "Map::range(", - ConvertObject(stmt->getRangeInit()), ')'); - PushBrace brace(*this); - - EmitByValueShadow(begin, std::string(begin_name)); - Convert(stmt->getLoopVarStmt()); - - ConvertForRangeBody(stmt); - - return false; -} - -bool ConverterRefCount::VisitCXXForRangeStmtVector( - clang::CXXForRangeStmt *stmt) { - auto *loop_var = stmt->getLoopVariable(); - auto loop_var_name = GetNamedDeclAsString(loop_var); - - StrCat("'loop_:"); - StrCat(keyword::kFor, - stmt->getLoopVariable()->getType().isConstQualified() ? "" : "mut", - loop_var_name, keyword::kIn, - ConvertObject(stmt->getRangeInit(), ObjectShape::Element)); - StrCat(keyword::kAs, ConvertPtrType(stmt->getRangeInit()->getType())); - - PushBrace brace(*this); - - auto type = loop_var->getType(); - bool copy = type.isPODType(ctx_) && !type->isRecordType(); - EmitByValueShadow(loop_var, loop_var_name + GetPointerDerefSuffix(type) + - (copy ? "" : ".clone()")); - - ConvertForRangeBody(stmt); - - return false; -} - -bool ConverterRefCount::VisitCXXForRangeStmtString( - clang::CXXForRangeStmt *stmt) { - auto *loop_var = stmt->getLoopVariable(); - auto loop_var_name = GetNamedDeclAsString(loop_var); - - StrCat("'loop_:"); - StrCat(keyword::kFor, - stmt->getLoopVariable()->getType().isConstQualified() ? "" : "mut", - loop_var_name, keyword::kIn, - ConvertObject(stmt->getRangeInit(), ObjectShape::Element)); - StrCat(".to_string_iterator() as StringIterator<", - ToString(loop_var->getType().getNonReferenceType()), '>'); - - PushBrace brace(*this); - - EmitByValueShadow(loop_var, loop_var_name + - GetPointerDerefSuffix(loop_var->getType()) + - ".clone()"); - ConvertForRangeBody(stmt); - - return false; -} - bool ConverterRefCount::VisitArrayInitLoopExpr(clang::ArrayInitLoopExpr *expr) { StrCat("Box::new"); PushParen outer(*this); diff --git a/cpp2rust/converter/models/converter_refcount.h b/cpp2rust/converter/models/converter_refcount.h index d4202d185..6ccd80ada 100644 --- a/cpp2rust/converter/models/converter_refcount.h +++ b/cpp2rust/converter/models/converter_refcount.h @@ -214,15 +214,6 @@ class ConverterRefCount final : public Converter { bool VisitCXXDeleteExpr(clang::CXXDeleteExpr *expr) override; - bool VisitCXXForRangeStmtMap(clang::CXXForRangeStmt *stmt) override; - - bool VisitCXXForRangeStmtVector(clang::CXXForRangeStmt *stmt) override; - - bool VisitCXXForRangeStmtString(clang::CXXForRangeStmt *stmt) override; - - void EmitByValueShadow(const clang::VarDecl *loop_var, std::string box_expr, - const std::string &type_override = ""); - std::string ConvertStream(clang::Expr *expr) override; bool VisitCXXConstructExpr(clang::CXXConstructExpr *expr) override; diff --git a/tests/unit/out/refcount/auto.rs b/tests/unit/out/refcount/auto.rs index 100c41315..d8017034a 100644 --- a/tests/unit/out/refcount/auto.rs +++ b/tests/unit/out/refcount/auto.rs @@ -24,9 +24,16 @@ fn main_0() -> i32 { (*v.borrow_mut()).push(__a1) }; let mut sum: i32 = 0; - 'loop_: for mut elem in v.as_pointer() as Ptr { - let mut elem: i32 = elem.read(); + let __begin1: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr)), + )); + let __end1: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { + let mut elem: i32 = ((*__begin1.borrow()).iter_deref().read()); sum += elem; + (*__begin1.borrow_mut()).iter_inc(); } assert!((sum == 3)); return 0; diff --git a/tests/unit/out/refcount/foreach.rs b/tests/unit/out/refcount/foreach.rs index 676cbe3ad..616e604b6 100644 --- a/tests/unit/out/refcount/foreach.rs +++ b/tests/unit/out/refcount/foreach.rs @@ -21,9 +21,16 @@ fn main_0() -> i32 { i.prefix_inc(); } let mut sum: i32 = 0; - 'loop_: for mut x in v.as_pointer() as Ptr { - let mut x: i32 = x.read(); + let __begin1: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr)), + )); + let __end1: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { + let mut x: i32 = ((*__begin1.borrow()).iter_deref().read()); sum += x; + (*__begin1.borrow_mut()).iter_inc(); } assert!((sum == 45)); return 0; diff --git a/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs b/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs index c6ecdf2c7..65819bd9f 100644 --- a/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs +++ b/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs @@ -25,9 +25,17 @@ fn main_0() -> i32 { let __a1 = 1; (*s.borrow_mut()).v.push(__a1) }; - 'loop_: for mut e in field_ref!(s.as_pointer(), v).as_pointer() as Ptr { - let mut e: i32 = e.read(); + let __begin1: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((field_ref!(s.as_pointer(), v).as_pointer() as Ptr)), + )); + let __end1: Value> = + Rc::new(RefCell::new(RandomAccessIterator::Vec( + (field_ref!(s.as_pointer(), v).as_pointer() as Ptr).to_end(), + ))); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { + let mut e: i32 = ((*__begin1.borrow()).iter_deref().read()); (*s.borrow_mut()).a.postfix_inc(); + (*__begin1.borrow_mut()).iter_inc(); } return 0; } diff --git a/tests/unit/out/refcount/foreach_double.rs b/tests/unit/out/refcount/foreach_double.rs index 293f327e3..57c3a7ce0 100644 --- a/tests/unit/out/refcount/foreach_double.rs +++ b/tests/unit/out/refcount/foreach_double.rs @@ -25,27 +25,89 @@ fn main_0() -> i32 { (*v.borrow_mut()).push(__a1) }; let mut square: i32 = 0; - 'loop_: for mut e1 in v.as_pointer() as Ptr { - let mut e1: i32 = e1.read(); - 'loop_: for mut e2 in v.as_pointer() as Ptr { - let mut e2: i32 = e2.read(); + let __begin1: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr)), + )); + let __end1: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { + let mut e1: i32 = ((*__begin1.borrow()).iter_deref().read()); + let __begin2: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr)), + )); + let __end2: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), + )); + 'loop_: while (*__begin2.borrow()) != (*__end2.borrow()) { + let mut e2: i32 = ((*__begin2.borrow()).iter_deref().read()); square += (e1 * e2); + (*__begin2.borrow_mut()).iter_inc(); } + (*__begin1.borrow_mut()).iter_inc(); } - 'loop_: for mut e1 in v.as_pointer() as Ptr { - 'loop_: for mut e2 in v.as_pointer() as Ptr { + let __begin1: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr)), + )); + let __end1: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { + let e1: Ptr = (*__begin1.borrow()).iter_deref(); + let __begin2: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr)), + )); + let __end2: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), + )); + 'loop_: while (*__begin2.borrow()) != (*__end2.borrow()) { + let e2: Ptr = (*__begin2.borrow()).iter_deref(); square += { ({ (e1.read()) } * { (e2.read()) }) }; + (*__begin2.borrow_mut()).iter_inc(); } + (*__begin1.borrow_mut()).iter_inc(); } - 'loop_: for mut e1 in v.as_pointer() as Ptr { - 'loop_: for mut e2 in v.as_pointer() as Ptr { + let __begin1: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr)), + )); + let __end1: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { + let e1: Ptr = (*__begin1.borrow()).iter_deref(); + let __begin2: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr)), + )); + let __end2: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), + )); + 'loop_: while (*__begin2.borrow()) != (*__end2.borrow()) { + let e2: Ptr = (*__begin2.borrow()).iter_deref(); square += { ({ (e1.read()) } * { (e2.read()) }) }; + (*__begin2.borrow_mut()).iter_inc(); } + (*__begin1.borrow_mut()).iter_inc(); } - 'loop_: for mut e1 in v.as_pointer() as Ptr { - 'loop_: for mut e2 in v.as_pointer() as Ptr { + let __begin1: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr)), + )); + let __end1: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { + let e1: Ptr = (*__begin1.borrow()).iter_deref(); + let __begin2: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr)), + )); + let __end2: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), + )); + 'loop_: while (*__begin2.borrow()) != (*__end2.borrow()) { + let e2: Ptr = (*__begin2.borrow()).iter_deref(); square += { ({ (e1.read()) } * { (e2.read()) }) }; + (*__begin2.borrow_mut()).iter_inc(); } + (*__begin1.borrow_mut()).iter_inc(); } let m: Value>> = Rc::new(RefCell::new(Vec::new())); let v1: Value> = Rc::new(RefCell::new(Vec::new())); @@ -63,10 +125,26 @@ fn main_0() -> i32 { let __a1 = std::mem::take(&mut (*v3.borrow_mut())); (*m.borrow_mut()).push(__a1) }; - 'loop_: for mut row in m.as_pointer() as Ptr> { - 'loop_: for mut col in Ptr::>::decay(&(row)) as Ptr { + let __begin1: Value>> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((m.as_pointer() as Ptr>)), + )); + let __end1: Value>> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((m.as_pointer() as Ptr>).to_end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { + let row: Ptr> = (*__begin1.borrow()).iter_deref(); + let __begin2: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((Ptr::>::decay(&(row)) as Ptr)), + )); + let __end2: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((Ptr::>::decay(&(row)) as Ptr).to_end()), + )); + 'loop_: while (*__begin2.borrow()) != (*__end2.borrow()) { + let col: Ptr = (*__begin2.borrow()).iter_deref(); square += { (col.read()) }; + (*__begin2.borrow_mut()).iter_inc(); } + (*__begin1.borrow_mut()).iter_inc(); } assert!((square == 144)); return 0; diff --git a/tests/unit/out/refcount/foreach_map.rs b/tests/unit/out/refcount/foreach_map.rs index 6ded20983..e6a0845e0 100644 --- a/tests/unit/out/refcount/foreach_map.rs +++ b/tests/unit/out/refcount/foreach_map.rs @@ -34,15 +34,28 @@ fn main_0() -> i32 { }; } let mut sum: f64 = 0_f64; - 'loop_: for __begin1 in Map::range(m.as_pointer()) { - let __begin1: Value, Value)>> = - Rc::new(RefCell::new(__begin1)); + let __begin1: Value, Value)>> = Rc::new(RefCell::new( + (m.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.begin()), + )); + let __end1: Value, Value)>> = Rc::new(RefCell::new( + (m.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { let i: Ptr<(Value, Value)> = (*__begin1.borrow()).iter_deref(); sum += (*(*i.upgrade().deref()).1.borrow()); + (*__begin1.borrow_mut()).iter_inc(); } - 'loop_: for __begin1 in Map::range(m.as_pointer()) { - let __begin1: Value, Value)>> = - Rc::new(RefCell::new(__begin1)); + let __begin1: Value, Value)>> = Rc::new(RefCell::new( + (m.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.begin()), + )); + let __end1: Value, Value)>> = Rc::new(RefCell::new( + (m.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { let i: Value<(Value, Value)> = Rc::new(RefCell::new(( Rc::new(RefCell::new( (*(*__begin1.borrow()).iter_deref().upgrade().deref()) @@ -58,11 +71,18 @@ fn main_0() -> i32 { )), ))); sum += ((*(*i.borrow()).0.borrow()) as f64); + (*__begin1.borrow_mut()).iter_inc(); } assert!((sum == 7475_f64)); - 'loop_: for __begin1 in Map::range(m.as_pointer()) { - let __begin1: Value, Value)>> = - Rc::new(RefCell::new(__begin1)); + let __begin1: Value, Value)>> = Rc::new(RefCell::new( + (m.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.begin()), + )); + let __end1: Value, Value)>> = Rc::new(RefCell::new( + (m.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { let i: Value<(Value, Value)> = Rc::new(RefCell::new(( Rc::new(RefCell::new( (*(*__begin1.borrow()).iter_deref().upgrade().deref()) @@ -79,12 +99,20 @@ fn main_0() -> i32 { ))); (*(*i.borrow()).1.borrow_mut()) = (-1_i32 as f64); assert!(((*(*i.borrow()).1.borrow()) == (-1_i32 as f64))); + (*__begin1.borrow_mut()).iter_inc(); } - 'loop_: for __begin1 in Map::range(m.as_pointer()) { - let __begin1: Value, Value)>> = - Rc::new(RefCell::new(__begin1)); + let __begin1: Value, Value)>> = Rc::new(RefCell::new( + (m.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.begin()), + )); + let __end1: Value, Value)>> = Rc::new(RefCell::new( + (m.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { let i: Ptr<(Value, Value)> = (*__begin1.borrow()).iter_deref(); assert!(((*(*i.upgrade().deref()).1.borrow()) != (-1_i32 as f64))); + (*__begin1.borrow_mut()).iter_inc(); } return 0; } diff --git a/tests/unit/out/refcount/foreach_mut.rs b/tests/unit/out/refcount/foreach_mut.rs index 4828b9078..2ca8c7065 100644 --- a/tests/unit/out/refcount/foreach_mut.rs +++ b/tests/unit/out/refcount/foreach_mut.rs @@ -25,21 +25,51 @@ fn main_0() -> i32 { (*v1.borrow_mut()).push(__a1) }; let mut sum: i32 = 0; - 'loop_: for mut x in v1.as_pointer() as Ptr { - let mut x: i32 = x.read(); + let __begin1: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v1.as_pointer() as Ptr)), + )); + let __end1: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v1.as_pointer() as Ptr).to_end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { + let mut x: i32 = ((*__begin1.borrow()).iter_deref().read()); sum += x.prefix_inc(); + (*__begin1.borrow_mut()).iter_inc(); } - 'loop_: for x in v1.as_pointer() as Ptr { - let mut x: i32 = x.read(); + let __begin1: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v1.as_pointer() as Ptr)), + )); + let __end1: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v1.as_pointer() as Ptr).to_end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { + let mut x: i32 = ((*__begin1.borrow()).iter_deref().read()); sum += x; + (*__begin1.borrow_mut()).iter_inc(); } - 'loop_: for mut x in v1.as_pointer() as Ptr { + let __begin1: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v1.as_pointer() as Ptr)), + )); + let __end1: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v1.as_pointer() as Ptr).to_end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { + let x: Ptr = (*__begin1.borrow()).iter_deref(); { x.with_mut(|__v| *__v = *__v + 10) }; + (*__begin1.borrow_mut()).iter_inc(); } - 'loop_: for mut x in v1.as_pointer() as Ptr { + let __begin1: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v1.as_pointer() as Ptr)), + )); + let __end1: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v1.as_pointer() as Ptr).to_end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { + let x: Ptr = (*__begin1.borrow()).iter_deref(); sum += { (x.read()) }; + (*__begin1.borrow_mut()).iter_inc(); } let v2: Value>> = Rc::new(RefCell::new(Vec::new())); { @@ -54,25 +84,53 @@ fn main_0() -> i32 { let __a1 = ((v1.as_pointer() as Ptr).offset(2_usize)); (*v2.borrow_mut()).push(__a1) }; - 'loop_: for mut p in v2.as_pointer() as Ptr> { - let mut p: Ptr = p.read(); + let __begin1: Value>> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v2.as_pointer() as Ptr>)), + )); + let __end1: Value>> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).to_end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { + let mut p: Ptr = ((*__begin1.borrow()).iter_deref().read()); { p.with_mut(|__v| *__v = *__v + 5) }; + (*__begin1.borrow_mut()).iter_inc(); } - 'loop_: for p in v2.as_pointer() as Ptr> { - let mut p: Ptr = p.read(); + let __begin1: Value>> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v2.as_pointer() as Ptr>)), + )); + let __end1: Value>> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).to_end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { + let mut p: Ptr = ((*__begin1.borrow()).iter_deref().read()); sum += { (p.read()) }; + (*__begin1.borrow_mut()).iter_inc(); } - 'loop_: for mut p in v2.as_pointer() as Ptr> { - let mut p: Ptr = p.read(); + let __begin1: Value>> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v2.as_pointer() as Ptr>)), + )); + let __end1: Value>> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).to_end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { + let mut p: Ptr = ((*__begin1.borrow()).iter_deref().read()); { p.with_mut(|__v| *__v = *__v + 5) }; + (*__begin1.borrow_mut()).iter_inc(); } - 'loop_: for mut p in v2.as_pointer() as Ptr> { - let mut p: Ptr = p.read(); + let __begin1: Value>> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v2.as_pointer() as Ptr>)), + )); + let __end1: Value>> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).to_end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { + let mut p: Ptr = ((*__begin1.borrow()).iter_deref().read()); sum += { (p.read()) }; + (*__begin1.borrow_mut()).iter_inc(); } assert!((sum == 168)); return 0; diff --git a/tests/unit/out/refcount/iterators.rs b/tests/unit/out/refcount/iterators.rs index 5bd79f7a9..74141fac6 100644 --- a/tests/unit/out/refcount/iterators.rs +++ b/tests/unit/out/refcount/iterators.rs @@ -16,15 +16,26 @@ fn main_0() -> i32 { __bytes.push(0); __bytes })); - 'loop_: for mut c in x.as_pointer().to_string_iterator() as StringIterator { + let mut __begin1: Ptr = (x.as_pointer() as Ptr); + let mut __end1: Ptr = (x.as_pointer() as Ptr).to_last(); + 'loop_: while __begin1 != __end1 { + let c: Ptr = __begin1.iter_deref(); c.with_mut(|__v| __v.prefix_inc()); + __begin1.iter_inc(); } - 'loop_: for mut c in x.as_pointer().to_string_iterator() as StringIterator { + let mut __begin1: Ptr = (x.as_pointer() as Ptr); + let mut __end1: Ptr = (x.as_pointer() as Ptr).to_last(); + 'loop_: while __begin1 != __end1 { + let c: Ptr = __begin1.iter_deref(); println!("{}", ((c.read()) as i32) as u8 as char); + __begin1.iter_inc(); } - 'loop_: for mut c in x.as_pointer().to_string_iterator() as StringIterator { - let mut c: i8 = c.read().clone(); + let mut __begin1: Ptr = (x.as_pointer() as Ptr); + let mut __end1: Ptr = (x.as_pointer() as Ptr).to_last(); + 'loop_: while __begin1 != __end1 { + let mut c: i8 = (__begin1.iter_deref().read()); println!("{}", (c as i32) as u8 as char); + __begin1.iter_inc(); } let v: Value>> = Rc::new(RefCell::new(Vec::new())); { @@ -35,9 +46,16 @@ fn main_0() -> i32 { let __a1 = Ptr::alloc(3); (*v.borrow_mut()).push(__a1) }; - 'loop_: for mut p in v.as_pointer() as Ptr> { - let mut p: Ptr = p.read(); + let __begin1: Value>> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr>)), + )); + let __end1: Value>> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr>).to_end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { + let mut p: Ptr = ((*__begin1.borrow()).iter_deref().read()); println!("{}", (p.read())); + (*__begin1.borrow_mut()).iter_inc(); } return 0; } diff --git a/tests/unit/out/refcount/map-reallocation.rs b/tests/unit/out/refcount/map-reallocation.rs index 114d64aab..cb10a4873 100644 --- a/tests/unit/out/refcount/map-reallocation.rs +++ b/tests/unit/out/refcount/map-reallocation.rs @@ -128,12 +128,19 @@ fn main_0() -> i32 { assert!(((p.read()) == 57005)); assert!(((*m.borrow()).len() == (((N + 1) as u32) as usize))); let mut prev: i32 = -1_i32; - 'loop_: for __begin1 in Map::range(m.as_pointer()) { - let __begin1: Value, Value)>> = - Rc::new(RefCell::new(__begin1)); + let __begin1: Value, Value)>> = Rc::new(RefCell::new( + (m.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.begin()), + )); + let __end1: Value, Value)>> = Rc::new(RefCell::new( + (m.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { let pair: Ptr<(Value, Value)> = (*__begin1.borrow()).iter_deref(); assert!(({ (*(*pair.upgrade().deref()).0.borrow()) } > { prev })); prev = (*(*pair.upgrade().deref()).0.borrow()); + (*__begin1.borrow_mut()).iter_inc(); } return 0; } diff --git a/tests/unit/out/refcount/map.rs b/tests/unit/out/refcount/map.rs index 101862155..89eb5ecf8 100644 --- a/tests/unit/out/refcount/map.rs +++ b/tests/unit/out/refcount/map.rs @@ -667,9 +667,15 @@ fn main_0() -> i32 { } assert!(((*m2.borrow()).len() == indexes.len())); let mut last: i32 = -1_i32; - 'loop_: for __begin1 in Map::range(m2.as_pointer()) { - let __begin1: Value, Value)>> = - Rc::new(RefCell::new(__begin1)); + let __begin1: Value, Value)>> = Rc::new(RefCell::new( + (m2.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.begin()), + )); + let __end1: Value, Value)>> = Rc::new(RefCell::new( + (m2.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { let pair: Ptr<(Value, Value)> = (*__begin1.borrow()).iter_deref(); assert!(({ (*(*pair.upgrade().deref()).0.borrow()) } > { last })); assert!( @@ -678,6 +684,7 @@ fn main_0() -> i32 { }) ); last = (*(*pair.upgrade().deref()).0.borrow()); + (*__begin1.borrow_mut()).iter_inc(); } k = 0; let value_0: Ptr = (*m.borrow()) diff --git a/tests/unit/out/refcount/map_key_identity.rs b/tests/unit/out/refcount/map_key_identity.rs index e48c038e3..c7b20afc4 100644 --- a/tests/unit/out/refcount/map_key_identity.rs +++ b/tests/unit/out/refcount/map_key_identity.rs @@ -229,9 +229,16 @@ fn main_0() -> i32 { ok = rhs_0 }; let mut distinct_count: usize = 0_usize; - 'loop_: for __begin1 in Map::range(distinct.as_pointer()) { - let __begin1: Value, Value)>> = - Rc::new(RefCell::new(__begin1)); + let __begin1: Value, Value)>> = + Rc::new(RefCell::new( + (distinct.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.begin()), + )); + let __end1: Value, Value)>> = Rc::new(RefCell::new( + (distinct.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { let entry: Ptr<(Value, Value)> = (*__begin1.borrow()).iter_deref(); if (distinct_count == 0_usize) { ok = { @@ -251,6 +258,7 @@ fn main_0() -> i32 { }; } distinct_count.prefix_inc(); + (*__begin1.borrow_mut()).iter_inc(); } ok = { ((ok as i32) & ((distinct_count == 2_usize) as i32)) != 0 }; let equivalent_a: Value = Rc::new(RefCell::new(Key { @@ -373,9 +381,17 @@ fn main_0() -> i32 { ok = rhs_0 }; let mut equivalent_count: usize = 0_usize; - 'loop_: for __begin2 in Map::range(equivalent.as_pointer()) { - let __begin2: Value, Value)>> = - Rc::new(RefCell::new(__begin2)); + let __begin2: Value, Value)>> = + Rc::new(RefCell::new( + (equivalent.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.begin()), + )); + let __end2: Value, Value)>> = + Rc::new(RefCell::new( + (equivalent.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.end()), + )); + 'loop_: while (*__begin2.borrow()) != (*__end2.borrow()) { let entry: Ptr<(Value, Value)> = (*__begin2.borrow()).iter_deref(); ok = { ((ok as i32) @@ -385,6 +401,7 @@ fn main_0() -> i32 { != 0 }; equivalent_count.prefix_inc(); + (*__begin2.borrow_mut()).iter_inc(); } ok = { ((ok as i32) & ((equivalent_count == 1_usize) as i32)) != 0 }; } diff --git a/tests/unit/out/refcount/unboxed_locals.rs b/tests/unit/out/refcount/unboxed_locals.rs index c26605f2e..51672aa9f 100644 --- a/tests/unit/out/refcount/unboxed_locals.rs +++ b/tests/unit/out/refcount/unboxed_locals.rs @@ -22,9 +22,16 @@ pub struct Pair { } pub fn total_2(v: Ptr>) -> i32 { let mut s: i32 = 0; - 'loop_: for mut x in Ptr::>::decay(&(v)) as Ptr { - let mut x: i32 = x.read(); + let __begin1: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((Ptr::>::decay(&(v)) as Ptr)), + )); + let __end1: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((Ptr::>::decay(&(v)) as Ptr).to_end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { + let mut x: i32 = ((*__begin1.borrow()).iter_deref().read()); s += x; + (*__begin1.borrow_mut()).iter_inc(); } return s; } diff --git a/tests/unit/out/refcount/vector3.rs b/tests/unit/out/refcount/vector3.rs index 0333ddd72..ecee50a70 100644 --- a/tests/unit/out/refcount/vector3.rs +++ b/tests/unit/out/refcount/vector3.rs @@ -29,23 +29,70 @@ fn main_0() -> i32 { index!(elem!((v.as_pointer() as Ptr>), 0_usize), 0_usize).write(1); index!(elem!((v.as_pointer() as Ptr>), 0_usize), 1_usize).write(5); index!(elem!((v.as_pointer() as Ptr>), 1_usize), 0_usize).write(6); - 'loop_: for mut v2 in v.as_pointer() as Ptr> { - 'loop_: for mut i in Ptr::>::decay(&(v2)) as Ptr { + let __begin1: Value>> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr>)), + )); + let __end1: Value>> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr>).to_end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { + let v2: Ptr> = (*__begin1.borrow()).iter_deref(); + let __begin2: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((Ptr::>::decay(&(v2)) as Ptr)), + )); + let __end2: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((Ptr::>::decay(&(v2)) as Ptr).to_end()), + )); + 'loop_: while (*__begin2.borrow()) != (*__end2.borrow()) { + let i: Ptr = (*__begin2.borrow()).iter_deref(); i.with_mut(|__v| __v.prefix_inc()); + (*__begin2.borrow_mut()).iter_inc(); } + (*__begin1.borrow_mut()).iter_inc(); } - 'loop_: for mut v2 in v.as_pointer() as Ptr> { - 'loop_: for mut i in Ptr::>::decay(&(v2)) as Ptr { - let mut i: i32 = i.read(); + let __begin1: Value>> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr>)), + )); + let __end1: Value>> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr>).to_end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { + let v2: Ptr> = (*__begin1.borrow()).iter_deref(); + let __begin2: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((Ptr::>::decay(&(v2)) as Ptr)), + )); + let __end2: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((Ptr::>::decay(&(v2)) as Ptr).to_end()), + )); + 'loop_: while (*__begin2.borrow()) != (*__end2.borrow()) { + let mut i: i32 = ((*__begin2.borrow()).iter_deref().read()); println!("{}", (i + 3)); + (*__begin2.borrow_mut()).iter_inc(); } + (*__begin1.borrow_mut()).iter_inc(); } - 'loop_: for mut v2 in v.as_pointer() as Ptr> { - let v2: Value> = Rc::new(RefCell::new(v2.upgrade().deref().clone())); - 'loop_: for mut i in v2.as_pointer() as Ptr { - let mut i: i32 = i.read(); + let __begin1: Value>> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr>)), + )); + let __end1: Value>> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v.as_pointer() as Ptr>).to_end()), + )); + 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { + let v2: Value> = Rc::new(RefCell::new( + (*(*__begin1.borrow()).iter_deref().upgrade().deref()).clone(), + )); + let __begin2: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v2.as_pointer() as Ptr)), + )); + let __end2: Value> = Rc::new(RefCell::new( + RandomAccessIterator::Vec((v2.as_pointer() as Ptr).to_end()), + )); + 'loop_: while (*__begin2.borrow()) != (*__end2.borrow()) { + let mut i: i32 = ((*__begin2.borrow()).iter_deref().read()); println!("{}", i); + (*__begin2.borrow_mut()).iter_inc(); } + (*__begin1.borrow_mut()).iter_inc(); } return 0; } diff --git a/tests/unit/out/unsafe/auto.rs b/tests/unit/out/unsafe/auto.rs index 86967b657..0e48ca3c7 100644 --- a/tests/unit/out/unsafe/auto.rs +++ b/tests/unit/out/unsafe/auto.rs @@ -26,9 +26,14 @@ unsafe fn main_0() -> i32 { v.push(__a1) }; let mut sum: i32 = 0; - 'loop_: for elem in 0..(v.len()) { - let mut elem = v[elem].clone(); + let mut __begin1: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); + let mut __end1: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); + 'loop_: while __begin1 != __end1 { + let mut elem: i32 = (*__begin1.iter_deref()); sum += elem; + __begin1.iter_inc(); } assert!(((sum) == (3))); return 0; diff --git a/tests/unit/out/unsafe/foreach.rs b/tests/unit/out/unsafe/foreach.rs index d6d231fb2..5677f2b7f 100644 --- a/tests/unit/out/unsafe/foreach.rs +++ b/tests/unit/out/unsafe/foreach.rs @@ -23,9 +23,14 @@ unsafe fn main_0() -> i32 { i.prefix_inc(); } let mut sum: i32 = 0; - 'loop_: for x in 0..(v.len()) { - let mut x = v[x].clone(); + let mut __begin1: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); + let mut __end1: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); + 'loop_: while __begin1 != __end1 { + let mut x: i32 = (*__begin1.iter_deref()); sum += x; + __begin1.iter_inc(); } assert!(((sum) == (45))); return 0; diff --git a/tests/unit/out/unsafe/foreach_disjoint_field_borrow.rs b/tests/unit/out/unsafe/foreach_disjoint_field_borrow.rs index 8ab6a468e..95c37df2a 100644 --- a/tests/unit/out/unsafe/foreach_disjoint_field_borrow.rs +++ b/tests/unit/out/unsafe/foreach_disjoint_field_borrow.rs @@ -24,9 +24,14 @@ unsafe fn main_0() -> i32 { let __a1 = 1; s.v.push(__a1) }; - 'loop_: for e in 0..(s.v.len()) { - let mut e = s.v[e].clone(); + let mut __begin1: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(s.v.as_mut_ptr()); + let mut __end1: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(s.v.as_mut_ptr().add(s.v.len())); + 'loop_: while __begin1 != __end1 { + let mut e: i32 = (*__begin1.iter_deref()); s.a.postfix_inc(); + __begin1.iter_inc(); } return 0; } diff --git a/tests/unit/out/unsafe/foreach_double.rs b/tests/unit/out/unsafe/foreach_double.rs index 7c6e3f33a..8d95c09df 100644 --- a/tests/unit/out/unsafe/foreach_double.rs +++ b/tests/unit/out/unsafe/foreach_double.rs @@ -27,33 +27,73 @@ unsafe fn main_0() -> i32 { v.push(__a1) }; let mut square: i32 = 0; - 'loop_: for e1 in 0..(v.len()) { - let mut e1 = v[e1].clone(); - 'loop_: for e2 in 0..(v.len()) { - let mut e2 = v[e2].clone(); + let mut __begin1: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); + let mut __end1: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); + 'loop_: while __begin1 != __end1 { + let mut e1: i32 = (*__begin1.iter_deref()); + let mut __begin2: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); + let mut __end2: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); + 'loop_: while __begin2 != __end2 { + let mut e2: i32 = (*__begin2.iter_deref()); square += ((e1) * (e2)); + __begin2.iter_inc(); } + __begin1.iter_inc(); } - 'loop_: for e1 in 0..(v.len()) { - let mut e1 = v.as_mut_ptr().add(e1); - 'loop_: for e2 in 0..(v.len()) { - let mut e2 = v.as_ptr().add(e2); + let mut __begin1: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); + let mut __end1: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); + 'loop_: while __begin1 != __end1 { + let e1: *mut i32 = &mut (*__begin1.iter_deref()); + let mut __begin2: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); + let mut __end2: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); + 'loop_: while __begin2 != __end2 { + let e2: *const i32 = &(*__begin2.iter_deref()); square += ((*e1) * (*e2)); + __begin2.iter_inc(); } + __begin1.iter_inc(); } - 'loop_: for e1 in 0..(v.len()) { - let mut e1 = v.as_ptr().add(e1); - 'loop_: for e2 in 0..(v.len()) { - let mut e2 = v.as_mut_ptr().add(e2); + let mut __begin1: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); + let mut __end1: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); + 'loop_: while __begin1 != __end1 { + let e1: *const i32 = &(*__begin1.iter_deref()); + let mut __begin2: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); + let mut __end2: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); + 'loop_: while __begin2 != __end2 { + let e2: *mut i32 = &mut (*__begin2.iter_deref()); square += ((*e1) * (*e2)); + __begin2.iter_inc(); } + __begin1.iter_inc(); } - 'loop_: for e1 in 0..(v.len()) { - let mut e1 = v.as_mut_ptr().add(e1); - 'loop_: for e2 in 0..(v.len()) { - let mut e2 = v.as_mut_ptr().add(e2); + let mut __begin1: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); + let mut __end1: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); + 'loop_: while __begin1 != __end1 { + let e1: *mut i32 = &mut (*__begin1.iter_deref()); + let mut __begin2: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); + let mut __end2: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); + 'loop_: while __begin2 != __end2 { + let e2: *mut i32 = &mut (*__begin2.iter_deref()); square += ((*e1) * (*e2)); + __begin2.iter_inc(); } + __begin1.iter_inc(); } let mut m: Vec> = Vec::new(); let mut v1: Vec = Vec::new(); @@ -71,12 +111,22 @@ unsafe fn main_0() -> i32 { let __a1 = std::mem::take(&mut v3); m.push(__a1) }; - 'loop_: for row in 0..(m.len()) { - let mut row = m.as_mut_ptr().add(row); - 'loop_: for col in 0..((*row).len()) { - let mut col = (*row).as_mut_ptr().add(col); + let mut __begin1: UnsafeRandomAccessIterator> = + UnsafeRandomAccessIterator::Vec(m.as_mut_ptr()); + let mut __end1: UnsafeRandomAccessIterator> = + UnsafeRandomAccessIterator::Vec(m.as_mut_ptr().add(m.len())); + 'loop_: while __begin1 != __end1 { + let row: *mut Vec = &mut (*__begin1.iter_deref()); + let mut __begin2: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec((*row).as_mut_ptr()); + let mut __end2: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec((*row).as_mut_ptr().add((*row).len())); + 'loop_: while __begin2 != __end2 { + let col: *mut i32 = &mut (*__begin2.iter_deref()); square += (*col); + __begin2.iter_inc(); } + __begin1.iter_inc(); } assert!(((square) == (144))); return 0; diff --git a/tests/unit/out/unsafe/foreach_map.rs b/tests/unit/out/unsafe/foreach_map.rs index f959c4322..c200557da 100644 --- a/tests/unit/out/unsafe/foreach_map.rs +++ b/tests/unit/out/unsafe/foreach_map.rs @@ -25,23 +25,35 @@ unsafe fn main_0() -> i32 { }; } let mut sum: f64 = 0_f64; - 'loop_: for __begin1 in UnsafeMap::range(&m as *const UnsafeMap) { + let mut __begin1: UnsafeBidirectionalIterator<(i32, f64)> = m.begin(); + let mut __end1: UnsafeBidirectionalIterator<(i32, f64)> = m.end(); + 'loop_: while __begin1 != __end1 { let i: *const (i32, f64) = &(*__begin1.iter_deref()); sum += (*i).1; + __begin1.iter_inc(); } - 'loop_: for __begin1 in UnsafeMap::range(&m as *const UnsafeMap) { + let mut __begin1: UnsafeBidirectionalIterator<(i32, f64)> = m.begin(); + let mut __end1: UnsafeBidirectionalIterator<(i32, f64)> = m.end(); + 'loop_: while __begin1 != __end1 { let mut i: (i32, f64) = (*__begin1.iter_deref()).clone(); sum += (i.0 as f64); + __begin1.iter_inc(); } assert!(((sum) == (7475_f64))); - 'loop_: for __begin1 in UnsafeMap::range(&m as *const UnsafeMap) { + let mut __begin1: UnsafeBidirectionalIterator<(i32, f64)> = m.begin(); + let mut __end1: UnsafeBidirectionalIterator<(i32, f64)> = m.end(); + 'loop_: while __begin1 != __end1 { let mut i: (i32, f64) = (*__begin1.iter_deref()).clone(); i.1 = (-1_i32 as f64); assert!(((i.1) == (-1_i32 as f64))); + __begin1.iter_inc(); } - 'loop_: for __begin1 in UnsafeMap::range(&m as *const UnsafeMap) { + let mut __begin1: UnsafeBidirectionalIterator<(i32, f64)> = m.begin(); + let mut __end1: UnsafeBidirectionalIterator<(i32, f64)> = m.end(); + 'loop_: while __begin1 != __end1 { let i: *const (i32, f64) = &(*__begin1.iter_deref()); assert!((((*i).1) != (-1_i32 as f64))); + __begin1.iter_inc(); } return 0; } diff --git a/tests/unit/out/unsafe/foreach_mut.rs b/tests/unit/out/unsafe/foreach_mut.rs index d3dce8649..8a93938c9 100644 --- a/tests/unit/out/unsafe/foreach_mut.rs +++ b/tests/unit/out/unsafe/foreach_mut.rs @@ -27,21 +27,41 @@ unsafe fn main_0() -> i32 { v1.push(__a1) }; let mut sum: i32 = 0; - 'loop_: for x in 0..(v1.len()) { - let mut x = v1[x].clone(); + let mut __begin1: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr()); + let mut __end1: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr().add(v1.len())); + 'loop_: while __begin1 != __end1 { + let mut x: i32 = (*__begin1.iter_deref()); sum += x.prefix_inc(); + __begin1.iter_inc(); } - 'loop_: for x in 0..(v1.len()) { - let x = v1[x].clone(); + let mut __begin1: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr()); + let mut __end1: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr().add(v1.len())); + 'loop_: while __begin1 != __end1 { + let x: i32 = (*__begin1.iter_deref()); sum += x; + __begin1.iter_inc(); } - 'loop_: for x in 0..(v1.len()) { - let mut x = v1.as_mut_ptr().add(x); + let mut __begin1: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr()); + let mut __end1: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr().add(v1.len())); + 'loop_: while __begin1 != __end1 { + let x: *mut i32 = &mut (*__begin1.iter_deref()); (*x) += 10; + __begin1.iter_inc(); } - 'loop_: for x in 0..(v1.len()) { - let mut x = v1.as_ptr().add(x); + let mut __begin1: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr()); + let mut __end1: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr().add(v1.len())); + 'loop_: while __begin1 != __end1 { + let x: *const i32 = &(*__begin1.iter_deref()); sum += (*x); + __begin1.iter_inc(); } let mut v2: Vec<*mut i32> = Vec::new(); { @@ -56,21 +76,41 @@ unsafe fn main_0() -> i32 { let __a1 = (&mut v1[(2_usize)] as *mut i32); v2.push(__a1) }; - 'loop_: for p in 0..(v2.len()) { - let mut p = v2[p].clone(); + let mut __begin1: UnsafeRandomAccessIterator<*mut i32> = + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()); + let mut __end1: UnsafeRandomAccessIterator<*mut i32> = + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(v2.len())); + 'loop_: while __begin1 != __end1 { + let mut p: *mut i32 = (*__begin1.iter_deref()); (*p) += 5; + __begin1.iter_inc(); } - 'loop_: for p in 0..(v2.len()) { - let p = v2[p].clone(); + let mut __begin1: UnsafeRandomAccessIterator<*mut i32> = + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()); + let mut __end1: UnsafeRandomAccessIterator<*mut i32> = + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(v2.len())); + 'loop_: while __begin1 != __end1 { + let p: *mut i32 = (*__begin1.iter_deref()); sum += (*p); + __begin1.iter_inc(); } - 'loop_: for p in 0..(v2.len()) { - let mut p = v2[p].clone(); + let mut __begin1: UnsafeRandomAccessIterator<*mut i32> = + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()); + let mut __end1: UnsafeRandomAccessIterator<*mut i32> = + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(v2.len())); + 'loop_: while __begin1 != __end1 { + let mut p: *mut i32 = (*__begin1.iter_deref()); (*p) += 5; + __begin1.iter_inc(); } - 'loop_: for p in 0..(v2.len()) { - let mut p = v2[p].clone(); + let mut __begin1: UnsafeRandomAccessIterator<*mut i32> = + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()); + let mut __end1: UnsafeRandomAccessIterator<*mut i32> = + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(v2.len())); + 'loop_: while __begin1 != __end1 { + let mut p: *const i32 = (*__begin1.iter_deref()).cast_const(); sum += (*p); + __begin1.iter_inc(); } assert!(((sum) == (168))); return 0; diff --git a/tests/unit/out/unsafe/iterators.rs b/tests/unit/out/unsafe/iterators.rs index 66d08982d..33ad4f67c 100644 --- a/tests/unit/out/unsafe/iterators.rs +++ b/tests/unit/out/unsafe/iterators.rs @@ -17,17 +17,26 @@ unsafe fn main_0() -> i32 { let s = c"hello".as_ptr(); std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1).to_vec() }; - 'loop_: for c in 0..(x.len() - 1) { - let mut c = x.as_mut_ptr().add(c); + let mut __begin1: *mut libc::c_char = x.as_mut_ptr(); + let mut __end1: *mut libc::c_char = x.as_mut_ptr().add(x.len() - 1); + 'loop_: while __begin1 != __end1 { + let c: *mut libc::c_char = &mut (*__begin1.iter_deref()); (*c).prefix_inc(); + __begin1.iter_inc(); } - 'loop_: for c in 0..(x.len() - 1) { - let mut c = x.as_mut_ptr().add(c); + let mut __begin1: *mut libc::c_char = x.as_mut_ptr(); + let mut __end1: *mut libc::c_char = x.as_mut_ptr().add(x.len() - 1); + 'loop_: while __begin1 != __end1 { + let c: *mut libc::c_char = &mut (*__begin1.iter_deref()); (unsafe { libc::printf(c"%c\n".as_ptr() as *const libc::c_char, ((*c) as i32)) }); + __begin1.iter_inc(); } - 'loop_: for c in 0..(x.len() - 1) { - let mut c = x[c].clone(); + let mut __begin1: *mut libc::c_char = x.as_mut_ptr(); + let mut __end1: *mut libc::c_char = x.as_mut_ptr().add(x.len() - 1); + 'loop_: while __begin1 != __end1 { + let mut c: libc::c_char = (*__begin1.iter_deref()); (unsafe { libc::printf(c"%c\n".as_ptr() as *const libc::c_char, (c as i32)) }); + __begin1.iter_inc(); } let mut v: Vec<*mut i32> = Vec::new(); { @@ -38,9 +47,14 @@ unsafe fn main_0() -> i32 { let __a1 = (Box::leak(Box::new(3)) as *mut i32); v.push(__a1) }; - 'loop_: for p in 0..(v.len()) { - let mut p = v[p].clone(); + let mut __begin1: UnsafeRandomAccessIterator<*mut i32> = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); + let mut __end1: UnsafeRandomAccessIterator<*mut i32> = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); + 'loop_: while __begin1 != __end1 { + let mut p: *mut i32 = (*__begin1.iter_deref()); (unsafe { libc::printf(c"%d\n".as_ptr() as *const libc::c_char, (*p)) }); + __begin1.iter_inc(); } return 0; } diff --git a/tests/unit/out/unsafe/map-reallocation.rs b/tests/unit/out/unsafe/map-reallocation.rs index aeb19296b..4ab689c8d 100644 --- a/tests/unit/out/unsafe/map-reallocation.rs +++ b/tests/unit/out/unsafe/map-reallocation.rs @@ -58,10 +58,13 @@ unsafe fn main_0() -> i32 { assert!(((*p) == (57005))); assert!(((m.len()) == ((((N) + (1)) as u32) as usize))); let mut prev: i32 = -1_i32; - 'loop_: for __begin1 in UnsafeMap::range(&m as *const UnsafeMap) { + let mut __begin1: UnsafeBidirectionalIterator<(i32, i32)> = m.begin(); + let mut __end1: UnsafeBidirectionalIterator<(i32, i32)> = m.end(); + 'loop_: while __begin1 != __end1 { let pair: *mut (i32, i32) = &mut (*__begin1.iter_deref()); assert!((((*pair).0) > (prev))); prev = (*pair).0; + __begin1.iter_inc(); } return 0; } diff --git a/tests/unit/out/unsafe/map.rs b/tests/unit/out/unsafe/map.rs index 93a688ead..6700cfc8d 100644 --- a/tests/unit/out/unsafe/map.rs +++ b/tests/unit/out/unsafe/map.rs @@ -191,11 +191,14 @@ unsafe fn main_0() -> i32 { } assert!(((m2.len()) == (indexes.len()))); let mut last: i32 = -1_i32; - 'loop_: for __begin1 in UnsafeMap::range(&m2 as *const UnsafeMap) { + let mut __begin1: UnsafeBidirectionalIterator<(i32, bool)> = m2.begin(); + let mut __end1: UnsafeBidirectionalIterator<(i32, bool)> = m2.end(); + 'loop_: while __begin1 != __end1 { let pair: *mut (i32, bool) = &mut (*__begin1.iter_deref()); assert!((((*pair).0) > (last))); assert!((((*pair).1 as i32) == (((*pair).0) % (2)))); last = (*pair).0; + __begin1.iter_inc(); } k = 0; let value_0: *const u32 = &raw const (*m.get(&(k as i16)).expect("out of range!")).1; diff --git a/tests/unit/out/unsafe/map_key_identity.rs b/tests/unit/out/unsafe/map_key_identity.rs index d49b8ea5c..373683a8a 100644 --- a/tests/unit/out/unsafe/map_key_identity.rs +++ b/tests/unit/out/unsafe/map_key_identity.rs @@ -118,7 +118,9 @@ unsafe fn main_0() -> i32 { }) as i32)) != 0; let mut distinct_count: usize = 0_usize; - 'loop_: for __begin1 in UnsafeMap::range(&distinct as *const UnsafeMap) { + let mut __begin1: UnsafeBidirectionalIterator<(Key, Mapped)> = distinct.begin(); + let mut __end1: UnsafeBidirectionalIterator<(Key, Mapped)> = distinct.end(); + 'loop_: while __begin1 != __end1 { let entry: *const (Key, Mapped) = &(*__begin1.iter_deref()); if ((distinct_count) == (0_usize)) { ok = ((ok as i32) @@ -130,6 +132,7 @@ unsafe fn main_0() -> i32 { != 0; } distinct_count.prefix_inc(); + __begin1.iter_inc(); } ok = ((ok as i32) & (((distinct_count) == (2_usize)) as i32)) != 0; let equivalent_a: Key = Key { @@ -179,14 +182,15 @@ unsafe fn main_0() -> i32 { as i32)) != 0; let mut equivalent_count: usize = 0_usize; - 'loop_: for __begin2 in - UnsafeMap::range(&equivalent as *const UnsafeMap) - { + let mut __begin2: UnsafeBidirectionalIterator<(Key, Mapped)> = equivalent.begin(); + let mut __end2: UnsafeBidirectionalIterator<(Key, Mapped)> = equivalent.end(); + 'loop_: while __begin2 != __end2 { let entry: *const (Key, Mapped) = &(*__begin2.iter_deref()); ok = ((ok as i32) & (((((*entry).0.order) == (3)) && (((*entry).1.value) == (31))) as i32)) != 0; equivalent_count.prefix_inc(); + __begin2.iter_inc(); } ok = ((ok as i32) & (((equivalent_count) == (1_usize)) as i32)) != 0; } diff --git a/tests/unit/out/unsafe/unboxed_locals.rs b/tests/unit/out/unsafe/unboxed_locals.rs index 3cb5a7c08..afe295962 100644 --- a/tests/unit/out/unsafe/unboxed_locals.rs +++ b/tests/unit/out/unsafe/unboxed_locals.rs @@ -20,9 +20,14 @@ pub struct Pair { } pub unsafe fn total_2(v: *const Vec) -> i32 { let mut s: i32 = 0; - 'loop_: for x in 0..((*v).len()) { - let mut x = (&(*v))[x].clone(); + let mut __begin1: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec((*v).as_ptr().cast_mut()); + let mut __end1: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec((*v).as_ptr().add((*v).len()).cast_mut()); + 'loop_: while __begin1 != __end1 { + let mut x: i32 = (*__begin1.iter_deref()); s += x; + __begin1.iter_inc(); } return s; } diff --git a/tests/unit/out/unsafe/vector3.rs b/tests/unit/out/unsafe/vector3.rs index 7bb74550e..d149c9fb0 100644 --- a/tests/unit/out/unsafe/vector3.rs +++ b/tests/unit/out/unsafe/vector3.rs @@ -29,26 +29,56 @@ unsafe fn main_0() -> i32 { v[(0_usize)][(0_usize)] = 1; v[(0_usize)][(1_usize)] = 5; v[(1_usize)][(0_usize)] = 6; - 'loop_: for v2 in 0..(v.len()) { - let mut v2 = v.as_mut_ptr().add(v2); - 'loop_: for i in 0..((*v2).len()) { - let mut i = (*v2).as_mut_ptr().add(i); + let mut __begin1: UnsafeRandomAccessIterator> = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); + let mut __end1: UnsafeRandomAccessIterator> = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); + 'loop_: while __begin1 != __end1 { + let v2: *mut Vec = &mut (*__begin1.iter_deref()); + let mut __begin2: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec((*v2).as_mut_ptr()); + let mut __end2: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec((*v2).as_mut_ptr().add((*v2).len())); + 'loop_: while __begin2 != __end2 { + let i: *mut i32 = &mut (*__begin2.iter_deref()); (*i).prefix_inc(); + __begin2.iter_inc(); } + __begin1.iter_inc(); } - 'loop_: for v2 in 0..(v.len()) { - let mut v2 = v.as_mut_ptr().add(v2); - 'loop_: for i in 0..((*v2).len()) { - let mut i = (&(*v2))[i].clone(); + let mut __begin1: UnsafeRandomAccessIterator> = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); + let mut __end1: UnsafeRandomAccessIterator> = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); + 'loop_: while __begin1 != __end1 { + let v2: *mut Vec = &mut (*__begin1.iter_deref()); + let mut __begin2: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec((*v2).as_mut_ptr()); + let mut __end2: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec((*v2).as_mut_ptr().add((*v2).len())); + 'loop_: while __begin2 != __end2 { + let mut i: i32 = (*__begin2.iter_deref()); (unsafe { libc::printf(c"%d\n".as_ptr() as *const libc::c_char, ((i) + (3))) }); + __begin2.iter_inc(); } + __begin1.iter_inc(); } - 'loop_: for v2 in 0..(v.len()) { - let mut v2 = v[v2].clone(); - 'loop_: for i in 0..(v2.len()) { - let mut i = v2[i].clone(); + let mut __begin1: UnsafeRandomAccessIterator> = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); + let mut __end1: UnsafeRandomAccessIterator> = + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); + 'loop_: while __begin1 != __end1 { + let mut v2: Vec = (*__begin1.iter_deref()).clone(); + let mut __begin2: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()); + let mut __end2: UnsafeRandomAccessIterator = + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(v2.len())); + 'loop_: while __begin2 != __end2 { + let mut i: i32 = (*__begin2.iter_deref()); (unsafe { libc::printf(c"%d\n".as_ptr() as *const libc::c_char, (i)) }); + __begin2.iter_inc(); } + __begin1.iter_inc(); } return 0; } From 9793efc269ea07583409bf8c14d668c513608c7d Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 19 Oct 2026 15:43:14 +0100 Subject: [PATCH 2/7] Add range support in interator --- cpp2rust/converter/converter.cpp | 14 +-- cpp2rust/converter/converter.h | 2 + .../converter/models/converter_refcount.cpp | 2 +- .../converter/models/converter_refcount.h | 2 + rules/iterator_category/shim.rs | 58 ++++++++++ tests/unit/out/refcount/auto.rs | 10 +- tests/unit/out/refcount/foreach.rs | 10 +- .../refcount/foreach_disjoint_field_borrow.rs | 13 +-- tests/unit/out/refcount/foreach_double.rs | 100 ++++++------------ tests/unit/out/refcount/foreach_map.rs | 44 +++----- tests/unit/out/refcount/foreach_mut.rs | 80 +++++--------- tests/unit/out/refcount/iterators.rs | 34 +++--- tests/unit/out/refcount/map-reallocation.rs | 10 +- tests/unit/out/refcount/map.rs | 10 +- tests/unit/out/refcount/map_key_identity.rs | 35 +++--- tests/unit/out/refcount/unboxed_locals.rs | 10 +- tests/unit/out/refcount/vector3.rs | 60 ++++------- tests/unit/out/unsafe/auto.rs | 10 +- tests/unit/out/unsafe/foreach.rs | 10 +- .../unsafe/foreach_disjoint_field_borrow.rs | 10 +- tests/unit/out/unsafe/foreach_double.rs | 100 +++++++----------- tests/unit/out/unsafe/foreach_map.rs | 20 +--- tests/unit/out/unsafe/foreach_mut.rs | 80 ++++++-------- tests/unit/out/unsafe/iterators.rs | 25 ++--- tests/unit/out/unsafe/map-reallocation.rs | 5 +- tests/unit/out/unsafe/map.rs | 5 +- tests/unit/out/unsafe/map_key_identity.rs | 10 +- tests/unit/out/unsafe/unboxed_locals.rs | 10 +- tests/unit/out/unsafe/vector3.rs | 60 +++++------ 29 files changed, 330 insertions(+), 509 deletions(-) diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp index b3ec88d24..d6a812e45 100644 --- a/cpp2rust/converter/converter.cpp +++ b/cpp2rust/converter/converter.cpp @@ -1495,19 +1495,19 @@ bool Converter::VisitCXXForRangeStmt(clang::CXXForRangeStmt *stmt) { stmt->getRangeStmt()->getSingleDecl()))) { Convert(stmt->getRangeStmt()); } - Convert(stmt->getBeginStmt()); - Convert(stmt->getEndStmt()); + auto *begin = + clang::cast(stmt->getBeginStmt()->getSingleDecl()); + auto *end = clang::cast(stmt->getEndStmt()->getSingleDecl()); StrCat("'loop_:"); - StrCat(keyword::kWhile); - ConvertCondition(stmt->getCond()); + StrCat(keyword::kFor, GetNamedDeclAsString(begin), keyword::kIn, + IterRangeName(), "::new(", ConvertFreshRValue(begin->getInit()), + token::kComma, ConvertFreshRValue(end->getInit()), ')'); { PushBrace brace(*this); - curr_for_inc_.emplace_back(stmt->getInc()); + curr_for_inc_.emplace_back(nullptr); Convert(stmt->getLoopVarStmt()); ConvertBodyStmts(stmt->getBody()); curr_for_inc_.pop_back(); - Convert(stmt->getInc()); - StrCat(token::kSemiColon); } return false; } diff --git a/cpp2rust/converter/converter.h b/cpp2rust/converter/converter.h index cd07a0ec8..127f67b44 100644 --- a/cpp2rust/converter/converter.h +++ b/cpp2rust/converter/converter.h @@ -223,6 +223,8 @@ class Converter : public clang::RecursiveASTVisitor { virtual bool VisitCXXForRangeStmt(clang::CXXForRangeStmt *stmt); + virtual const char *IterRangeName() const { return "UnsafeIterRange"; } + virtual bool VisitBreakStmt(clang::BreakStmt *stmt); virtual bool VisitContinueStmt(clang::ContinueStmt *stmt); diff --git a/cpp2rust/converter/models/converter_refcount.cpp b/cpp2rust/converter/models/converter_refcount.cpp index 42ea9d1fd..a9b483fd8 100644 --- a/cpp2rust/converter/models/converter_refcount.cpp +++ b/cpp2rust/converter/models/converter_refcount.cpp @@ -158,7 +158,7 @@ bool ConverterRefCount::NeedsMut(const clang::VarDecl *decl, bool ConverterRefCount::IsUnboxedVar(const clang::ValueDecl *decl) const { auto *var = clang::dyn_cast(decl); - return var && !boxed_vars_->contains(var); + return var && (var->isImplicit() || !boxed_vars_->contains(var)); } bool ConverterRefCount::IsUnboxedPlace(const clang::Expr *expr) const { diff --git a/cpp2rust/converter/models/converter_refcount.h b/cpp2rust/converter/models/converter_refcount.h index 6ccd80ada..19db53228 100644 --- a/cpp2rust/converter/models/converter_refcount.h +++ b/cpp2rust/converter/models/converter_refcount.h @@ -435,6 +435,8 @@ class ConverterRefCount final : public Converter { // Whether decl is a local variable or a parameter that is stored directly // instead of in a Value, as no pointer to it is ever made. bool IsUnboxedVar(const clang::ValueDecl *decl) const; + + const char *IterRangeName() const override { return "IterRange"; } // Whether expr is an unboxed variable or a field of one, which is accessed // in place. bool IsUnboxedPlace(const clang::Expr *expr) const; diff --git a/rules/iterator_category/shim.rs b/rules/iterator_category/shim.rs index 3994c5093..81524d304 100644 --- a/rules/iterator_category/shim.rs +++ b/rules/iterator_category/shim.rs @@ -451,3 +451,61 @@ random_access_iterator!( UnsafeCppRandomAccessIterator, std::ptr::null_mut() ); + +pub struct IterRange { + cur: I, + end: I, + elem: PhantomData, +} + +impl IterRange { + pub fn new(cur: I, end: I) -> Self { + Self { + cur, + end, + elem: PhantomData, + } + } +} + +impl, T> Iterator for IterRange { + type Item = I; + + fn next(&mut self) -> Option { + if self.cur == self.end { + return None; + } + let it = self.cur.clone(); + self.cur.iter_inc(); + Some(it) + } +} + +pub struct UnsafeIterRange { + cur: I, + end: I, + elem: PhantomData, +} + +impl UnsafeIterRange { + pub fn new(cur: I, end: I) -> Self { + Self { + cur, + end, + elem: PhantomData, + } + } +} + +impl, T> Iterator for UnsafeIterRange { + type Item = I; + + fn next(&mut self) -> Option { + if self.cur == self.end { + return None; + } + let it = self.cur.clone(); + self.cur.iter_inc(); + Some(it) + } +} diff --git a/tests/unit/out/refcount/auto.rs b/tests/unit/out/refcount/auto.rs index d8017034a..785e2fc31 100644 --- a/tests/unit/out/refcount/auto.rs +++ b/tests/unit/out/refcount/auto.rs @@ -24,16 +24,12 @@ fn main_0() -> i32 { (*v.borrow_mut()).push(__a1) }; let mut sum: i32 = 0; - let __begin1: Value> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr)), - )); - let __end1: Value> = Rc::new(RefCell::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { - let mut elem: i32 = ((*__begin1.borrow()).iter_deref().read()); + ) { + let mut elem: i32 = (__begin1.iter_deref().read()); sum += elem; - (*__begin1.borrow_mut()).iter_inc(); } assert!((sum == 3)); return 0; diff --git a/tests/unit/out/refcount/foreach.rs b/tests/unit/out/refcount/foreach.rs index 616e604b6..472751d56 100644 --- a/tests/unit/out/refcount/foreach.rs +++ b/tests/unit/out/refcount/foreach.rs @@ -21,16 +21,12 @@ fn main_0() -> i32 { i.prefix_inc(); } let mut sum: i32 = 0; - let __begin1: Value> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr)), - )); - let __end1: Value> = Rc::new(RefCell::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { - let mut x: i32 = ((*__begin1.borrow()).iter_deref().read()); + ) { + let mut x: i32 = (__begin1.iter_deref().read()); sum += x; - (*__begin1.borrow_mut()).iter_inc(); } assert!((sum == 45)); return 0; diff --git a/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs b/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs index 65819bd9f..e4af19528 100644 --- a/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs +++ b/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs @@ -25,17 +25,14 @@ fn main_0() -> i32 { let __a1 = 1; (*s.borrow_mut()).v.push(__a1) }; - let __begin1: Value> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( RandomAccessIterator::Vec((field_ref!(s.as_pointer(), v).as_pointer() as Ptr)), - )); - let __end1: Value> = - Rc::new(RefCell::new(RandomAccessIterator::Vec( + RandomAccessIterator::Vec( (field_ref!(s.as_pointer(), v).as_pointer() as Ptr).to_end(), - ))); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { - let mut e: i32 = ((*__begin1.borrow()).iter_deref().read()); + ), + ) { + let mut e: i32 = (__begin1.iter_deref().read()); (*s.borrow_mut()).a.postfix_inc(); - (*__begin1.borrow_mut()).iter_inc(); } return 0; } diff --git a/tests/unit/out/refcount/foreach_double.rs b/tests/unit/out/refcount/foreach_double.rs index 57c3a7ce0..544295f47 100644 --- a/tests/unit/out/refcount/foreach_double.rs +++ b/tests/unit/out/refcount/foreach_double.rs @@ -25,89 +25,57 @@ fn main_0() -> i32 { (*v.borrow_mut()).push(__a1) }; let mut square: i32 = 0; - let __begin1: Value> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr)), - )); - let __end1: Value> = Rc::new(RefCell::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { - let mut e1: i32 = ((*__begin1.borrow()).iter_deref().read()); - let __begin2: Value> = Rc::new(RefCell::new( + ) { + let mut e1: i32 = (__begin1.iter_deref().read()); + 'loop_: for __begin2 in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr)), - )); - let __end2: Value> = Rc::new(RefCell::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), - )); - 'loop_: while (*__begin2.borrow()) != (*__end2.borrow()) { - let mut e2: i32 = ((*__begin2.borrow()).iter_deref().read()); + ) { + let mut e2: i32 = (__begin2.iter_deref().read()); square += (e1 * e2); - (*__begin2.borrow_mut()).iter_inc(); } - (*__begin1.borrow_mut()).iter_inc(); } - let __begin1: Value> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr)), - )); - let __end1: Value> = Rc::new(RefCell::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { - let e1: Ptr = (*__begin1.borrow()).iter_deref(); - let __begin2: Value> = Rc::new(RefCell::new( + ) { + let e1: Ptr = __begin1.iter_deref(); + 'loop_: for __begin2 in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr)), - )); - let __end2: Value> = Rc::new(RefCell::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), - )); - 'loop_: while (*__begin2.borrow()) != (*__end2.borrow()) { - let e2: Ptr = (*__begin2.borrow()).iter_deref(); + ) { + let e2: Ptr = __begin2.iter_deref(); square += { ({ (e1.read()) } * { (e2.read()) }) }; - (*__begin2.borrow_mut()).iter_inc(); } - (*__begin1.borrow_mut()).iter_inc(); } - let __begin1: Value> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr)), - )); - let __end1: Value> = Rc::new(RefCell::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { - let e1: Ptr = (*__begin1.borrow()).iter_deref(); - let __begin2: Value> = Rc::new(RefCell::new( + ) { + let e1: Ptr = __begin1.iter_deref(); + 'loop_: for __begin2 in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr)), - )); - let __end2: Value> = Rc::new(RefCell::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), - )); - 'loop_: while (*__begin2.borrow()) != (*__end2.borrow()) { - let e2: Ptr = (*__begin2.borrow()).iter_deref(); + ) { + let e2: Ptr = __begin2.iter_deref(); square += { ({ (e1.read()) } * { (e2.read()) }) }; - (*__begin2.borrow_mut()).iter_inc(); } - (*__begin1.borrow_mut()).iter_inc(); } - let __begin1: Value> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr)), - )); - let __end1: Value> = Rc::new(RefCell::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { - let e1: Ptr = (*__begin1.borrow()).iter_deref(); - let __begin2: Value> = Rc::new(RefCell::new( + ) { + let e1: Ptr = __begin1.iter_deref(); + 'loop_: for __begin2 in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr)), - )); - let __end2: Value> = Rc::new(RefCell::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), - )); - 'loop_: while (*__begin2.borrow()) != (*__end2.borrow()) { - let e2: Ptr = (*__begin2.borrow()).iter_deref(); + ) { + let e2: Ptr = __begin2.iter_deref(); square += { ({ (e1.read()) } * { (e2.read()) }) }; - (*__begin2.borrow_mut()).iter_inc(); } - (*__begin1.borrow_mut()).iter_inc(); } let m: Value>> = Rc::new(RefCell::new(Vec::new())); let v1: Value> = Rc::new(RefCell::new(Vec::new())); @@ -125,26 +93,18 @@ fn main_0() -> i32 { let __a1 = std::mem::take(&mut (*v3.borrow_mut())); (*m.borrow_mut()).push(__a1) }; - let __begin1: Value>> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( RandomAccessIterator::Vec((m.as_pointer() as Ptr>)), - )); - let __end1: Value>> = Rc::new(RefCell::new( RandomAccessIterator::Vec((m.as_pointer() as Ptr>).to_end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { - let row: Ptr> = (*__begin1.borrow()).iter_deref(); - let __begin2: Value> = Rc::new(RefCell::new( + ) { + let row: Ptr> = __begin1.iter_deref(); + 'loop_: for __begin2 in IterRange::new( RandomAccessIterator::Vec((Ptr::>::decay(&(row)) as Ptr)), - )); - let __end2: Value> = Rc::new(RefCell::new( RandomAccessIterator::Vec((Ptr::>::decay(&(row)) as Ptr).to_end()), - )); - 'loop_: while (*__begin2.borrow()) != (*__end2.borrow()) { - let col: Ptr = (*__begin2.borrow()).iter_deref(); + ) { + let col: Ptr = __begin2.iter_deref(); square += { (col.read()) }; - (*__begin2.borrow_mut()).iter_inc(); } - (*__begin1.borrow_mut()).iter_inc(); } assert!((square == 144)); return 0; diff --git a/tests/unit/out/refcount/foreach_map.rs b/tests/unit/out/refcount/foreach_map.rs index e6a0845e0..c4016f524 100644 --- a/tests/unit/out/refcount/foreach_map.rs +++ b/tests/unit/out/refcount/foreach_map.rs @@ -34,64 +34,53 @@ fn main_0() -> i32 { }; } let mut sum: f64 = 0_f64; - let __begin1: Value, Value)>> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( (m.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.begin()), - )); - let __end1: Value, Value)>> = Rc::new(RefCell::new( (m.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { - let i: Ptr<(Value, Value)> = (*__begin1.borrow()).iter_deref(); + ) { + let i: Ptr<(Value, Value)> = __begin1.iter_deref(); sum += (*(*i.upgrade().deref()).1.borrow()); - (*__begin1.borrow_mut()).iter_inc(); } - let __begin1: Value, Value)>> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( (m.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.begin()), - )); - let __end1: Value, Value)>> = Rc::new(RefCell::new( (m.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { + ) { let i: Value<(Value, Value)> = Rc::new(RefCell::new(( Rc::new(RefCell::new( - (*(*__begin1.borrow()).iter_deref().upgrade().deref()) + (*__begin1.iter_deref().upgrade().deref()) .0 .borrow() .clone(), )), Rc::new(RefCell::new( - (*(*__begin1.borrow()).iter_deref().upgrade().deref()) + (*__begin1.iter_deref().upgrade().deref()) .1 .borrow() .clone(), )), ))); sum += ((*(*i.borrow()).0.borrow()) as f64); - (*__begin1.borrow_mut()).iter_inc(); } assert!((sum == 7475_f64)); - let __begin1: Value, Value)>> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( (m.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.begin()), - )); - let __end1: Value, Value)>> = Rc::new(RefCell::new( (m.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { + ) { let i: Value<(Value, Value)> = Rc::new(RefCell::new(( Rc::new(RefCell::new( - (*(*__begin1.borrow()).iter_deref().upgrade().deref()) + (*__begin1.iter_deref().upgrade().deref()) .0 .borrow() .clone(), )), Rc::new(RefCell::new( - (*(*__begin1.borrow()).iter_deref().upgrade().deref()) + (*__begin1.iter_deref().upgrade().deref()) .1 .borrow() .clone(), @@ -99,20 +88,15 @@ fn main_0() -> i32 { ))); (*(*i.borrow()).1.borrow_mut()) = (-1_i32 as f64); assert!(((*(*i.borrow()).1.borrow()) == (-1_i32 as f64))); - (*__begin1.borrow_mut()).iter_inc(); } - let __begin1: Value, Value)>> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( (m.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.begin()), - )); - let __end1: Value, Value)>> = Rc::new(RefCell::new( (m.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { - let i: Ptr<(Value, Value)> = (*__begin1.borrow()).iter_deref(); + ) { + let i: Ptr<(Value, Value)> = __begin1.iter_deref(); assert!(((*(*i.upgrade().deref()).1.borrow()) != (-1_i32 as f64))); - (*__begin1.borrow_mut()).iter_inc(); } return 0; } diff --git a/tests/unit/out/refcount/foreach_mut.rs b/tests/unit/out/refcount/foreach_mut.rs index 2ca8c7065..1e7ee2e6e 100644 --- a/tests/unit/out/refcount/foreach_mut.rs +++ b/tests/unit/out/refcount/foreach_mut.rs @@ -25,51 +25,35 @@ fn main_0() -> i32 { (*v1.borrow_mut()).push(__a1) }; let mut sum: i32 = 0; - let __begin1: Value> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( RandomAccessIterator::Vec((v1.as_pointer() as Ptr)), - )); - let __end1: Value> = Rc::new(RefCell::new( RandomAccessIterator::Vec((v1.as_pointer() as Ptr).to_end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { - let mut x: i32 = ((*__begin1.borrow()).iter_deref().read()); + ) { + let mut x: i32 = (__begin1.iter_deref().read()); sum += x.prefix_inc(); - (*__begin1.borrow_mut()).iter_inc(); } - let __begin1: Value> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( RandomAccessIterator::Vec((v1.as_pointer() as Ptr)), - )); - let __end1: Value> = Rc::new(RefCell::new( RandomAccessIterator::Vec((v1.as_pointer() as Ptr).to_end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { - let mut x: i32 = ((*__begin1.borrow()).iter_deref().read()); + ) { + let mut x: i32 = (__begin1.iter_deref().read()); sum += x; - (*__begin1.borrow_mut()).iter_inc(); } - let __begin1: Value> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( RandomAccessIterator::Vec((v1.as_pointer() as Ptr)), - )); - let __end1: Value> = Rc::new(RefCell::new( RandomAccessIterator::Vec((v1.as_pointer() as Ptr).to_end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { - let x: Ptr = (*__begin1.borrow()).iter_deref(); + ) { + let x: Ptr = __begin1.iter_deref(); { x.with_mut(|__v| *__v = *__v + 10) }; - (*__begin1.borrow_mut()).iter_inc(); } - let __begin1: Value> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( RandomAccessIterator::Vec((v1.as_pointer() as Ptr)), - )); - let __end1: Value> = Rc::new(RefCell::new( RandomAccessIterator::Vec((v1.as_pointer() as Ptr).to_end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { - let x: Ptr = (*__begin1.borrow()).iter_deref(); + ) { + let x: Ptr = __begin1.iter_deref(); sum += { (x.read()) }; - (*__begin1.borrow_mut()).iter_inc(); } let v2: Value>> = Rc::new(RefCell::new(Vec::new())); { @@ -84,53 +68,37 @@ fn main_0() -> i32 { let __a1 = ((v1.as_pointer() as Ptr).offset(2_usize)); (*v2.borrow_mut()).push(__a1) }; - let __begin1: Value>> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( RandomAccessIterator::Vec((v2.as_pointer() as Ptr>)), - )); - let __end1: Value>> = Rc::new(RefCell::new( RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).to_end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { - let mut p: Ptr = ((*__begin1.borrow()).iter_deref().read()); + ) { + let mut p: Ptr = (__begin1.iter_deref().read()); { p.with_mut(|__v| *__v = *__v + 5) }; - (*__begin1.borrow_mut()).iter_inc(); } - let __begin1: Value>> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( RandomAccessIterator::Vec((v2.as_pointer() as Ptr>)), - )); - let __end1: Value>> = Rc::new(RefCell::new( RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).to_end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { - let mut p: Ptr = ((*__begin1.borrow()).iter_deref().read()); + ) { + let mut p: Ptr = (__begin1.iter_deref().read()); sum += { (p.read()) }; - (*__begin1.borrow_mut()).iter_inc(); } - let __begin1: Value>> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( RandomAccessIterator::Vec((v2.as_pointer() as Ptr>)), - )); - let __end1: Value>> = Rc::new(RefCell::new( RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).to_end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { - let mut p: Ptr = ((*__begin1.borrow()).iter_deref().read()); + ) { + let mut p: Ptr = (__begin1.iter_deref().read()); { p.with_mut(|__v| *__v = *__v + 5) }; - (*__begin1.borrow_mut()).iter_inc(); } - let __begin1: Value>> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( RandomAccessIterator::Vec((v2.as_pointer() as Ptr>)), - )); - let __end1: Value>> = Rc::new(RefCell::new( RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).to_end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { - let mut p: Ptr = ((*__begin1.borrow()).iter_deref().read()); + ) { + let mut p: Ptr = (__begin1.iter_deref().read()); sum += { (p.read()) }; - (*__begin1.borrow_mut()).iter_inc(); } assert!((sum == 168)); return 0; diff --git a/tests/unit/out/refcount/iterators.rs b/tests/unit/out/refcount/iterators.rs index 74141fac6..ed09ac217 100644 --- a/tests/unit/out/refcount/iterators.rs +++ b/tests/unit/out/refcount/iterators.rs @@ -16,26 +16,26 @@ fn main_0() -> i32 { __bytes.push(0); __bytes })); - let mut __begin1: Ptr = (x.as_pointer() as Ptr); - let mut __end1: Ptr = (x.as_pointer() as Ptr).to_last(); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in IterRange::new( + (x.as_pointer() as Ptr), + (x.as_pointer() as Ptr).to_last(), + ) { let c: Ptr = __begin1.iter_deref(); c.with_mut(|__v| __v.prefix_inc()); - __begin1.iter_inc(); } - let mut __begin1: Ptr = (x.as_pointer() as Ptr); - let mut __end1: Ptr = (x.as_pointer() as Ptr).to_last(); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in IterRange::new( + (x.as_pointer() as Ptr), + (x.as_pointer() as Ptr).to_last(), + ) { let c: Ptr = __begin1.iter_deref(); println!("{}", ((c.read()) as i32) as u8 as char); - __begin1.iter_inc(); } - let mut __begin1: Ptr = (x.as_pointer() as Ptr); - let mut __end1: Ptr = (x.as_pointer() as Ptr).to_last(); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in IterRange::new( + (x.as_pointer() as Ptr), + (x.as_pointer() as Ptr).to_last(), + ) { let mut c: i8 = (__begin1.iter_deref().read()); println!("{}", (c as i32) as u8 as char); - __begin1.iter_inc(); } let v: Value>> = Rc::new(RefCell::new(Vec::new())); { @@ -46,16 +46,12 @@ fn main_0() -> i32 { let __a1 = Ptr::alloc(3); (*v.borrow_mut()).push(__a1) }; - let __begin1: Value>> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr>)), - )); - let __end1: Value>> = Rc::new(RefCell::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr>).to_end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { - let mut p: Ptr = ((*__begin1.borrow()).iter_deref().read()); + ) { + let mut p: Ptr = (__begin1.iter_deref().read()); println!("{}", (p.read())); - (*__begin1.borrow_mut()).iter_inc(); } return 0; } diff --git a/tests/unit/out/refcount/map-reallocation.rs b/tests/unit/out/refcount/map-reallocation.rs index cb10a4873..1ec5bd45c 100644 --- a/tests/unit/out/refcount/map-reallocation.rs +++ b/tests/unit/out/refcount/map-reallocation.rs @@ -128,19 +128,15 @@ fn main_0() -> i32 { assert!(((p.read()) == 57005)); assert!(((*m.borrow()).len() == (((N + 1) as u32) as usize))); let mut prev: i32 = -1_i32; - let __begin1: Value, Value)>> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( (m.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.begin()), - )); - let __end1: Value, Value)>> = Rc::new(RefCell::new( (m.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { - let pair: Ptr<(Value, Value)> = (*__begin1.borrow()).iter_deref(); + ) { + let pair: Ptr<(Value, Value)> = __begin1.iter_deref(); assert!(({ (*(*pair.upgrade().deref()).0.borrow()) } > { prev })); prev = (*(*pair.upgrade().deref()).0.borrow()); - (*__begin1.borrow_mut()).iter_inc(); } return 0; } diff --git a/tests/unit/out/refcount/map.rs b/tests/unit/out/refcount/map.rs index 89eb5ecf8..6a8ccb117 100644 --- a/tests/unit/out/refcount/map.rs +++ b/tests/unit/out/refcount/map.rs @@ -667,16 +667,13 @@ fn main_0() -> i32 { } assert!(((*m2.borrow()).len() == indexes.len())); let mut last: i32 = -1_i32; - let __begin1: Value, Value)>> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( (m2.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.begin()), - )); - let __end1: Value, Value)>> = Rc::new(RefCell::new( (m2.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { - let pair: Ptr<(Value, Value)> = (*__begin1.borrow()).iter_deref(); + ) { + let pair: Ptr<(Value, Value)> = __begin1.iter_deref(); assert!(({ (*(*pair.upgrade().deref()).0.borrow()) } > { last })); assert!( ({ ((*(*pair.upgrade().deref()).1.borrow()) as i32) } == { @@ -684,7 +681,6 @@ fn main_0() -> i32 { }) ); last = (*(*pair.upgrade().deref()).0.borrow()); - (*__begin1.borrow_mut()).iter_inc(); } k = 0; let value_0: Ptr = (*m.borrow()) diff --git a/tests/unit/out/refcount/map_key_identity.rs b/tests/unit/out/refcount/map_key_identity.rs index c7b20afc4..3992b2517 100644 --- a/tests/unit/out/refcount/map_key_identity.rs +++ b/tests/unit/out/refcount/map_key_identity.rs @@ -229,17 +229,13 @@ fn main_0() -> i32 { ok = rhs_0 }; let mut distinct_count: usize = 0_usize; - let __begin1: Value, Value)>> = - Rc::new(RefCell::new( - (distinct.as_pointer() as Ptr, Value)>>) - .with(|__m: &Map, Value)>| __m.begin()), - )); - let __end1: Value, Value)>> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( + (distinct.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.begin()), (distinct.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { - let entry: Ptr<(Value, Value)> = (*__begin1.borrow()).iter_deref(); + ) { + let entry: Ptr<(Value, Value)> = __begin1.iter_deref(); if (distinct_count == 0_usize) { ok = { ((ok as i32) @@ -258,7 +254,6 @@ fn main_0() -> i32 { }; } distinct_count.prefix_inc(); - (*__begin1.borrow_mut()).iter_inc(); } ok = { ((ok as i32) & ((distinct_count == 2_usize) as i32)) != 0 }; let equivalent_a: Value = Rc::new(RefCell::new(Key { @@ -381,18 +376,13 @@ fn main_0() -> i32 { ok = rhs_0 }; let mut equivalent_count: usize = 0_usize; - let __begin2: Value, Value)>> = - Rc::new(RefCell::new( - (equivalent.as_pointer() as Ptr, Value)>>) - .with(|__m: &Map, Value)>| __m.begin()), - )); - let __end2: Value, Value)>> = - Rc::new(RefCell::new( - (equivalent.as_pointer() as Ptr, Value)>>) - .with(|__m: &Map, Value)>| __m.end()), - )); - 'loop_: while (*__begin2.borrow()) != (*__end2.borrow()) { - let entry: Ptr<(Value, Value)> = (*__begin2.borrow()).iter_deref(); + 'loop_: for __begin2 in IterRange::new( + (equivalent.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.begin()), + (equivalent.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.end()), + ) { + let entry: Ptr<(Value, Value)> = __begin2.iter_deref(); ok = { ((ok as i32) & ((({ (*(*entry.upgrade().deref()).0.borrow()).order } == 3) @@ -401,7 +391,6 @@ fn main_0() -> i32 { != 0 }; equivalent_count.prefix_inc(); - (*__begin2.borrow_mut()).iter_inc(); } ok = { ((ok as i32) & ((equivalent_count == 1_usize) as i32)) != 0 }; } diff --git a/tests/unit/out/refcount/unboxed_locals.rs b/tests/unit/out/refcount/unboxed_locals.rs index 51672aa9f..b66a40c95 100644 --- a/tests/unit/out/refcount/unboxed_locals.rs +++ b/tests/unit/out/refcount/unboxed_locals.rs @@ -22,16 +22,12 @@ pub struct Pair { } pub fn total_2(v: Ptr>) -> i32 { let mut s: i32 = 0; - let __begin1: Value> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( RandomAccessIterator::Vec((Ptr::>::decay(&(v)) as Ptr)), - )); - let __end1: Value> = Rc::new(RefCell::new( RandomAccessIterator::Vec((Ptr::>::decay(&(v)) as Ptr).to_end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { - let mut x: i32 = ((*__begin1.borrow()).iter_deref().read()); + ) { + let mut x: i32 = (__begin1.iter_deref().read()); s += x; - (*__begin1.borrow_mut()).iter_inc(); } return s; } diff --git a/tests/unit/out/refcount/vector3.rs b/tests/unit/out/refcount/vector3.rs index ecee50a70..5b477ee2b 100644 --- a/tests/unit/out/refcount/vector3.rs +++ b/tests/unit/out/refcount/vector3.rs @@ -29,70 +29,46 @@ fn main_0() -> i32 { index!(elem!((v.as_pointer() as Ptr>), 0_usize), 0_usize).write(1); index!(elem!((v.as_pointer() as Ptr>), 0_usize), 1_usize).write(5); index!(elem!((v.as_pointer() as Ptr>), 1_usize), 0_usize).write(6); - let __begin1: Value>> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr>)), - )); - let __end1: Value>> = Rc::new(RefCell::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr>).to_end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { - let v2: Ptr> = (*__begin1.borrow()).iter_deref(); - let __begin2: Value> = Rc::new(RefCell::new( + ) { + let v2: Ptr> = __begin1.iter_deref(); + 'loop_: for __begin2 in IterRange::new( RandomAccessIterator::Vec((Ptr::>::decay(&(v2)) as Ptr)), - )); - let __end2: Value> = Rc::new(RefCell::new( RandomAccessIterator::Vec((Ptr::>::decay(&(v2)) as Ptr).to_end()), - )); - 'loop_: while (*__begin2.borrow()) != (*__end2.borrow()) { - let i: Ptr = (*__begin2.borrow()).iter_deref(); + ) { + let i: Ptr = __begin2.iter_deref(); i.with_mut(|__v| __v.prefix_inc()); - (*__begin2.borrow_mut()).iter_inc(); } - (*__begin1.borrow_mut()).iter_inc(); } - let __begin1: Value>> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr>)), - )); - let __end1: Value>> = Rc::new(RefCell::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr>).to_end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { - let v2: Ptr> = (*__begin1.borrow()).iter_deref(); - let __begin2: Value> = Rc::new(RefCell::new( + ) { + let v2: Ptr> = __begin1.iter_deref(); + 'loop_: for __begin2 in IterRange::new( RandomAccessIterator::Vec((Ptr::>::decay(&(v2)) as Ptr)), - )); - let __end2: Value> = Rc::new(RefCell::new( RandomAccessIterator::Vec((Ptr::>::decay(&(v2)) as Ptr).to_end()), - )); - 'loop_: while (*__begin2.borrow()) != (*__end2.borrow()) { - let mut i: i32 = ((*__begin2.borrow()).iter_deref().read()); + ) { + let mut i: i32 = (__begin2.iter_deref().read()); println!("{}", (i + 3)); - (*__begin2.borrow_mut()).iter_inc(); } - (*__begin1.borrow_mut()).iter_inc(); } - let __begin1: Value>> = Rc::new(RefCell::new( + 'loop_: for __begin1 in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr>)), - )); - let __end1: Value>> = Rc::new(RefCell::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr>).to_end()), - )); - 'loop_: while (*__begin1.borrow()) != (*__end1.borrow()) { + ) { let v2: Value> = Rc::new(RefCell::new( - (*(*__begin1.borrow()).iter_deref().upgrade().deref()).clone(), + (*__begin1.iter_deref().upgrade().deref()).clone(), )); - let __begin2: Value> = Rc::new(RefCell::new( + 'loop_: for __begin2 in IterRange::new( RandomAccessIterator::Vec((v2.as_pointer() as Ptr)), - )); - let __end2: Value> = Rc::new(RefCell::new( RandomAccessIterator::Vec((v2.as_pointer() as Ptr).to_end()), - )); - 'loop_: while (*__begin2.borrow()) != (*__end2.borrow()) { - let mut i: i32 = ((*__begin2.borrow()).iter_deref().read()); + ) { + let mut i: i32 = (__begin2.iter_deref().read()); println!("{}", i); - (*__begin2.borrow_mut()).iter_inc(); } - (*__begin1.borrow_mut()).iter_inc(); } return 0; } diff --git a/tests/unit/out/unsafe/auto.rs b/tests/unit/out/unsafe/auto.rs index 0e48ca3c7..41d0ea81d 100644 --- a/tests/unit/out/unsafe/auto.rs +++ b/tests/unit/out/unsafe/auto.rs @@ -26,14 +26,12 @@ unsafe fn main_0() -> i32 { v.push(__a1) }; let mut sum: i32 = 0; - let mut __begin1: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); - let mut __end1: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), + ) { let mut elem: i32 = (*__begin1.iter_deref()); sum += elem; - __begin1.iter_inc(); } assert!(((sum) == (3))); return 0; diff --git a/tests/unit/out/unsafe/foreach.rs b/tests/unit/out/unsafe/foreach.rs index 5677f2b7f..600f9cc18 100644 --- a/tests/unit/out/unsafe/foreach.rs +++ b/tests/unit/out/unsafe/foreach.rs @@ -23,14 +23,12 @@ unsafe fn main_0() -> i32 { i.prefix_inc(); } let mut sum: i32 = 0; - let mut __begin1: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); - let mut __end1: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), + ) { let mut x: i32 = (*__begin1.iter_deref()); sum += x; - __begin1.iter_inc(); } assert!(((sum) == (45))); return 0; diff --git a/tests/unit/out/unsafe/foreach_disjoint_field_borrow.rs b/tests/unit/out/unsafe/foreach_disjoint_field_borrow.rs index 95c37df2a..eba015803 100644 --- a/tests/unit/out/unsafe/foreach_disjoint_field_borrow.rs +++ b/tests/unit/out/unsafe/foreach_disjoint_field_borrow.rs @@ -24,14 +24,12 @@ unsafe fn main_0() -> i32 { let __a1 = 1; s.v.push(__a1) }; - let mut __begin1: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(s.v.as_mut_ptr()); - let mut __end1: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(s.v.as_mut_ptr().add(s.v.len())); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec(s.v.as_mut_ptr()), + UnsafeRandomAccessIterator::Vec(s.v.as_mut_ptr().add(s.v.len())), + ) { let mut e: i32 = (*__begin1.iter_deref()); s.a.postfix_inc(); - __begin1.iter_inc(); } return 0; } diff --git a/tests/unit/out/unsafe/foreach_double.rs b/tests/unit/out/unsafe/foreach_double.rs index 8d95c09df..d0825a3ae 100644 --- a/tests/unit/out/unsafe/foreach_double.rs +++ b/tests/unit/out/unsafe/foreach_double.rs @@ -27,73 +27,57 @@ unsafe fn main_0() -> i32 { v.push(__a1) }; let mut square: i32 = 0; - let mut __begin1: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); - let mut __end1: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), + ) { let mut e1: i32 = (*__begin1.iter_deref()); - let mut __begin2: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); - let mut __end2: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); - 'loop_: while __begin2 != __end2 { + 'loop_: for __begin2 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), + ) { let mut e2: i32 = (*__begin2.iter_deref()); square += ((e1) * (e2)); - __begin2.iter_inc(); } - __begin1.iter_inc(); } - let mut __begin1: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); - let mut __end1: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), + ) { let e1: *mut i32 = &mut (*__begin1.iter_deref()); - let mut __begin2: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); - let mut __end2: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); - 'loop_: while __begin2 != __end2 { + 'loop_: for __begin2 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), + ) { let e2: *const i32 = &(*__begin2.iter_deref()); square += ((*e1) * (*e2)); - __begin2.iter_inc(); } - __begin1.iter_inc(); } - let mut __begin1: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); - let mut __end1: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), + ) { let e1: *const i32 = &(*__begin1.iter_deref()); - let mut __begin2: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); - let mut __end2: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); - 'loop_: while __begin2 != __end2 { + 'loop_: for __begin2 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), + ) { let e2: *mut i32 = &mut (*__begin2.iter_deref()); square += ((*e1) * (*e2)); - __begin2.iter_inc(); } - __begin1.iter_inc(); } - let mut __begin1: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); - let mut __end1: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), + ) { let e1: *mut i32 = &mut (*__begin1.iter_deref()); - let mut __begin2: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); - let mut __end2: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); - 'loop_: while __begin2 != __end2 { + 'loop_: for __begin2 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), + ) { let e2: *mut i32 = &mut (*__begin2.iter_deref()); square += ((*e1) * (*e2)); - __begin2.iter_inc(); } - __begin1.iter_inc(); } let mut m: Vec> = Vec::new(); let mut v1: Vec = Vec::new(); @@ -111,22 +95,18 @@ unsafe fn main_0() -> i32 { let __a1 = std::mem::take(&mut v3); m.push(__a1) }; - let mut __begin1: UnsafeRandomAccessIterator> = - UnsafeRandomAccessIterator::Vec(m.as_mut_ptr()); - let mut __end1: UnsafeRandomAccessIterator> = - UnsafeRandomAccessIterator::Vec(m.as_mut_ptr().add(m.len())); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec(m.as_mut_ptr()), + UnsafeRandomAccessIterator::Vec(m.as_mut_ptr().add(m.len())), + ) { let row: *mut Vec = &mut (*__begin1.iter_deref()); - let mut __begin2: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec((*row).as_mut_ptr()); - let mut __end2: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec((*row).as_mut_ptr().add((*row).len())); - 'loop_: while __begin2 != __end2 { + 'loop_: for __begin2 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec((*row).as_mut_ptr()), + UnsafeRandomAccessIterator::Vec((*row).as_mut_ptr().add((*row).len())), + ) { let col: *mut i32 = &mut (*__begin2.iter_deref()); square += (*col); - __begin2.iter_inc(); } - __begin1.iter_inc(); } assert!(((square) == (144))); return 0; diff --git a/tests/unit/out/unsafe/foreach_map.rs b/tests/unit/out/unsafe/foreach_map.rs index c200557da..2008534c5 100644 --- a/tests/unit/out/unsafe/foreach_map.rs +++ b/tests/unit/out/unsafe/foreach_map.rs @@ -25,35 +25,23 @@ unsafe fn main_0() -> i32 { }; } let mut sum: f64 = 0_f64; - let mut __begin1: UnsafeBidirectionalIterator<(i32, f64)> = m.begin(); - let mut __end1: UnsafeBidirectionalIterator<(i32, f64)> = m.end(); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new(m.begin(), m.end()) { let i: *const (i32, f64) = &(*__begin1.iter_deref()); sum += (*i).1; - __begin1.iter_inc(); } - let mut __begin1: UnsafeBidirectionalIterator<(i32, f64)> = m.begin(); - let mut __end1: UnsafeBidirectionalIterator<(i32, f64)> = m.end(); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new(m.begin(), m.end()) { let mut i: (i32, f64) = (*__begin1.iter_deref()).clone(); sum += (i.0 as f64); - __begin1.iter_inc(); } assert!(((sum) == (7475_f64))); - let mut __begin1: UnsafeBidirectionalIterator<(i32, f64)> = m.begin(); - let mut __end1: UnsafeBidirectionalIterator<(i32, f64)> = m.end(); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new(m.begin(), m.end()) { let mut i: (i32, f64) = (*__begin1.iter_deref()).clone(); i.1 = (-1_i32 as f64); assert!(((i.1) == (-1_i32 as f64))); - __begin1.iter_inc(); } - let mut __begin1: UnsafeBidirectionalIterator<(i32, f64)> = m.begin(); - let mut __end1: UnsafeBidirectionalIterator<(i32, f64)> = m.end(); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new(m.begin(), m.end()) { let i: *const (i32, f64) = &(*__begin1.iter_deref()); assert!((((*i).1) != (-1_i32 as f64))); - __begin1.iter_inc(); } return 0; } diff --git a/tests/unit/out/unsafe/foreach_mut.rs b/tests/unit/out/unsafe/foreach_mut.rs index 8a93938c9..2a9adeb9a 100644 --- a/tests/unit/out/unsafe/foreach_mut.rs +++ b/tests/unit/out/unsafe/foreach_mut.rs @@ -27,41 +27,33 @@ unsafe fn main_0() -> i32 { v1.push(__a1) }; let mut sum: i32 = 0; - let mut __begin1: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr()); - let mut __end1: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr().add(v1.len())); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr()), + UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr().add(v1.len())), + ) { let mut x: i32 = (*__begin1.iter_deref()); sum += x.prefix_inc(); - __begin1.iter_inc(); } - let mut __begin1: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr()); - let mut __end1: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr().add(v1.len())); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr()), + UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr().add(v1.len())), + ) { let x: i32 = (*__begin1.iter_deref()); sum += x; - __begin1.iter_inc(); } - let mut __begin1: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr()); - let mut __end1: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr().add(v1.len())); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr()), + UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr().add(v1.len())), + ) { let x: *mut i32 = &mut (*__begin1.iter_deref()); (*x) += 10; - __begin1.iter_inc(); } - let mut __begin1: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr()); - let mut __end1: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr().add(v1.len())); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr()), + UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr().add(v1.len())), + ) { let x: *const i32 = &(*__begin1.iter_deref()); sum += (*x); - __begin1.iter_inc(); } let mut v2: Vec<*mut i32> = Vec::new(); { @@ -76,41 +68,33 @@ unsafe fn main_0() -> i32 { let __a1 = (&mut v1[(2_usize)] as *mut i32); v2.push(__a1) }; - let mut __begin1: UnsafeRandomAccessIterator<*mut i32> = - UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()); - let mut __end1: UnsafeRandomAccessIterator<*mut i32> = - UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(v2.len())); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()), + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(v2.len())), + ) { let mut p: *mut i32 = (*__begin1.iter_deref()); (*p) += 5; - __begin1.iter_inc(); } - let mut __begin1: UnsafeRandomAccessIterator<*mut i32> = - UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()); - let mut __end1: UnsafeRandomAccessIterator<*mut i32> = - UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(v2.len())); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()), + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(v2.len())), + ) { let p: *mut i32 = (*__begin1.iter_deref()); sum += (*p); - __begin1.iter_inc(); } - let mut __begin1: UnsafeRandomAccessIterator<*mut i32> = - UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()); - let mut __end1: UnsafeRandomAccessIterator<*mut i32> = - UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(v2.len())); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()), + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(v2.len())), + ) { let mut p: *mut i32 = (*__begin1.iter_deref()); (*p) += 5; - __begin1.iter_inc(); } - let mut __begin1: UnsafeRandomAccessIterator<*mut i32> = - UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()); - let mut __end1: UnsafeRandomAccessIterator<*mut i32> = - UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(v2.len())); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()), + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(v2.len())), + ) { let mut p: *const i32 = (*__begin1.iter_deref()).cast_const(); sum += (*p); - __begin1.iter_inc(); } assert!(((sum) == (168))); return 0; diff --git a/tests/unit/out/unsafe/iterators.rs b/tests/unit/out/unsafe/iterators.rs index 33ad4f67c..4a3cb4488 100644 --- a/tests/unit/out/unsafe/iterators.rs +++ b/tests/unit/out/unsafe/iterators.rs @@ -17,26 +17,17 @@ unsafe fn main_0() -> i32 { let s = c"hello".as_ptr(); std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1).to_vec() }; - let mut __begin1: *mut libc::c_char = x.as_mut_ptr(); - let mut __end1: *mut libc::c_char = x.as_mut_ptr().add(x.len() - 1); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new(x.as_mut_ptr(), x.as_mut_ptr().add(x.len() - 1)) { let c: *mut libc::c_char = &mut (*__begin1.iter_deref()); (*c).prefix_inc(); - __begin1.iter_inc(); } - let mut __begin1: *mut libc::c_char = x.as_mut_ptr(); - let mut __end1: *mut libc::c_char = x.as_mut_ptr().add(x.len() - 1); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new(x.as_mut_ptr(), x.as_mut_ptr().add(x.len() - 1)) { let c: *mut libc::c_char = &mut (*__begin1.iter_deref()); (unsafe { libc::printf(c"%c\n".as_ptr() as *const libc::c_char, ((*c) as i32)) }); - __begin1.iter_inc(); } - let mut __begin1: *mut libc::c_char = x.as_mut_ptr(); - let mut __end1: *mut libc::c_char = x.as_mut_ptr().add(x.len() - 1); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new(x.as_mut_ptr(), x.as_mut_ptr().add(x.len() - 1)) { let mut c: libc::c_char = (*__begin1.iter_deref()); (unsafe { libc::printf(c"%c\n".as_ptr() as *const libc::c_char, (c as i32)) }); - __begin1.iter_inc(); } let mut v: Vec<*mut i32> = Vec::new(); { @@ -47,14 +38,12 @@ unsafe fn main_0() -> i32 { let __a1 = (Box::leak(Box::new(3)) as *mut i32); v.push(__a1) }; - let mut __begin1: UnsafeRandomAccessIterator<*mut i32> = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); - let mut __end1: UnsafeRandomAccessIterator<*mut i32> = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), + ) { let mut p: *mut i32 = (*__begin1.iter_deref()); (unsafe { libc::printf(c"%d\n".as_ptr() as *const libc::c_char, (*p)) }); - __begin1.iter_inc(); } return 0; } diff --git a/tests/unit/out/unsafe/map-reallocation.rs b/tests/unit/out/unsafe/map-reallocation.rs index 4ab689c8d..a83ebe3aa 100644 --- a/tests/unit/out/unsafe/map-reallocation.rs +++ b/tests/unit/out/unsafe/map-reallocation.rs @@ -58,13 +58,10 @@ unsafe fn main_0() -> i32 { assert!(((*p) == (57005))); assert!(((m.len()) == ((((N) + (1)) as u32) as usize))); let mut prev: i32 = -1_i32; - let mut __begin1: UnsafeBidirectionalIterator<(i32, i32)> = m.begin(); - let mut __end1: UnsafeBidirectionalIterator<(i32, i32)> = m.end(); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new(m.begin(), m.end()) { let pair: *mut (i32, i32) = &mut (*__begin1.iter_deref()); assert!((((*pair).0) > (prev))); prev = (*pair).0; - __begin1.iter_inc(); } return 0; } diff --git a/tests/unit/out/unsafe/map.rs b/tests/unit/out/unsafe/map.rs index 6700cfc8d..a408b08e7 100644 --- a/tests/unit/out/unsafe/map.rs +++ b/tests/unit/out/unsafe/map.rs @@ -191,14 +191,11 @@ unsafe fn main_0() -> i32 { } assert!(((m2.len()) == (indexes.len()))); let mut last: i32 = -1_i32; - let mut __begin1: UnsafeBidirectionalIterator<(i32, bool)> = m2.begin(); - let mut __end1: UnsafeBidirectionalIterator<(i32, bool)> = m2.end(); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new(m2.begin(), m2.end()) { let pair: *mut (i32, bool) = &mut (*__begin1.iter_deref()); assert!((((*pair).0) > (last))); assert!((((*pair).1 as i32) == (((*pair).0) % (2)))); last = (*pair).0; - __begin1.iter_inc(); } k = 0; let value_0: *const u32 = &raw const (*m.get(&(k as i16)).expect("out of range!")).1; diff --git a/tests/unit/out/unsafe/map_key_identity.rs b/tests/unit/out/unsafe/map_key_identity.rs index 373683a8a..46a778dc0 100644 --- a/tests/unit/out/unsafe/map_key_identity.rs +++ b/tests/unit/out/unsafe/map_key_identity.rs @@ -118,9 +118,7 @@ unsafe fn main_0() -> i32 { }) as i32)) != 0; let mut distinct_count: usize = 0_usize; - let mut __begin1: UnsafeBidirectionalIterator<(Key, Mapped)> = distinct.begin(); - let mut __end1: UnsafeBidirectionalIterator<(Key, Mapped)> = distinct.end(); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new(distinct.begin(), distinct.end()) { let entry: *const (Key, Mapped) = &(*__begin1.iter_deref()); if ((distinct_count) == (0_usize)) { ok = ((ok as i32) @@ -132,7 +130,6 @@ unsafe fn main_0() -> i32 { != 0; } distinct_count.prefix_inc(); - __begin1.iter_inc(); } ok = ((ok as i32) & (((distinct_count) == (2_usize)) as i32)) != 0; let equivalent_a: Key = Key { @@ -182,15 +179,12 @@ unsafe fn main_0() -> i32 { as i32)) != 0; let mut equivalent_count: usize = 0_usize; - let mut __begin2: UnsafeBidirectionalIterator<(Key, Mapped)> = equivalent.begin(); - let mut __end2: UnsafeBidirectionalIterator<(Key, Mapped)> = equivalent.end(); - 'loop_: while __begin2 != __end2 { + 'loop_: for __begin2 in UnsafeIterRange::new(equivalent.begin(), equivalent.end()) { let entry: *const (Key, Mapped) = &(*__begin2.iter_deref()); ok = ((ok as i32) & (((((*entry).0.order) == (3)) && (((*entry).1.value) == (31))) as i32)) != 0; equivalent_count.prefix_inc(); - __begin2.iter_inc(); } ok = ((ok as i32) & (((equivalent_count) == (1_usize)) as i32)) != 0; } diff --git a/tests/unit/out/unsafe/unboxed_locals.rs b/tests/unit/out/unsafe/unboxed_locals.rs index afe295962..2a12ae537 100644 --- a/tests/unit/out/unsafe/unboxed_locals.rs +++ b/tests/unit/out/unsafe/unboxed_locals.rs @@ -20,14 +20,12 @@ pub struct Pair { } pub unsafe fn total_2(v: *const Vec) -> i32 { let mut s: i32 = 0; - let mut __begin1: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec((*v).as_ptr().cast_mut()); - let mut __end1: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec((*v).as_ptr().add((*v).len()).cast_mut()); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec((*v).as_ptr().cast_mut()), + UnsafeRandomAccessIterator::Vec((*v).as_ptr().add((*v).len()).cast_mut()), + ) { let mut x: i32 = (*__begin1.iter_deref()); s += x; - __begin1.iter_inc(); } return s; } diff --git a/tests/unit/out/unsafe/vector3.rs b/tests/unit/out/unsafe/vector3.rs index d149c9fb0..d843874d9 100644 --- a/tests/unit/out/unsafe/vector3.rs +++ b/tests/unit/out/unsafe/vector3.rs @@ -29,56 +29,44 @@ unsafe fn main_0() -> i32 { v[(0_usize)][(0_usize)] = 1; v[(0_usize)][(1_usize)] = 5; v[(1_usize)][(0_usize)] = 6; - let mut __begin1: UnsafeRandomAccessIterator> = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); - let mut __end1: UnsafeRandomAccessIterator> = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), + ) { let v2: *mut Vec = &mut (*__begin1.iter_deref()); - let mut __begin2: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec((*v2).as_mut_ptr()); - let mut __end2: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec((*v2).as_mut_ptr().add((*v2).len())); - 'loop_: while __begin2 != __end2 { + 'loop_: for __begin2 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec((*v2).as_mut_ptr()), + UnsafeRandomAccessIterator::Vec((*v2).as_mut_ptr().add((*v2).len())), + ) { let i: *mut i32 = &mut (*__begin2.iter_deref()); (*i).prefix_inc(); - __begin2.iter_inc(); } - __begin1.iter_inc(); } - let mut __begin1: UnsafeRandomAccessIterator> = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); - let mut __end1: UnsafeRandomAccessIterator> = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), + ) { let v2: *mut Vec = &mut (*__begin1.iter_deref()); - let mut __begin2: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec((*v2).as_mut_ptr()); - let mut __end2: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec((*v2).as_mut_ptr().add((*v2).len())); - 'loop_: while __begin2 != __end2 { + 'loop_: for __begin2 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec((*v2).as_mut_ptr()), + UnsafeRandomAccessIterator::Vec((*v2).as_mut_ptr().add((*v2).len())), + ) { let mut i: i32 = (*__begin2.iter_deref()); (unsafe { libc::printf(c"%d\n".as_ptr() as *const libc::c_char, ((i) + (3))) }); - __begin2.iter_inc(); } - __begin1.iter_inc(); } - let mut __begin1: UnsafeRandomAccessIterator> = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); - let mut __end1: UnsafeRandomAccessIterator> = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); - 'loop_: while __begin1 != __end1 { + 'loop_: for __begin1 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), + UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), + ) { let mut v2: Vec = (*__begin1.iter_deref()).clone(); - let mut __begin2: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()); - let mut __end2: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(v2.len())); - 'loop_: while __begin2 != __end2 { + 'loop_: for __begin2 in UnsafeIterRange::new( + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()), + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(v2.len())), + ) { let mut i: i32 = (*__begin2.iter_deref()); (unsafe { libc::printf(c"%d\n".as_ptr() as *const libc::c_char, (i)) }); - __begin2.iter_inc(); } - __begin1.iter_inc(); } return 0; } From 36c96c80c1ca2a213268f1821fa22d2b26bdda9e Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 19 Oct 2026 15:46:16 +0100 Subject: [PATCH 3/7] Handle iterators in boxed vars analyser --- cpp2rust/converter/models/boxed_vars.cpp | 19 +++++++++++++++---- cpp2rust/converter/models/boxed_vars.h | 1 + .../converter/models/converter_refcount.cpp | 2 +- 3 files changed, 17 insertions(+), 5 deletions(-) diff --git a/cpp2rust/converter/models/boxed_vars.cpp b/cpp2rust/converter/models/boxed_vars.cpp index e64d6db84..916ad2ccf 100644 --- a/cpp2rust/converter/models/boxed_vars.cpp +++ b/cpp2rust/converter/models/boxed_vars.cpp @@ -95,8 +95,17 @@ class AddressTakenVisitor : public clang::RecursiveASTVisitor { public: AddressTakenVisitor(clang::ASTContext &ctx, - std::unordered_set &vars) - : ctx_(ctx), address_taken_(vars) {} + std::unordered_set &vars, + std::unordered_set &iterators) + : ctx_(ctx), address_taken_(vars), range_iterators_(iterators) {} + + bool VisitCXXForRangeStmt(clang::CXXForRangeStmt *stmt) { + if (auto *begin = stmt->getBeginStmt()) { + range_iterators_.insert( + clang::cast(begin->getSingleDecl())); + } + return true; + } bool shouldVisitTemplateInstantiations() const { return true; } @@ -249,18 +258,20 @@ class AddressTakenVisitor clang::ASTContext &ctx_; std::unordered_set &address_taken_; + std::unordered_set &range_iterators_; // The references to variables that only access their value. std::unordered_set value_uses_; }; } // namespace BoxedVars::BoxedVars(clang::ASTContext &ctx) : ctx_(ctx) { - AddressTakenVisitor(ctx, address_taken_) + AddressTakenVisitor(ctx, address_taken_, range_iterators_) .TraverseDecl(ctx.getTranslationUnitDecl()); } bool BoxedVars::contains(const clang::VarDecl *decl) const { - return !CanUnbox(ctx_, decl) || address_taken_.contains(decl); + return !range_iterators_.contains(decl) && + (!CanUnbox(ctx_, decl) || address_taken_.contains(decl)); } namespace { diff --git a/cpp2rust/converter/models/boxed_vars.h b/cpp2rust/converter/models/boxed_vars.h index 15e043e9c..d54baef97 100644 --- a/cpp2rust/converter/models/boxed_vars.h +++ b/cpp2rust/converter/models/boxed_vars.h @@ -28,6 +28,7 @@ class BoxedVars { private: clang::ASTContext &ctx_; std::unordered_set address_taken_; + std::unordered_set range_iterators_; }; // The reads of the value of variables in a returned expression that are the diff --git a/cpp2rust/converter/models/converter_refcount.cpp b/cpp2rust/converter/models/converter_refcount.cpp index a9b483fd8..42ea9d1fd 100644 --- a/cpp2rust/converter/models/converter_refcount.cpp +++ b/cpp2rust/converter/models/converter_refcount.cpp @@ -158,7 +158,7 @@ bool ConverterRefCount::NeedsMut(const clang::VarDecl *decl, bool ConverterRefCount::IsUnboxedVar(const clang::ValueDecl *decl) const { auto *var = clang::dyn_cast(decl); - return var && (var->isImplicit() || !boxed_vars_->contains(var)); + return var && !boxed_vars_->contains(var); } bool ConverterRefCount::IsUnboxedPlace(const clang::Expr *expr) const { From 8a44d365c9dc6203a99d5c5512783241a61c68c3 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 19 Oct 2026 15:51:33 +0100 Subject: [PATCH 4/7] Use the iter variable name for __begin --- cpp2rust/converter/converter.cpp | 1 + tests/unit/out/refcount/auto.rs | 4 +- tests/unit/out/refcount/foreach.rs | 4 +- .../refcount/foreach_disjoint_field_borrow.rs | 4 +- tests/unit/out/refcount/foreach_double.rs | 40 +++++++++---------- tests/unit/out/refcount/foreach_map.rs | 32 +++++---------- tests/unit/out/refcount/foreach_mut.rs | 32 +++++++-------- tests/unit/out/refcount/iterators.rs | 16 ++++---- tests/unit/out/refcount/map-reallocation.rs | 4 +- tests/unit/out/refcount/map.rs | 4 +- tests/unit/out/refcount/map_key_identity.rs | 8 ++-- tests/unit/out/refcount/unboxed_locals.rs | 4 +- tests/unit/out/refcount/vector3.rs | 27 ++++++------- tests/unit/out/unsafe/auto.rs | 4 +- tests/unit/out/unsafe/foreach.rs | 4 +- .../unsafe/foreach_disjoint_field_borrow.rs | 4 +- tests/unit/out/unsafe/foreach_double.rs | 40 +++++++++---------- tests/unit/out/unsafe/foreach_map.rs | 16 ++++---- tests/unit/out/unsafe/foreach_mut.rs | 32 +++++++-------- tests/unit/out/unsafe/iterators.rs | 16 ++++---- tests/unit/out/unsafe/map-reallocation.rs | 4 +- tests/unit/out/unsafe/map.rs | 4 +- tests/unit/out/unsafe/map_key_identity.rs | 8 ++-- tests/unit/out/unsafe/unboxed_locals.rs | 4 +- tests/unit/out/unsafe/vector3.rs | 24 +++++------ 25 files changed, 164 insertions(+), 176 deletions(-) diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp index d6a812e45..6629d1502 100644 --- a/cpp2rust/converter/converter.cpp +++ b/cpp2rust/converter/converter.cpp @@ -1498,6 +1498,7 @@ bool Converter::VisitCXXForRangeStmt(clang::CXXForRangeStmt *stmt) { auto *begin = clang::cast(stmt->getBeginStmt()->getSingleDecl()); auto *end = clang::cast(stmt->getEndStmt()->getSingleDecl()); + begin->setDeclName(stmt->getLoopVariable()->getDeclName()); StrCat("'loop_:"); StrCat(keyword::kFor, GetNamedDeclAsString(begin), keyword::kIn, IterRangeName(), "::new(", ConvertFreshRValue(begin->getInit()), diff --git a/tests/unit/out/refcount/auto.rs b/tests/unit/out/refcount/auto.rs index 785e2fc31..f675c212d 100644 --- a/tests/unit/out/refcount/auto.rs +++ b/tests/unit/out/refcount/auto.rs @@ -24,11 +24,11 @@ fn main_0() -> i32 { (*v.borrow_mut()).push(__a1) }; let mut sum: i32 = 0; - 'loop_: for __begin1 in IterRange::new( + 'loop_: for elem in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr)), RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), ) { - let mut elem: i32 = (__begin1.iter_deref().read()); + let mut elem: i32 = (elem.iter_deref().read()); sum += elem; } assert!((sum == 3)); diff --git a/tests/unit/out/refcount/foreach.rs b/tests/unit/out/refcount/foreach.rs index 472751d56..a7acd0a41 100644 --- a/tests/unit/out/refcount/foreach.rs +++ b/tests/unit/out/refcount/foreach.rs @@ -21,11 +21,11 @@ fn main_0() -> i32 { i.prefix_inc(); } let mut sum: i32 = 0; - 'loop_: for __begin1 in IterRange::new( + 'loop_: for x in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr)), RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), ) { - let mut x: i32 = (__begin1.iter_deref().read()); + let mut x: i32 = (x.iter_deref().read()); sum += x; } assert!((sum == 45)); diff --git a/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs b/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs index e4af19528..8ccdc239f 100644 --- a/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs +++ b/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs @@ -25,13 +25,13 @@ fn main_0() -> i32 { let __a1 = 1; (*s.borrow_mut()).v.push(__a1) }; - 'loop_: for __begin1 in IterRange::new( + 'loop_: for e in IterRange::new( RandomAccessIterator::Vec((field_ref!(s.as_pointer(), v).as_pointer() as Ptr)), RandomAccessIterator::Vec( (field_ref!(s.as_pointer(), v).as_pointer() as Ptr).to_end(), ), ) { - let mut e: i32 = (__begin1.iter_deref().read()); + let mut e: i32 = (e.iter_deref().read()); (*s.borrow_mut()).a.postfix_inc(); } return 0; diff --git a/tests/unit/out/refcount/foreach_double.rs b/tests/unit/out/refcount/foreach_double.rs index 544295f47..a34ba7363 100644 --- a/tests/unit/out/refcount/foreach_double.rs +++ b/tests/unit/out/refcount/foreach_double.rs @@ -25,55 +25,55 @@ fn main_0() -> i32 { (*v.borrow_mut()).push(__a1) }; let mut square: i32 = 0; - 'loop_: for __begin1 in IterRange::new( + 'loop_: for e1 in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr)), RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), ) { - let mut e1: i32 = (__begin1.iter_deref().read()); - 'loop_: for __begin2 in IterRange::new( + let mut e1: i32 = (e1.iter_deref().read()); + 'loop_: for e2 in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr)), RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), ) { - let mut e2: i32 = (__begin2.iter_deref().read()); + let mut e2: i32 = (e2.iter_deref().read()); square += (e1 * e2); } } - 'loop_: for __begin1 in IterRange::new( + 'loop_: for e1 in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr)), RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), ) { - let e1: Ptr = __begin1.iter_deref(); - 'loop_: for __begin2 in IterRange::new( + let e1: Ptr = e1.iter_deref(); + 'loop_: for e2 in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr)), RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), ) { - let e2: Ptr = __begin2.iter_deref(); + let e2: Ptr = e2.iter_deref(); square += { ({ (e1.read()) } * { (e2.read()) }) }; } } - 'loop_: for __begin1 in IterRange::new( + 'loop_: for e1 in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr)), RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), ) { - let e1: Ptr = __begin1.iter_deref(); - 'loop_: for __begin2 in IterRange::new( + let e1: Ptr = e1.iter_deref(); + 'loop_: for e2 in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr)), RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), ) { - let e2: Ptr = __begin2.iter_deref(); + let e2: Ptr = e2.iter_deref(); square += { ({ (e1.read()) } * { (e2.read()) }) }; } } - 'loop_: for __begin1 in IterRange::new( + 'loop_: for e1 in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr)), RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), ) { - let e1: Ptr = __begin1.iter_deref(); - 'loop_: for __begin2 in IterRange::new( + let e1: Ptr = e1.iter_deref(); + 'loop_: for e2 in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr)), RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), ) { - let e2: Ptr = __begin2.iter_deref(); + let e2: Ptr = e2.iter_deref(); square += { ({ (e1.read()) } * { (e2.read()) }) }; } } @@ -93,16 +93,16 @@ fn main_0() -> i32 { let __a1 = std::mem::take(&mut (*v3.borrow_mut())); (*m.borrow_mut()).push(__a1) }; - 'loop_: for __begin1 in IterRange::new( + 'loop_: for row in IterRange::new( RandomAccessIterator::Vec((m.as_pointer() as Ptr>)), RandomAccessIterator::Vec((m.as_pointer() as Ptr>).to_end()), ) { - let row: Ptr> = __begin1.iter_deref(); - 'loop_: for __begin2 in IterRange::new( + let row: Ptr> = row.iter_deref(); + 'loop_: for col in IterRange::new( RandomAccessIterator::Vec((Ptr::>::decay(&(row)) as Ptr)), RandomAccessIterator::Vec((Ptr::>::decay(&(row)) as Ptr).to_end()), ) { - let col: Ptr = __begin2.iter_deref(); + let col: Ptr = col.iter_deref(); square += { (col.read()) }; } } diff --git a/tests/unit/out/refcount/foreach_map.rs b/tests/unit/out/refcount/foreach_map.rs index c4016f524..f5a23ac6c 100644 --- a/tests/unit/out/refcount/foreach_map.rs +++ b/tests/unit/out/refcount/foreach_map.rs @@ -34,16 +34,16 @@ fn main_0() -> i32 { }; } let mut sum: f64 = 0_f64; - 'loop_: for __begin1 in IterRange::new( + 'loop_: for i in IterRange::new( (m.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.begin()), (m.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.end()), ) { - let i: Ptr<(Value, Value)> = __begin1.iter_deref(); + let i: Ptr<(Value, Value)> = i.iter_deref(); sum += (*(*i.upgrade().deref()).1.borrow()); } - 'loop_: for __begin1 in IterRange::new( + 'loop_: for i in IterRange::new( (m.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.begin()), (m.as_pointer() as Ptr, Value)>>) @@ -51,22 +51,16 @@ fn main_0() -> i32 { ) { let i: Value<(Value, Value)> = Rc::new(RefCell::new(( Rc::new(RefCell::new( - (*__begin1.iter_deref().upgrade().deref()) - .0 - .borrow() - .clone(), + (*i.iter_deref().upgrade().deref()).0.borrow().clone(), )), Rc::new(RefCell::new( - (*__begin1.iter_deref().upgrade().deref()) - .1 - .borrow() - .clone(), + (*i.iter_deref().upgrade().deref()).1.borrow().clone(), )), ))); sum += ((*(*i.borrow()).0.borrow()) as f64); } assert!((sum == 7475_f64)); - 'loop_: for __begin1 in IterRange::new( + 'loop_: for i in IterRange::new( (m.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.begin()), (m.as_pointer() as Ptr, Value)>>) @@ -74,28 +68,22 @@ fn main_0() -> i32 { ) { let i: Value<(Value, Value)> = Rc::new(RefCell::new(( Rc::new(RefCell::new( - (*__begin1.iter_deref().upgrade().deref()) - .0 - .borrow() - .clone(), + (*i.iter_deref().upgrade().deref()).0.borrow().clone(), )), Rc::new(RefCell::new( - (*__begin1.iter_deref().upgrade().deref()) - .1 - .borrow() - .clone(), + (*i.iter_deref().upgrade().deref()).1.borrow().clone(), )), ))); (*(*i.borrow()).1.borrow_mut()) = (-1_i32 as f64); assert!(((*(*i.borrow()).1.borrow()) == (-1_i32 as f64))); } - 'loop_: for __begin1 in IterRange::new( + 'loop_: for i in IterRange::new( (m.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.begin()), (m.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.end()), ) { - let i: Ptr<(Value, Value)> = __begin1.iter_deref(); + let i: Ptr<(Value, Value)> = i.iter_deref(); assert!(((*(*i.upgrade().deref()).1.borrow()) != (-1_i32 as f64))); } return 0; diff --git a/tests/unit/out/refcount/foreach_mut.rs b/tests/unit/out/refcount/foreach_mut.rs index 1e7ee2e6e..8dc505be2 100644 --- a/tests/unit/out/refcount/foreach_mut.rs +++ b/tests/unit/out/refcount/foreach_mut.rs @@ -25,34 +25,34 @@ fn main_0() -> i32 { (*v1.borrow_mut()).push(__a1) }; let mut sum: i32 = 0; - 'loop_: for __begin1 in IterRange::new( + 'loop_: for x in IterRange::new( RandomAccessIterator::Vec((v1.as_pointer() as Ptr)), RandomAccessIterator::Vec((v1.as_pointer() as Ptr).to_end()), ) { - let mut x: i32 = (__begin1.iter_deref().read()); + let mut x: i32 = (x.iter_deref().read()); sum += x.prefix_inc(); } - 'loop_: for __begin1 in IterRange::new( + 'loop_: for x in IterRange::new( RandomAccessIterator::Vec((v1.as_pointer() as Ptr)), RandomAccessIterator::Vec((v1.as_pointer() as Ptr).to_end()), ) { - let mut x: i32 = (__begin1.iter_deref().read()); + let mut x: i32 = (x.iter_deref().read()); sum += x; } - 'loop_: for __begin1 in IterRange::new( + 'loop_: for x in IterRange::new( RandomAccessIterator::Vec((v1.as_pointer() as Ptr)), RandomAccessIterator::Vec((v1.as_pointer() as Ptr).to_end()), ) { - let x: Ptr = __begin1.iter_deref(); + let x: Ptr = x.iter_deref(); { x.with_mut(|__v| *__v = *__v + 10) }; } - 'loop_: for __begin1 in IterRange::new( + 'loop_: for x in IterRange::new( RandomAccessIterator::Vec((v1.as_pointer() as Ptr)), RandomAccessIterator::Vec((v1.as_pointer() as Ptr).to_end()), ) { - let x: Ptr = __begin1.iter_deref(); + let x: Ptr = x.iter_deref(); sum += { (x.read()) }; } let v2: Value>> = Rc::new(RefCell::new(Vec::new())); @@ -68,36 +68,36 @@ fn main_0() -> i32 { let __a1 = ((v1.as_pointer() as Ptr).offset(2_usize)); (*v2.borrow_mut()).push(__a1) }; - 'loop_: for __begin1 in IterRange::new( + 'loop_: for p in IterRange::new( RandomAccessIterator::Vec((v2.as_pointer() as Ptr>)), RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).to_end()), ) { - let mut p: Ptr = (__begin1.iter_deref().read()); + let mut p: Ptr = (p.iter_deref().read()); { p.with_mut(|__v| *__v = *__v + 5) }; } - 'loop_: for __begin1 in IterRange::new( + 'loop_: for p in IterRange::new( RandomAccessIterator::Vec((v2.as_pointer() as Ptr>)), RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).to_end()), ) { - let mut p: Ptr = (__begin1.iter_deref().read()); + let mut p: Ptr = (p.iter_deref().read()); sum += { (p.read()) }; } - 'loop_: for __begin1 in IterRange::new( + 'loop_: for p in IterRange::new( RandomAccessIterator::Vec((v2.as_pointer() as Ptr>)), RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).to_end()), ) { - let mut p: Ptr = (__begin1.iter_deref().read()); + let mut p: Ptr = (p.iter_deref().read()); { p.with_mut(|__v| *__v = *__v + 5) }; } - 'loop_: for __begin1 in IterRange::new( + 'loop_: for p in IterRange::new( RandomAccessIterator::Vec((v2.as_pointer() as Ptr>)), RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).to_end()), ) { - let mut p: Ptr = (__begin1.iter_deref().read()); + let mut p: Ptr = (p.iter_deref().read()); sum += { (p.read()) }; } assert!((sum == 168)); diff --git a/tests/unit/out/refcount/iterators.rs b/tests/unit/out/refcount/iterators.rs index ed09ac217..822e170a8 100644 --- a/tests/unit/out/refcount/iterators.rs +++ b/tests/unit/out/refcount/iterators.rs @@ -16,25 +16,25 @@ fn main_0() -> i32 { __bytes.push(0); __bytes })); - 'loop_: for __begin1 in IterRange::new( + 'loop_: for c in IterRange::new( (x.as_pointer() as Ptr), (x.as_pointer() as Ptr).to_last(), ) { - let c: Ptr = __begin1.iter_deref(); + let c: Ptr = c.iter_deref(); c.with_mut(|__v| __v.prefix_inc()); } - 'loop_: for __begin1 in IterRange::new( + 'loop_: for c in IterRange::new( (x.as_pointer() as Ptr), (x.as_pointer() as Ptr).to_last(), ) { - let c: Ptr = __begin1.iter_deref(); + let c: Ptr = c.iter_deref(); println!("{}", ((c.read()) as i32) as u8 as char); } - 'loop_: for __begin1 in IterRange::new( + 'loop_: for c in IterRange::new( (x.as_pointer() as Ptr), (x.as_pointer() as Ptr).to_last(), ) { - let mut c: i8 = (__begin1.iter_deref().read()); + let mut c: i8 = (c.iter_deref().read()); println!("{}", (c as i32) as u8 as char); } let v: Value>> = Rc::new(RefCell::new(Vec::new())); @@ -46,11 +46,11 @@ fn main_0() -> i32 { let __a1 = Ptr::alloc(3); (*v.borrow_mut()).push(__a1) }; - 'loop_: for __begin1 in IterRange::new( + 'loop_: for p in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr>)), RandomAccessIterator::Vec((v.as_pointer() as Ptr>).to_end()), ) { - let mut p: Ptr = (__begin1.iter_deref().read()); + let mut p: Ptr = (p.iter_deref().read()); println!("{}", (p.read())); } return 0; diff --git a/tests/unit/out/refcount/map-reallocation.rs b/tests/unit/out/refcount/map-reallocation.rs index 1ec5bd45c..5f407c2bd 100644 --- a/tests/unit/out/refcount/map-reallocation.rs +++ b/tests/unit/out/refcount/map-reallocation.rs @@ -128,13 +128,13 @@ fn main_0() -> i32 { assert!(((p.read()) == 57005)); assert!(((*m.borrow()).len() == (((N + 1) as u32) as usize))); let mut prev: i32 = -1_i32; - 'loop_: for __begin1 in IterRange::new( + 'loop_: for pair in IterRange::new( (m.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.begin()), (m.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.end()), ) { - let pair: Ptr<(Value, Value)> = __begin1.iter_deref(); + let pair: Ptr<(Value, Value)> = pair.iter_deref(); assert!(({ (*(*pair.upgrade().deref()).0.borrow()) } > { prev })); prev = (*(*pair.upgrade().deref()).0.borrow()); } diff --git a/tests/unit/out/refcount/map.rs b/tests/unit/out/refcount/map.rs index 6a8ccb117..490a32f41 100644 --- a/tests/unit/out/refcount/map.rs +++ b/tests/unit/out/refcount/map.rs @@ -667,13 +667,13 @@ fn main_0() -> i32 { } assert!(((*m2.borrow()).len() == indexes.len())); let mut last: i32 = -1_i32; - 'loop_: for __begin1 in IterRange::new( + 'loop_: for pair in IterRange::new( (m2.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.begin()), (m2.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.end()), ) { - let pair: Ptr<(Value, Value)> = __begin1.iter_deref(); + let pair: Ptr<(Value, Value)> = pair.iter_deref(); assert!(({ (*(*pair.upgrade().deref()).0.borrow()) } > { last })); assert!( ({ ((*(*pair.upgrade().deref()).1.borrow()) as i32) } == { diff --git a/tests/unit/out/refcount/map_key_identity.rs b/tests/unit/out/refcount/map_key_identity.rs index 3992b2517..d6c75770b 100644 --- a/tests/unit/out/refcount/map_key_identity.rs +++ b/tests/unit/out/refcount/map_key_identity.rs @@ -229,13 +229,13 @@ fn main_0() -> i32 { ok = rhs_0 }; let mut distinct_count: usize = 0_usize; - 'loop_: for __begin1 in IterRange::new( + 'loop_: for entry in IterRange::new( (distinct.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.begin()), (distinct.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.end()), ) { - let entry: Ptr<(Value, Value)> = __begin1.iter_deref(); + let entry: Ptr<(Value, Value)> = entry.iter_deref(); if (distinct_count == 0_usize) { ok = { ((ok as i32) @@ -376,13 +376,13 @@ fn main_0() -> i32 { ok = rhs_0 }; let mut equivalent_count: usize = 0_usize; - 'loop_: for __begin2 in IterRange::new( + 'loop_: for entry in IterRange::new( (equivalent.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.begin()), (equivalent.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.end()), ) { - let entry: Ptr<(Value, Value)> = __begin2.iter_deref(); + let entry: Ptr<(Value, Value)> = entry.iter_deref(); ok = { ((ok as i32) & ((({ (*(*entry.upgrade().deref()).0.borrow()).order } == 3) diff --git a/tests/unit/out/refcount/unboxed_locals.rs b/tests/unit/out/refcount/unboxed_locals.rs index b66a40c95..a4d2eb5bd 100644 --- a/tests/unit/out/refcount/unboxed_locals.rs +++ b/tests/unit/out/refcount/unboxed_locals.rs @@ -22,11 +22,11 @@ pub struct Pair { } pub fn total_2(v: Ptr>) -> i32 { let mut s: i32 = 0; - 'loop_: for __begin1 in IterRange::new( + 'loop_: for x in IterRange::new( RandomAccessIterator::Vec((Ptr::>::decay(&(v)) as Ptr)), RandomAccessIterator::Vec((Ptr::>::decay(&(v)) as Ptr).to_end()), ) { - let mut x: i32 = (__begin1.iter_deref().read()); + let mut x: i32 = (x.iter_deref().read()); s += x; } return s; diff --git a/tests/unit/out/refcount/vector3.rs b/tests/unit/out/refcount/vector3.rs index 5b477ee2b..2b5ec9579 100644 --- a/tests/unit/out/refcount/vector3.rs +++ b/tests/unit/out/refcount/vector3.rs @@ -29,44 +29,43 @@ fn main_0() -> i32 { index!(elem!((v.as_pointer() as Ptr>), 0_usize), 0_usize).write(1); index!(elem!((v.as_pointer() as Ptr>), 0_usize), 1_usize).write(5); index!(elem!((v.as_pointer() as Ptr>), 1_usize), 0_usize).write(6); - 'loop_: for __begin1 in IterRange::new( + 'loop_: for v2 in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr>)), RandomAccessIterator::Vec((v.as_pointer() as Ptr>).to_end()), ) { - let v2: Ptr> = __begin1.iter_deref(); - 'loop_: for __begin2 in IterRange::new( + let v2: Ptr> = v2.iter_deref(); + 'loop_: for i in IterRange::new( RandomAccessIterator::Vec((Ptr::>::decay(&(v2)) as Ptr)), RandomAccessIterator::Vec((Ptr::>::decay(&(v2)) as Ptr).to_end()), ) { - let i: Ptr = __begin2.iter_deref(); + let i: Ptr = i.iter_deref(); i.with_mut(|__v| __v.prefix_inc()); } } - 'loop_: for __begin1 in IterRange::new( + 'loop_: for v2 in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr>)), RandomAccessIterator::Vec((v.as_pointer() as Ptr>).to_end()), ) { - let v2: Ptr> = __begin1.iter_deref(); - 'loop_: for __begin2 in IterRange::new( + let v2: Ptr> = v2.iter_deref(); + 'loop_: for i in IterRange::new( RandomAccessIterator::Vec((Ptr::>::decay(&(v2)) as Ptr)), RandomAccessIterator::Vec((Ptr::>::decay(&(v2)) as Ptr).to_end()), ) { - let mut i: i32 = (__begin2.iter_deref().read()); + let mut i: i32 = (i.iter_deref().read()); println!("{}", (i + 3)); } } - 'loop_: for __begin1 in IterRange::new( + 'loop_: for v2 in IterRange::new( RandomAccessIterator::Vec((v.as_pointer() as Ptr>)), RandomAccessIterator::Vec((v.as_pointer() as Ptr>).to_end()), ) { - let v2: Value> = Rc::new(RefCell::new( - (*__begin1.iter_deref().upgrade().deref()).clone(), - )); - 'loop_: for __begin2 in IterRange::new( + let v2: Value> = + Rc::new(RefCell::new((*v2.iter_deref().upgrade().deref()).clone())); + 'loop_: for i in IterRange::new( RandomAccessIterator::Vec((v2.as_pointer() as Ptr)), RandomAccessIterator::Vec((v2.as_pointer() as Ptr).to_end()), ) { - let mut i: i32 = (__begin2.iter_deref().read()); + let mut i: i32 = (i.iter_deref().read()); println!("{}", i); } } diff --git a/tests/unit/out/unsafe/auto.rs b/tests/unit/out/unsafe/auto.rs index 41d0ea81d..ec99d0772 100644 --- a/tests/unit/out/unsafe/auto.rs +++ b/tests/unit/out/unsafe/auto.rs @@ -26,11 +26,11 @@ unsafe fn main_0() -> i32 { v.push(__a1) }; let mut sum: i32 = 0; - 'loop_: for __begin1 in UnsafeIterRange::new( + 'loop_: for elem in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), ) { - let mut elem: i32 = (*__begin1.iter_deref()); + let mut elem: i32 = (*elem.iter_deref()); sum += elem; } assert!(((sum) == (3))); diff --git a/tests/unit/out/unsafe/foreach.rs b/tests/unit/out/unsafe/foreach.rs index 600f9cc18..4d44741fb 100644 --- a/tests/unit/out/unsafe/foreach.rs +++ b/tests/unit/out/unsafe/foreach.rs @@ -23,11 +23,11 @@ unsafe fn main_0() -> i32 { i.prefix_inc(); } let mut sum: i32 = 0; - 'loop_: for __begin1 in UnsafeIterRange::new( + 'loop_: for x in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), ) { - let mut x: i32 = (*__begin1.iter_deref()); + let mut x: i32 = (*x.iter_deref()); sum += x; } assert!(((sum) == (45))); diff --git a/tests/unit/out/unsafe/foreach_disjoint_field_borrow.rs b/tests/unit/out/unsafe/foreach_disjoint_field_borrow.rs index eba015803..a7e3ae5aa 100644 --- a/tests/unit/out/unsafe/foreach_disjoint_field_borrow.rs +++ b/tests/unit/out/unsafe/foreach_disjoint_field_borrow.rs @@ -24,11 +24,11 @@ unsafe fn main_0() -> i32 { let __a1 = 1; s.v.push(__a1) }; - 'loop_: for __begin1 in UnsafeIterRange::new( + 'loop_: for e in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec(s.v.as_mut_ptr()), UnsafeRandomAccessIterator::Vec(s.v.as_mut_ptr().add(s.v.len())), ) { - let mut e: i32 = (*__begin1.iter_deref()); + let mut e: i32 = (*e.iter_deref()); s.a.postfix_inc(); } return 0; diff --git a/tests/unit/out/unsafe/foreach_double.rs b/tests/unit/out/unsafe/foreach_double.rs index d0825a3ae..3355e50fe 100644 --- a/tests/unit/out/unsafe/foreach_double.rs +++ b/tests/unit/out/unsafe/foreach_double.rs @@ -27,55 +27,55 @@ unsafe fn main_0() -> i32 { v.push(__a1) }; let mut square: i32 = 0; - 'loop_: for __begin1 in UnsafeIterRange::new( + 'loop_: for e1 in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), ) { - let mut e1: i32 = (*__begin1.iter_deref()); - 'loop_: for __begin2 in UnsafeIterRange::new( + let mut e1: i32 = (*e1.iter_deref()); + 'loop_: for e2 in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), ) { - let mut e2: i32 = (*__begin2.iter_deref()); + let mut e2: i32 = (*e2.iter_deref()); square += ((e1) * (e2)); } } - 'loop_: for __begin1 in UnsafeIterRange::new( + 'loop_: for e1 in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), ) { - let e1: *mut i32 = &mut (*__begin1.iter_deref()); - 'loop_: for __begin2 in UnsafeIterRange::new( + let e1: *mut i32 = &mut (*e1.iter_deref()); + 'loop_: for e2 in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), ) { - let e2: *const i32 = &(*__begin2.iter_deref()); + let e2: *const i32 = &(*e2.iter_deref()); square += ((*e1) * (*e2)); } } - 'loop_: for __begin1 in UnsafeIterRange::new( + 'loop_: for e1 in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), ) { - let e1: *const i32 = &(*__begin1.iter_deref()); - 'loop_: for __begin2 in UnsafeIterRange::new( + let e1: *const i32 = &(*e1.iter_deref()); + 'loop_: for e2 in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), ) { - let e2: *mut i32 = &mut (*__begin2.iter_deref()); + let e2: *mut i32 = &mut (*e2.iter_deref()); square += ((*e1) * (*e2)); } } - 'loop_: for __begin1 in UnsafeIterRange::new( + 'loop_: for e1 in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), ) { - let e1: *mut i32 = &mut (*__begin1.iter_deref()); - 'loop_: for __begin2 in UnsafeIterRange::new( + let e1: *mut i32 = &mut (*e1.iter_deref()); + 'loop_: for e2 in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), ) { - let e2: *mut i32 = &mut (*__begin2.iter_deref()); + let e2: *mut i32 = &mut (*e2.iter_deref()); square += ((*e1) * (*e2)); } } @@ -95,16 +95,16 @@ unsafe fn main_0() -> i32 { let __a1 = std::mem::take(&mut v3); m.push(__a1) }; - 'loop_: for __begin1 in UnsafeIterRange::new( + 'loop_: for row in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec(m.as_mut_ptr()), UnsafeRandomAccessIterator::Vec(m.as_mut_ptr().add(m.len())), ) { - let row: *mut Vec = &mut (*__begin1.iter_deref()); - 'loop_: for __begin2 in UnsafeIterRange::new( + let row: *mut Vec = &mut (*row.iter_deref()); + 'loop_: for col in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec((*row).as_mut_ptr()), UnsafeRandomAccessIterator::Vec((*row).as_mut_ptr().add((*row).len())), ) { - let col: *mut i32 = &mut (*__begin2.iter_deref()); + let col: *mut i32 = &mut (*col.iter_deref()); square += (*col); } } diff --git a/tests/unit/out/unsafe/foreach_map.rs b/tests/unit/out/unsafe/foreach_map.rs index 2008534c5..f866932a7 100644 --- a/tests/unit/out/unsafe/foreach_map.rs +++ b/tests/unit/out/unsafe/foreach_map.rs @@ -25,22 +25,22 @@ unsafe fn main_0() -> i32 { }; } let mut sum: f64 = 0_f64; - 'loop_: for __begin1 in UnsafeIterRange::new(m.begin(), m.end()) { - let i: *const (i32, f64) = &(*__begin1.iter_deref()); + 'loop_: for i in UnsafeIterRange::new(m.begin(), m.end()) { + let i: *const (i32, f64) = &(*i.iter_deref()); sum += (*i).1; } - 'loop_: for __begin1 in UnsafeIterRange::new(m.begin(), m.end()) { - let mut i: (i32, f64) = (*__begin1.iter_deref()).clone(); + 'loop_: for i in UnsafeIterRange::new(m.begin(), m.end()) { + let mut i: (i32, f64) = (*i.iter_deref()).clone(); sum += (i.0 as f64); } assert!(((sum) == (7475_f64))); - 'loop_: for __begin1 in UnsafeIterRange::new(m.begin(), m.end()) { - let mut i: (i32, f64) = (*__begin1.iter_deref()).clone(); + 'loop_: for i in UnsafeIterRange::new(m.begin(), m.end()) { + let mut i: (i32, f64) = (*i.iter_deref()).clone(); i.1 = (-1_i32 as f64); assert!(((i.1) == (-1_i32 as f64))); } - 'loop_: for __begin1 in UnsafeIterRange::new(m.begin(), m.end()) { - let i: *const (i32, f64) = &(*__begin1.iter_deref()); + 'loop_: for i in UnsafeIterRange::new(m.begin(), m.end()) { + let i: *const (i32, f64) = &(*i.iter_deref()); assert!((((*i).1) != (-1_i32 as f64))); } return 0; diff --git a/tests/unit/out/unsafe/foreach_mut.rs b/tests/unit/out/unsafe/foreach_mut.rs index 2a9adeb9a..126986f52 100644 --- a/tests/unit/out/unsafe/foreach_mut.rs +++ b/tests/unit/out/unsafe/foreach_mut.rs @@ -27,32 +27,32 @@ unsafe fn main_0() -> i32 { v1.push(__a1) }; let mut sum: i32 = 0; - 'loop_: for __begin1 in UnsafeIterRange::new( + 'loop_: for x in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr()), UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr().add(v1.len())), ) { - let mut x: i32 = (*__begin1.iter_deref()); + let mut x: i32 = (*x.iter_deref()); sum += x.prefix_inc(); } - 'loop_: for __begin1 in UnsafeIterRange::new( + 'loop_: for x in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr()), UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr().add(v1.len())), ) { - let x: i32 = (*__begin1.iter_deref()); + let x: i32 = (*x.iter_deref()); sum += x; } - 'loop_: for __begin1 in UnsafeIterRange::new( + 'loop_: for x in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr()), UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr().add(v1.len())), ) { - let x: *mut i32 = &mut (*__begin1.iter_deref()); + let x: *mut i32 = &mut (*x.iter_deref()); (*x) += 10; } - 'loop_: for __begin1 in UnsafeIterRange::new( + 'loop_: for x in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr()), UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr().add(v1.len())), ) { - let x: *const i32 = &(*__begin1.iter_deref()); + let x: *const i32 = &(*x.iter_deref()); sum += (*x); } let mut v2: Vec<*mut i32> = Vec::new(); @@ -68,32 +68,32 @@ unsafe fn main_0() -> i32 { let __a1 = (&mut v1[(2_usize)] as *mut i32); v2.push(__a1) }; - 'loop_: for __begin1 in UnsafeIterRange::new( + 'loop_: for p in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()), UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(v2.len())), ) { - let mut p: *mut i32 = (*__begin1.iter_deref()); + let mut p: *mut i32 = (*p.iter_deref()); (*p) += 5; } - 'loop_: for __begin1 in UnsafeIterRange::new( + 'loop_: for p in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()), UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(v2.len())), ) { - let p: *mut i32 = (*__begin1.iter_deref()); + let p: *mut i32 = (*p.iter_deref()); sum += (*p); } - 'loop_: for __begin1 in UnsafeIterRange::new( + 'loop_: for p in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()), UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(v2.len())), ) { - let mut p: *mut i32 = (*__begin1.iter_deref()); + let mut p: *mut i32 = (*p.iter_deref()); (*p) += 5; } - 'loop_: for __begin1 in UnsafeIterRange::new( + 'loop_: for p in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()), UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(v2.len())), ) { - let mut p: *const i32 = (*__begin1.iter_deref()).cast_const(); + let mut p: *const i32 = (*p.iter_deref()).cast_const(); sum += (*p); } assert!(((sum) == (168))); diff --git a/tests/unit/out/unsafe/iterators.rs b/tests/unit/out/unsafe/iterators.rs index 4a3cb4488..e80197bf9 100644 --- a/tests/unit/out/unsafe/iterators.rs +++ b/tests/unit/out/unsafe/iterators.rs @@ -17,16 +17,16 @@ unsafe fn main_0() -> i32 { let s = c"hello".as_ptr(); std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1).to_vec() }; - 'loop_: for __begin1 in UnsafeIterRange::new(x.as_mut_ptr(), x.as_mut_ptr().add(x.len() - 1)) { - let c: *mut libc::c_char = &mut (*__begin1.iter_deref()); + 'loop_: for c in UnsafeIterRange::new(x.as_mut_ptr(), x.as_mut_ptr().add(x.len() - 1)) { + let c: *mut libc::c_char = &mut (*c.iter_deref()); (*c).prefix_inc(); } - 'loop_: for __begin1 in UnsafeIterRange::new(x.as_mut_ptr(), x.as_mut_ptr().add(x.len() - 1)) { - let c: *mut libc::c_char = &mut (*__begin1.iter_deref()); + 'loop_: for c in UnsafeIterRange::new(x.as_mut_ptr(), x.as_mut_ptr().add(x.len() - 1)) { + let c: *mut libc::c_char = &mut (*c.iter_deref()); (unsafe { libc::printf(c"%c\n".as_ptr() as *const libc::c_char, ((*c) as i32)) }); } - 'loop_: for __begin1 in UnsafeIterRange::new(x.as_mut_ptr(), x.as_mut_ptr().add(x.len() - 1)) { - let mut c: libc::c_char = (*__begin1.iter_deref()); + 'loop_: for c in UnsafeIterRange::new(x.as_mut_ptr(), x.as_mut_ptr().add(x.len() - 1)) { + let mut c: libc::c_char = (*c.iter_deref()); (unsafe { libc::printf(c"%c\n".as_ptr() as *const libc::c_char, (c as i32)) }); } let mut v: Vec<*mut i32> = Vec::new(); @@ -38,11 +38,11 @@ unsafe fn main_0() -> i32 { let __a1 = (Box::leak(Box::new(3)) as *mut i32); v.push(__a1) }; - 'loop_: for __begin1 in UnsafeIterRange::new( + 'loop_: for p in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), ) { - let mut p: *mut i32 = (*__begin1.iter_deref()); + let mut p: *mut i32 = (*p.iter_deref()); (unsafe { libc::printf(c"%d\n".as_ptr() as *const libc::c_char, (*p)) }); } return 0; diff --git a/tests/unit/out/unsafe/map-reallocation.rs b/tests/unit/out/unsafe/map-reallocation.rs index a83ebe3aa..cd901948d 100644 --- a/tests/unit/out/unsafe/map-reallocation.rs +++ b/tests/unit/out/unsafe/map-reallocation.rs @@ -58,8 +58,8 @@ unsafe fn main_0() -> i32 { assert!(((*p) == (57005))); assert!(((m.len()) == ((((N) + (1)) as u32) as usize))); let mut prev: i32 = -1_i32; - 'loop_: for __begin1 in UnsafeIterRange::new(m.begin(), m.end()) { - let pair: *mut (i32, i32) = &mut (*__begin1.iter_deref()); + 'loop_: for pair in UnsafeIterRange::new(m.begin(), m.end()) { + let pair: *mut (i32, i32) = &mut (*pair.iter_deref()); assert!((((*pair).0) > (prev))); prev = (*pair).0; } diff --git a/tests/unit/out/unsafe/map.rs b/tests/unit/out/unsafe/map.rs index a408b08e7..1ce885479 100644 --- a/tests/unit/out/unsafe/map.rs +++ b/tests/unit/out/unsafe/map.rs @@ -191,8 +191,8 @@ unsafe fn main_0() -> i32 { } assert!(((m2.len()) == (indexes.len()))); let mut last: i32 = -1_i32; - 'loop_: for __begin1 in UnsafeIterRange::new(m2.begin(), m2.end()) { - let pair: *mut (i32, bool) = &mut (*__begin1.iter_deref()); + 'loop_: for pair in UnsafeIterRange::new(m2.begin(), m2.end()) { + let pair: *mut (i32, bool) = &mut (*pair.iter_deref()); assert!((((*pair).0) > (last))); assert!((((*pair).1 as i32) == (((*pair).0) % (2)))); last = (*pair).0; diff --git a/tests/unit/out/unsafe/map_key_identity.rs b/tests/unit/out/unsafe/map_key_identity.rs index 46a778dc0..2126b2134 100644 --- a/tests/unit/out/unsafe/map_key_identity.rs +++ b/tests/unit/out/unsafe/map_key_identity.rs @@ -118,8 +118,8 @@ unsafe fn main_0() -> i32 { }) as i32)) != 0; let mut distinct_count: usize = 0_usize; - 'loop_: for __begin1 in UnsafeIterRange::new(distinct.begin(), distinct.end()) { - let entry: *const (Key, Mapped) = &(*__begin1.iter_deref()); + 'loop_: for entry in UnsafeIterRange::new(distinct.begin(), distinct.end()) { + let entry: *const (Key, Mapped) = &(*entry.iter_deref()); if ((distinct_count) == (0_usize)) { ok = ((ok as i32) & (((((*entry).0.order) == (1)) && (((*entry).1.value) == (11))) as i32)) @@ -179,8 +179,8 @@ unsafe fn main_0() -> i32 { as i32)) != 0; let mut equivalent_count: usize = 0_usize; - 'loop_: for __begin2 in UnsafeIterRange::new(equivalent.begin(), equivalent.end()) { - let entry: *const (Key, Mapped) = &(*__begin2.iter_deref()); + 'loop_: for entry in UnsafeIterRange::new(equivalent.begin(), equivalent.end()) { + let entry: *const (Key, Mapped) = &(*entry.iter_deref()); ok = ((ok as i32) & (((((*entry).0.order) == (3)) && (((*entry).1.value) == (31))) as i32)) != 0; diff --git a/tests/unit/out/unsafe/unboxed_locals.rs b/tests/unit/out/unsafe/unboxed_locals.rs index 2a12ae537..fa6fad91f 100644 --- a/tests/unit/out/unsafe/unboxed_locals.rs +++ b/tests/unit/out/unsafe/unboxed_locals.rs @@ -20,11 +20,11 @@ pub struct Pair { } pub unsafe fn total_2(v: *const Vec) -> i32 { let mut s: i32 = 0; - 'loop_: for __begin1 in UnsafeIterRange::new( + 'loop_: for x in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec((*v).as_ptr().cast_mut()), UnsafeRandomAccessIterator::Vec((*v).as_ptr().add((*v).len()).cast_mut()), ) { - let mut x: i32 = (*__begin1.iter_deref()); + let mut x: i32 = (*x.iter_deref()); s += x; } return s; diff --git a/tests/unit/out/unsafe/vector3.rs b/tests/unit/out/unsafe/vector3.rs index d843874d9..912f971e2 100644 --- a/tests/unit/out/unsafe/vector3.rs +++ b/tests/unit/out/unsafe/vector3.rs @@ -29,42 +29,42 @@ unsafe fn main_0() -> i32 { v[(0_usize)][(0_usize)] = 1; v[(0_usize)][(1_usize)] = 5; v[(1_usize)][(0_usize)] = 6; - 'loop_: for __begin1 in UnsafeIterRange::new( + 'loop_: for v2 in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), ) { - let v2: *mut Vec = &mut (*__begin1.iter_deref()); - 'loop_: for __begin2 in UnsafeIterRange::new( + let v2: *mut Vec = &mut (*v2.iter_deref()); + 'loop_: for i in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec((*v2).as_mut_ptr()), UnsafeRandomAccessIterator::Vec((*v2).as_mut_ptr().add((*v2).len())), ) { - let i: *mut i32 = &mut (*__begin2.iter_deref()); + let i: *mut i32 = &mut (*i.iter_deref()); (*i).prefix_inc(); } } - 'loop_: for __begin1 in UnsafeIterRange::new( + 'loop_: for v2 in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), ) { - let v2: *mut Vec = &mut (*__begin1.iter_deref()); - 'loop_: for __begin2 in UnsafeIterRange::new( + let v2: *mut Vec = &mut (*v2.iter_deref()); + 'loop_: for i in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec((*v2).as_mut_ptr()), UnsafeRandomAccessIterator::Vec((*v2).as_mut_ptr().add((*v2).len())), ) { - let mut i: i32 = (*__begin2.iter_deref()); + let mut i: i32 = (*i.iter_deref()); (unsafe { libc::printf(c"%d\n".as_ptr() as *const libc::c_char, ((i) + (3))) }); } } - 'loop_: for __begin1 in UnsafeIterRange::new( + 'loop_: for v2 in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), ) { - let mut v2: Vec = (*__begin1.iter_deref()).clone(); - 'loop_: for __begin2 in UnsafeIterRange::new( + let mut v2: Vec = (*v2.iter_deref()).clone(); + 'loop_: for i in UnsafeIterRange::new( UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()), UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(v2.len())), ) { - let mut i: i32 = (*__begin2.iter_deref()); + let mut i: i32 = (*i.iter_deref()); (unsafe { libc::printf(c"%d\n".as_ptr() as *const libc::c_char, (i)) }); } } From 58b5873e0688b667b7a0a97dd478d30c27933f00 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 19 Oct 2026 16:49:58 +0100 Subject: [PATCH 5/7] Make iteration nicer --- cpp2rust/converter/converter.cpp | 4 +- cpp2rust/converter/converter.h | 2 - .../converter/models/converter_refcount.h | 2 - docs/src/runtime/iterators.md | 7 +- libcc2rs/src/iterators.rs | 24 ------ rules/iterator_category/shim.rs | 80 ++++++++++++------- rules/vector/tgt_refcount.rs | 10 +-- rules/vector/tgt_unsafe.rs | 10 +-- .../refcount/dangling-prvalue-as-lvalue.rs | 3 +- .../out/unsafe/dangling-prvalue-as-lvalue.rs | 3 +- tests/unit/out/refcount/auto.rs | 4 +- .../refcount/elidable_iterator_copy_cxx11.rs | 37 ++++----- tests/unit/out/refcount/find.rs | 40 ++++------ tests/unit/out/refcount/fn_ptr_stable_sort.rs | 18 ++--- tests/unit/out/refcount/foreach.rs | 4 +- .../refcount/foreach_disjoint_field_borrow.rs | 6 +- tests/unit/out/refcount/foreach_double.rs | 40 +++++----- tests/unit/out/refcount/foreach_mut.rs | 32 ++++---- tests/unit/out/refcount/iterator_freshness.rs | 5 +- tests/unit/out/refcount/iterators.rs | 4 +- tests/unit/out/refcount/operator_traits.rs | 77 +++++++++--------- tests/unit/out/refcount/sort.rs | 21 +++-- .../refcount/split_binop_aliased_borrows.rs | 5 +- .../refcount/unboxed_conditional_iterator.rs | 23 +++--- tests/unit/out/refcount/unboxed_locals.rs | 4 +- tests/unit/out/refcount/vector.rs | 18 ++--- tests/unit/out/refcount/vector3.rs | 24 +++--- .../out/refcount/vector_with_allocator.rs | 18 ++--- tests/unit/out/refcount/void_return.rs | 6 +- tests/unit/out/unsafe/auto.rs | 5 +- .../unsafe/elidable_iterator_copy_cxx11.rs | 33 +++----- tests/unit/out/unsafe/find.rs | 41 ++++------ tests/unit/out/unsafe/fn_ptr_stable_sort.rs | 16 ++-- tests/unit/out/unsafe/foreach.rs | 5 +- .../unsafe/foreach_disjoint_field_borrow.rs | 5 +- tests/unit/out/unsafe/foreach_double.rs | 50 +++--------- tests/unit/out/unsafe/foreach_map.rs | 8 +- tests/unit/out/unsafe/foreach_mut.rs | 40 ++-------- tests/unit/out/unsafe/iterator_freshness.rs | 3 +- tests/unit/out/unsafe/iterators.rs | 11 +-- tests/unit/out/unsafe/map-reallocation.rs | 2 +- tests/unit/out/unsafe/map.rs | 2 +- tests/unit/out/unsafe/map_key_identity.rs | 4 +- tests/unit/out/unsafe/operator_traits.rs | 78 +++++------------- tests/unit/out/unsafe/sort.rs | 17 +--- .../out/unsafe/split_binop_aliased_borrows.rs | 2 +- .../unsafe/unboxed_conditional_iterator.rs | 16 ++-- tests/unit/out/unsafe/unboxed_locals.rs | 5 +- tests/unit/out/unsafe/vector.rs | 20 ++--- tests/unit/out/unsafe/vector3.rs | 30 ++----- .../unit/out/unsafe/vector_with_allocator.rs | 20 ++--- tests/unit/out/unsafe/void_return.rs | 6 +- 52 files changed, 364 insertions(+), 586 deletions(-) diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp index 6629d1502..164e249c7 100644 --- a/cpp2rust/converter/converter.cpp +++ b/cpp2rust/converter/converter.cpp @@ -1501,8 +1501,8 @@ bool Converter::VisitCXXForRangeStmt(clang::CXXForRangeStmt *stmt) { begin->setDeclName(stmt->getLoopVariable()->getDeclName()); StrCat("'loop_:"); StrCat(keyword::kFor, GetNamedDeclAsString(begin), keyword::kIn, - IterRangeName(), "::new(", ConvertFreshRValue(begin->getInit()), - token::kComma, ConvertFreshRValue(end->getInit()), ')'); + "IterRange::new(", ConvertFreshRValue(begin->getInit()), token::kComma, + ConvertFreshRValue(end->getInit()), ')'); { PushBrace brace(*this); curr_for_inc_.emplace_back(nullptr); diff --git a/cpp2rust/converter/converter.h b/cpp2rust/converter/converter.h index 127f67b44..cd07a0ec8 100644 --- a/cpp2rust/converter/converter.h +++ b/cpp2rust/converter/converter.h @@ -223,8 +223,6 @@ class Converter : public clang::RecursiveASTVisitor { virtual bool VisitCXXForRangeStmt(clang::CXXForRangeStmt *stmt); - virtual const char *IterRangeName() const { return "UnsafeIterRange"; } - virtual bool VisitBreakStmt(clang::BreakStmt *stmt); virtual bool VisitContinueStmt(clang::ContinueStmt *stmt); diff --git a/cpp2rust/converter/models/converter_refcount.h b/cpp2rust/converter/models/converter_refcount.h index 19db53228..6ccd80ada 100644 --- a/cpp2rust/converter/models/converter_refcount.h +++ b/cpp2rust/converter/models/converter_refcount.h @@ -435,8 +435,6 @@ class ConverterRefCount final : public Converter { // Whether decl is a local variable or a parameter that is stored directly // instead of in a Value, as no pointer to it is ever made. bool IsUnboxedVar(const clang::ValueDecl *decl) const; - - const char *IterRangeName() const override { return "IterRange"; } // Whether expr is an unboxed variable or a field of one, which is accessed // in place. bool IsUnboxedPlace(const clang::Expr *expr) const; diff --git a/docs/src/runtime/iterators.md b/docs/src/runtime/iterators.md index 7e1861f1a..c1c56feb8 100644 --- a/docs/src/runtime/iterators.md +++ b/docs/src/runtime/iterators.md @@ -27,11 +27,8 @@ for x in v.as_pointer() as Ptr { } ``` -Two variants serve special cases. `StringIterator`, returned by -`to_string_iterator`, stops before the trailing zero byte, so iterating a -`std::string` visits its characters only. `PtrValueIter` yields copies of the -elements instead of pointers to them; rule bodies use it to feed a range of C -memory to Rust iterator adaptors: +`PtrValueIter` yields copies of the elements instead of pointers to them; rule +bodies use it to feed a range of C memory to Rust iterator adaptors: ```rust // std::accumulate(first, last, init) diff --git a/libcc2rs/src/iterators.rs b/libcc2rs/src/iterators.rs index 81e42da7e..d7626d0e2 100644 --- a/libcc2rs/src/iterators.rs +++ b/libcc2rs/src/iterators.rs @@ -24,27 +24,3 @@ impl Iterator for CStringIterator { Some(ch) } } - -impl Ptr { - pub fn to_string_iterator(&self) -> StringIterator { - StringIterator { ptr: self.clone() } - } -} - -pub struct StringIterator { - ptr: Ptr, -} - -impl Iterator for StringIterator { - type Item = Ptr; - fn next(&mut self) -> Option { - // stop before the null terminator at the last position - if self.ptr.get_offset().wrapping_add(1) < self.ptr.len() { - let value = self.ptr.clone(); - self.ptr += 1; - Some(value) - } else { - None - } - } -} diff --git a/rules/iterator_category/shim.rs b/rules/iterator_category/shim.rs index 81524d304..bc7832ffa 100644 --- a/rules/iterator_category/shim.rs +++ b/rules/iterator_category/shim.rs @@ -452,23 +452,44 @@ random_access_iterator!( std::ptr::null_mut() ); -pub struct IterRange { +pub trait IterStep: Clone + PartialEq { + fn iter_step(&mut self); +} + +macro_rules! iter_step { + ($name:ty, $iter:ident) => { + impl IterStep for $name { + fn iter_step(&mut self) { + $iter::::iter_inc(self); + } + } + }; +} + +iter_step!(Ptr, CppIterator); +iter_step!(*mut T, UnsafeCppIterator); +iter_step!(*const T, UnsafeCppIterator); +iter_step!(InputIterator, CppIterator); +iter_step!(ForwardIterator, CppIterator); +iter_step!(UnsafeInputIterator, UnsafeCppIterator); +iter_step!(UnsafeForwardIterator, UnsafeCppIterator); +iter_step!(BidirectionalIterator, CppIterator); +iter_step!(UnsafeBidirectionalIterator, UnsafeCppIterator); +iter_step!(RandomAccessIterator, CppIterator); +iter_step!(UnsafeRandomAccessIterator, UnsafeCppIterator); + +pub struct IterRange { cur: I, end: I, - elem: PhantomData, } -impl IterRange { +impl IterRange { pub fn new(cur: I, end: I) -> Self { - Self { - cur, - end, - elem: PhantomData, - } + Self { cur, end } } } -impl, T> Iterator for IterRange { +impl Iterator for IterRange { type Item = I; fn next(&mut self) -> Option { @@ -476,36 +497,33 @@ impl, T> Iterator for IterRange { return None; } let it = self.cur.clone(); - self.cur.iter_inc(); + self.cur.iter_step(); Some(it) } } -pub struct UnsafeIterRange { - cur: I, - end: I, - elem: PhantomData, +pub trait CppRange { + type Iter; + fn begin(&self) -> Self::Iter; + fn end(&self) -> Self::Iter; } -impl UnsafeIterRange { - pub fn new(cur: I, end: I) -> Self { - Self { - cur, - end, - elem: PhantomData, - } +impl CppRange for Vec { + type Iter = UnsafeRandomAccessIterator; + fn begin(&self) -> Self::Iter { + UnsafeRandomAccessIterator::Vec(self.as_ptr().cast_mut()) + } + fn end(&self) -> Self::Iter { + UnsafeRandomAccessIterator::Vec(self.as_ptr().wrapping_add(self.len()).cast_mut()) } } -impl, T> Iterator for UnsafeIterRange { - type Item = I; - - fn next(&mut self) -> Option { - if self.cur == self.end { - return None; - } - let it = self.cur.clone(); - self.cur.iter_inc(); - Some(it) +impl CppRange for Ptr { + type Iter = RandomAccessIterator; + fn begin(&self) -> Self::Iter { + RandomAccessIterator::Vec(self.clone()) + } + fn end(&self) -> Self::Iter { + RandomAccessIterator::Vec(self.to_end()) } } diff --git a/rules/vector/tgt_refcount.rs b/rules/vector/tgt_refcount.rs index e4f1077f6..111566a2a 100644 --- a/rules/vector/tgt_refcount.rs +++ b/rules/vector/tgt_refcount.rs @@ -32,11 +32,11 @@ fn f69(a0: Ptr) -> Ptr { } fn f72(a0: Ptr) -> RandomAccessIterator { - RandomAccessIterator::Vec(a0) + a0.begin() } fn f76(a0: Ptr) -> RandomAccessIterator { - RandomAccessIterator::Vec(a0.to_end()) + a0.end() } fn f77(a0: &mut Vec, a1: RandomAccessIterator, a2: T1) -> RandomAccessIterator { @@ -68,11 +68,11 @@ fn f93(a0: Ptr) -> Ptr { } fn f95(a0: Ptr) -> RandomAccessIterator { - RandomAccessIterator::Vec(a0) + a0.begin() } fn f96(a0: Ptr) -> RandomAccessIterator { - RandomAccessIterator::Vec(a0.to_end()) + a0.end() } fn f98(a0: Ptr>, a1: usize) -> Ptr> { @@ -107,7 +107,7 @@ fn f103(a0: Ptr>, a1: &mut Vec) { } fn f104(a0: Ptr) -> RandomAccessIterator { - RandomAccessIterator::Vec(a0.to_end()) + a0.end() } fn f105(a0: Ptr>, a1: Vec) { diff --git a/rules/vector/tgt_unsafe.rs b/rules/vector/tgt_unsafe.rs index d8c5fa4b2..ffcb4fccd 100644 --- a/rules/vector/tgt_unsafe.rs +++ b/rules/vector/tgt_unsafe.rs @@ -79,7 +79,7 @@ unsafe fn f71(a0: &mut Vec, a1: usize) { } unsafe fn f72(a0: &mut Vec) -> UnsafeRandomAccessIterator { - UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr()) + a0.begin() } unsafe fn f73(a0: &mut Vec, a1: &mut T1) { @@ -97,7 +97,7 @@ unsafe fn f75(a0: &mut Vec) { } unsafe fn f76(a0: &mut Vec) -> UnsafeRandomAccessIterator { - UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr().add(a0.len())) + a0.end() } unsafe fn f77(a0: &mut Vec, a1: UnsafeRandomAccessIterator, a2: T1) -> UnsafeRandomAccessIterator { @@ -141,11 +141,11 @@ unsafe fn f93(a0: &mut Vec) -> *const T1 { } unsafe fn f95(a0: Vec) -> UnsafeRandomAccessIterator { - UnsafeRandomAccessIterator::Vec(a0.as_ptr().cast_mut()) + a0.begin() } unsafe fn f96(a0: Vec) -> UnsafeRandomAccessIterator { - UnsafeRandomAccessIterator::Vec(a0.as_ptr().add(a0.len()).cast_mut()) + a0.end() } unsafe fn f97(a0: &mut Vec, a1: &mut Vec) { @@ -189,7 +189,7 @@ unsafe fn f103(a0: &mut Vec, a1: &mut Vec) { } unsafe fn f104(a0: Vec) -> UnsafeRandomAccessIterator { - UnsafeRandomAccessIterator::Vec(a0.as_ptr().add(a0.len()).cast_mut()) + a0.end() } unsafe fn f105(a0: &mut Vec, a1: Vec) { diff --git a/tests/ub/out/refcount/dangling-prvalue-as-lvalue.rs b/tests/ub/out/refcount/dangling-prvalue-as-lvalue.rs index dea049e02..b079f5f17 100644 --- a/tests/ub/out/refcount/dangling-prvalue-as-lvalue.rs +++ b/tests/ub/out/refcount/dangling-prvalue-as-lvalue.rs @@ -15,8 +15,7 @@ pub fn main() { } fn main_0() -> i32 { let v: Value> = Rc::new(RefCell::new(vec![1, 2])); - let b: Ptr = - ({ foo_0(RandomAccessIterator::Vec((v.as_pointer() as Ptr)).iter_deref()) }); + let b: Ptr = ({ foo_0((v.as_pointer() as Ptr).begin().iter_deref()) }); (*v.borrow_mut()).clear(); return (b.read()); } diff --git a/tests/ub/out/unsafe/dangling-prvalue-as-lvalue.rs b/tests/ub/out/unsafe/dangling-prvalue-as-lvalue.rs index 2abcddf6e..0bee63fe1 100644 --- a/tests/ub/out/unsafe/dangling-prvalue-as-lvalue.rs +++ b/tests/ub/out/unsafe/dangling-prvalue-as-lvalue.rs @@ -17,8 +17,7 @@ pub fn main() { } unsafe fn main_0() -> i32 { let mut v: Vec = vec![1, 2]; - let b: *const i32 = - (unsafe { foo_0(&(*UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_deref())) }); + let b: *const i32 = (unsafe { foo_0(&(*v.begin().iter_deref())) }); v.clear(); return (*b); } diff --git a/tests/unit/out/refcount/auto.rs b/tests/unit/out/refcount/auto.rs index f675c212d..7dfe2c935 100644 --- a/tests/unit/out/refcount/auto.rs +++ b/tests/unit/out/refcount/auto.rs @@ -25,8 +25,8 @@ fn main_0() -> i32 { }; let mut sum: i32 = 0; 'loop_: for elem in IterRange::new( - RandomAccessIterator::Vec((v.as_pointer() as Ptr)), - RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), + (v.as_pointer() as Ptr).begin(), + (v.as_pointer() as Ptr).end(), ) { let mut elem: i32 = (elem.iter_deref().read()); sum += elem; diff --git a/tests/unit/out/refcount/elidable_iterator_copy_cxx11.rs b/tests/unit/out/refcount/elidable_iterator_copy_cxx11.rs index 9a7ae4e17..ae79c0e9e 100644 --- a/tests/unit/out/refcount/elidable_iterator_copy_cxx11.rs +++ b/tests/unit/out/refcount/elidable_iterator_copy_cxx11.rs @@ -21,55 +21,52 @@ fn main_0() -> i32 { (*v.borrow_mut()).push(__a1) }; let it: Value> = Rc::new(RefCell::new({ - let mut __it = RandomAccessIterator::Vec((v.as_pointer() as Ptr)); - while __it != RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()) - && __it.iter_deref().with(|__v| *__v != 7) + let mut __it = (v.as_pointer() as Ptr).begin(); + while __it != (v.as_pointer() as Ptr).end() && __it.iter_deref().with(|__v| *__v != 7) { __it.iter_inc(); } __it })); - assert!((*it.borrow()) != RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end())); + assert!((*it.borrow()) != (v.as_pointer() as Ptr).end()); assert!((((*it.borrow()).iter_deref().read()) == 7)); { - let __n = RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()) - .iter_distance(&RandomAccessIterator::Vec((v.as_pointer() as Ptr))); + let __n = (v.as_pointer() as Ptr) + .end() + .iter_distance(&(v.as_pointer() as Ptr).begin()); let __random = std::hash::RandomState::new(); for __i in (1..__n).rev() { let __j = (std::hash::BuildHasher::hash_one(&__random, __i) % (__i + 1) as u64) as isize; - let __x = RandomAccessIterator::Vec((v.as_pointer() as Ptr)).iter_at(__i); - let __y = RandomAccessIterator::Vec((v.as_pointer() as Ptr)).iter_at(__j); + let __x = (v.as_pointer() as Ptr).begin().iter_at(__i); + let __y = (v.as_pointer() as Ptr).begin().iter_at(__j); let __tmp = __x.read(); __x.write(__y.read()); __y.write(__tmp); } }; { - let __n = RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()) - .iter_distance(&RandomAccessIterator::Vec((v.as_pointer() as Ptr))); + let __n = (v.as_pointer() as Ptr) + .end() + .iter_distance(&(v.as_pointer() as Ptr).begin()); let mut __order: Vec = (0..__n).collect(); __order.sort_by(|&__x, &__y| { - RandomAccessIterator::Vec((v.as_pointer() as Ptr)) + (v.as_pointer() as Ptr) + .begin() .iter_at(__x) .with(|__a| { - RandomAccessIterator::Vec((v.as_pointer() as Ptr)) + (v.as_pointer() as Ptr) + .begin() .iter_at(__y) .with(|__b| __a.cmp(__b)) }) }); let __values: Vec<_> = __order .iter() - .map(|&__i| { - RandomAccessIterator::Vec((v.as_pointer() as Ptr)) - .iter_at(__i) - .read() - }) + .map(|&__i| (v.as_pointer() as Ptr).begin().iter_at(__i).read()) .collect(); for (__i, __v) in (0..__n).zip(__values) { - RandomAccessIterator::Vec((v.as_pointer() as Ptr)) - .iter_at(__i) - .write(__v); + (v.as_pointer() as Ptr).begin().iter_at(__i).write(__v); } }; assert!(({ (*v.borrow())[0_usize] } == 4) && ({ (*v.borrow())[1_usize] } == 7)); diff --git a/tests/unit/out/refcount/find.rs b/tests/unit/out/refcount/find.rs index de56d1695..b2a01feb2 100644 --- a/tests/unit/out/refcount/find.rs +++ b/tests/unit/out/refcount/find.rs @@ -24,12 +24,10 @@ fn main_0() -> i32 { let __a1 = 3; (*v.borrow_mut()).push(__a1) }; - let v_begin: Value> = Rc::new(RefCell::new( - RandomAccessIterator::Vec((v.as_pointer() as Ptr)), - )); - let v_end: Value> = Rc::new(RefCell::new(RandomAccessIterator::Vec( - (v.as_pointer() as Ptr).to_end(), - ))); + let v_begin: Value> = + Rc::new(RefCell::new((v.as_pointer() as Ptr).begin())); + let v_end: Value> = + Rc::new(RefCell::new((v.as_pointer() as Ptr).end())); let it: Value> = Rc::new(RefCell::new({ let mut __it = (*v_begin.borrow()).clone(); while __it != (*v_end.borrow()).clone() && __it.iter_deref().with(|__v| *__v != 2) { @@ -37,8 +35,7 @@ fn main_0() -> i32 { } __it })); - let mut v_result_true: bool = - (*it.borrow()) != RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()); + let mut v_result_true: bool = (*it.borrow()) != (v.as_pointer() as Ptr).end(); let m: Value, Value)>> = Rc::new(RefCell::new(Map::new())); (m.as_pointer() as Ptr, Value)>>) .with_mut(|__m: &mut Map, Value)>| { @@ -91,51 +88,48 @@ fn main_0() -> i32 { assert!( ((v_result_true) && (m_result_true)) && ({ - let mut __it = RandomAccessIterator::Vec((v.as_pointer() as Ptr)); - while __it != RandomAccessIterator::Vec((v.as_pointer() as Ptr)) + let mut __it = (v.as_pointer() as Ptr).begin(); + while __it != (v.as_pointer() as Ptr).begin() && __it.iter_deref().with(|__v| *__v != 2) { __it.iter_inc(); } __it - } == RandomAccessIterator::Vec((v.as_pointer() as Ptr))) + } == (v.as_pointer() as Ptr).begin()) ); let w: Value> = Rc::new(RefCell::new(vec![1, 2, 3, 4, 5])); assert!( { - let mut __it = - RandomAccessIterator::Vec((w.as_pointer() as Ptr)).iter_add(2_isize); - while __it != RandomAccessIterator::Vec((w.as_pointer() as Ptr).to_end()) + let mut __it = (w.as_pointer() as Ptr).begin().iter_add(2_isize); + while __it != (w.as_pointer() as Ptr).end() && __it.iter_deref().with(|__v| *__v != 4) { __it.iter_inc(); } __it - } == RandomAccessIterator::Vec((w.as_pointer() as Ptr)).iter_add(3_isize) + } == (w.as_pointer() as Ptr).begin().iter_add(3_isize) ); assert!( { - let mut __it = - RandomAccessIterator::Vec((w.as_pointer() as Ptr)).iter_add(2_isize); - while __it != RandomAccessIterator::Vec((w.as_pointer() as Ptr).to_end()) + let mut __it = (w.as_pointer() as Ptr).begin().iter_add(2_isize); + while __it != (w.as_pointer() as Ptr).end() && __it.iter_deref().with(|__v| *__v != 1) { __it.iter_inc(); } __it - } == RandomAccessIterator::Vec((w.as_pointer() as Ptr).to_end()) + } == (w.as_pointer() as Ptr).end() ); assert!( { - let mut __it = - RandomAccessIterator::Vec((w.as_pointer() as Ptr)).iter_add(2_isize); - while __it != RandomAccessIterator::Vec((w.as_pointer() as Ptr)).iter_add(4_isize) + let mut __it = (w.as_pointer() as Ptr).begin().iter_add(2_isize); + while __it != (w.as_pointer() as Ptr).begin().iter_add(4_isize) && __it.iter_deref().with(|__v| *__v != 5) { __it.iter_inc(); } __it - } == RandomAccessIterator::Vec((w.as_pointer() as Ptr)).iter_add(4_isize) + } == (w.as_pointer() as Ptr).begin().iter_add(4_isize) ); return 0; } diff --git a/tests/unit/out/refcount/fn_ptr_stable_sort.rs b/tests/unit/out/refcount/fn_ptr_stable_sort.rs index 6e40e5a33..377b0f76d 100644 --- a/tests/unit/out/refcount/fn_ptr_stable_sort.rs +++ b/tests/unit/out/refcount/fn_ptr_stable_sort.rs @@ -36,12 +36,13 @@ fn main_0() -> i32 { (*v.borrow_mut()).push(__a1) }; { - let __n = RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()) - .iter_distance(&RandomAccessIterator::Vec((v.as_pointer() as Ptr))); + let __n = (v.as_pointer() as Ptr) + .end() + .iter_distance(&(v.as_pointer() as Ptr).begin()); let mut __order: Vec = (0..__n).collect(); __order.sort_by(|&__x, &__y| { - let __a = RandomAccessIterator::Vec((v.as_pointer() as Ptr)).iter_at(__x); - let __b = RandomAccessIterator::Vec((v.as_pointer() as Ptr)).iter_at(__y); + let __a = (v.as_pointer() as Ptr).begin().iter_at(__x); + let __b = (v.as_pointer() as Ptr).begin().iter_at(__y); if Compare_0.call(__a.clone(), __b.clone()) { std::cmp::Ordering::Less } else if Compare_0.call(__b, __a) { @@ -52,14 +53,11 @@ fn main_0() -> i32 { }); let __values: Vec<_> = __order .iter() - .map(|&__i| { - RandomAccessIterator::Vec((v.as_pointer() as Ptr)) - .iter_at(__i) - .read() - }) + .map(|&__i| (v.as_pointer() as Ptr).begin().iter_at(__i).read()) .collect(); for (__i, __v) in (0..__n).zip(__values) { - RandomAccessIterator::Vec((v.as_pointer() as Ptr)) + (v.as_pointer() as Ptr) + .begin() .iter_at(__i) .write(__v); } diff --git a/tests/unit/out/refcount/foreach.rs b/tests/unit/out/refcount/foreach.rs index a7acd0a41..06fc3977f 100644 --- a/tests/unit/out/refcount/foreach.rs +++ b/tests/unit/out/refcount/foreach.rs @@ -22,8 +22,8 @@ fn main_0() -> i32 { } let mut sum: i32 = 0; 'loop_: for x in IterRange::new( - RandomAccessIterator::Vec((v.as_pointer() as Ptr)), - RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), + (v.as_pointer() as Ptr).begin(), + (v.as_pointer() as Ptr).end(), ) { let mut x: i32 = (x.iter_deref().read()); sum += x; diff --git a/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs b/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs index 8ccdc239f..7d7a1c25f 100644 --- a/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs +++ b/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs @@ -26,10 +26,8 @@ fn main_0() -> i32 { (*s.borrow_mut()).v.push(__a1) }; 'loop_: for e in IterRange::new( - RandomAccessIterator::Vec((field_ref!(s.as_pointer(), v).as_pointer() as Ptr)), - RandomAccessIterator::Vec( - (field_ref!(s.as_pointer(), v).as_pointer() as Ptr).to_end(), - ), + (field_ref!(s.as_pointer(), v).as_pointer() as Ptr).begin(), + (field_ref!(s.as_pointer(), v).as_pointer() as Ptr).end(), ) { let mut e: i32 = (e.iter_deref().read()); (*s.borrow_mut()).a.postfix_inc(); diff --git a/tests/unit/out/refcount/foreach_double.rs b/tests/unit/out/refcount/foreach_double.rs index a34ba7363..b4122174c 100644 --- a/tests/unit/out/refcount/foreach_double.rs +++ b/tests/unit/out/refcount/foreach_double.rs @@ -26,52 +26,52 @@ fn main_0() -> i32 { }; let mut square: i32 = 0; 'loop_: for e1 in IterRange::new( - RandomAccessIterator::Vec((v.as_pointer() as Ptr)), - RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), + (v.as_pointer() as Ptr).begin(), + (v.as_pointer() as Ptr).end(), ) { let mut e1: i32 = (e1.iter_deref().read()); 'loop_: for e2 in IterRange::new( - RandomAccessIterator::Vec((v.as_pointer() as Ptr)), - RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), + (v.as_pointer() as Ptr).begin(), + (v.as_pointer() as Ptr).end(), ) { let mut e2: i32 = (e2.iter_deref().read()); square += (e1 * e2); } } 'loop_: for e1 in IterRange::new( - RandomAccessIterator::Vec((v.as_pointer() as Ptr)), - RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), + (v.as_pointer() as Ptr).begin(), + (v.as_pointer() as Ptr).end(), ) { let e1: Ptr = e1.iter_deref(); 'loop_: for e2 in IterRange::new( - RandomAccessIterator::Vec((v.as_pointer() as Ptr)), - RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), + (v.as_pointer() as Ptr).begin(), + (v.as_pointer() as Ptr).end(), ) { let e2: Ptr = e2.iter_deref(); square += { ({ (e1.read()) } * { (e2.read()) }) }; } } 'loop_: for e1 in IterRange::new( - RandomAccessIterator::Vec((v.as_pointer() as Ptr)), - RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), + (v.as_pointer() as Ptr).begin(), + (v.as_pointer() as Ptr).end(), ) { let e1: Ptr = e1.iter_deref(); 'loop_: for e2 in IterRange::new( - RandomAccessIterator::Vec((v.as_pointer() as Ptr)), - RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), + (v.as_pointer() as Ptr).begin(), + (v.as_pointer() as Ptr).end(), ) { let e2: Ptr = e2.iter_deref(); square += { ({ (e1.read()) } * { (e2.read()) }) }; } } 'loop_: for e1 in IterRange::new( - RandomAccessIterator::Vec((v.as_pointer() as Ptr)), - RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), + (v.as_pointer() as Ptr).begin(), + (v.as_pointer() as Ptr).end(), ) { let e1: Ptr = e1.iter_deref(); 'loop_: for e2 in IterRange::new( - RandomAccessIterator::Vec((v.as_pointer() as Ptr)), - RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()), + (v.as_pointer() as Ptr).begin(), + (v.as_pointer() as Ptr).end(), ) { let e2: Ptr = e2.iter_deref(); square += { ({ (e1.read()) } * { (e2.read()) }) }; @@ -94,13 +94,13 @@ fn main_0() -> i32 { (*m.borrow_mut()).push(__a1) }; 'loop_: for row in IterRange::new( - RandomAccessIterator::Vec((m.as_pointer() as Ptr>)), - RandomAccessIterator::Vec((m.as_pointer() as Ptr>).to_end()), + (m.as_pointer() as Ptr>).begin(), + (m.as_pointer() as Ptr>).end(), ) { let row: Ptr> = row.iter_deref(); 'loop_: for col in IterRange::new( - RandomAccessIterator::Vec((Ptr::>::decay(&(row)) as Ptr)), - RandomAccessIterator::Vec((Ptr::>::decay(&(row)) as Ptr).to_end()), + (Ptr::>::decay(&(row)) as Ptr).begin(), + (Ptr::>::decay(&(row)) as Ptr).end(), ) { let col: Ptr = col.iter_deref(); square += { (col.read()) }; diff --git a/tests/unit/out/refcount/foreach_mut.rs b/tests/unit/out/refcount/foreach_mut.rs index 8dc505be2..92f66396b 100644 --- a/tests/unit/out/refcount/foreach_mut.rs +++ b/tests/unit/out/refcount/foreach_mut.rs @@ -26,22 +26,22 @@ fn main_0() -> i32 { }; let mut sum: i32 = 0; 'loop_: for x in IterRange::new( - RandomAccessIterator::Vec((v1.as_pointer() as Ptr)), - RandomAccessIterator::Vec((v1.as_pointer() as Ptr).to_end()), + (v1.as_pointer() as Ptr).begin(), + (v1.as_pointer() as Ptr).end(), ) { let mut x: i32 = (x.iter_deref().read()); sum += x.prefix_inc(); } 'loop_: for x in IterRange::new( - RandomAccessIterator::Vec((v1.as_pointer() as Ptr)), - RandomAccessIterator::Vec((v1.as_pointer() as Ptr).to_end()), + (v1.as_pointer() as Ptr).begin(), + (v1.as_pointer() as Ptr).end(), ) { let mut x: i32 = (x.iter_deref().read()); sum += x; } 'loop_: for x in IterRange::new( - RandomAccessIterator::Vec((v1.as_pointer() as Ptr)), - RandomAccessIterator::Vec((v1.as_pointer() as Ptr).to_end()), + (v1.as_pointer() as Ptr).begin(), + (v1.as_pointer() as Ptr).end(), ) { let x: Ptr = x.iter_deref(); { @@ -49,8 +49,8 @@ fn main_0() -> i32 { }; } 'loop_: for x in IterRange::new( - RandomAccessIterator::Vec((v1.as_pointer() as Ptr)), - RandomAccessIterator::Vec((v1.as_pointer() as Ptr).to_end()), + (v1.as_pointer() as Ptr).begin(), + (v1.as_pointer() as Ptr).end(), ) { let x: Ptr = x.iter_deref(); sum += { (x.read()) }; @@ -69,8 +69,8 @@ fn main_0() -> i32 { (*v2.borrow_mut()).push(__a1) }; 'loop_: for p in IterRange::new( - RandomAccessIterator::Vec((v2.as_pointer() as Ptr>)), - RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).to_end()), + (v2.as_pointer() as Ptr>).begin(), + (v2.as_pointer() as Ptr>).end(), ) { let mut p: Ptr = (p.iter_deref().read()); { @@ -78,15 +78,15 @@ fn main_0() -> i32 { }; } 'loop_: for p in IterRange::new( - RandomAccessIterator::Vec((v2.as_pointer() as Ptr>)), - RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).to_end()), + (v2.as_pointer() as Ptr>).begin(), + (v2.as_pointer() as Ptr>).end(), ) { let mut p: Ptr = (p.iter_deref().read()); sum += { (p.read()) }; } 'loop_: for p in IterRange::new( - RandomAccessIterator::Vec((v2.as_pointer() as Ptr>)), - RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).to_end()), + (v2.as_pointer() as Ptr>).begin(), + (v2.as_pointer() as Ptr>).end(), ) { let mut p: Ptr = (p.iter_deref().read()); { @@ -94,8 +94,8 @@ fn main_0() -> i32 { }; } 'loop_: for p in IterRange::new( - RandomAccessIterator::Vec((v2.as_pointer() as Ptr>)), - RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).to_end()), + (v2.as_pointer() as Ptr>).begin(), + (v2.as_pointer() as Ptr>).end(), ) { let mut p: Ptr = (p.iter_deref().read()); sum += { (p.read()) }; diff --git a/tests/unit/out/refcount/iterator_freshness.rs b/tests/unit/out/refcount/iterator_freshness.rs index 48f08d0bf..f84b4b162 100644 --- a/tests/unit/out/refcount/iterator_freshness.rs +++ b/tests/unit/out/refcount/iterator_freshness.rs @@ -19,9 +19,8 @@ fn main_0() -> i32 { .map(|_| ::default()) .collect::>(), )); - let it: Value> = Rc::new(RefCell::new(RandomAccessIterator::Vec( - (vec_.as_pointer() as Ptr), - ))); + let it: Value> = + Rc::new(RefCell::new((vec_.as_pointer() as Ptr).begin())); ({ foo_0((*it.borrow()).clone()) }); return 0; } diff --git a/tests/unit/out/refcount/iterators.rs b/tests/unit/out/refcount/iterators.rs index 822e170a8..899364dd6 100644 --- a/tests/unit/out/refcount/iterators.rs +++ b/tests/unit/out/refcount/iterators.rs @@ -47,8 +47,8 @@ fn main_0() -> i32 { (*v.borrow_mut()).push(__a1) }; 'loop_: for p in IterRange::new( - RandomAccessIterator::Vec((v.as_pointer() as Ptr>)), - RandomAccessIterator::Vec((v.as_pointer() as Ptr>).to_end()), + (v.as_pointer() as Ptr>).begin(), + (v.as_pointer() as Ptr>).end(), ) { let mut p: Ptr = (p.iter_deref().read()); println!("{}", (p.read())); diff --git a/tests/unit/out/refcount/operator_traits.rs b/tests/unit/out/refcount/operator_traits.rs index 133a20072..6556afb8f 100644 --- a/tests/unit/out/refcount/operator_traits.rs +++ b/tests/unit/out/refcount/operator_traits.rs @@ -161,28 +161,28 @@ fn main_0() -> i32 { assert!((w.v == 2)); let lts: Value> = Rc::new(RefCell::new(vec![Lt { v: 3 }, Lt { v: 1 }, Lt { v: 2 }])); { - let __n = RandomAccessIterator::Vec((lts.as_pointer() as Ptr).to_end()) - .iter_distance(&RandomAccessIterator::Vec((lts.as_pointer() as Ptr))); + let __n = (lts.as_pointer() as Ptr) + .end() + .iter_distance(&(lts.as_pointer() as Ptr).begin()); let mut __order: Vec = (0..__n).collect(); __order.sort_by(|&__x, &__y| { - RandomAccessIterator::Vec((lts.as_pointer() as Ptr)) + (lts.as_pointer() as Ptr) + .begin() .iter_at(__x) .with(|__a| { - RandomAccessIterator::Vec((lts.as_pointer() as Ptr)) + (lts.as_pointer() as Ptr) + .begin() .iter_at(__y) .with(|__b| __a.cmp(__b)) }) }); let __values: Vec<_> = __order .iter() - .map(|&__i| { - RandomAccessIterator::Vec((lts.as_pointer() as Ptr)) - .iter_at(__i) - .read() - }) + .map(|&__i| (lts.as_pointer() as Ptr).begin().iter_at(__i).read()) .collect(); for (__i, __v) in (0..__n).zip(__values) { - RandomAccessIterator::Vec((lts.as_pointer() as Ptr)) + (lts.as_pointer() as Ptr) + .begin() .iter_at(__i) .write(__v); } @@ -196,8 +196,8 @@ fn main_0() -> i32 { let mut nine: Eq = Eq { v: 9 }; assert!( ({ - let mut __it = RandomAccessIterator::Vec((eqs.as_pointer() as Ptr)); - while __it != RandomAccessIterator::Vec((eqs.as_pointer() as Ptr).to_end()) + let mut __it = (eqs.as_pointer() as Ptr).begin(); + while __it != (eqs.as_pointer() as Ptr).end() && __it.iter_deref().with(|__v| *__v != two) { __it.iter_inc(); @@ -210,40 +210,40 @@ fn main_0() -> i32 { ); assert!( { - let mut __it = RandomAccessIterator::Vec((eqs.as_pointer() as Ptr)); - while __it != RandomAccessIterator::Vec((eqs.as_pointer() as Ptr).to_end()) + let mut __it = (eqs.as_pointer() as Ptr).begin(); + while __it != (eqs.as_pointer() as Ptr).end() && __it.iter_deref().with(|__v| *__v != nine) { __it.iter_inc(); } __it - } == RandomAccessIterator::Vec((eqs.as_pointer() as Ptr).to_end()) + } == (eqs.as_pointer() as Ptr).end() ); let cmps: Value> = Rc::new(RefCell::new(vec![Cmp { v: 3 }, Cmp { v: 1 }, Cmp { v: 2 }])); { - let __n = RandomAccessIterator::Vec((cmps.as_pointer() as Ptr).to_end()) - .iter_distance(&RandomAccessIterator::Vec((cmps.as_pointer() as Ptr))); + let __n = (cmps.as_pointer() as Ptr) + .end() + .iter_distance(&(cmps.as_pointer() as Ptr).begin()); let mut __order: Vec = (0..__n).collect(); __order.sort_by(|&__x, &__y| { - RandomAccessIterator::Vec((cmps.as_pointer() as Ptr)) + (cmps.as_pointer() as Ptr) + .begin() .iter_at(__x) .with(|__a| { - RandomAccessIterator::Vec((cmps.as_pointer() as Ptr)) + (cmps.as_pointer() as Ptr) + .begin() .iter_at(__y) .with(|__b| __a.cmp(__b)) }) }); let __values: Vec<_> = __order .iter() - .map(|&__i| { - RandomAccessIterator::Vec((cmps.as_pointer() as Ptr)) - .iter_at(__i) - .read() - }) + .map(|&__i| (cmps.as_pointer() as Ptr).begin().iter_at(__i).read()) .collect(); for (__i, __v) in (0..__n).zip(__values) { - RandomAccessIterator::Vec((cmps.as_pointer() as Ptr)) + (cmps.as_pointer() as Ptr) + .begin() .iter_at(__i) .write(__v); } @@ -252,8 +252,8 @@ fn main_0() -> i32 { let mut three: Cmp = Cmp { v: 3 }; assert!( ({ - let mut __it = RandomAccessIterator::Vec((cmps.as_pointer() as Ptr)); - while __it != RandomAccessIterator::Vec((cmps.as_pointer() as Ptr).to_end()) + let mut __it = (cmps.as_pointer() as Ptr).begin(); + while __it != (cmps.as_pointer() as Ptr).end() && __it.iter_deref().with(|__v| *__v != three) { __it.iter_inc(); @@ -266,16 +266,17 @@ fn main_0() -> i32 { ); let frees: Value> = Rc::new(RefCell::new(vec![Free { v: 2 }, Free { v: 1 }])); { - let __n = RandomAccessIterator::Vec((frees.as_pointer() as Ptr).to_end()) - .iter_distance(&RandomAccessIterator::Vec( - (frees.as_pointer() as Ptr), - )); + let __n = (frees.as_pointer() as Ptr) + .end() + .iter_distance(&(frees.as_pointer() as Ptr).begin()); let mut __order: Vec = (0..__n).collect(); __order.sort_by(|&__x, &__y| { - RandomAccessIterator::Vec((frees.as_pointer() as Ptr)) + (frees.as_pointer() as Ptr) + .begin() .iter_at(__x) .with(|__a| { - RandomAccessIterator::Vec((frees.as_pointer() as Ptr)) + (frees.as_pointer() as Ptr) + .begin() .iter_at(__y) .with(|__b| __a.cmp(__b)) }) @@ -283,13 +284,15 @@ fn main_0() -> i32 { let __values: Vec<_> = __order .iter() .map(|&__i| { - RandomAccessIterator::Vec((frees.as_pointer() as Ptr)) + (frees.as_pointer() as Ptr) + .begin() .iter_at(__i) .read() }) .collect(); for (__i, __v) in (0..__n).zip(__values) { - RandomAccessIterator::Vec((frees.as_pointer() as Ptr)) + (frees.as_pointer() as Ptr) + .begin() .iter_at(__i) .write(__v); } @@ -298,8 +301,8 @@ fn main_0() -> i32 { let mut ftwo: Free = Free { v: 2 }; assert!( ({ - let mut __it = RandomAccessIterator::Vec((frees.as_pointer() as Ptr)); - while __it != RandomAccessIterator::Vec((frees.as_pointer() as Ptr).to_end()) + let mut __it = (frees.as_pointer() as Ptr).begin(); + while __it != (frees.as_pointer() as Ptr).end() && __it.iter_deref().with(|__v| *__v != ftwo) { __it.iter_inc(); diff --git a/tests/unit/out/refcount/sort.rs b/tests/unit/out/refcount/sort.rs index a0ec040ff..e04700c5c 100644 --- a/tests/unit/out/refcount/sort.rs +++ b/tests/unit/out/refcount/sort.rs @@ -53,30 +53,27 @@ fn main_0() -> i32 { (*v.borrow_mut()).push(__a1) }; { - let __n = RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()) - .iter_distance(&RandomAccessIterator::Vec((v.as_pointer() as Ptr))); + let __n = (v.as_pointer() as Ptr) + .end() + .iter_distance(&(v.as_pointer() as Ptr).begin()); let mut __order: Vec = (0..__n).collect(); __order.sort_by(|&__x, &__y| { - RandomAccessIterator::Vec((v.as_pointer() as Ptr)) + (v.as_pointer() as Ptr) + .begin() .iter_at(__x) .with(|__a| { - RandomAccessIterator::Vec((v.as_pointer() as Ptr)) + (v.as_pointer() as Ptr) + .begin() .iter_at(__y) .with(|__b| __a.cmp(__b)) }) }); let __values: Vec<_> = __order .iter() - .map(|&__i| { - RandomAccessIterator::Vec((v.as_pointer() as Ptr)) - .iter_at(__i) - .read() - }) + .map(|&__i| (v.as_pointer() as Ptr).begin().iter_at(__i).read()) .collect(); for (__i, __v) in (0..__n).zip(__values) { - RandomAccessIterator::Vec((v.as_pointer() as Ptr)) - .iter_at(__i) - .write(__v); + (v.as_pointer() as Ptr).begin().iter_at(__i).write(__v); } }; let mut i: u32 = 0_u32; diff --git a/tests/unit/out/refcount/split_binop_aliased_borrows.rs b/tests/unit/out/refcount/split_binop_aliased_borrows.rs index 1691fb8aa..72746798c 100644 --- a/tests/unit/out/refcount/split_binop_aliased_borrows.rs +++ b/tests/unit/out/refcount/split_binop_aliased_borrows.rs @@ -12,9 +12,8 @@ pub fn main() { } fn main_0() -> i32 { let v: Value> = Rc::new(RefCell::new(vec![1, 2])); - let p: Value> = Rc::new(RefCell::new(RandomAccessIterator::Vec( - (v.as_pointer() as Ptr), - ))); + let p: Value> = + Rc::new(RefCell::new((v.as_pointer() as Ptr).begin())); let r: Ptr = (v.as_pointer() as Ptr).offset(1_usize); let __rhs = (r.read()); (*p.borrow()).iter_deref().write(__rhs); diff --git a/tests/unit/out/refcount/unboxed_conditional_iterator.rs b/tests/unit/out/refcount/unboxed_conditional_iterator.rs index 21fae41de..682c775ef 100644 --- a/tests/unit/out/refcount/unboxed_conditional_iterator.rs +++ b/tests/unit/out/refcount/unboxed_conditional_iterator.rs @@ -48,8 +48,8 @@ pub fn lehmer_2(mut sigma: Ptr, mut len: u32, mut code: Ptr) { let mut i: u32 = 0_u32; 'loop_: while (i < len) { let it: Value> = Rc::new(RefCell::new({ - let mut __it = RandomAccessIterator::Vec((items.as_pointer() as Ptr)); - while __it != RandomAccessIterator::Vec((items.as_pointer() as Ptr).to_end()) + let mut __it = (items.as_pointer() as Ptr).begin(); + while __it != (items.as_pointer() as Ptr).end() && __it .iter_deref() .with(|__v| *__v != (elem!(sigma, i).read())) @@ -58,12 +58,9 @@ pub fn lehmer_2(mut sigma: Ptr, mut len: u32, mut code: Ptr) { } __it })); - assert!( - (*it.borrow()) != RandomAccessIterator::Vec((items.as_pointer() as Ptr).to_end()) - ); - let __rhs = ((*it.borrow()) - .iter_distance(&RandomAccessIterator::Vec((items.as_pointer() as Ptr))) - as u32); + assert!((*it.borrow()) != (items.as_pointer() as Ptr).end()); + let __rhs = + ((*it.borrow()).iter_distance(&(items.as_pointer() as Ptr).begin()) as u32); elem!(code, i).write(__rhs); { let idx = >::from((*it.borrow()).clone()) @@ -77,12 +74,10 @@ pub fn lehmer_2(mut sigma: Ptr, mut len: u32, mut code: Ptr) { } pub fn sum_3(v: Ptr>) -> i32 { let mut s: i32 = 0; - let it: Value> = Rc::new(RefCell::new(RandomAccessIterator::Vec( - (Ptr::>::decay(&(v)) as Ptr), - ))); - 'loop_: while (*it.borrow()) - != RandomAccessIterator::Vec((Ptr::>::decay(&(v)) as Ptr).to_end()) - { + let it: Value> = Rc::new(RefCell::new( + (Ptr::>::decay(&(v)) as Ptr).begin(), + )); + 'loop_: while (*it.borrow()) != (Ptr::>::decay(&(v)) as Ptr).end() { s += ((*it.borrow()).iter_deref().read()); (*it.borrow_mut()).iter_inc(); } diff --git a/tests/unit/out/refcount/unboxed_locals.rs b/tests/unit/out/refcount/unboxed_locals.rs index a4d2eb5bd..94e5196c4 100644 --- a/tests/unit/out/refcount/unboxed_locals.rs +++ b/tests/unit/out/refcount/unboxed_locals.rs @@ -23,8 +23,8 @@ pub struct Pair { pub fn total_2(v: Ptr>) -> i32 { let mut s: i32 = 0; 'loop_: for x in IterRange::new( - RandomAccessIterator::Vec((Ptr::>::decay(&(v)) as Ptr)), - RandomAccessIterator::Vec((Ptr::>::decay(&(v)) as Ptr).to_end()), + (Ptr::>::decay(&(v)) as Ptr).begin(), + (Ptr::>::decay(&(v)) as Ptr).end(), ) { let mut x: i32 = (x.iter_deref().read()); s += x; diff --git a/tests/unit/out/refcount/vector.rs b/tests/unit/out/refcount/vector.rs index 9cb8df477..b74721bc1 100644 --- a/tests/unit/out/refcount/vector.rs +++ b/tests/unit/out/refcount/vector.rs @@ -55,11 +55,9 @@ fn main_0() -> i32 { }; assert!(((*v2.borrow()).len() == 3_usize)); { - let idx = >::from(RandomAccessIterator::Vec( - (v2.as_pointer() as Ptr), - )) - .vec_ptr() - .get_offset(); + let idx = >::from((v2.as_pointer() as Ptr).begin()) + .vec_ptr() + .get_offset(); (v2.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(idx)); RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay()) }; @@ -67,13 +65,11 @@ fn main_0() -> i32 { assert!(({ (*v2.borrow())[0_usize] } == 2)); assert!(({ (*v2.borrow())[1_usize] } == 3)); { - let __off = >::from(RandomAccessIterator::Vec( - (v2.as_pointer() as Ptr), - )) - .vec_ptr() - .get_offset(); + let __off = >::from((v2.as_pointer() as Ptr).begin()) + .vec_ptr() + .get_offset(); (*v2.borrow_mut()).insert(__off, 100); - >::from(RandomAccessIterator::Vec((v2.as_pointer() as Ptr))) + >::from((v2.as_pointer() as Ptr).begin()) }; ({ copy_0((*v2.borrow()).clone()) }); assert!(((*v2.borrow()).len() == 3_usize)); diff --git a/tests/unit/out/refcount/vector3.rs b/tests/unit/out/refcount/vector3.rs index 2b5ec9579..f29da1f9a 100644 --- a/tests/unit/out/refcount/vector3.rs +++ b/tests/unit/out/refcount/vector3.rs @@ -30,40 +30,40 @@ fn main_0() -> i32 { index!(elem!((v.as_pointer() as Ptr>), 0_usize), 1_usize).write(5); index!(elem!((v.as_pointer() as Ptr>), 1_usize), 0_usize).write(6); 'loop_: for v2 in IterRange::new( - RandomAccessIterator::Vec((v.as_pointer() as Ptr>)), - RandomAccessIterator::Vec((v.as_pointer() as Ptr>).to_end()), + (v.as_pointer() as Ptr>).begin(), + (v.as_pointer() as Ptr>).end(), ) { let v2: Ptr> = v2.iter_deref(); 'loop_: for i in IterRange::new( - RandomAccessIterator::Vec((Ptr::>::decay(&(v2)) as Ptr)), - RandomAccessIterator::Vec((Ptr::>::decay(&(v2)) as Ptr).to_end()), + (Ptr::>::decay(&(v2)) as Ptr).begin(), + (Ptr::>::decay(&(v2)) as Ptr).end(), ) { let i: Ptr = i.iter_deref(); i.with_mut(|__v| __v.prefix_inc()); } } 'loop_: for v2 in IterRange::new( - RandomAccessIterator::Vec((v.as_pointer() as Ptr>)), - RandomAccessIterator::Vec((v.as_pointer() as Ptr>).to_end()), + (v.as_pointer() as Ptr>).begin(), + (v.as_pointer() as Ptr>).end(), ) { let v2: Ptr> = v2.iter_deref(); 'loop_: for i in IterRange::new( - RandomAccessIterator::Vec((Ptr::>::decay(&(v2)) as Ptr)), - RandomAccessIterator::Vec((Ptr::>::decay(&(v2)) as Ptr).to_end()), + (Ptr::>::decay(&(v2)) as Ptr).begin(), + (Ptr::>::decay(&(v2)) as Ptr).end(), ) { let mut i: i32 = (i.iter_deref().read()); println!("{}", (i + 3)); } } 'loop_: for v2 in IterRange::new( - RandomAccessIterator::Vec((v.as_pointer() as Ptr>)), - RandomAccessIterator::Vec((v.as_pointer() as Ptr>).to_end()), + (v.as_pointer() as Ptr>).begin(), + (v.as_pointer() as Ptr>).end(), ) { let v2: Value> = Rc::new(RefCell::new((*v2.iter_deref().upgrade().deref()).clone())); 'loop_: for i in IterRange::new( - RandomAccessIterator::Vec((v2.as_pointer() as Ptr)), - RandomAccessIterator::Vec((v2.as_pointer() as Ptr).to_end()), + (v2.as_pointer() as Ptr).begin(), + (v2.as_pointer() as Ptr).end(), ) { let mut i: i32 = (i.iter_deref().read()); println!("{}", i); diff --git a/tests/unit/out/refcount/vector_with_allocator.rs b/tests/unit/out/refcount/vector_with_allocator.rs index 9af36ebc9..382795fa5 100644 --- a/tests/unit/out/refcount/vector_with_allocator.rs +++ b/tests/unit/out/refcount/vector_with_allocator.rs @@ -100,11 +100,9 @@ fn main_0() -> i32 { }; assert!(((*v2.borrow()).len() == 3_usize)); { - let idx = >::from(RandomAccessIterator::Vec( - (v2.as_pointer() as Ptr), - )) - .vec_ptr() - .get_offset(); + let idx = >::from((v2.as_pointer() as Ptr).begin()) + .vec_ptr() + .get_offset(); (v2.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(idx)); RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay()) }; @@ -112,13 +110,11 @@ fn main_0() -> i32 { assert!(({ (*v2.borrow())[0_usize] } == 2)); assert!(({ (*v2.borrow())[1_usize] } == 3)); { - let __off = >::from(RandomAccessIterator::Vec( - (v2.as_pointer() as Ptr), - )) - .vec_ptr() - .get_offset(); + let __off = >::from((v2.as_pointer() as Ptr).begin()) + .vec_ptr() + .get_offset(); (*v2.borrow_mut()).insert(__off, 100); - >::from(RandomAccessIterator::Vec((v2.as_pointer() as Ptr))) + >::from((v2.as_pointer() as Ptr).begin()) }; ({ copy_0((*v2.borrow()).clone()) }); assert!(((*v2.borrow()).len() == 3_usize)); diff --git a/tests/unit/out/refcount/void_return.rs b/tests/unit/out/refcount/void_return.rs index a83d7348a..1b8776ad2 100644 --- a/tests/unit/out/refcount/void_return.rs +++ b/tests/unit/out/refcount/void_return.rs @@ -58,10 +58,8 @@ pub fn main() { fn main_0() -> i32 { let v: Value> = Rc::new(RefCell::new(vec![1, 3, 0, 2, 8, 7])); ({ - let _first: RandomAccessIterator = - RandomAccessIterator::Vec((v.as_pointer() as Ptr)); - let _last: RandomAccessIterator = - RandomAccessIterator::Vec((v.as_pointer() as Ptr).to_end()); + let _first: RandomAccessIterator = (v.as_pointer() as Ptr).begin(); + let _last: RandomAccessIterator = (v.as_pointer() as Ptr).end(); f1_0(_first, _last) }); let a: Value> = Rc::new(RefCell::new(Box::new([1, 2, 3]))); diff --git a/tests/unit/out/unsafe/auto.rs b/tests/unit/out/unsafe/auto.rs index ec99d0772..8a5f25a2d 100644 --- a/tests/unit/out/unsafe/auto.rs +++ b/tests/unit/out/unsafe/auto.rs @@ -26,10 +26,7 @@ unsafe fn main_0() -> i32 { v.push(__a1) }; let mut sum: i32 = 0; - 'loop_: for elem in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), - ) { + 'loop_: for elem in IterRange::new(v.begin(), v.end()) { let mut elem: i32 = (*elem.iter_deref()); sum += elem; } diff --git a/tests/unit/out/unsafe/elidable_iterator_copy_cxx11.rs b/tests/unit/out/unsafe/elidable_iterator_copy_cxx11.rs index e34a538c7..ff68cccfe 100644 --- a/tests/unit/out/unsafe/elidable_iterator_copy_cxx11.rs +++ b/tests/unit/out/unsafe/elidable_iterator_copy_cxx11.rs @@ -23,46 +23,31 @@ unsafe fn main_0() -> i32 { v.push(__a1) }; let mut it: UnsafeRandomAccessIterator = { - let mut __it = UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); - while __it != UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())) - && *__it.iter_deref() != 7 - { + let mut __it = v.begin(); + while __it != v.end() && *__it.iter_deref() != 7 { __it.iter_inc(); } __it }; - assert!(it != UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len()))); + assert!(it != v.end()); assert!(((*it.iter_deref()) == (7))); { - let __n = UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())) - .iter_distance(&UnsafeRandomAccessIterator::Vec(v.as_mut_ptr())); + let __n = v.end().iter_distance(&v.begin()); for __i in (1..__n).rev() { let __j = libc::rand() as isize % (__i + 1); - std::ptr::swap( - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__i), - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__j), - ); + std::ptr::swap(v.begin().iter_at(__i), v.begin().iter_at(__j)); } }; { - let __n = UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())) - .iter_distance(&UnsafeRandomAccessIterator::Vec(v.as_mut_ptr())); + let __n = v.end().iter_distance(&v.begin()); let mut __order: Vec = (0..__n).collect(); - __order.sort_by(|&__x, &__y| { - (*UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__x)) - .cmp(&*UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__y)) - }); + __order.sort_by(|&__x, &__y| (*v.begin().iter_at(__x)).cmp(&*v.begin().iter_at(__y))); let __values: Vec<_> = __order .iter() - .map(|&__i| { - std::ptr::read(UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__i)) - }) + .map(|&__i| std::ptr::read(v.begin().iter_at(__i))) .collect(); for (__i, __v) in (0..__n).zip(__values) { - std::ptr::write( - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__i), - __v, - ); + std::ptr::write(v.begin().iter_at(__i), __v); } }; assert!(((v[(0_usize)]) == (4)) && ((v[(1_usize)]) == (7))); diff --git a/tests/unit/out/unsafe/find.rs b/tests/unit/out/unsafe/find.rs index ca95dc517..d5374dadb 100644 --- a/tests/unit/out/unsafe/find.rs +++ b/tests/unit/out/unsafe/find.rs @@ -26,10 +26,8 @@ unsafe fn main_0() -> i32 { let __a1 = 3; v.push(__a1) }; - let mut v_begin: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); - let mut v_end: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); + let mut v_begin: UnsafeRandomAccessIterator = v.begin(); + let mut v_end: UnsafeRandomAccessIterator = v.end(); let mut it: UnsafeRandomAccessIterator = { let mut __it = (v_begin).clone(); while __it != (v_end).clone() && *__it.iter_deref() != 2 { @@ -37,8 +35,7 @@ unsafe fn main_0() -> i32 { } __it }; - let mut v_result_true: bool = - it != UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); + let mut v_result_true: bool = it != v.end(); let mut m: UnsafeMap = UnsafeMap::new(); (*&mut (*m.get_or_insert_with(1.clone(), || (1, ::default()))).1) = 1_f64; (*&mut (*m.get_or_insert_with(2.clone(), || (2, ::default()))).1) = 2_f64; @@ -49,48 +46,40 @@ unsafe fn main_0() -> i32 { assert!( ((v_result_true) && (m_result_true)) && ({ - let mut __it = UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); - while __it != UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()) - && *__it.iter_deref() != 2 - { + let mut __it = v.begin(); + while __it != v.begin() && *__it.iter_deref() != 2 { __it.iter_inc(); } __it - } == UnsafeRandomAccessIterator::Vec(v.as_mut_ptr())) + } == v.begin()) ); let mut w: Vec = vec![1, 2, 3, 4, 5]; assert!( { - let mut __it = UnsafeRandomAccessIterator::Vec(w.as_mut_ptr()).iter_add(2_isize); - while __it != UnsafeRandomAccessIterator::Vec(w.as_mut_ptr().add(w.len())) - && *__it.iter_deref() != 4 - { + let mut __it = w.begin().iter_add(2_isize); + while __it != w.end() && *__it.iter_deref() != 4 { __it.iter_inc(); } __it - } == UnsafeRandomAccessIterator::Vec(w.as_mut_ptr()).iter_add(3_isize) + } == w.begin().iter_add(3_isize) ); assert!( { - let mut __it = UnsafeRandomAccessIterator::Vec(w.as_mut_ptr()).iter_add(2_isize); - while __it != UnsafeRandomAccessIterator::Vec(w.as_mut_ptr().add(w.len())) - && *__it.iter_deref() != 1 - { + let mut __it = w.begin().iter_add(2_isize); + while __it != w.end() && *__it.iter_deref() != 1 { __it.iter_inc(); } __it - } == UnsafeRandomAccessIterator::Vec(w.as_mut_ptr().add(w.len())) + } == w.end() ); assert!( { - let mut __it = UnsafeRandomAccessIterator::Vec(w.as_mut_ptr()).iter_add(2_isize); - while __it != UnsafeRandomAccessIterator::Vec(w.as_mut_ptr()).iter_add(4_isize) - && *__it.iter_deref() != 5 - { + let mut __it = w.begin().iter_add(2_isize); + while __it != w.begin().iter_add(4_isize) && *__it.iter_deref() != 5 { __it.iter_inc(); } __it - } == UnsafeRandomAccessIterator::Vec(w.as_mut_ptr()).iter_add(4_isize) + } == w.begin().iter_add(4_isize) ); return 0; } diff --git a/tests/unit/out/unsafe/fn_ptr_stable_sort.rs b/tests/unit/out/unsafe/fn_ptr_stable_sort.rs index 814c7ced9..1e52426a1 100644 --- a/tests/unit/out/unsafe/fn_ptr_stable_sort.rs +++ b/tests/unit/out/unsafe/fn_ptr_stable_sort.rs @@ -36,12 +36,11 @@ unsafe fn main_0() -> i32 { v.push(__a1) }; { - let __n = UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())) - .iter_distance(&UnsafeRandomAccessIterator::Vec(v.as_mut_ptr())); + let __n = v.end().iter_distance(&v.begin()); let mut __order: Vec = (0..__n).collect(); __order.sort_by(|&__x, &__y| { - let __a = UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__x) as *const _; - let __b = UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__y) as *const _; + let __a = v.begin().iter_at(__x) as *const _; + let __b = v.begin().iter_at(__y) as *const _; if (Compare_0 as unsafe fn(*const Item, *const Item) -> bool).call(__a, __b) { std::cmp::Ordering::Less } else if (Compare_0 as unsafe fn(*const Item, *const Item) -> bool).call(__b, __a) { @@ -52,15 +51,10 @@ unsafe fn main_0() -> i32 { }); let __values: Vec<_> = __order .iter() - .map(|&__i| { - std::ptr::read(UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__i)) - }) + .map(|&__i| std::ptr::read(v.begin().iter_at(__i))) .collect(); for (__i, __v) in (0..__n).zip(__values) { - std::ptr::write( - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__i), - __v, - ); + std::ptr::write(v.begin().iter_at(__i), __v); } }; assert!(((v[(0_usize)].key) == (1))); diff --git a/tests/unit/out/unsafe/foreach.rs b/tests/unit/out/unsafe/foreach.rs index 4d44741fb..79f288c1b 100644 --- a/tests/unit/out/unsafe/foreach.rs +++ b/tests/unit/out/unsafe/foreach.rs @@ -23,10 +23,7 @@ unsafe fn main_0() -> i32 { i.prefix_inc(); } let mut sum: i32 = 0; - 'loop_: for x in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), - ) { + 'loop_: for x in IterRange::new(v.begin(), v.end()) { let mut x: i32 = (*x.iter_deref()); sum += x; } diff --git a/tests/unit/out/unsafe/foreach_disjoint_field_borrow.rs b/tests/unit/out/unsafe/foreach_disjoint_field_borrow.rs index a7e3ae5aa..9821d8d7a 100644 --- a/tests/unit/out/unsafe/foreach_disjoint_field_borrow.rs +++ b/tests/unit/out/unsafe/foreach_disjoint_field_borrow.rs @@ -24,10 +24,7 @@ unsafe fn main_0() -> i32 { let __a1 = 1; s.v.push(__a1) }; - 'loop_: for e in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec(s.v.as_mut_ptr()), - UnsafeRandomAccessIterator::Vec(s.v.as_mut_ptr().add(s.v.len())), - ) { + 'loop_: for e in IterRange::new(s.v.begin(), s.v.end()) { let mut e: i32 = (*e.iter_deref()); s.a.postfix_inc(); } diff --git a/tests/unit/out/unsafe/foreach_double.rs b/tests/unit/out/unsafe/foreach_double.rs index 3355e50fe..da7b346da 100644 --- a/tests/unit/out/unsafe/foreach_double.rs +++ b/tests/unit/out/unsafe/foreach_double.rs @@ -27,54 +27,30 @@ unsafe fn main_0() -> i32 { v.push(__a1) }; let mut square: i32 = 0; - 'loop_: for e1 in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), - ) { + 'loop_: for e1 in IterRange::new(v.begin(), v.end()) { let mut e1: i32 = (*e1.iter_deref()); - 'loop_: for e2 in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), - ) { + 'loop_: for e2 in IterRange::new(v.begin(), v.end()) { let mut e2: i32 = (*e2.iter_deref()); square += ((e1) * (e2)); } } - 'loop_: for e1 in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), - ) { + 'loop_: for e1 in IterRange::new(v.begin(), v.end()) { let e1: *mut i32 = &mut (*e1.iter_deref()); - 'loop_: for e2 in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), - ) { + 'loop_: for e2 in IterRange::new(v.begin(), v.end()) { let e2: *const i32 = &(*e2.iter_deref()); square += ((*e1) * (*e2)); } } - 'loop_: for e1 in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), - ) { + 'loop_: for e1 in IterRange::new(v.begin(), v.end()) { let e1: *const i32 = &(*e1.iter_deref()); - 'loop_: for e2 in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), - ) { + 'loop_: for e2 in IterRange::new(v.begin(), v.end()) { let e2: *mut i32 = &mut (*e2.iter_deref()); square += ((*e1) * (*e2)); } } - 'loop_: for e1 in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), - ) { + 'loop_: for e1 in IterRange::new(v.begin(), v.end()) { let e1: *mut i32 = &mut (*e1.iter_deref()); - 'loop_: for e2 in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), - ) { + 'loop_: for e2 in IterRange::new(v.begin(), v.end()) { let e2: *mut i32 = &mut (*e2.iter_deref()); square += ((*e1) * (*e2)); } @@ -95,15 +71,9 @@ unsafe fn main_0() -> i32 { let __a1 = std::mem::take(&mut v3); m.push(__a1) }; - 'loop_: for row in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec(m.as_mut_ptr()), - UnsafeRandomAccessIterator::Vec(m.as_mut_ptr().add(m.len())), - ) { + 'loop_: for row in IterRange::new(m.begin(), m.end()) { let row: *mut Vec = &mut (*row.iter_deref()); - 'loop_: for col in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec((*row).as_mut_ptr()), - UnsafeRandomAccessIterator::Vec((*row).as_mut_ptr().add((*row).len())), - ) { + 'loop_: for col in IterRange::new((*row).begin(), (*row).end()) { let col: *mut i32 = &mut (*col.iter_deref()); square += (*col); } diff --git a/tests/unit/out/unsafe/foreach_map.rs b/tests/unit/out/unsafe/foreach_map.rs index f866932a7..0e0ea4f17 100644 --- a/tests/unit/out/unsafe/foreach_map.rs +++ b/tests/unit/out/unsafe/foreach_map.rs @@ -25,21 +25,21 @@ unsafe fn main_0() -> i32 { }; } let mut sum: f64 = 0_f64; - 'loop_: for i in UnsafeIterRange::new(m.begin(), m.end()) { + 'loop_: for i in IterRange::new(m.begin(), m.end()) { let i: *const (i32, f64) = &(*i.iter_deref()); sum += (*i).1; } - 'loop_: for i in UnsafeIterRange::new(m.begin(), m.end()) { + 'loop_: for i in IterRange::new(m.begin(), m.end()) { let mut i: (i32, f64) = (*i.iter_deref()).clone(); sum += (i.0 as f64); } assert!(((sum) == (7475_f64))); - 'loop_: for i in UnsafeIterRange::new(m.begin(), m.end()) { + 'loop_: for i in IterRange::new(m.begin(), m.end()) { let mut i: (i32, f64) = (*i.iter_deref()).clone(); i.1 = (-1_i32 as f64); assert!(((i.1) == (-1_i32 as f64))); } - 'loop_: for i in UnsafeIterRange::new(m.begin(), m.end()) { + 'loop_: for i in IterRange::new(m.begin(), m.end()) { let i: *const (i32, f64) = &(*i.iter_deref()); assert!((((*i).1) != (-1_i32 as f64))); } diff --git a/tests/unit/out/unsafe/foreach_mut.rs b/tests/unit/out/unsafe/foreach_mut.rs index 126986f52..3b6869788 100644 --- a/tests/unit/out/unsafe/foreach_mut.rs +++ b/tests/unit/out/unsafe/foreach_mut.rs @@ -27,31 +27,19 @@ unsafe fn main_0() -> i32 { v1.push(__a1) }; let mut sum: i32 = 0; - 'loop_: for x in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr()), - UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr().add(v1.len())), - ) { + 'loop_: for x in IterRange::new(v1.begin(), v1.end()) { let mut x: i32 = (*x.iter_deref()); sum += x.prefix_inc(); } - 'loop_: for x in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr()), - UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr().add(v1.len())), - ) { + 'loop_: for x in IterRange::new(v1.begin(), v1.end()) { let x: i32 = (*x.iter_deref()); sum += x; } - 'loop_: for x in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr()), - UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr().add(v1.len())), - ) { + 'loop_: for x in IterRange::new(v1.begin(), v1.end()) { let x: *mut i32 = &mut (*x.iter_deref()); (*x) += 10; } - 'loop_: for x in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr()), - UnsafeRandomAccessIterator::Vec(v1.as_mut_ptr().add(v1.len())), - ) { + 'loop_: for x in IterRange::new(v1.begin(), v1.end()) { let x: *const i32 = &(*x.iter_deref()); sum += (*x); } @@ -68,31 +56,19 @@ unsafe fn main_0() -> i32 { let __a1 = (&mut v1[(2_usize)] as *mut i32); v2.push(__a1) }; - 'loop_: for p in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()), - UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(v2.len())), - ) { + 'loop_: for p in IterRange::new(v2.begin(), v2.end()) { let mut p: *mut i32 = (*p.iter_deref()); (*p) += 5; } - 'loop_: for p in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()), - UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(v2.len())), - ) { + 'loop_: for p in IterRange::new(v2.begin(), v2.end()) { let p: *mut i32 = (*p.iter_deref()); sum += (*p); } - 'loop_: for p in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()), - UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(v2.len())), - ) { + 'loop_: for p in IterRange::new(v2.begin(), v2.end()) { let mut p: *mut i32 = (*p.iter_deref()); (*p) += 5; } - 'loop_: for p in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()), - UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(v2.len())), - ) { + 'loop_: for p in IterRange::new(v2.begin(), v2.end()) { let mut p: *const i32 = (*p.iter_deref()).cast_const(); sum += (*p); } diff --git a/tests/unit/out/unsafe/iterator_freshness.rs b/tests/unit/out/unsafe/iterator_freshness.rs index a3ddb1f65..1c1756e6a 100644 --- a/tests/unit/out/unsafe/iterator_freshness.rs +++ b/tests/unit/out/unsafe/iterator_freshness.rs @@ -17,8 +17,7 @@ unsafe fn main_0() -> i32 { let mut vec_: Vec = (0..(4_usize) as usize) .map(|_| ::default()) .collect::>(); - let mut it: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(vec_.as_mut_ptr()); + let mut it: UnsafeRandomAccessIterator = vec_.begin(); (unsafe { foo_0((it).clone()) }); return 0; } diff --git a/tests/unit/out/unsafe/iterators.rs b/tests/unit/out/unsafe/iterators.rs index e80197bf9..b2389c057 100644 --- a/tests/unit/out/unsafe/iterators.rs +++ b/tests/unit/out/unsafe/iterators.rs @@ -17,15 +17,15 @@ unsafe fn main_0() -> i32 { let s = c"hello".as_ptr(); std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1).to_vec() }; - 'loop_: for c in UnsafeIterRange::new(x.as_mut_ptr(), x.as_mut_ptr().add(x.len() - 1)) { + 'loop_: for c in IterRange::new(x.as_mut_ptr(), x.as_mut_ptr().add(x.len() - 1)) { let c: *mut libc::c_char = &mut (*c.iter_deref()); (*c).prefix_inc(); } - 'loop_: for c in UnsafeIterRange::new(x.as_mut_ptr(), x.as_mut_ptr().add(x.len() - 1)) { + 'loop_: for c in IterRange::new(x.as_mut_ptr(), x.as_mut_ptr().add(x.len() - 1)) { let c: *mut libc::c_char = &mut (*c.iter_deref()); (unsafe { libc::printf(c"%c\n".as_ptr() as *const libc::c_char, ((*c) as i32)) }); } - 'loop_: for c in UnsafeIterRange::new(x.as_mut_ptr(), x.as_mut_ptr().add(x.len() - 1)) { + 'loop_: for c in IterRange::new(x.as_mut_ptr(), x.as_mut_ptr().add(x.len() - 1)) { let mut c: libc::c_char = (*c.iter_deref()); (unsafe { libc::printf(c"%c\n".as_ptr() as *const libc::c_char, (c as i32)) }); } @@ -38,10 +38,7 @@ unsafe fn main_0() -> i32 { let __a1 = (Box::leak(Box::new(3)) as *mut i32); v.push(__a1) }; - 'loop_: for p in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), - ) { + 'loop_: for p in IterRange::new(v.begin(), v.end()) { let mut p: *mut i32 = (*p.iter_deref()); (unsafe { libc::printf(c"%d\n".as_ptr() as *const libc::c_char, (*p)) }); } diff --git a/tests/unit/out/unsafe/map-reallocation.rs b/tests/unit/out/unsafe/map-reallocation.rs index cd901948d..8b3bddbd8 100644 --- a/tests/unit/out/unsafe/map-reallocation.rs +++ b/tests/unit/out/unsafe/map-reallocation.rs @@ -58,7 +58,7 @@ unsafe fn main_0() -> i32 { assert!(((*p) == (57005))); assert!(((m.len()) == ((((N) + (1)) as u32) as usize))); let mut prev: i32 = -1_i32; - 'loop_: for pair in UnsafeIterRange::new(m.begin(), m.end()) { + 'loop_: for pair in IterRange::new(m.begin(), m.end()) { let pair: *mut (i32, i32) = &mut (*pair.iter_deref()); assert!((((*pair).0) > (prev))); prev = (*pair).0; diff --git a/tests/unit/out/unsafe/map.rs b/tests/unit/out/unsafe/map.rs index 1ce885479..58d16941c 100644 --- a/tests/unit/out/unsafe/map.rs +++ b/tests/unit/out/unsafe/map.rs @@ -191,7 +191,7 @@ unsafe fn main_0() -> i32 { } assert!(((m2.len()) == (indexes.len()))); let mut last: i32 = -1_i32; - 'loop_: for pair in UnsafeIterRange::new(m2.begin(), m2.end()) { + 'loop_: for pair in IterRange::new(m2.begin(), m2.end()) { let pair: *mut (i32, bool) = &mut (*pair.iter_deref()); assert!((((*pair).0) > (last))); assert!((((*pair).1 as i32) == (((*pair).0) % (2)))); diff --git a/tests/unit/out/unsafe/map_key_identity.rs b/tests/unit/out/unsafe/map_key_identity.rs index 2126b2134..9d82b0548 100644 --- a/tests/unit/out/unsafe/map_key_identity.rs +++ b/tests/unit/out/unsafe/map_key_identity.rs @@ -118,7 +118,7 @@ unsafe fn main_0() -> i32 { }) as i32)) != 0; let mut distinct_count: usize = 0_usize; - 'loop_: for entry in UnsafeIterRange::new(distinct.begin(), distinct.end()) { + 'loop_: for entry in IterRange::new(distinct.begin(), distinct.end()) { let entry: *const (Key, Mapped) = &(*entry.iter_deref()); if ((distinct_count) == (0_usize)) { ok = ((ok as i32) @@ -179,7 +179,7 @@ unsafe fn main_0() -> i32 { as i32)) != 0; let mut equivalent_count: usize = 0_usize; - 'loop_: for entry in UnsafeIterRange::new(equivalent.begin(), equivalent.end()) { + 'loop_: for entry in IterRange::new(equivalent.begin(), equivalent.end()) { let entry: *const (Key, Mapped) = &(*entry.iter_deref()); ok = ((ok as i32) & (((((*entry).0.order) == (3)) && (((*entry).1.value) == (31))) as i32)) diff --git a/tests/unit/out/unsafe/operator_traits.rs b/tests/unit/out/unsafe/operator_traits.rs index 718531e00..b75c6abb4 100644 --- a/tests/unit/out/unsafe/operator_traits.rs +++ b/tests/unit/out/unsafe/operator_traits.rs @@ -139,24 +139,15 @@ unsafe fn main_0() -> i32 { assert!(((w.v) == (2))); let mut lts: Vec = vec![Lt { v: 3 }, Lt { v: 1 }, Lt { v: 2 }]; { - let __n = UnsafeRandomAccessIterator::Vec(lts.as_mut_ptr().add(lts.len())) - .iter_distance(&UnsafeRandomAccessIterator::Vec(lts.as_mut_ptr())); + let __n = lts.end().iter_distance(<s.begin()); let mut __order: Vec = (0..__n).collect(); - __order.sort_by(|&__x, &__y| { - (*UnsafeRandomAccessIterator::Vec(lts.as_mut_ptr()).iter_at(__x)) - .cmp(&*UnsafeRandomAccessIterator::Vec(lts.as_mut_ptr()).iter_at(__y)) - }); + __order.sort_by(|&__x, &__y| (*lts.begin().iter_at(__x)).cmp(&*lts.begin().iter_at(__y))); let __values: Vec<_> = __order .iter() - .map(|&__i| { - std::ptr::read(UnsafeRandomAccessIterator::Vec(lts.as_mut_ptr()).iter_at(__i)) - }) + .map(|&__i| std::ptr::read(lts.begin().iter_at(__i))) .collect(); for (__i, __v) in (0..__n).zip(__values) { - std::ptr::write( - UnsafeRandomAccessIterator::Vec(lts.as_mut_ptr()).iter_at(__i), - __v, - ); + std::ptr::write(lts.begin().iter_at(__i), __v); } }; assert!( @@ -167,10 +158,8 @@ unsafe fn main_0() -> i32 { let mut nine: Eq = Eq { v: 9 }; assert!( (((*{ - let mut __it = UnsafeRandomAccessIterator::Vec(eqs.as_mut_ptr()); - while __it != UnsafeRandomAccessIterator::Vec(eqs.as_mut_ptr().add(eqs.len())) - && *__it.iter_deref() != two - { + let mut __it = eqs.begin(); + while __it != eqs.end() && *__it.iter_deref() != two { __it.iter_inc(); } __it @@ -180,45 +169,32 @@ unsafe fn main_0() -> i32 { ); assert!( { - let mut __it = UnsafeRandomAccessIterator::Vec(eqs.as_mut_ptr()); - while __it != UnsafeRandomAccessIterator::Vec(eqs.as_mut_ptr().add(eqs.len())) - && *__it.iter_deref() != nine - { + let mut __it = eqs.begin(); + while __it != eqs.end() && *__it.iter_deref() != nine { __it.iter_inc(); } __it - } == UnsafeRandomAccessIterator::Vec(eqs.as_mut_ptr().add(eqs.len())) + } == eqs.end() ); let mut cmps: Vec = vec![Cmp { v: 3 }, Cmp { v: 1 }, Cmp { v: 2 }]; { - let __n = UnsafeRandomAccessIterator::Vec(cmps.as_mut_ptr().add(cmps.len())) - .iter_distance(&UnsafeRandomAccessIterator::Vec(cmps.as_mut_ptr())); + let __n = cmps.end().iter_distance(&cmps.begin()); let mut __order: Vec = (0..__n).collect(); - __order.sort_by(|&__x, &__y| { - (*UnsafeRandomAccessIterator::Vec(cmps.as_mut_ptr()).iter_at(__x)) - .cmp(&*UnsafeRandomAccessIterator::Vec(cmps.as_mut_ptr()).iter_at(__y)) - }); + __order.sort_by(|&__x, &__y| (*cmps.begin().iter_at(__x)).cmp(&*cmps.begin().iter_at(__y))); let __values: Vec<_> = __order .iter() - .map(|&__i| { - std::ptr::read(UnsafeRandomAccessIterator::Vec(cmps.as_mut_ptr()).iter_at(__i)) - }) + .map(|&__i| std::ptr::read(cmps.begin().iter_at(__i))) .collect(); for (__i, __v) in (0..__n).zip(__values) { - std::ptr::write( - UnsafeRandomAccessIterator::Vec(cmps.as_mut_ptr()).iter_at(__i), - __v, - ); + std::ptr::write(cmps.begin().iter_at(__i), __v); } }; assert!(((cmps[(0_usize)].v) == (1)) && ((cmps[(2_usize)].v) == (3))); let mut three: Cmp = Cmp { v: 3 }; assert!( (((*{ - let mut __it = UnsafeRandomAccessIterator::Vec(cmps.as_mut_ptr()); - while __it != UnsafeRandomAccessIterator::Vec(cmps.as_mut_ptr().add(cmps.len())) - && *__it.iter_deref() != three - { + let mut __it = cmps.begin(); + while __it != cmps.end() && *__it.iter_deref() != three { __it.iter_inc(); } __it @@ -228,34 +204,24 @@ unsafe fn main_0() -> i32 { ); let mut frees: Vec = vec![Free { v: 2 }, Free { v: 1 }]; { - let __n = UnsafeRandomAccessIterator::Vec(frees.as_mut_ptr().add(frees.len())) - .iter_distance(&UnsafeRandomAccessIterator::Vec(frees.as_mut_ptr())); + let __n = frees.end().iter_distance(&frees.begin()); let mut __order: Vec = (0..__n).collect(); - __order.sort_by(|&__x, &__y| { - (*UnsafeRandomAccessIterator::Vec(frees.as_mut_ptr()).iter_at(__x)) - .cmp(&*UnsafeRandomAccessIterator::Vec(frees.as_mut_ptr()).iter_at(__y)) - }); + __order + .sort_by(|&__x, &__y| (*frees.begin().iter_at(__x)).cmp(&*frees.begin().iter_at(__y))); let __values: Vec<_> = __order .iter() - .map(|&__i| { - std::ptr::read(UnsafeRandomAccessIterator::Vec(frees.as_mut_ptr()).iter_at(__i)) - }) + .map(|&__i| std::ptr::read(frees.begin().iter_at(__i))) .collect(); for (__i, __v) in (0..__n).zip(__values) { - std::ptr::write( - UnsafeRandomAccessIterator::Vec(frees.as_mut_ptr()).iter_at(__i), - __v, - ); + std::ptr::write(frees.begin().iter_at(__i), __v); } }; assert!(((frees[(0_usize)].v) == (1))); let mut ftwo: Free = Free { v: 2 }; assert!( (((*{ - let mut __it = UnsafeRandomAccessIterator::Vec(frees.as_mut_ptr()); - while __it != UnsafeRandomAccessIterator::Vec(frees.as_mut_ptr().add(frees.len())) - && *__it.iter_deref() != ftwo - { + let mut __it = frees.begin(); + while __it != frees.end() && *__it.iter_deref() != ftwo { __it.iter_inc(); } __it diff --git a/tests/unit/out/unsafe/sort.rs b/tests/unit/out/unsafe/sort.rs index fc4469412..305cb4034 100644 --- a/tests/unit/out/unsafe/sort.rs +++ b/tests/unit/out/unsafe/sort.rs @@ -55,24 +55,15 @@ unsafe fn main_0() -> i32 { v.push(__a1) }; { - let __n = UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())) - .iter_distance(&UnsafeRandomAccessIterator::Vec(v.as_mut_ptr())); + let __n = v.end().iter_distance(&v.begin()); let mut __order: Vec = (0..__n).collect(); - __order.sort_by(|&__x, &__y| { - (*UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__x)) - .cmp(&*UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__y)) - }); + __order.sort_by(|&__x, &__y| (*v.begin().iter_at(__x)).cmp(&*v.begin().iter_at(__y))); let __values: Vec<_> = __order .iter() - .map(|&__i| { - std::ptr::read(UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__i)) - }) + .map(|&__i| std::ptr::read(v.begin().iter_at(__i))) .collect(); for (__i, __v) in (0..__n).zip(__values) { - std::ptr::write( - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__i), - __v, - ); + std::ptr::write(v.begin().iter_at(__i), __v); } }; let mut i: u32 = 0_u32; diff --git a/tests/unit/out/unsafe/split_binop_aliased_borrows.rs b/tests/unit/out/unsafe/split_binop_aliased_borrows.rs index 2fbfba5d7..d88858f0a 100644 --- a/tests/unit/out/unsafe/split_binop_aliased_borrows.rs +++ b/tests/unit/out/unsafe/split_binop_aliased_borrows.rs @@ -14,7 +14,7 @@ pub fn main() { } unsafe fn main_0() -> i32 { let mut v: Vec = vec![1, 2]; - let mut p: UnsafeRandomAccessIterator = UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); + let mut p: UnsafeRandomAccessIterator = v.begin(); let r: *const i32 = &v[(1_usize)]; (*p.iter_deref()) = (*r); assert!(((v[(0_usize)]) == (2))); diff --git a/tests/unit/out/unsafe/unboxed_conditional_iterator.rs b/tests/unit/out/unsafe/unboxed_conditional_iterator.rs index 6cbbacdec..66c28d74d 100644 --- a/tests/unit/out/unsafe/unboxed_conditional_iterator.rs +++ b/tests/unit/out/unsafe/unboxed_conditional_iterator.rs @@ -44,17 +44,14 @@ pub unsafe fn lehmer_2(mut sigma: *const u32, mut len: u32, mut code: *mut u32) let mut i: u32 = 0_u32; 'loop_: while ((i) < (len)) { let mut it: UnsafeRandomAccessIterator = { - let mut __it = UnsafeRandomAccessIterator::Vec(items.as_mut_ptr()); - while __it != UnsafeRandomAccessIterator::Vec(items.as_mut_ptr().add(items.len())) - && *__it.iter_deref() != (*sigma.offset((i) as isize)) - { + let mut __it = items.begin(); + while __it != items.end() && *__it.iter_deref() != (*sigma.offset((i) as isize)) { __it.iter_inc(); } __it }; - assert!(it != UnsafeRandomAccessIterator::Vec(items.as_mut_ptr().add(items.len()))); - (*code.offset((i) as isize)) = - (it.iter_distance(&UnsafeRandomAccessIterator::Vec(items.as_mut_ptr())) as u32); + assert!(it != items.end()); + (*code.offset((i) as isize)) = (it.iter_distance(&items.begin()) as u32); { let pos = >::from((it).clone()) .vec_ptr() @@ -67,9 +64,8 @@ pub unsafe fn lehmer_2(mut sigma: *const u32, mut len: u32, mut code: *mut u32) } pub unsafe fn sum_3(v: *mut Vec) -> i32 { let mut s: i32 = 0; - let mut it: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec((*v).as_mut_ptr()); - 'loop_: while it != UnsafeRandomAccessIterator::Vec((*v).as_mut_ptr().add((*v).len())) { + let mut it: UnsafeRandomAccessIterator = (*v).begin(); + 'loop_: while it != (*v).end() { s += (*it.iter_deref()); it.iter_inc(); } diff --git a/tests/unit/out/unsafe/unboxed_locals.rs b/tests/unit/out/unsafe/unboxed_locals.rs index fa6fad91f..66905320f 100644 --- a/tests/unit/out/unsafe/unboxed_locals.rs +++ b/tests/unit/out/unsafe/unboxed_locals.rs @@ -20,10 +20,7 @@ pub struct Pair { } pub unsafe fn total_2(v: *const Vec) -> i32 { let mut s: i32 = 0; - 'loop_: for x in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec((*v).as_ptr().cast_mut()), - UnsafeRandomAccessIterator::Vec((*v).as_ptr().add((*v).len()).cast_mut()), - ) { + 'loop_: for x in IterRange::new((*v).begin(), (*v).end()) { let mut x: i32 = (*x.iter_deref()); s += x; } diff --git a/tests/unit/out/unsafe/vector.rs b/tests/unit/out/unsafe/vector.rs index 06cdf633c..faf70ee93 100644 --- a/tests/unit/out/unsafe/vector.rs +++ b/tests/unit/out/unsafe/vector.rs @@ -56,25 +56,21 @@ unsafe fn main_0() -> i32 { }; assert!(((v2.len()) == (3_usize))); { - let pos = >::from(UnsafeRandomAccessIterator::Vec( - v2.as_mut_ptr(), - )) - .vec_ptr() - .offset_from(v2.as_ptr()) as usize; + let pos = >::from(v2.begin()) + .vec_ptr() + .offset_from(v2.as_ptr()) as usize; v2.remove(pos); - >::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) + >::from(v2.begin()) }; assert!(((v2.len()) == (2_usize))); assert!(((v2[(0_usize)]) == (2))); assert!(((v2[(1_usize)]) == (3))); { - let pos = >::from(UnsafeRandomAccessIterator::Vec( - v2.as_mut_ptr(), - )) - .vec_ptr() - .offset_from(v2.as_ptr()) as usize; + let pos = >::from(v2.begin()) + .vec_ptr() + .offset_from(v2.as_ptr()) as usize; v2.insert(pos, 100); - >::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) + >::from(v2.begin()) }; (unsafe { copy_0(v2.clone()) }); assert!(((v2.len()) == (3_usize))); diff --git a/tests/unit/out/unsafe/vector3.rs b/tests/unit/out/unsafe/vector3.rs index 912f971e2..4b5876414 100644 --- a/tests/unit/out/unsafe/vector3.rs +++ b/tests/unit/out/unsafe/vector3.rs @@ -29,41 +29,23 @@ unsafe fn main_0() -> i32 { v[(0_usize)][(0_usize)] = 1; v[(0_usize)][(1_usize)] = 5; v[(1_usize)][(0_usize)] = 6; - 'loop_: for v2 in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), - ) { + 'loop_: for v2 in IterRange::new(v.begin(), v.end()) { let v2: *mut Vec = &mut (*v2.iter_deref()); - 'loop_: for i in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec((*v2).as_mut_ptr()), - UnsafeRandomAccessIterator::Vec((*v2).as_mut_ptr().add((*v2).len())), - ) { + 'loop_: for i in IterRange::new((*v2).begin(), (*v2).end()) { let i: *mut i32 = &mut (*i.iter_deref()); (*i).prefix_inc(); } } - 'loop_: for v2 in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), - ) { + 'loop_: for v2 in IterRange::new(v.begin(), v.end()) { let v2: *mut Vec = &mut (*v2.iter_deref()); - 'loop_: for i in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec((*v2).as_mut_ptr()), - UnsafeRandomAccessIterator::Vec((*v2).as_mut_ptr().add((*v2).len())), - ) { + 'loop_: for i in IterRange::new((*v2).begin(), (*v2).end()) { let mut i: i32 = (*i.iter_deref()); (unsafe { libc::printf(c"%d\n".as_ptr() as *const libc::c_char, ((i) + (3))) }); } } - 'loop_: for v2 in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()), - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())), - ) { + 'loop_: for v2 in IterRange::new(v.begin(), v.end()) { let mut v2: Vec = (*v2.iter_deref()).clone(); - 'loop_: for i in UnsafeIterRange::new( - UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()), - UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(v2.len())), - ) { + 'loop_: for i in IterRange::new(v2.begin(), v2.end()) { let mut i: i32 = (*i.iter_deref()); (unsafe { libc::printf(c"%d\n".as_ptr() as *const libc::c_char, (i)) }); } diff --git a/tests/unit/out/unsafe/vector_with_allocator.rs b/tests/unit/out/unsafe/vector_with_allocator.rs index d568aece8..acd93cbfa 100644 --- a/tests/unit/out/unsafe/vector_with_allocator.rs +++ b/tests/unit/out/unsafe/vector_with_allocator.rs @@ -131,25 +131,21 @@ unsafe fn main_0() -> i32 { }; assert!(((v2.len()) == (3_usize))); { - let pos = >::from(UnsafeRandomAccessIterator::Vec( - v2.as_mut_ptr(), - )) - .vec_ptr() - .offset_from(v2.as_ptr()) as usize; + let pos = >::from(v2.begin()) + .vec_ptr() + .offset_from(v2.as_ptr()) as usize; v2.remove(pos); - >::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) + >::from(v2.begin()) }; assert!(((v2.len()) == (2_usize))); assert!(((v2[(0_usize)]) == (2))); assert!(((v2[(1_usize)]) == (3))); { - let pos = >::from(UnsafeRandomAccessIterator::Vec( - v2.as_mut_ptr(), - )) - .vec_ptr() - .offset_from(v2.as_ptr()) as usize; + let pos = >::from(v2.begin()) + .vec_ptr() + .offset_from(v2.as_ptr()) as usize; v2.insert(pos, 100); - >::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) + >::from(v2.begin()) }; (unsafe { copy_0(v2.clone()) }); assert!(((v2.len()) == (3_usize))); diff --git a/tests/unit/out/unsafe/void_return.rs b/tests/unit/out/unsafe/void_return.rs index f224dcedf..6f6aa23d7 100644 --- a/tests/unit/out/unsafe/void_return.rs +++ b/tests/unit/out/unsafe/void_return.rs @@ -50,10 +50,8 @@ pub fn main() { unsafe fn main_0() -> i32 { let mut v: Vec = vec![1, 3, 0, 2, 8, 7]; (unsafe { - let _first: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()); - let _last: UnsafeRandomAccessIterator = - UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())); + let _first: UnsafeRandomAccessIterator = v.begin(); + let _last: UnsafeRandomAccessIterator = v.end(); f1_0(_first, _last) }); let mut a: [i32; 3] = [1, 2, 3]; From ccf6a2e08177a951cb9b603047816238c04c60db Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 19 Oct 2026 16:54:03 +0100 Subject: [PATCH 6/7] Move handlign of __range in visitdeclstmt --- cpp2rust/converter/converter.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp index 164e249c7..f8c25666c 100644 --- a/cpp2rust/converter/converter.cpp +++ b/cpp2rust/converter/converter.cpp @@ -1373,6 +1373,9 @@ bool Converter::VisitDeclStmt(clang::DeclStmt *stmt) { hoisted_records_ += std::move(buf).str(); continue; } + if (var && IsAliasOfInit(ctx_, var)) { + continue; + } if (var && var->isImplicit()) { VisitVarDecl(var); } else { @@ -1491,10 +1494,7 @@ bool Converter::VisitForStmt(clang::ForStmt *stmt) { bool Converter::VisitCXXForRangeStmt(clang::CXXForRangeStmt *stmt) { PushBreakTarget push(break_target_, BreakTarget::Loop); Convert(stmt->getInit()); - if (!IsAliasOfInit(ctx_, clang::cast( - stmt->getRangeStmt()->getSingleDecl()))) { - Convert(stmt->getRangeStmt()); - } + Convert(stmt->getRangeStmt()); auto *begin = clang::cast(stmt->getBeginStmt()->getSingleDecl()); auto *end = clang::cast(stmt->getEndStmt()->getSingleDecl()); From 5b567e195f2d556653230f9b4322a8a11661b3d4 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 19 Oct 2026 17:01:20 +0100 Subject: [PATCH 7/7] Add const begin rule --- rules/map/src.cpp | 5 +++++ rules/map/tgt_refcount.rs | 4 ++++ rules/map/tgt_unsafe.rs | 4 ++++ 3 files changed, 13 insertions(+) diff --git a/rules/map/src.cpp b/rules/map/src.cpp index 8bf47b3b1..4177680d8 100644 --- a/rules/map/src.cpp +++ b/rules/map/src.cpp @@ -98,3 +98,8 @@ std::size_t f28(std::map &o, const typename std::map::key_type &key) { return o.erase(key); } + +template +typename std::map::const_iterator f29(const std::map &o) { + return o.begin(); +} diff --git a/rules/map/tgt_refcount.rs b/rules/map/tgt_refcount.rs index 06c92082f..394ae6edf 100644 --- a/rules/map/tgt_refcount.rs +++ b/rules/map/tgt_refcount.rs @@ -113,3 +113,7 @@ fn f27( fn f28(a0: Ptr, Value)>>, a1: T1) -> usize { a0.with_mut(|__m: &mut Map, Value)>| __m.erase_key(&a1)) } + +fn f29(a0: Ptr, Value)>>) -> BidirectionalIterator<(Value, Value)> { + a0.with(|__m: &Map, Value)>| __m.begin()) +} diff --git a/rules/map/tgt_unsafe.rs b/rules/map/tgt_unsafe.rs index 073c0cc63..50440d791 100644 --- a/rules/map/tgt_unsafe.rs +++ b/rules/map/tgt_unsafe.rs @@ -85,3 +85,7 @@ unsafe fn f27( unsafe fn f28(a0: &mut UnsafeMap, a1: T1) -> usize { a0.erase_key(&a1) } + +unsafe fn f29(a0: UnsafeMap) -> UnsafeBidirectionalIterator<(T1, T2)> { + a0.begin() +}