Drop declares object from index

Author: lucic71

cpp2rust/converter/rules/rules_loader.cpp

@@ -8,6 +8,7 @@
 #include <clang/Basic/LangOptions.h>
 #include <clang/Lex/Lexer.h>
 #include <clang/Lex/Preprocessor.h>
+#include <clang/Sema/Lookup.h>
 #include <clang/Sema/Sema.h>
 #include <llvm/ADT/DenseSet.h>
 #include <llvm/ADT/STLExtras.h>
@@ -203,6 +204,7 @@ class RuleUsageCollector
           AddTemplateArgs(spec->getTemplateArgs().asArray());
         }
         AddSpecialMembers(record);
+        AddIterator(type, record);
       }
       return;
     }
@@ -226,6 +228,46 @@ class RuleUsageCollector
     }
   }
 
+  void AddIterator(clang::QualType type, const clang::CXXRecordDecl *record) {
+    auto *std_namespace = sema_.getStdNamespace();
+    if (!std_namespace ||
+        !ctx_.getSourceManager().isInSystemHeader(record->getLocation())) {
+      return;
+    }
+    clang::ClassTemplateDecl *traits = nullptr;
+    for (auto *decl :
+         std_namespace->lookup(&ctx_.Idents.get("iterator_traits"))) {
+      if ((traits = llvm::dyn_cast<clang::ClassTemplateDecl>(decl))) {
+        break;
+      }
+    }
+    if (!traits) {
+      return;
+    }
+    auto loc = record->getLocation();
+    RuleDecls::Trial trial(sema_);
+    clang::TemplateArgumentListInfo args(loc, loc);
+    args.addArgument(
+        clang::TemplateArgumentLoc(clang::TemplateArgument(type),
+                                   ctx_.getTrivialTypeSourceInfo(type, loc)));
+    auto instance = sema_.CheckTemplateIdType(
+        clang::ElaboratedTypeKeyword::None, clang::TemplateName(traits), loc,
+        args, /*Scope=*/nullptr, /*ForNestedNameSpecifier=*/false);
+    if (instance.isNull() || !sema_.isCompleteType(loc, instance) ||
+        trial.failed()) {
+      return;
+    }
+    auto *instance_record = instance->getAsCXXRecordDecl();
+    if (!instance_record) {
+      return;
+    }
+    clang::LookupResult category(sema_, &ctx_.Idents.get("iterator_category"),
+                                 loc, clang::Sema::LookupMemberName);
+    if (sema_.LookupQualifiedName(category, instance_record)) {
+      AddKey(kAnyIteratorKey);
+    }
+  }
+
   void AddTemplateArgs(llvm::ArrayRef<clang::TemplateArgument> args) {
     for (const auto &arg : args) {
       switch (arg.getKind()) {
@@ -299,31 +341,8 @@ unsigned CxxStandard(const clang::LangOptions &opts) {
   return 11;
 }
 
-bool IsDeclared(clang::ASTContext &ctx, llvm::StringRef key) {
-  const clang::DeclContext *scope = ctx.getTranslationUnitDecl();
-  while (true) {
-    auto [name, rest] = key.split('/');
-    auto found = scope->lookup(&ctx.Idents.get(name));
-    if (rest.empty()) {
-      return !found.empty();
-    }
-    scope = nullptr;
-    for (auto decl : found) {
-      if (llvm::isa<clang::NamespaceDecl, clang::TagDecl>(decl)) {
-        scope = llvm::cast<clang::DeclContext>(decl);
-        break;
-      }
-    }
-    if (!scope) {
-      return false;
-    }
-    key = rest;
-  }
-}
-
 std::string BuildRulesEpilogue(const std::unordered_set<std::string> &keys,
-                               clang::ASTContext &ctx) {
-  const auto &opts = ctx.getLangOpts();
+                               const clang::LangOptions &opts) {
   bool is_cxx = opts.CPlusPlus;
   const auto &index = is_cxx ? CxxIndex() : CIndex();
   unsigned standard = is_cxx ? CxxStandard(opts) : 0;
@@ -352,13 +371,6 @@ std::string BuildRulesEpilogue(const std::unordered_set<std::string> &keys,
           })) {
         continue;
       }
-      if (auto declared = rule->getArray("declares");
-          declared &&
-          !llvm::all_of(*declared, [&](const llvm::json::Value &name) {
-            return IsDeclared(ctx, *name.getAsString());
-          })) {
-        continue;
-      }
       out += WrapRule(*rule, is_cxx);
     }
   }
