Make diff smaller

Author: lucic71

cpp2rust/converter/rules/decls.cpp

@@ -12,36 +12,12 @@
 #include <llvm/ADT/STLExtras.h>
 
 #include <cassert>
-#include <ranges>
-#include <string>
-#include <unordered_set>
 #include <vector>
 
 namespace cpp2rust::RuleDecls {
 
 namespace {
 
-std::string NameKey(const clang::NamedDecl *decl) {
-  std::vector<std::string> scopes;
-  for (auto scope = decl->getDeclContext(); scope; scope = scope->getParent()) {
-    if (auto ns = llvm::dyn_cast<clang::NamespaceDecl>(scope)) {
-      if (!ns->isInline() && !ns->isAnonymousNamespace()) {
-        scopes.push_back(ns->getNameAsString());
-      }
-    } else if (auto record = llvm::dyn_cast<clang::RecordDecl>(scope)) {
-      scopes.push_back(record->getNameAsString());
-    } else if (auto enum_decl = llvm::dyn_cast<clang::EnumDecl>(scope);
-               enum_decl && enum_decl->isScoped()) {
-      scopes.push_back(enum_decl->getNameAsString());
-    }
-  }
-  std::string key;
-  for (const auto &scope : scopes | std::views::reverse) {
-    key += scope + '/';
-  }
-  return key + decl->getNameAsString();
-}
-
 const clang::Decl *getScope(clang::QualType type) {
   type = type.getNonReferenceType();
   if (type->isPointerType()) {
@@ -188,85 +164,6 @@ ExprKey getExprKey(clang::ASTContext &ctx, const clang::Expr *expr) {
   return {};
 }
 
-void AddRequiredClasses(clang::QualType type,
-                        std::unordered_set<std::string> &required) {
-  if (type.isNull()) {
-    return;
-  }
-  if (type->isPointerType() || type->isReferenceType()) {
-    return AddRequiredClasses(type->getPointeeType(), required);
-  }
-  if (auto array = type->getAsArrayTypeUnsafe()) {
-    return AddRequiredClasses(array->getElementType(), required);
-  }
-  if (auto fn = type->getAs<clang::FunctionType>()) {
-    AddRequiredClasses(fn->getReturnType(), required);
-    if (auto proto = llvm::dyn_cast<clang::FunctionProtoType>(fn)) {
-      for (auto param : proto->param_types()) {
-        AddRequiredClasses(param, required);
-      }
-    }
-    return;
-  }
-  if (auto name = type->getAs<clang::DependentNameType>()) {
-    auto qualifier = name->getQualifier();
-    if (qualifier.getKind() == clang::NestedNameSpecifier::Kind::Type) {
-      AddRequiredClasses(clang::QualType(qualifier.getAsType(), 0), required);
-    }
-    return;
-  }
-  if (auto alias = type->getAs<clang::TypedefType>()) {
-    if (auto record = llvm::dyn_cast<clang::RecordDecl>(
-            alias->getDecl()->getDeclContext())) {
-      if (auto key = ClassKey(record); !key.empty()) {
-        required.insert(key);
-      }
-    }
-  }
-  const clang::NamedDecl *decl = type->getAsTagDecl();
-  if (auto spec = type->getAs<clang::TemplateSpecializationType>()) {
-    for (const auto &arg : spec->template_arguments()) {
-      if (arg.getKind() == clang::TemplateArgument::Type) {
-        AddRequiredClasses(arg.getAsType(), required);
-      }
-    }
-    if (auto tmpl = spec->getTemplateName().getAsTemplateDecl();
-        tmpl && llvm::isa<clang::ClassTemplateDecl>(tmpl)) {
-      decl = tmpl;
-    }
-  }
-  if (!decl) {
-    return;
-  }
-  if (auto key = ClassKey(decl); !key.empty()) {
-    required.insert(key);
-  }
-}
-
-const clang::Expr *RuleExpr(const clang::Decl *decl) {
-  if (auto var = llvm::dyn_cast<clang::VarDecl>(decl)) {
-    return var->getInit();
-  }
-  auto fn = decl->getAsFunction();
-  if (!fn) {
-    return nullptr;
-  }
-  auto body = llvm::dyn_cast_or_null<clang::CompoundStmt>(fn->getBody());
-  if (!body || body->size() != 1) {
-    return nullptr;
-  }
-  auto ret = llvm::dyn_cast<clang::ReturnStmt>(body->body_front());
-  return ret ? ret->getRetValue() : nullptr;
-}
-
-const clang::Expr *IgnoreImplicitAndFunctionalCast(const clang::Expr *expr) {
-  expr = expr->IgnoreImplicit();
-  if (auto cast = llvm::dyn_cast<clang::CXXFunctionalCastExpr>(expr)) {
-    expr = cast->getSubExpr()->IgnoreImplicit();
-  }
-  return expr;
-}
-
 } // namespace
 
 const clang::Expr *SkipImplicit(const clang::Expr *expr) {
@@ -392,127 +289,6 @@ std::vector<const void *> GetTypeKeys(clang::ASTContext &ctx,
 
 ExprKey GetDeclKey(const clang::NamedDecl *decl) { return getDeclKey(decl); }
 
-std::string ClassKey(const clang::NamedDecl *decl) {
-  if (auto alias = llvm::dyn_cast<clang::TypedefNameDecl>(decl)) {
-    auto tag = alias->getUnderlyingType()->getAsTagDecl();
-    if (!tag) {
-      return {};
-    }
-    decl = tag;
-  }
-  if (auto spec =
-          llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(decl)) {
-    decl = spec->getSpecializedTemplate();
-  }
-  if (auto tag = llvm::dyn_cast<clang::TagDecl>(decl);
-      tag && !tag->getIdentifier()) {
-    decl = tag->getTypedefNameForAnonDecl();
-    if (!decl) {
-      return {};
-    }
-  }
-  return NameKey(decl);
-}
-
-std::string MemberName(clang::DeclarationName name) {
-  if (name.getNameKind() == clang::DeclarationName::CXXConversionFunctionName) {
-    return "operator";
-  }
-  return name.getAsString();
-}
-
-std::string MemberKey(const std::string &class_key, const std::string &name) {
-  if (class_key.empty()) {
-    return {};
-  }
-  return class_key + '/' + name;
-}
-
-std::string ConstructorKey(const std::string &class_key) {
-  return MemberKey(class_key, class_key.substr(class_key.rfind('/') + 1));
-}
-
-std::string FunctionKey(const clang::FunctionDecl *decl) {
-  if (const clang::FunctionDecl *definition = nullptr;
-      decl->isDefined(definition) &&
-      !decl->getASTContext().getSourceManager().isInSystemHeader(
-          definition->getLocation())) {
-    return {};
-  }
-  if (auto method = llvm::dyn_cast<clang::CXXMethodDecl>(decl)) {
-    auto class_key = ClassKey(method->getParent());
-    if (llvm::isa<clang::CXXConstructorDecl>(method)) {
-      return ConstructorKey(class_key);
-    }
-    return MemberKey(class_key, MemberName(method->getDeclName()));
-  }
-  return NameKey(decl);
-}
-
-std::string DeclKey(const clang::NamedDecl *decl) {
-  if (auto fn = decl->getAsFunction()) {
-    return FunctionKey(fn);
-  }
-  if (auto record = llvm::dyn_cast<clang::RecordDecl>(decl->getDeclContext())) {
-    return MemberKey(ClassKey(record), MemberName(decl->getDeclName()));
-  }
-  return NameKey(decl);
-}
-
-std::string ExprKeyString(clang::ASTContext &ctx, const clang::Expr *expr) {
-  expr = expr->IgnoreParenImpCasts();
-  if (llvm::isa<clang::IntegerLiteral>(expr) &&
-      expr->getBeginLoc().isMacroID()) {
-    return clang::Lexer::getImmediateMacroName(
-               expr->getBeginLoc(), ctx.getSourceManager(), ctx.getLangOpts())
-        .str();
-  }
-  if (auto call = llvm::dyn_cast<clang::CallExpr>(expr)) {
-    if (auto callee = call->getDirectCallee()) {
-      return FunctionKey(callee);
-    }
-    return {};
-  }
-  if (auto construct = llvm::dyn_cast<clang::CXXConstructExpr>(expr)) {
-    return FunctionKey(construct->getConstructor());
-  }
-  if (auto member = llvm::dyn_cast<clang::MemberExpr>(expr)) {
-    return DeclKey(member->getMemberDecl());
-  }
-  if (auto ref = llvm::dyn_cast<clang::DeclRefExpr>(expr)) {
-    return DeclKey(ref->getDecl());
-  }
-  if (auto unary = llvm::dyn_cast<clang::UnaryOperator>(expr)) {
-    return ExprKeyString(ctx, unary->getSubExpr());
-  }
-  return {};
-}
-
-std::string TypeKey(clang::QualType type) {
-  if (auto decltype_type =
-          llvm::dyn_cast<clang::DecltypeType>(type.getTypePtr())) {
-    type = decltype_type->getUnderlyingType();
-  }
-  if (auto typeof_type =
-          llvm::dyn_cast<clang::TypeOfExprType>(type.getTypePtr())) {
-    type = typeof_type->getUnderlyingExpr()->getType();
-  }
-  if (auto alias = type->getAs<clang::TypedefType>();
-      alias && type.getCanonicalType()->isBuiltinType()) {
-    return DeclKey(alias->getDecl());
-  }
-  if (auto sugar = type->getAs<clang::PredefinedSugarType>()) {
-    return sugar->getIdentifier()->getName().str();
-  }
-  if (auto builtin = type->getAs<clang::BuiltinType>()) {
-    return builtin->getName(clang::PrintingPolicy(clang::LangOptions())).str();
-  }
-  if (auto tag = type->getAsTagDecl()) {
-    return ClassKey(tag);
-  }
-  return {};
-}
-
 clang::QualType EnableIfSameType(const clang::Decl *rule) {
   auto tmpl = llvm::dyn_cast<clang::TemplateDecl>(rule);
   if (!tmpl) {
@@ -561,119 +337,4 @@ clang::QualType EnableIfSameType(const clang::Decl *rule) {
   return {};
 }
 
-std::string ClassOf(clang::QualType type) {
-  while (type->isPointerType() || type->isReferenceType()) {
-    type = type->getPointeeType();
-  }
-  if (auto spec = type->getAs<clang::TemplateSpecializationType>()) {
-    auto decl = spec->getTemplateName().getAsTemplateDecl();
-    if (decl && llvm::isa<clang::ClassTemplateDecl>(decl)) {
-      return ClassKey(decl);
-    }
-    return {};
-  }
-  if (auto name = type->getAs<clang::DependentNameType>()) {
-    auto qualifier = name->getQualifier();
-    if (qualifier.getKind() == clang::NestedNameSpecifier::Kind::Type) {
-      return ClassOf(clang::QualType(qualifier.getAsType(), 0));
-    }
-  }
-  return {};
-}
-
-std::unordered_set<std::string>
-RequiredClasses(const clang::Decl *rule, const clang::TypedefNameDecl *alias) {
-  std::unordered_set<std::string> required;
-  if (alias) {
-    AddRequiredClasses(alias->getUnderlyingType(), required);
-  } else if (auto fn = rule->getAsFunction()) {
-    AddRequiredClasses(fn->getType(), required);
-  } else if (auto var = llvm::dyn_cast<clang::VarDecl>(rule)) {
-    AddRequiredClasses(var->getType(), required);
-  }
-  return required;
-}
-
-std::string ClassOfParameters(const clang::Decl *rule) {
-  auto fn = rule->getAsFunction();
-  if (!fn) {
-    return {};
-  }
-  for (const auto *param : fn->parameters()) {
-    if (auto class_key = ClassOf(param->getType()); !class_key.empty()) {
-      return class_key;
-    }
-  }
-  return {};
-}
-
-std::string ClassOfEnableIf(const clang::Decl *rule) {
-  auto same = EnableIfSameType(rule);
-  return same.isNull() ? std::string() : ClassOf(same);
-}
-
-std::string DependentExprKey(const clang::Expr *expr) {
-  auto member = llvm::dyn_cast<clang::CXXDependentScopeMemberExpr>(expr);
-  if (auto call = llvm::dyn_cast<clang::CallExpr>(expr)) {
-    if (auto callee = call->getDirectCallee()) {
-      return FunctionKey(callee);
-    }
-    auto callee = call->getCallee()->IgnoreParenImpCasts();
-    member = llvm::dyn_cast<clang::CXXDependentScopeMemberExpr>(callee);
-    if (auto overloads = llvm::dyn_cast<clang::UnresolvedMemberExpr>(callee);
-        overloads && overloads->decls_begin() != overloads->decls_end()) {
-      return DeclKey((*overloads->decls_begin())->getUnderlyingDecl());
-    }
-    if (auto ref = llvm::dyn_cast<clang::DependentScopeDeclRefExpr>(callee)) {
-      auto qualifier = ref->getQualifier();
-      if (qualifier.getKind() == clang::NestedNameSpecifier::Kind::Type) {
-        return MemberKey(ClassOf(clang::QualType(qualifier.getAsType(), 0)),
-                         MemberName(ref->getDeclName()));
-      }
-    }
-    if (auto lookup = llvm::dyn_cast<clang::UnresolvedLookupExpr>(callee);
-        lookup && lookup->getQualifier() &&
-        !llvm::isa<clang::CXXOperatorCallExpr>(call) &&
-        lookup->decls_begin() != lookup->decls_end()) {
-      return DeclKey((*lookup->decls_begin())->getUnderlyingDecl());
-    }
-  }
-  if (member && !member->isArrow() &&
-      member->getBaseType()
-          .getNonReferenceType()
-          ->getAs<clang::TemplateSpecializationType>()) {
-    return MemberKey(ClassOf(member->getBaseType()),
-                     MemberName(member->getMember()));
-  }
-  if (auto construct =
-          llvm::dyn_cast<clang::CXXUnresolvedConstructExpr>(expr)) {
-    auto class_key = ClassOf(construct->getTypeAsWritten());
-    return ConstructorKey(class_key);
-  }
-  return {};
-}
-
-std::string RuleExprKey(clang::ASTContext &ctx, const clang::Decl *rule) {
-  auto expr = RuleExpr(rule);
-  if (!expr) {
-    return {};
-  }
-  expr = IgnoreImplicitAndFunctionalCast(expr);
-  if (!expr->isTypeDependent() && !expr->isValueDependent()) {
-    return ExprKeyString(ctx, expr);
-  }
-  return DependentExprKey(expr);
-}
-
-std::string RuleTypeKey(const clang::TypedefNameDecl *rule) {
-  auto type = rule->getUnderlyingType();
-  while (type->isPointerType() || type->isReferenceType()) {
-    type = type->getPointeeType();
-  }
-  if (!type->isDependentType()) {
-    return TypeKey(type);
-  }
-  return ClassOf(type);
-}
-
 } // namespace cpp2rust::RuleDecls