Force each typedef to have a translation rule

cpp2rust/converter/converter.cpp

@@ -770,13 +770,13 @@ bool Converter::IsPassThroughRule(clang::Expr *expr) const {
              rule->body[0]);
 }
 
-bool Converter::RecordDerivesCopy(const clang::RecordDecl *decl) {
+bool Converter::RecordDerivesCopy(clang::QualType type) {
+  auto decl = type->getAsRecordDecl();
   if (auto cxx = llvm::dyn_cast<clang::CXXRecordDecl>(decl);
       cxx && cxx->isLambda()) {
     return false;
   }
-  if (auto rule =
-          RuleRegistry::Search(ctx_, ctx_.getCanonicalTagType(decl)).first) {
+  if (auto rule = RuleRegistry::Search(ctx_, type).first) {
     auto &derives = rule->type_info.derives;
     return std::find(derives.begin(), derives.end(), "Copy") != derives.end();
   }
@@ -804,9 +804,9 @@ bool Converter::RecordHasCopyableFields(const clang::RecordDecl *decl) {
     }
 
     // Look recursively into fields that are RecordDecl, or arrays of them
-    if (auto field_record =
-            ctx_.getBaseElementType(f->getType())->getAsRecordDecl()) {
-      if (!RecordDerivesCopy(field_record)) {
+    if (auto field_type = ctx_.getBaseElementType(f->getType());
+        field_type->getAsRecordDecl()) {
+      if (!RecordDerivesCopy(field_type)) {
         return false;
       }
     }
@@ -2304,11 +2304,6 @@ std::string Converter::getIntegerLiteral(clang::IntegerLiteral *expr,
   auto type_as_string = GetUnsafeTypeAsString(ty);
 
   if (ty->isFloatingType() || incl_type) {
-    if (value.isZero()) {
-      if (auto init = Mapper::MapInitializer(*this, ty); !init.empty()) {
-        return init;
-      }
-    }
     return getTypedLiteral(num_as_string.c_str(), type_as_string);
   }
 
@@ -4227,8 +4222,8 @@ std::string Converter::GetArrayDefaultAsString(clang::QualType qual_type) {
     auto size_as_string = GetNumAsString(array_type->getSize());
     auto element_type = array_type->getElementType();
     auto element_type_as_string = GetDefaultAsString(element_type);
-    if (auto *rec = element_type->getAsRecordDecl()) {
-      if (!RecordDerivesCopy(rec)) {
+    if (element_type->getAsRecordDecl()) {
+      if (!RecordDerivesCopy(element_type)) {
         return std::format("std::array::from_fn::<_, {}, _>(|_| {})",
                            size_as_string.c_str(), element_type_as_string);
       }

cpp2rust/converter/converter.h

@@ -365,8 +365,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
     if (ty->isBuiltinType() || ty->isEnumeralType()) {
       return true;
     }
-    if (auto *record = ty->getAsRecordDecl()) {
-      return RecordDerivesCopy(record);
+    if (ty->getAsRecordDecl()) {
+      return RecordDerivesCopy(ty);
     }
     return false;
   }
@@ -791,7 +791,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual bool TypeDerivesDefault(clang::QualType qual_type);
 
-  bool RecordDerivesCopy(const clang::RecordDecl *decl);
+  bool RecordDerivesCopy(clang::QualType type);
 
   bool IsPassThroughRule(clang::Expr *expr) const;
 

cpp2rust/converter/converter_lib.cpp

@@ -274,6 +274,14 @@ bool IsUserDefinedDecl(const clang::Decl *decl) {
                })) {
       return false;
     }
+  } else if (auto tag = llvm::dyn_cast<clang::TagDecl>(decl)) {
+    if (auto definition = tag->getDefinition()) {
+      decl = definition;
+    } else if (llvm::any_of(tag->redecls(), [&](auto redecl) {
+                 return src_mgr.isInSystemHeader(redecl->getLocation());
+               })) {
+      return false;
+    }
   }
   auto src_loc = decl->getLocation();
   if (auto *spec =

cpp2rust/converter/models/boxed_vars.cpp

@@ -260,6 +260,9 @@ class AddressTakenVisitor
   }
 
   void AddressTaken(const clang::ValueDecl *decl) {
+    if (!IsUserDefinedDecl(decl)) {
+      return;
+    }
     if (auto *var = clang::dyn_cast<clang::VarDecl>(decl);
         var && CanUnbox(ctx_, var)) {
       address_taken_.insert(var);

cpp2rust/converter/rules/decls.cpp

@@ -13,6 +13,8 @@
 #include <optional>
 #include <vector>
 
+#include "converter/converter_lib.h"
+
 namespace cpp2rust::RuleDecls {
 
 const clang::Expr *SkipImplicit(const clang::Expr *expr) {
@@ -103,4 +105,72 @@ DeduceFromType(clang::Sema &sema, clang::TemplateParameterList *params,
   return std::vector<clang::TemplateArgument>(deduced.begin(), deduced.end());
 }
 
+bool IsInternal(const clang::NamedDecl *decl) {
+  if (decl->getAccess() == clang::AS_private ||
+      decl->getAccess() == clang::AS_protected) {
+    return true;
+  }
+  auto &opts = decl->getASTContext().getLangOpts();
+  if (decl->isReserved(opts) != clang::ReservedIdentifierStatus::NotReserved) {
+    return true;
+  }
+  for (auto context = decl->getDeclContext(); context;
+       context = context->getParent()) {
+    if (context->isInlineNamespace()) {
+      continue;
+    }
+    auto named = llvm::dyn_cast<clang::NamedDecl>(context);
+    if (named && named->getIdentifier() &&
+        named->isReserved(opts) !=
+            clang::ReservedIdentifierStatus::NotReserved) {
+      return true;
+    }
+  }
+  return false;
+}
+
+clang::QualType PeelSugar(clang::ASTContext &ctx, clang::QualType type) {
+  while (!llvm::isa<clang::TypedefType, clang::PredefinedSugarType>(
+             type.getTypePtr()) &&
+         type != type.getSingleStepDesugaredType(ctx)) {
+    type = type.getSingleStepDesugaredType(ctx);
+  }
+  return type;
+}
+
+const clang::Type *GetSugar(clang::QualType type) {
+  if (auto typeof_type =
+          llvm::dyn_cast<clang::TypeOfExprType>(type.getTypePtr())) {
+    type = typeof_type->getUnderlyingExpr()->getType();
+  }
+  if (llvm::isa<clang::TypedefType, clang::PredefinedSugarType>(
+          type.getTypePtr())) {
+    return type.getTypePtr();
+  }
+  return nullptr;
+}
+
+clang::QualType SkipInternalTypedefs(clang::ASTContext &ctx,
+                                     clang::QualType use) {
+  auto cvr = use.getLocalCVRQualifiers();
+  auto type = PeelSugar(ctx, use);
+  while (auto typedef_type =
+             llvm::dyn_cast<clang::TypedefType>(type.getTypePtr())) {
+    auto decl = typedef_type->getDecl();
+    if (!IsInternal(decl) && !IsUserDefinedDecl(decl)) {
+      break;
+    }
+    type = PeelSugar(ctx, typedef_type->desugar());
+    cvr |= type.getLocalCVRQualifiers();
+  }
+  return type.withCVRQualifiers(cvr);
+}
+
+const clang::TypedefNameDecl *SpelledTypedef(clang::ASTContext &ctx,
+                                             clang::QualType use) {
+  auto sugar = GetSugar(PeelSugar(ctx, use));
+  auto typedef_type = llvm::dyn_cast_or_null<clang::TypedefType>(sugar);
+  return typedef_type ? typedef_type->getDecl() : nullptr;
+}
+
 } // namespace cpp2rust::RuleDecls

cpp2rust/converter/rules/decls.h

@@ -46,4 +46,16 @@ std::optional<std::vector<clang::TemplateArgument>>
 DeduceFromType(clang::Sema &sema, clang::TemplateParameterList *params,
                clang::QualType pattern, clang::QualType actual);
 
+bool IsInternal(const clang::NamedDecl *decl);
+
+clang::QualType PeelSugar(clang::ASTContext &ctx, clang::QualType type);
+
+const clang::Type *GetSugar(clang::QualType type);
+
+clang::QualType SkipInternalTypedefs(clang::ASTContext &ctx,
+                                     clang::QualType use);
+
+const clang::TypedefNameDecl *SpelledTypedef(clang::ASTContext &ctx,
+                                             clang::QualType use);
+
 } // namespace cpp2rust::RuleDecls

cpp2rust/converter/rules/registry.cpp

@@ -3,6 +3,7 @@
 
 #include "converter/rules/registry.h"
 
+#include <clang/AST/Attr.h>
 #include <clang/AST/DeclCXX.h>
 #include <clang/AST/DeclTemplate.h>
 #include <clang/Basic/SourceManager.h>
@@ -273,22 +274,23 @@ struct TypeRuleMatch {
 
 TypeRuleMatch findType(clang::QualType use) {
   TypeRuleMatch best;
-  auto consider = [&](const RuleKeys::TypeKey &key) {
-    auto [begin, end] = types_.equal_range(key);
-    for (auto it = begin; it != end; ++it) {
-      auto match = AstMatcher::MatchType(*sema_, use, it->second.decl);
-      if (!match) {
-        continue;
-      }
-      if (best.rule_decl) {
-        if (match->depth > best.match.depth) {
+  auto &ctx = sema_->Context;
+  auto consider = [&](clang::QualType type, bool templates) {
+    for (auto key : RuleKeys::GetTypeKeys(ctx, type)) {
+      auto [begin, end] = types_.equal_range(key);
+      for (auto it = begin; it != end; ++it) {
+        if (!templates && llvm::isa<clang::TemplateDecl>(it->second.decl)) {
           continue;
         }
-        if (match->depth == best.match.depth) {
+        auto match = AstMatcher::MatchType(*sema_, type, it->second.decl);
+        if (!match) {
+          continue;
+        }
+        if (best.rule_decl) {
           auto better = AstMatcher::MoreSpecializedType(*sema_, it->second.decl,
                                                         best.rule_decl->decl);
           if (!better) {
-            use.dump(llvm::errs(), sema_->Context);
+            type.dump(llvm::errs(), ctx);
             it->second.decl->dump(llvm::errs());
             best.rule_decl->decl->dump(llvm::errs());
             llvm::report_fatal_error(
@@ -298,12 +300,31 @@ TypeRuleMatch findType(clang::QualType use) {
             continue;
           }
         }
+        best = {&it->second, *std::move(match)};
       }
-      best = {&it->second, *std::move(match)};
     }
   };
-  for (auto key : RuleKeys::GetTypeKeys(sema_->Context, use)) {
-    consider(key);
+  auto skipped = RuleDecls::SkipInternalTypedefs(ctx, use);
+  if (RuleDecls::SpelledTypedef(ctx, skipped) !=
+      RuleDecls::SpelledTypedef(ctx, use)) {
+    consider(use, /*templates=*/false);
+    if (best.rule_decl) {
+      return best;
+    }
+  }
+  use = skipped;
+  if (auto tag = use->getAsTagDecl();
+      tag &&
+      (IsUserDefinedDecl(tag) || tag->hasAttr<clang::TransparentUnionAttr>())) {
+    return best;
+  }
+  consider(use, /*templates=*/true);
+  if (!best.rule_decl) {
+    auto spelled = RuleDecls::SpelledTypedef(ctx, use);
+    if (spelled && !IsUserDefinedDecl(spelled)) {
+      use.dump(llvm::errs(), ctx);
+      llvm::report_fatal_error("typedef has no type rule");
+    }
   }
   return best;
 }
@@ -401,8 +422,11 @@ Matcher::Match<TranslationRule::TypeRule> Search(clang::ASTContext &ctx,
   if (!match.rule_decl) {
     return {};
   }
-  return {&match.rule_decl->rule,
-          getBindings(match.rule_decl->decl, match.match.args)};
+  auto bindings = getBindings(match.rule_decl->decl, match.match.args);
+  if (auto generic = match.rule_decl->rule.generic) {
+    return Search(ctx, bindings.at(generic - 1).getAsType());
+  }
+  return {&match.rule_decl->rule, std::move(bindings)};
 }
 
 const TranslationRule::ExprRule *GetExprRule(clang::ASTContext &ctx,

cpp2rust/converter/rules/rule_keys.cpp

@@ -42,6 +42,9 @@ const clang::Decl *getParent(clang::QualType type) {
           llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(record)) {
     return spec->getSpecializedTemplate()->getCanonicalDecl();
   }
+  if (auto tmpl = record->getDescribedClassTemplate()) {
+    return tmpl->getCanonicalDecl();
+  }
   return record->getCanonicalDecl();
 }
 
@@ -277,21 +280,17 @@ std::vector<TypeKey> GetTypeKeys(clang::ASTContext &ctx, clang::QualType use) {
       record && !use->isDependentType() && !IsUserDefinedDecl(record)) {
     keys.push_back(kAnyClass);
   }
-  for (auto type = use;; type = type.getSingleStepDesugaredType(ctx)) {
-    if (auto typedef_type =
-            llvm::dyn_cast<clang::TypedefType>(type.getTypePtr())) {
-      if (auto owner = llvm::dyn_cast<clang::CXXRecordDecl>(
-              typedef_type->getDecl()->getDeclContext())) {
-        auto key = GetTypeKey(ctx.getCanonicalTagType(owner));
-        if (key && !llvm::is_contained(keys, *key)) {
-          keys.push_back(*key);
-        }
+  if (auto typedef_type =
+          llvm::dyn_cast<clang::TypedefType>(use.getTypePtr())) {
+    if (auto owner = llvm::dyn_cast<clang::CXXRecordDecl>(
+            typedef_type->getDecl()->getDeclContext())) {
+      auto key = GetTypeKey(ctx.getCanonicalTagType(owner));
+      if (key && !llvm::is_contained(keys, *key)) {
+        keys.push_back(*key);
       }
     }
-    if (type.getSingleStepDesugaredType(ctx) == type) {
-      return keys;
-    }
   }
+  return keys;
 }
 
 std::optional<ExprKey> GetDeclKey(const clang::NamedDecl *decl) {