Swift: fix printing of unextracted entities

This was still printing explicitly ignored classes.

Author: redsun82

swift/extractor/print_unextracted/main.cpp

@@ -1,4 +1,6 @@
 #include <iostream>
+#include <vector>
+#include <map>
 
 #include "swift/extractor/translators/DeclTranslator.h"
 #include "swift/extractor/translators/ExprTranslator.h"
@@ -8,37 +10,35 @@
 
 using namespace codeql;
 
-#define CHECK_CLASS(KIND, CLASS, PARENT)                             \
-  if (!detail::HasTranslate##CLASS##KIND<KIND##Translator>::value && \
-      !detail::HasTranslate##PARENT<KIND##Translator>::value) {      \
-    std::cout << "  " #CLASS #KIND "\n";                             \
-  }
-
 int main() {
-  std::cout << "Unextracted Decls:\n";
+  std::map<const char*, std::vector<const char*>> unextracted;
+
+#define CHECK_CLASS(KIND, CLASS, PARENT)                                                \
+  if (KIND##Translator::getPolicyFor##CLASS##KIND() == TranslatorPolicy::emitUnknown) { \
+    unextracted[#KIND].push_back(#CLASS #KIND);                                         \
+  }
 
 #define DECL(CLASS, PARENT) CHECK_CLASS(Decl, CLASS, PARENT)
 #include "swift/AST/DeclNodes.def"
 
-  std::cout << "\nUnextracted Stmts:\n";
-
 #define STMT(CLASS, PARENT) CHECK_CLASS(Stmt, CLASS, PARENT)
 #include "swift/AST/StmtNodes.def"
 
-  std::cout << "\nUnextracted Exprs:\n";
-
 #define EXPR(CLASS, PARENT) CHECK_CLASS(Expr, CLASS, PARENT)
 #include "swift/AST/ExprNodes.def"
 
-  std::cout << "\nUnextracted Patterns:\n";
-
 #define PATTERN(CLASS, PARENT) CHECK_CLASS(Pattern, CLASS, PARENT)
 #include "swift/AST/PatternNodes.def"
 
-  std::cout << "\nUnextracted Types:\n";
-
 #define TYPE(CLASS, PARENT) CHECK_CLASS(Type, CLASS, PARENT)
 #include "swift/AST/TypeNodes.def"
 
+  for (const auto& [kind, classes] : unextracted) {
+    std::cout << "Unextracted " << kind << " subclasses:\n";
+    for (auto cls : classes) {
+      std::cout << "  " << cls << '\n';
+    }
+    std::cout << '\n';
+  }
   return 0;
 }

swift/extractor/translators/TranslatorBase.h

@@ -58,6 +58,13 @@ DEFINE_TRANSLATE_CHECKER(TypeRepr, , )
 #include "swift/AST/TypeReprNodes.def"
 }  // namespace detail
 
+enum class TranslatorPolicy {
+  ignore,
+  translate,
+  translateParent,
+  emitUnknown,
+};
+
 // we want to override the default swift visitor behaviour of chaining calls to immediate
 // superclasses by default and instead provide our own TBD default (using the exact type).
 // Moreover, if the implementation class has translate##CLASS##KIND (that uses generated C++
@@ -66,15 +73,30 @@ DEFINE_TRANSLATE_CHECKER(TypeRepr, , )
 // A special case is for explicitly ignored classes marked with void, which we should never
 // encounter.
 #define DEFINE_VISIT(KIND, CLASS, PARENT)                                            \
-  void visit##CLASS##KIND(swift::CLASS##KIND* e) {                                   \
+ public:                                                                             \
+  static constexpr TranslatorPolicy getPolicyFor##CLASS##KIND() {                    \
     if constexpr (std::is_same_v<CLASS##KIND##Tag, void>) {                          \
+      return TranslatorPolicy::ignore;                                               \
+    } else if constexpr (detail::HasTranslate##CLASS##KIND<CrtpSubclass>::value) {   \
+      return TranslatorPolicy::translate;                                            \
+    } else if constexpr (detail::HasTranslate##PARENT<CrtpSubclass>::value) {        \
+      return TranslatorPolicy::translateParent;                                      \
+    } else {                                                                         \
+      return TranslatorPolicy::emitUnknown;                                          \
+    }                                                                                \
+  }                                                                                  \
+                                                                                     \
+ private:                                                                            \
+  void visit##CLASS##KIND(swift::CLASS##KIND* e) {                                   \
+    constexpr auto policy = getPolicyFor##CLASS##KIND();                             \
+    if constexpr (policy == TranslatorPolicy::ignore) {                              \
       std::cerr << "Unexpected " #CLASS #KIND "\n";                                  \
       return;                                                                        \
-    } else if constexpr (detail::HasTranslate##CLASS##KIND<CrtpSubclass>::value) {   \
+    } else if constexpr (policy == TranslatorPolicy::translate) {                    \
       dispatcher.emit(static_cast<CrtpSubclass*>(this)->translate##CLASS##KIND(*e)); \
-    } else if constexpr (detail::HasTranslate##PARENT<CrtpSubclass>::value) {        \
+    } else if constexpr (policy == TranslatorPolicy::translateParent) {              \
       dispatcher.emit(static_cast<CrtpSubclass*>(this)->translate##PARENT(*e));      \
-    } else {                                                                         \
+    } else if constexpr (policy == TranslatorPolicy::emitUnknown) {                  \
       dispatcher.emitUnknown(e);                                                     \
     }                                                                                \
   }