Merge pull request #9230 from github/redsun82/swift-use-generated-classes

Swift: use structured generated C++ classes in `DeclVisitor`

Author: AlexDenisov

swift/codegen/schema.yml

@@ -13,25 +13,23 @@ _directories:
   stmt: Stmt$
 
 Element:
-  is_unknown:
-    type: predicate
-    _tags: [ no_qltest ]
+  is_unknown: predicate
+  _tags: [ no_qltest ]
 
 File:
   name: string
 
 Locatable:
-  location:
-    type: Location
-    _tags: [no_qltest]
+  location: Location?
+  _tags: [ no_qltest ]
 
 Location:
-  _tags: [ no_qltest ]
   file: File
   start_line: int
   start_column: int
   end_line: int
   end_column: int
+  _tags: [ no_qltest ]
 
 Type:
   diagnostics_name: string

swift/codegen/templates/cpp_classes.mustache

@@ -7,12 +7,18 @@
 #include <vector>
 
 #include "swift/extractor/trap/TrapLabel.h"
+#include "swift/extractor/trap/TrapTagTraits.h"
 #include "./TrapEntries.h"
 
 namespace codeql {
 {{#classes}}
 
-struct {{name}}{{#final}} : Binding<{{name}}Tag>{{#bases}}, {{ref.name}}{{/bases}}{{/final}}{{^final}}{{#has_bases}}: {{#bases}}{{^first}}, {{/first}}{{ref.name}}{{/bases}}{{/has_bases}}{{/final}} {
+struct {{name}}{{#has_bases}} : {{#bases}}{{^first}}, {{/first}}{{ref.name}}{{/bases}}{{/has_bases}} {
+  {{#final}}
+  explicit {{name}}(TrapLabel<{{name}}Tag> id) : id{id} {}
+
+  TrapLabel<{{name}}Tag> id{};
+  {{/final}}
   {{#fields}}
   {{type}} {{field_name}}{};
   {{/fields}}
@@ -54,5 +60,10 @@ struct {{name}}{{#final}} : Binding<{{name}}Tag>{{#bases}}, {{ref.name}}{{/bases
     {{/fields}}
   }
 };
+
+template <>
+struct detail::ToTrapClassFunctor<{{name}}Tag> {
+  using type = {{name}};
+};
 {{/classes}}
 }

swift/extractor/SwiftDispatcher.h

@@ -35,6 +35,18 @@ class SwiftDispatcher {
     trap.emit(entry);
   }
 
+  template <typename Entry>
+  void emit(const std::optional<Entry>& entry) {
+    if (entry) {
+      emit(*entry);
+    }
+  }
+
+  template <typename... Cases>
+  void emit(const std::variant<Cases...>& entry) {
+    std::visit([this](const auto& e) { this->emit(e); }, entry);
+  }
+
   // This is a helper method to emit TRAP entries for AST nodes that we don't fully support yet.
   template <typename E>
   void emitUnknown(E* entity) {
@@ -92,6 +104,11 @@ class SwiftDispatcher {
     return label;
   }
 
+  template <typename E, typename... Args, std::enable_if_t<!std::is_pointer_v<E>>* = nullptr>
+  TrapLabelOf<E> assignNewLabel(const E& e, Args&&... args) {
+    return assignNewLabel(&e, std::forward<Args>(args)...);
+  }
+
   template <typename Tag>
   TrapLabel<Tag> createLabel() {
     auto ret = arena.allocateLabel<Tag>();
@@ -129,6 +146,30 @@ class SwiftDispatcher {
                    locatableLabel);
   }
 
+  // return `std::optional(fetchLabel(arg))` if arg converts to true, otherwise std::nullopt
+  // universal reference `Arg&&` is used to catch both temporary and non-const references, not
+  // for perfect forwarding
+  template <typename Arg>
+  auto fetchOptionalLabel(Arg&& arg) -> std::optional<decltype(fetchLabel(arg))> {
+    if (arg) {
+      return fetchLabel(arg);
+    }
+    return std::nullopt;
+  }
+
+  // map `fetchLabel` on the iterable `arg`, returning a vector of all labels
+  // universal reference `Arg&&` is used to catch both temporary and non-const references, not
+  // for perfect forwarding
+  template <typename Iterable>
+  auto fetchRepeatedLabels(Iterable&& arg) {
+    std::vector<decltype(fetchLabel(*arg.begin()))> ret;
+    ret.reserve(arg.size());
+    for (auto&& e : arg) {
+      ret.push_back(fetchLabel(e));
+    }
+    return ret;
+  }
+
   // In order to not emit duplicated entries for declarations, we restrict emission to only
   // Decls declared within the current "scope".
   // Depending on the whether we are extracting a primary source file or not the scope is defined as
@@ -138,14 +179,14 @@ class SwiftDispatcher {
   //  - extracting a primary source file: in this mode, we extract several files belonging to the
   //    same module one by one. In this mode, we restrict emission only to the same file ignoring
   //    all the other files.
-  bool shouldEmitDeclBody(swift::Decl* decl) {
-    if (decl->getModuleContext() != &currentModule) {
+  bool shouldEmitDeclBody(const swift::Decl& decl) {
+    if (decl.getModuleContext() != &currentModule) {
       return false;
     }
     if (!currentPrimarySourceFile) {
       return true;
     }
-    if (auto context = decl->getDeclContext()) {
+    if (auto context = decl.getDeclContext()) {
       return currentPrimarySourceFile == context->getParentSourceFile();
     }
     return false;
@@ -178,7 +219,7 @@ class SwiftDispatcher {
     auto locLabel = createLabel<LocationTag>('{', fileLabel, "}:", startLine, ':', startColumn, ':',
                                              endLine, ':', endColumn);
     trap.emit(LocationsTrap{locLabel, fileLabel, startLine, startColumn, endLine, endColumn});
-    trap.emit(LocatablesTrap{locatableLabel, locLabel});
+    trap.emit(LocatableLocationsTrap{locatableLabel, locLabel});
   }
 
   template <typename Tag, typename... Ts>

swift/extractor/trap/TrapLabel.h

@@ -58,11 +58,6 @@ inline auto trapQuoted(const std::string& s) {
   return std::quoted(s, '"', '"');
 }
 
-template <typename Tag>
-struct Binding {
-  TrapLabel<Tag> id;
-};
-
 }  // namespace codeql
 
 namespace std {

swift/extractor/trap/TrapTagTraits.h

@@ -19,6 +19,10 @@ struct ToTagOverride : ToTagFunctor<T> {};
 // must be instantiated to map trap labels to the corresponding generated binding trap entry
 template <typename Label>
 struct ToBindingTrapFunctor;
+
+// must be instantiated to map trap tags to the corresponding generated trap class
+template <typename Tag>
+struct ToTrapClassFunctor;
 }  // namespace detail
 
 template <typename T>
@@ -30,4 +34,7 @@ using TrapLabelOf = TrapLabel<TrapTagOf<T>>;
 template <typename T>
 using BindingTrapOf = typename detail::ToBindingTrapFunctor<TrapLabelOf<T>>::type;
 
+template <typename T>
+using TrapClassOf = typename detail::ToTrapClassFunctor<TrapTagOf<T>>::type;
+
 }  // namespace codeql