@@ -553,7 +565,7 @@ void PragmaHandler::HandlePragma(clang::Preprocessor &PP,
   RuleUsageCollector collector(CI_.getSema(), keys);
   collector.TraverseDecl(ctx.getTranslationUnitDecl());
 
-  auto text = BuildRulesEpilogue(keys, ctx);
+  auto text = BuildRulesEpilogue(keys, ctx.getLangOpts());
   log() << "rules loaded for this translation unit:\n" << text;
   auto rules_file = src_mgr.createFileID(
       llvm::MemoryBuffer::getMemBufferCopy(text, "<cpp2rust-rules>"),

cpp2rust/converter/rules/rules_loader.h

@@ -21,6 +21,8 @@ inline constexpr const char *kPragmaName = "cpp2rust_rules";
 
 inline constexpr const char *kAnyClassKey = "*";
 
+inline constexpr const char *kAnyIteratorKey = "std/iterator_traits";
+
 std::string ClassKey(const clang::NamedDecl *decl);
 
 std::string MemberName(clang::DeclarationName name);

cpp2rust/rule_preprocessing/cpp_rule_indexer.cpp

@@ -5,7 +5,6 @@
 #include <clang/AST/Decl.h>
 #include <clang/AST/DeclTemplate.h>
 #include <clang/AST/ExprCXX.h>
-#include <clang/AST/RecursiveASTVisitor.h>
 #include <clang/Basic/TokenKinds.h>
 #include <clang/Frontend/ASTUnit.h>
 #include <clang/Tooling/Tooling.h>
@@ -134,55 +133,6 @@ std::string ClassOfParameters(const clang::Decl *rule) {
   return {};
 }
 
-class DeclaredNames : public clang::RecursiveASTVisitor<DeclaredNames> {
-public:
-  explicit DeclaredNames(const clang::SourceManager &sm) : sm_(sm) {}
-
-  bool
-  VisitTemplateSpecializationType(clang::TemplateSpecializationType *type) {
-    add(type->getTemplateName().getAsTemplateDecl());
-    return true;
-  }
-
-  bool VisitTagType(clang::TagType *type) {
-    add(type->getDecl());
-    return true;
-  }
-
-  bool VisitDeclRefExpr(clang::DeclRefExpr *expr) {
-    add(expr->getDecl());
-    return true;
-  }
-
-  bool VisitOverloadExpr(clang::OverloadExpr *expr) {
-    if (expr->decls_begin() != expr->decls_end()) {
-      add((*expr->decls_begin())->getUnderlyingDecl());
-    }
-    return true;
-  }
-
-  std::unordered_set<std::string> names;
-
-private:
-  void add(const clang::NamedDecl *decl) {
-    if (!decl || !sm_.isInSystemHeader(decl->getLocation())) {
-      return;
-    }
-    if (auto key = RulesLoader::ClassKey(decl); !key.empty()) {
-      names.insert(key);
-    }
-  }
-
-  const clang::SourceManager &sm_;
-};
-
-std::unordered_set<std::string> DeclaredNamesOf(clang::ASTContext &ctx,
-                                                const clang::Decl *rule) {
-  DeclaredNames visitor(ctx.getSourceManager());
-  visitor.TraverseDecl(const_cast<clang::Decl *>(rule));
-  return std::move(visitor.names);
-}
-
 const clang::Expr *RuleExpr(const clang::Decl *decl) {
   if (auto var = llvm::dyn_cast<clang::VarDecl>(decl)) {
     return var->getInit();
@@ -323,7 +273,7 @@ void IndexRuleFile(clang::ASTContext &ctx, const std::string &dir_name,
     auto text = clang::tooling::getText(range, ctx).str() + '\n';
     llvm::json::Object rule{{"dir", dir_name}, {"name", name}, {"text", text}};
     if (any_class) {
-      rule["declares"] = llvm::json::Array(DeclaredNamesOf(ctx, decl));
+      rule["requires"] = llvm::json::Array{RulesLoader::kAnyIteratorKey};
     } else if (auto required = RequiredClasses(decl, alias);
                !required.empty()) {
       rule["requires"] = llvm::json::Array(required);