Change Mapper::Map to return std::optional<std::string>

Agent-Logs-Url: https://github.com/Cpp2Rust/cpp2rust/sessions/67f75cb5-f531-44bf-bf7e-122072105ac0

Co-authored-by: nunoplopes <2998477+nunoplopes@users.noreply.github.com>

Author: Copilot

cpp2rust/converter/converter.cpp

@@ -65,9 +65,9 @@ bool Converter::Convert(clang::QualType qual_type) {
     return false;
   }
 
-  if (Mapper::Contains(qual_type) &&
-      Mapper::Map(qual_type) != ignore_rule_type_) {
-    StrCat(Mapper::Map(qual_type));
+  if (auto mapped = Mapper::Map(qual_type);
+      mapped && *mapped != ignore_rule_type_) {
+    StrCat(*mapped);
     return false;
   }
 
@@ -76,7 +76,7 @@ bool Converter::Convert(clang::QualType qual_type) {
 }
 
 bool Converter::ConvertMappedType(clang::QualType qual_type) {
-  std::string type_as_string = Mapper::Map(qual_type);
+  std::string type_as_string = Mapper::Map(qual_type).value_or(std::string{});
   if (type_as_string == ignore_rule_type_) {
     return false;
   }
@@ -551,7 +551,7 @@ static bool recordDerivesCopy(const clang::RecordDecl *decl) {
   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(f->getType());
+    auto mapped = Mapper::Map(f->getType()).value_or(std::string{});
     if (mapped.starts_with("Vec<")) {
       return false;
     }
@@ -1105,7 +1105,7 @@ bool Converter::VisitCXXForRangeStmtMap(clang::CXXForRangeStmt *stmt) {
   auto loop_var_name = GetNamedDeclAsString(loop_var);
 
   StrCat("'loop_:");
-  auto map_type = Mapper::Map(stmt->getRangeInit()->getType());
+  auto map_type = Mapper::Map(stmt->getRangeInit()->getType()).value_or(std::string{});
   StrCat(keyword::kFor, loop_var_name, keyword::kIn,
          "UnsafeMapIterator::begin(&");
   Convert(stmt->getRangeInit());
@@ -1234,7 +1234,7 @@ bool Converter::GetFmtArg(clang::Expr *arg, std::string &fmt,
     fmt_width.erase(0, fmt_width.find_first_not_of(' '));
     fmt_width.erase(fmt_width.find_last_not_of(' ') + 1);
   } else if (!arg->getType()->isCharType() &&
-             Mapper::Map(arg->getType()) != "Vec<u8>") {
+             Mapper::Map(arg->getType()).value_or(std::string{}) != "Vec<u8>") {
     fmt += ("{:" + fmt_width + fmt_trait + "}");
     fmt_width.clear(); // Reset setw after first usage
     arg_str = ToString(arg);
@@ -1251,7 +1251,7 @@ bool Converter::GetFmtArg(clang::Expr *arg, std::string &fmt,
 bool Converter::GetRawArg(clang::Expr *arg, std::string &raw_args) {
   if (arg->getType()->isCharType()) {
     raw_args += "(&[" + ToString(arg) + "]";
-  } else if (Mapper::Map(arg->getType()) == "Vec<u8>") {
+  } else if (Mapper::Map(arg->getType()).value_or(std::string{}) == "Vec<u8>") {
     PushExprKind push(*this, ExprKind::RValue);
     std::string str = ToString(arg);
     raw_args += "(&(" + str + ")[..(" + str + ").len() - 1]";
@@ -1630,7 +1630,7 @@ std::string Converter::getIntegerLiteral(clang::IntegerLiteral *expr,
 }
 
 bool Converter::VisitIntegerLiteral(clang::IntegerLiteral *expr) {
-  StrCat(getIntegerLiteral(expr, Mapper::Map(expr->getType()) != "i32"));
+  StrCat(getIntegerLiteral(expr, Mapper::Map(expr->getType()).value_or(std::string{}) != "i32"));
   computed_expr_type_ = ComputedExprType::FreshValue;
   return false;
 }
@@ -2672,7 +2672,7 @@ bool Converter::VisitEnumDecl(clang::EnumDecl *decl) {
   }
   Mapper::AddRuleForUserDefinedType(decl);
   StrCat("#[derive(Clone, Copy, PartialEq, Debug, Default)]");
-  StrCat(std::format("enum {}", Mapper::Map(ctx_.getCanonicalTagType(decl))));
+  StrCat(std::format("enum {}", Mapper::Map(ctx_.getCanonicalTagType(decl)).value_or(std::string{})));
   StrCat("{");
   bool first_enumerator = true;
   for (auto e : decl->enumerators()) {
@@ -3055,9 +3055,11 @@ void Converter::ConvertVarInit(clang::QualType qual_type, clang::Expr *expr) {
 void Converter::ConvertUnsignedArithOperand(clang::Expr *expr,
                                             clang::QualType type) {
   Convert(expr);
+  auto expr_mapped = Mapper::Map(expr->getType()).value_or(std::string{});
+  auto type_mapped = Mapper::Map(type).value_or(std::string{});
   if ((expr->isIntegerConstantExpr(ctx_) &&
        !clang::isa<clang::ImplicitCastExpr>(expr)) ||
-      Mapper::Map(expr->getType()) != Mapper::Map(type)) {
+      expr_mapped != type_mapped) {
     ConvertCast(type);
   }
 }

cpp2rust/converter/converter_lib.cpp

@@ -567,18 +567,15 @@ bool HasReceiver(clang::Expr *expr) {
 std::optional<IteratorCategory>
 GetStrongestIteratorCategory(clang::QualType type) {
   type = type.getNonReferenceType().getUnqualifiedType();
-  if (!Mapper::Contains(type)) {
+  auto mapped = Mapper::Map(type);
+  if (!mapped) {
     return std::nullopt;
   }
   if (Mapper::MapsToRefcountPointer(type)) {
     return IteratorCategory::Contiguous;
   }
-  auto mapped = Mapper::Map(type);
-  if (mapped.empty()) {
-    return std::nullopt;
-  }
-  if (mapped.starts_with("RefcountMapIter<") ||
-      mapped.starts_with("UnsafeMapIterator<")) {
+  if (mapped->starts_with("RefcountMapIter<") ||
+      mapped->starts_with("UnsafeMapIterator<")) {
     return IteratorCategory::Bidirectional;
   }
   return std::nullopt;

cpp2rust/converter/mapper.cpp

@@ -612,15 +612,15 @@ std::string InstantiateTemplate(const clang::Expr *expr,
   return instantiateTgt(types_map, text);
 }
 
-std::string Map(clang::QualType qual_type) {
+std::optional<std::string> Map(clang::QualType qual_type) {
   if (auto it = search(qual_type); it != types_.end()) {
     auto types_map = matchTemplate(it->first, ToString(qual_type)).value();
     for (auto &kv : types_map) {
       kv.second = mapTypeStringRecursive(kv.second);
     }
     return instantiateTgt(types_map, it->second.type_info.type);
   }
-  return {};
+  return std::nullopt;
 }
 
 bool MapsToPointer(clang::QualType qual_type) {

cpp2rust/converter/mapper.h

@@ -8,6 +8,7 @@
 #include <clang/AST/Type.h>
 
 #include <filesystem>
+#include <optional>
 #include <string>
 #include <unordered_map>
 
@@ -29,7 +30,7 @@ class PushASTContext {
 bool Contains(clang::QualType qual_type);
 bool Contains(const clang::Expr *expr);
 
-std::string Map(clang::QualType qual_type);
+std::optional<std::string> Map(clang::QualType qual_type);
 const TranslationRule::ExprTgt *GetExprTgt(const clang::Expr *expr);
 std::string MapFunctionName(const clang::FunctionDecl *decl);
 std::string InstantiateTemplate(const clang::Expr *expr,

cpp2rust/converter/models/converter_refcount.cpp

@@ -36,7 +36,7 @@ static bool IsBoxedType(std::string_view type) {
 }
 
 static bool IsBoxedType(clang::QualType type) {
-  return IsBoxedType(Mapper::Map(type.getUnqualifiedType()));
+  return IsBoxedType(Mapper::Map(type.getUnqualifiedType()).value_or(std::string{}));
 }
 
 static bool NeedsMutAccess(const clang::CXXMethodDecl *method,