Drop printer depdendncies in converter

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -1720,7 +1720,6 @@ const clang::Expr *Converter::GetParentExpr(const clang::Expr *expr) {
 bool Converter::GetFmtArg(clang::Expr *arg, std::string &fmt,
                           std::string &fmt_args, const char *&fmt_trait,
                           std::string &fmt_width) {
-  std::string arg_str = Printer::ToString(ctx_, arg);
   if (auto *str_lit =
           clang::dyn_cast<clang::StringLiteral>(arg->IgnoreImplicit())) {
     if (!IsAsciiStringLiteral(str_lit)) {
@@ -1734,20 +1733,20 @@ bool Converter::GetFmtArg(clang::Expr *arg, std::string &fmt,
     fmt += trim;
   } else if (auto ch = GetEscapedUTF8CharLiteral(arg); !ch.empty()) {
     fmt += std::move(ch);
-  } else if (arg_str.contains("std::endl")) {
+  } else if (IsStdFunction(arg, "endl")) {
     fmt += "\\n";
-  } else if (arg_str.contains("std::hex")) {
+  } else if (IsStdFunction(arg, "hex")) {
     fmt_trait = "x";
-  } else if (arg_str.contains("std::dec")) {
+  } else if (IsStdFunction(arg, "dec")) {
     fmt_trait = "";
-  } else if (arg_str.contains("Setw")) {
+  } else if (IsStdFunction(arg, "setw")) {
     fmt_width = Trim(ToString(arg));
   } else if (!arg->getType()->isCharType() &&
              Mapper::Map(*this, arg->getType()) !=
                  std::format("Vec<{}>", CharRustType())) {
     fmt += ("{:" + fmt_width + fmt_trait + "}");
     fmt_width.clear(); // Reset setw after first usage
-    arg_str = ToString(arg);
+    auto arg_str = ToString(arg);
     if (arg->getType()->isBooleanType()) {
       arg_str = std::format("({} as u8)", std::move(arg_str));
     }
@@ -1767,7 +1766,7 @@ bool Converter::GetRawArg(clang::Expr *arg, std::string &raw_args) {
     std::string str = ToString(arg);
     raw_args += "(&(" + str + ").iter().take((" + str +
                 ").len() - 1).map(|&c| c as u8).collect::<Vec<u8>>()[..]";
-  } else if (Printer::ToString(ctx_, arg).contains("std::endl")) {
+  } else if (IsStdFunction(arg, "endl")) {
     raw_args += "(&[b'\\n']";
   } else if (clang::isa<clang::StringLiteral>(arg->IgnoreImplicit())) {
     raw_args += "(b" + GetEscapedStringLiteral(arg);
@@ -1853,8 +1852,7 @@ void Converter::ConvertCallToOstream(clang::CallExpr *expr) {
 }
 
 void Converter::ConvertPrintf(clang::CallExpr *expr) {
-  bool is_fprintf =
-      Printer::ToString(ctx_, expr->getCallee()).starts_with("int fprintf");
+  bool is_fprintf = IsCDecl(expr->getDirectCallee(), "fprintf");
 
   StrCat("printf(");
   for (unsigned i = is_fprintf; i < expr->getNumArgs(); ++i) {
@@ -2338,9 +2336,8 @@ std::optional<Converter::TempMaterializationCtx>
 Converter::ConvertCallExpr(clang::CallExpr *expr) {
   auto *callee = expr->getCallee();
 
-  auto fn = Printer::ToString(ctx_, callee);
-  bool is_printf = fn.starts_with("int printf");
-  bool is_fprintf = fn.starts_with("int fprintf");
+  bool is_printf = IsCDecl(expr->getDirectCallee(), "printf");
+  bool is_fprintf = IsCDecl(expr->getDirectCallee(), "fprintf");
   unsigned format_arg = is_fprintf ? 1 : 0;
   if ((is_printf || is_fprintf) &&
       clang::isa<clang::StringLiteral>(
@@ -4295,7 +4292,7 @@ std::string Converter::GetArrayDefaultAsString(clang::QualType qual_type) {
   if (clang::isa<clang::IncompleteArrayType>(qual_type)) {
     return "[]";
   }
-  if (Printer::ToString(ctx_, qual_type).contains("std::array")) {
+  if (IsStdDecl(qual_type->getAsCXXRecordDecl(), "array")) {
     assert(GetTemplateArgs(qual_type).has_value());
     auto template_args = *GetTemplateArgs(qual_type);
     assert(template_args.size() == 2);

cpp2rust/converter/converter_lib.cpp

@@ -668,19 +668,42 @@ bool IsConvertibleFunctionDecl(const clang::FunctionDecl *decl) {
   return decl->hasBody() && decl->isThisDeclarationADefinition();
 }
 
+bool IsStdDecl(const clang::NamedDecl *decl, llvm::StringRef name) {
+  return decl && decl->isInStdNamespace() && decl->getIdentifier() &&
+         decl->getName() == name;
+}
+
 bool IsUniquePtr(clang::QualType type) {
-  auto *record_decl = type.getNonReferenceType()->getAsCXXRecordDecl();
-  return record_decl && record_decl->getNameAsString() == "unique_ptr";
+  return IsStdDecl(type.getNonReferenceType()->getAsCXXRecordDecl(),
+                   "unique_ptr");
 }
 
 bool IsCallToOstream(clang::CallExpr *expr) {
-  if (auto *op = clang::dyn_cast<clang::CXXOperatorCallExpr>(expr)) {
-    if (auto *record_decl = expr->getType()->getAsCXXRecordDecl()) {
-      return record_decl->getNameAsString() == "basic_ostream" &&
-             op->getOperator() == clang::OverloadedOperatorKind::OO_LessLess;
-    }
+  auto *op = clang::dyn_cast<clang::CXXOperatorCallExpr>(expr);
+  return op &&
+         op->getOperator() == clang::OverloadedOperatorKind::OO_LessLess &&
+         IsStdDecl(expr->getType()->getAsCXXRecordDecl(), "basic_ostream");
+}
+
+bool IsCDecl(const clang::NamedDecl *decl, llvm::StringRef name) {
+  bool is_extern_c = false;
+  if (auto *function = clang::dyn_cast_or_null<clang::FunctionDecl>(decl)) {
+    is_extern_c = function->isExternC();
+  } else if (auto *var = clang::dyn_cast_or_null<clang::VarDecl>(decl)) {
+    is_extern_c = var->isExternC();
   }
-  return false;
+  return is_extern_c && decl->getIdentifier() && decl->getName() == name;
+}
+
+bool IsStdFunction(const clang::Expr *expr, llvm::StringRef name) {
+  expr = expr->IgnoreUnlessSpelledInSource();
+  const clang::NamedDecl *decl = nullptr;
+  if (auto *call = clang::dyn_cast<clang::CallExpr>(expr)) {
+    decl = call->getDirectCallee();
+  } else if (auto *ref = clang::dyn_cast<clang::DeclRefExpr>(expr)) {
+    decl = clang::dyn_cast<clang::FunctionDecl>(ref->getDecl());
+  }
+  return IsStdDecl(decl, name);
 }
 
 bool IsAsciiStringLiteral(const clang::StringLiteral *str) {

cpp2rust/converter/converter_lib.h

@@ -147,10 +147,16 @@ bool IsMethodOnPtr(const clang::CXXMethodDecl *method);
 
 bool IsConvertibleFunctionDecl(const clang::FunctionDecl *decl);
 
+bool IsStdDecl(const clang::NamedDecl *decl, llvm::StringRef name);
+
 bool IsUniquePtr(clang::QualType type);
 
 bool IsCallToOstream(clang::CallExpr *expr);
 
+bool IsCDecl(const clang::NamedDecl *decl, llvm::StringRef name);
+
+bool IsStdFunction(const clang::Expr *expr, llvm::StringRef name);
+
 bool IsAsciiStringLiteral(const clang::StringLiteral *str);
 
 bool IsInitExprOfStringLiteral(const clang::InitListExpr *expr);

cpp2rust/converter/models/converter_refcount.cpp

@@ -15,7 +15,6 @@
 #include "converter/converter_lib.h"
 #include "converter/lex.h"
 #include "converter/mapper.h"
-#include "converter/printer.h"
 #include "converter/rules/registry.h"
 
 namespace cpp2rust {
@@ -1234,19 +1233,24 @@ static std::vector<const char *> printf2fmt(std::string &format) {
 }
 
 void ConverterRefCount::ConvertPrintf(clang::CallExpr *expr) {
-  bool is_fprintf =
-      Printer::ToString(ctx_, expr->getCallee()).starts_with("int fprintf");
+  bool is_fprintf = IsCDecl(expr->getDirectCallee(), "fprintf");
   auto format = GetEscapedStringLiteral(clang::cast<clang::StringLiteral>(
       expr->getArg(is_fprintf)->IgnoreImplicit()));
   bool ends_newline = format.ends_with("\\n\"");
 
-  auto fd = is_fprintf ? Printer::ToString(ctx_, expr->getArg(0)) : "stdout";
-  if (fd == "stdout" || fd == "__stdoutp") {
+  const clang::NamedDecl *stream = nullptr;
+  if (auto *ref = clang::dyn_cast<clang::DeclRefExpr>(
+          expr->getArg(0)->IgnoreParenImpCasts())) {
+    stream = ref->getDecl();
+  }
+  if (!is_fprintf || IsCDecl(stream, "stdout") ||
+      IsCDecl(stream, "__stdoutp")) {
     StrCat(ends_newline ? "println!(" : "print!(");
-  } else if (fd == "stderr" || fd == "__stderrp") {
+  } else if (IsCDecl(stream, "stderr") || IsCDecl(stream, "__stderrp")) {
     StrCat(ends_newline ? "eprintln!(" : "eprint!(");
   } else {
-    llvm::errs() << "Unknown fprintf fd: " << fd << '\n';
+    llvm::errs() << "Unknown fprintf fd:\n";
+    expr->getArg(0)->dump(llvm::errs(), ctx_);
     exit(1);
   }
   if (ends_newline) {