Translate iterator categories

CMakeLists.txt

@@ -179,6 +179,9 @@ file(GLOB_RECURSE rule_preprocessor_sources
 file(GLOB_RECURSE libcc2rs_sources CONFIGURE_DEPENDS
      ${PROJECT_SOURCE_DIR}/libcc2rs/src/*.rs
      ${PROJECT_SOURCE_DIR}/libcc2rs-macros/src/*.rs)
+file(GLOB rule_shim_sources CONFIGURE_DEPENDS
+     ${PROJECT_SOURCE_DIR}/rules/*/shim.rs)
+list(APPEND libcc2rs_sources ${rule_shim_sources})
 list(APPEND libcc2rs_sources
      ${PROJECT_SOURCE_DIR}/libcc2rs/Cargo.toml
      ${PROJECT_SOURCE_DIR}/libcc2rs-macros/Cargo.toml)

cpp2rust/converter/converter.cpp

@@ -793,21 +793,6 @@ bool Converter::RecordHasCopyableFields(const clang::RecordDecl *decl) {
     return false;
   }
   for (auto f : decl->fields()) {
-    // Records that contain std::vector, std::array, std::string or anything
-    // that is translated to Vec<>, do not derive Copy
-    auto mapped = Mapper::Map(*this, f->getType());
-    if (mapped.starts_with("Vec<")) {
-      return false;
-    }
-
-    if (IsUniquePtr(f->getType())) {
-      return false;
-    }
-
-    if (mapped.starts_with("BTreeMap<")) {
-      return false;
-    }
-
     if (auto ptr_ty = f->getType()->getAs<clang::PointerType>()) {
       if (ptr_ty->getPointeeType()->isFunctionType()) {
         if (!FunctionPointerImplementsCopy()) {
@@ -1575,7 +1560,7 @@ bool Converter::VisitCXXForRangeStmtMap(clang::CXXForRangeStmt *stmt) {
   StrCat("'loop_:");
   auto map_type = Mapper::Map(*this, stmt->getRangeInit()->getType());
   StrCat(keyword::kFor, GetNamedDeclAsString(begin), keyword::kIn,
-         "UnsafeMapIterator::begin(&");
+         "UnsafeMap::range(&");
   Convert(stmt->getRangeInit());
   StrCat(std::format(" as *const {})", map_type));
   {
@@ -3362,9 +3347,6 @@ bool Converter::ConvertCXXOperatorCallExpr(clang::CXXOperatorCallExpr *expr) {
   case clang::OverloadedOperatorKind::OO_Arrow:
     if (IsUniquePtr(expr->getArg(0)->getType())) {
       ConvertUniquePtrDeref(expr);
-    } else if (GetStrongestIteratorCategory(ctx_, expr->getArg(0)->getType()) ==
-               IteratorCategory::Bidirectional) {
-      Convert(expr->getArg(0));
     } else if (expr->getOperator() == clang::OverloadedOperatorKind::OO_Star) {
       PushParen paren(*this);
       StrCat(token::kStar);
@@ -3914,8 +3896,6 @@ void Converter::ConvertCXXConstructExprArgs(clang::CXXConstructExpr *expr) {
 }
 
 bool Converter::VisitCXXConstructExpr(clang::CXXConstructExpr *expr) {
-  PushSuppressIteratorClone push(*this, expr);
-
   if (expr->isElidable()) {
     Convert(expr->getArg(0));
     return false;
@@ -3938,11 +3918,9 @@ bool Converter::VisitCXXConstructExpr(clang::CXXConstructExpr *expr) {
     return false;
   }
   if (IsPassThroughConstructor(ctor)) {
-    // Take suppress before recursing into the child.
-    bool suppress = PushSuppressIteratorClone::take(*this);
     Convert(expr->getArg(0));
     if ((ctor->isCopyConstructor() || IsDefaultedMoveConstructor(ctor)) &&
-        !suppress && !TypeIsCopyable(expr->getType())) {
+        !TypeIsCopyable(expr->getType())) {
       StrCat(".clone()");
       SetFreshType(expr->getType());
     }
@@ -5452,14 +5430,6 @@ void Converter::ConvertConstructFromArgs(clang::QualType type,
 std::string Converter::AccessLValueObject(clang::MemberExpr *member) {
   auto *object = member->getBase();
   auto type = object->getType();
-  if (member->isArrow()) {
-    auto *op =
-        clang::dyn_cast<clang::CXXOperatorCallExpr>(object->IgnoreImplicit());
-    if (op && GetStrongestIteratorCategory(ctx_, op->getArg(0)->getType()) ==
-                  IteratorCategory::Bidirectional) {
-      return ToString(object);
-    }
-  }
   if (type->isPointerType() ||
       (IsReferenceType(object) && clang::isa<clang::CallExpr>(object))) {
     return std::format("({}{})", GetPointerDerefPrefix(type->getPointeeType()),

cpp2rust/converter/converter.h

@@ -841,7 +841,6 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   std::string ufcs_receiver_;
   bool in_const_initializer_ = false;
   std::optional<bool> autoref_mut_;
-  bool suppress_iterator_clone_ = false;
 
   struct PushExplicitAutoref {
     Converter &c;
@@ -853,41 +852,6 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
     ~PushExplicitAutoref() { c.autoref_mut_ = prev; }
   };
 
-  struct PushSuppressIteratorClone {
-    Converter &c;
-    bool prev;
-    PushSuppressIteratorClone(Converter &c, clang::CXXConstructExpr *expr)
-        : c(c), prev(c.suppress_iterator_clone_) {
-      auto *ctor = expr->getConstructor();
-      if (!ctor->isCopyOrMoveConstructor() &&
-          ctor->isConvertingConstructor(/*AllowExplicit=*/false) &&
-          ctor->getNumParams() == 1 && IsIteratorType(expr->getType())) {
-        c.suppress_iterator_clone_ = true;
-      }
-    }
-    ~PushSuppressIteratorClone() { c.suppress_iterator_clone_ = prev; }
-    PushSuppressIteratorClone(const PushSuppressIteratorClone &) = delete;
-    PushSuppressIteratorClone &
-    operator=(const PushSuppressIteratorClone &) = delete;
-
-    static bool take(Converter &c) {
-      return std::exchange(c.suppress_iterator_clone_, false);
-    }
-
-  private:
-    static bool IsIteratorType(clang::QualType qt) {
-      if (auto *record = qt->getAsCXXRecordDecl()) {
-        for (auto *d : record->decls()) {
-          if (auto *tnd = llvm::dyn_cast<clang::TypedefNameDecl>(d)) {
-            if (tnd->getName() == "iterator_category")
-              return true;
-          }
-        }
-      }
-      return false;
-    }
-  };
-
   struct PushConstInitializer {
     Converter &c;
     bool prev;

cpp2rust/converter/converter_lib.cpp

@@ -1892,7 +1892,7 @@ clang::Expr *GetCallee(clang::CallExpr *expr) {
 }
 
 bool HasReceiver(clang::Expr *expr) {
-  if (clang::isa<clang::CXXMemberCallExpr>(expr))
+  if (clang::isa<clang::CXXMemberCallExpr, clang::MemberExpr>(expr))
     return true;
   if (auto *opcall = clang::dyn_cast<clang::CXXOperatorCallExpr>(expr)) {
     if (auto *callee = opcall->getCalleeDecl()) {
@@ -1920,26 +1920,6 @@ std::optional<clang::QualType> GetParamImplicitConvertTarget(clang::Expr *expr,
   return fn->getParamDecl(param_idx)->getType().getNonReferenceType();
 }
 
-std::optional<IteratorCategory>
-GetStrongestIteratorCategory(clang::ASTContext &ctx, clang::QualType type) {
-  type = type.getNonReferenceType().getUnqualifiedType();
-  if (!Mapper::Contains(ctx, type)) {
-    return std::nullopt;
-  }
-  if (RuleRegistry::MapsToRefcountPointer(ctx, type)) {
-    return IteratorCategory::Contiguous;
-  }
-  auto mapped = Mapper::Map(ctx, type);
-  if (mapped.empty()) {
-    return std::nullopt;
-  }
-  if (mapped.starts_with("RefcountMapIter<") ||
-      mapped.starts_with("UnsafeMapIterator<")) {
-    return IteratorCategory::Bidirectional;
-  }
-  return std::nullopt;
-}
-
 std::string GetClassName(clang::QualType type) {
   if (auto *record = type->getAsCXXRecordDecl())
     return record->getQualifiedNameAsString();

cpp2rust/converter/converter_lib.h

@@ -28,17 +28,6 @@ class Sema;
 
 namespace cpp2rust {
 
-// Order matters: each category is a superset of the previous one.
-// Use >= to check "at least this capable".
-enum class IteratorCategory {
-  Forward,
-  Bidirectional,
-  RandomAccess,
-  Contiguous,
-};
-
-std::optional<IteratorCategory>
-GetStrongestIteratorCategory(clang::ASTContext &ctx, clang::QualType type);
 bool IsBuiltinConstantP(const clang::Expr *expr);
 
 bool IsGlobalVar(const clang::VarDecl *decl);

cpp2rust/converter/models/converter_refcount.cpp

@@ -97,8 +97,8 @@ static bool IsFieldOfVectorElem(const clang::MemberExpr *expr) {
 }
 
 static bool IsPointerType(clang::ASTContext &ctx, clang::QualType type) {
-  return type->isPointerType() || GetStrongestIteratorCategory(ctx, type) ==
-                                      IteratorCategory::Contiguous;
+  return type->isPointerType() ||
+         RuleRegistry::MapsToRefcountPointer(ctx, type);
 }
 
 void ConverterRefCount::PendingDeref::set(std::string str, bool fresh) {
@@ -2279,7 +2279,7 @@ bool ConverterRefCount::VisitCXXForRangeStmtMap(clang::CXXForRangeStmt *stmt) {
   auto begin_name = GetNamedDeclAsString(begin);
 
   StrCat("'loop_:");
-  StrCat(keyword::kFor, begin_name, keyword::kIn, "RefcountMapIter::begin(",
+  StrCat(keyword::kFor, begin_name, keyword::kIn, "Map::range(",
          ConvertObject(stmt->getRangeInit()), ')');
   PushBrace brace(*this);
 
@@ -2375,7 +2375,6 @@ bool ConverterRefCount::VisitCXXConstructExpr(clang::CXXConstructExpr *expr) {
                      getConversionKind() != ConversionKind::Unboxed;
   PushConversionKind push(*this, boxed_array ? ConversionKind::Pointee
                                              : ConversionKind::Unboxed);
-  PushSuppressIteratorClone push_suppress(*this, expr);
 
   if (auto str = GetMappedAsString(expr, expr->getArgs(), expr->getNumArgs());
       !str.empty()) {
@@ -2408,9 +2407,7 @@ bool ConverterRefCount::VisitCXXConstructExpr(clang::CXXConstructExpr *expr) {
 
   if (ctor->isCopyOrMoveConstructor() &&
       !IsConvertibleCopyOrMoveConstructor(ctor)) {
-    StrCat(PushSuppressIteratorClone::take(*this)
-               ? ConvertRValue(expr->getArg(0))
-               : ConvertFreshRValue(expr->getArg(0)));
+    StrCat(ConvertFreshRValue(expr->getArg(0)));
     return false;
   }
 
@@ -2848,12 +2845,6 @@ bool ConverterRefCount::ConvertCXXOperatorCallExpr(
       break;
     }
 
-    if (GetStrongestIteratorCategory(ctx_, expr->getArg(0)->getType()) ==
-        IteratorCategory::Bidirectional) {
-      Convert(expr->getArg(0));
-      break;
-    }
-
     {
       bool deref = !isAddrOf();
       PushParen paren(*this, deref);
@@ -3314,7 +3305,8 @@ void ConverterRefCount::ConvertArrow(clang::Expr *expr) {
   bool is_overloaded_arrow =
       op && op->getOperator() == clang::OverloadedOperatorKind::OO_Arrow;
 
-  if (!is_overloaded_arrow || IsUserOperatorCall(op)) {
+  if (!is_overloaded_arrow || IsUserOperatorCall(op) ||
+      RuleRegistry::ReturnsPointer(ctx_, expr)) {
     auto pointee_type = expr->getType()->getPointeeType();
     // Virtual methods, which take &mut self, are called through PtrDyn.
     if (auto *record = pointee_type->getAsRecordDecl();
@@ -3333,12 +3325,6 @@ void ConverterRefCount::ConvertArrow(clang::Expr *expr) {
     return;
   }
 
-  if (GetStrongestIteratorCategory(ctx_, op->getArg(0)->getType()) ==
-      IteratorCategory::Bidirectional) {
-    Convert(op->getArg(0));
-    return;
-  }
-
   Convert(expr);
 }
 
@@ -3348,12 +3334,6 @@ std::string ConverterRefCount::AccessLValueObject(clang::MemberExpr *member) {
 
   bool is_mut = method && !method->isConst();
   if (member->isArrow()) {
-    auto *op =
-        clang::dyn_cast<clang::CXXOperatorCallExpr>(object->IgnoreImplicit());
-    if (op && GetStrongestIteratorCategory(ctx_, op->getArg(0)->getType()) ==
-                  IteratorCategory::Bidirectional) {
-      return ConvertRValue(op->getArg(0));
-    }
     auto str = is_mut ? ConvertLValue(object) : ConvertRValue(object);
     auto pointee_type = object->getType()->getPointeeType();
     return DerefPtrExpr(str, pointee_type);

cpp2rust/converter/rules/decls.cpp

@@ -77,30 +77,6 @@ const clang::Expr *GetMacroMemberBase(const clang::SourceManager &sm,
   }
 }
 
-clang::QualType EnableIfSameType(const clang::Decl *rule) {
-  auto tmpl = llvm::dyn_cast<clang::TemplateDecl>(rule);
-  if (!tmpl) {
-    return {};
-  }
-  for (auto param : *tmpl->getTemplateParameters()) {
-    auto type_param = llvm::dyn_cast<clang::TemplateTypeParmDecl>(param);
-    if (!type_param || type_param->getIdentifier() ||
-        !type_param->hasDefaultArgument()) {
-      continue;
-    }
-    auto same = type_param->getDefaultArgument()
-                    .getArgument()
-                    .getAsType()
-                    ->getAs<clang::TemplateSpecializationType>();
-    if (!same || !same->isTypeAlias() ||
-        same->getTemplateName().getAsTemplateDecl()->getName() != "SameAs") {
-      continue;
-    }
-    return same->template_arguments()[1].getAsType();
-  }
-  return {};
-}
-
 std::optional<std::vector<clang::TemplateArgument>>
 DeduceFromType(clang::Sema &sema, clang::TemplateParameterList *params,
                clang::QualType pattern, clang::QualType actual) {

cpp2rust/converter/rules/decls.h

@@ -42,8 +42,6 @@ const clang::Expr *GetReturned(const clang::FunctionDecl *rule);
 const clang::Expr *GetMacroMemberBase(const clang::SourceManager &sm,
                                       const clang::MemberExpr *member);
 
-clang::QualType EnableIfSameType(const clang::Decl *rule);
-
 std::optional<std::vector<clang::TemplateArgument>>
 DeduceFromType(clang::Sema &sema, clang::TemplateParameterList *params,
                clang::QualType pattern, clang::QualType actual);

cpp2rust/converter/rules/expr_matcher.cpp

@@ -155,10 +155,6 @@ std::vector<clang::Expr *> getOperands(clang::ASTContext &ctx,
     auto base =
         const_cast<clang::Expr *>(macro_base ? macro_base : member->getBase())
             ->IgnoreParenImpCasts();
-    if (auto arrow = llvm::dyn_cast<clang::CXXOperatorCallExpr>(base);
-        arrow && arrow->getOperator() == clang::OO_Arrow) {
-      base = arrow->getArg(0);
-    }
     operands.push_back(getObject(ctx, base));
   }
   while (!operands.empty() &&