Swift: collapse TypeRepr hierarchy

Now `TypeRepr` is a final class in the AST, which is more or less just
a type with a location in code.

As the frontend does not provide a direct way to get a type from a
type representation, this information must be provided when fetching
the label of a type repr.

This meant:
* removing the type repr field from `EnumIsCaseExpr`: this is a virtual
  AST node introduced in place of some kinds of `IsEpxr`. The type
  repr is still available from the `ConditionalCheckedCastExpr` wrapped
  by this virtual node, and we will rebuild the original `IsExpr` with
  the IPA layer.
* some logic to get the type of keypath roots has been added to
  `KeyPathExpr`. This was done to keep the `TypeRepr` to `Type` relation
  total in the DB, but goes against the design of a dumb extractor. The
  logic could be moved to QL in the future
* in the control flow library, `TypeRepr` children are now ignored. As
  far as I can tell, there is no runtime evaluation going on in
  `TypeRepr`s, so it does not make much sense to have control flow
  through them.

Author: redsun82

swift/codegen/schema.yml

@@ -7,8 +7,7 @@ _includes:
 _directories:
   decl: Decl$|Context$
   pattern: Pattern$
-  type: Type$
-  typerepr: TypeRepr$
+  type: Type(Repr)?$
   expr: Expr$
   stmt: Stmt$
 
@@ -181,6 +180,7 @@ Stmt:
 
 TypeRepr:
   _extends: AstNode
+  type: Type
 
 FunctionType:
   _extends: AnyFunctionType
@@ -391,7 +391,6 @@ EnumIsCaseExpr:
   _extends: Expr
   _children:
     sub_expr: Expr
-    type_repr: TypeRepr
     element: EnumElementDecl
 
 ErrorExpr:
@@ -442,7 +441,7 @@ KeyPathDotExpr:
 KeyPathExpr:
   _extends: Expr
   _children:
-    parsed_root: Expr?
+    root: TypeRepr?
     parsed_path: Expr?
 
 LazyInitializerExpr:
@@ -1162,87 +1161,3 @@ FloatLiteralExpr:
 IntegerLiteralExpr:
   _extends: NumberLiteralExpr
   string_value: string
-
-ErrorTypeRepr:
-  _extends: TypeRepr
-
-AttributedTypeRepr:
-  _extends: TypeRepr
-
-IdentTypeRepr:
-  _extends: TypeRepr
-
-ComponentIdentTypeRepr:
-  _extends: IdentTypeRepr
-
-SimpleIdentTypeRepr:
-  _extends: ComponentIdentTypeRepr
-
-GenericIdentTypeRepr:
-  _extends: ComponentIdentTypeRepr
-
-CompoundIdentTypeRepr:
-  _extends: IdentTypeRepr
-
-FunctionTypeRepr:
-  _extends: TypeRepr
-
-ArrayTypeRepr:
-  _extends: TypeRepr
-
-DictionaryTypeRepr:
-  _extends: TypeRepr
-
-OptionalTypeRepr:
-  _extends: TypeRepr
-
-ImplicitlyUnwrappedOptionalTypeRepr:
-  _extends: TypeRepr
-
-TupleTypeRepr:
-  _extends: TypeRepr
-
-CompositionTypeRepr:
-  _extends: TypeRepr
-
-MetatypeTypeRepr:
-  _extends: TypeRepr
-
-ProtocolTypeRepr:
-  _extends: TypeRepr
-
-OpaqueReturnTypeRepr:
-  _extends: TypeRepr
-
-NamedOpaqueReturnTypeRepr:
-  _extends: TypeRepr
-
-ExistentialTypeRepr:
-  _extends: TypeRepr
-
-PlaceholderTypeRepr:
-  _extends: TypeRepr
-
-SpecifierTypeRepr:
-  _extends: TypeRepr
-
-InOutTypeRepr:
-  _extends: SpecifierTypeRepr
-
-SharedTypeRepr:
-  _extends: SpecifierTypeRepr
-
-OwnedTypeRepr:
-  _extends: SpecifierTypeRepr
-
-IsolatedTypeRepr:
-  _extends: SpecifierTypeRepr
-
-CompileTimeConstTypeRepr:
-  _extends: SpecifierTypeRepr
-
-FixedTypeRepr:
-  _extends: TypeRepr
-
-SilBoxTypeRepr:
-  _extends: TypeRepr

swift/extractor/infra/SwiftDispatcher.h

@@ -64,8 +64,8 @@ class SwiftDispatcher {
   // This method gives a TRAP label for already emitted AST node.
   // If the AST node was not emitted yet, then the emission is dispatched to a corresponding
   // visitor (see `visit(T *)` methods below).
-  template <typename E>
-  TrapLabelOf<E> fetchLabel(E* e) {
+  template <typename E, typename... Args>
+  TrapLabelOf<E> fetchLabel(E* e, Args&&... args) {
     assert(e && "trying to fetch a label on nullptr, maybe fetchOptionalLabel is to be used?");
     // this is required so we avoid any recursive loop: a `fetchLabel` during the visit of `e` might
     // end up calling `fetchLabel` on `e` itself, so we want the visit of `e` to call `fetchLabel`
@@ -76,7 +76,7 @@ class SwiftDispatcher {
       return *l;
     }
     waitingForNewLabel = e;
-    visit(e);
+    visit(e, std::forward<Args>(args)...);
     if (auto l = store.get(e)) {
       if constexpr (!std::is_base_of_v<swift::TypeBase, E>) {
         attachLocation(e, *l);
@@ -158,10 +158,10 @@ class SwiftDispatcher {
   // 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))> {
+  template <typename Arg, typename... Args>
+  auto fetchOptionalLabel(Arg&& arg, Args&&... args) -> std::optional<decltype(fetchLabel(arg))> {
     if (arg) {
-      return fetchLabel(arg);
+      return fetchLabel(arg, std::forward<Args>(args)...);
     }
     return std::nullopt;
   }
@@ -251,9 +251,11 @@ class SwiftDispatcher {
 
   template <typename Tag, typename T, typename... Ts>
   bool fetchLabelFromUnionCase(const llvm::PointerUnion<Ts...> u, TrapLabel<Tag>& output) {
-    if (auto e = u.template dyn_cast<T>()) {
-      output = fetchLabel(e);
-      return true;
+    if constexpr (!std::is_same_v<T, swift::TypeRepr*>) {
+      if (auto e = u.template dyn_cast<T>()) {
+        output = fetchLabel(e);
+        return true;
+      }
     }
     return false;
   }
@@ -279,7 +281,7 @@ class SwiftDispatcher {
   virtual void visit(swift::CaseLabelItem* item) = 0;
   virtual void visit(swift::Expr* expr) = 0;
   virtual void visit(swift::Pattern* pattern) = 0;
-  virtual void visit(swift::TypeRepr* type) = 0;
+  virtual void visit(swift::TypeRepr* typeRepr, swift::Type type) = 0;
   virtual void visit(swift::TypeBase* type) = 0;
 
   const swift::SourceManager& sourceManager;

swift/extractor/infra/SwiftTagTraits.h

@@ -14,7 +14,6 @@ using SILBlockStorageTypeTag = SilBlockStorageTypeTag;
 using SILBoxTypeTag = SilBoxTypeTag;
 using SILFunctionTypeTag = SilFunctionTypeTag;
 using SILTokenTypeTag = SilTokenTypeTag;
-using SILBoxTypeReprTag = SilBoxTypeReprTag;
 
 #define MAP_TYPE_TO_TAG(TYPE, TAG)           \
   template <>                                \
@@ -57,9 +56,6 @@ MAP_TAG(Pattern);
 #include <swift/AST/PatternNodes.def>
 
 MAP_TAG(TypeRepr);
-#define ABSTRACT_TYPEREPR(CLASS, PARENT) MAP_SUBTAG(CLASS##TypeRepr, PARENT)
-#define TYPEREPR(CLASS, PARENT) ABSTRACT_TYPEREPR(CLASS, PARENT)
-#include <swift/AST/TypeReprNodes.def>
 
 MAP_TYPE_TO_TAG(TypeBase, TypeTag);
 #define ABSTRACT_TYPE(CLASS, PARENT) MAP_SUBTAG(CLASS##Type, PARENT)

swift/extractor/trap/BUILD.bazel

@@ -1,6 +1,6 @@
 load("//swift:rules.bzl", "swift_cc_library")
 
-_dirs = ("", "decl/", "expr/", "pattern/", "stmt/", "type/", "typerepr/")
+_dirs = ("", "decl/", "expr/", "pattern/", "stmt/", "type/")
 
 genrule(
     name = "cppgen",

swift/extractor/visitors/ExprVisitor.cpp

@@ -188,9 +188,8 @@ void ExprVisitor::visitEnumIsCaseExpr(swift::EnumIsCaseExpr* expr) {
   assert(expr->getCaseTypeRepr() && "EnumIsCaseExpr has CaseTypeRepr");
   assert(expr->getEnumElement() && "EnumIsCaseExpr has EnumElement");
   auto subExpr = dispatcher_.fetchLabel(expr->getSubExpr());
-  auto typeRepr = dispatcher_.fetchLabel(expr->getCaseTypeRepr());
   auto enumElement = dispatcher_.fetchLabel(expr->getEnumElement());
-  dispatcher_.emit(EnumIsCaseExprsTrap{label, subExpr, typeRepr, enumElement});
+  dispatcher_.emit(EnumIsCaseExprsTrap{label, subExpr, enumElement});
 }
 
 void ExprVisitor::visitMakeTemporarilyEscapableExpr(swift::MakeTemporarilyEscapableExpr* expr) {
@@ -288,7 +287,9 @@ void ExprVisitor::visitErasureExpr(swift::ErasureExpr* expr) {
 
 codeql::TypeExpr ExprVisitor::translateTypeExpr(const swift::TypeExpr& expr) {
   TypeExpr entry{dispatcher_.assignNewLabel(expr)};
-  entry.type_repr = dispatcher_.fetchOptionalLabel(expr.getTypeRepr());
+  if (expr.getTypeRepr() && expr.getInstanceType()) {
+    entry.type_repr = dispatcher_.fetchLabel(expr.getTypeRepr(), expr.getInstanceType());
+  }
   return entry;
 }
 
@@ -478,9 +479,14 @@ void ExprVisitor::visitKeyPathExpr(swift::KeyPathExpr* expr) {
       auto pathLabel = dispatcher_.fetchLabel(path);
       dispatcher_.emit(KeyPathExprParsedPathsTrap{label, pathLabel});
     }
-    if (auto root = expr->getParsedRoot()) {
-      auto rootLabel = dispatcher_.fetchLabel(root);
-      dispatcher_.emit(KeyPathExprParsedRootsTrap{label, rootLabel});
+    // TODO maybe move this logic to QL?
+    if (auto rootTypeRepr = expr->getRootType()) {
+      auto keyPathType = expr->getType()->getAs<swift::BoundGenericClassType>();
+      assert(keyPathType && "KeyPathExpr must have BoundGenericClassType");
+      auto keyPathTypeArgs = keyPathType->getGenericArgs();
+      assert(keyPathTypeArgs.size() != 0 && "KeyPathExpr type must have generic args");
+      auto rootLabel = dispatcher_.fetchLabel(rootTypeRepr, keyPathTypeArgs[0]);
+      dispatcher_.emit(KeyPathExprRootsTrap{label, rootLabel});
     }
   }
 }

swift/extractor/visitors/PatternVisitor.cpp

@@ -18,8 +18,8 @@ void PatternVisitor::visitTypedPattern(swift::TypedPattern* pattern) {
   assert(pattern->getSubPattern() && "expect TypedPattern to have a SubPattern");
   dispatcher_.emit(TypedPatternsTrap{label, dispatcher_.fetchLabel(pattern->getSubPattern())});
   if (auto typeRepr = pattern->getTypeRepr()) {
-    dispatcher_.emit(
-        TypedPatternTypeReprsTrap{label, dispatcher_.fetchLabel(pattern->getTypeRepr())});
+    dispatcher_.emit(TypedPatternTypeReprsTrap{
+        label, dispatcher_.fetchLabel(pattern->getTypeRepr(), pattern->getType())});
   }
 }
 
@@ -63,7 +63,8 @@ void PatternVisitor::visitIsPattern(swift::IsPattern* pattern) {
   dispatcher_.emit(IsPatternsTrap{label});
 
   if (auto typeRepr = pattern->getCastTypeRepr()) {
-    dispatcher_.emit(IsPatternCastTypeReprsTrap{label, dispatcher_.fetchLabel(typeRepr)});
+    dispatcher_.emit(IsPatternCastTypeReprsTrap{
+        label, dispatcher_.fetchLabel(typeRepr, pattern->getCastType())});
   }
   if (auto subPattern = pattern->getSubPattern()) {
     dispatcher_.emit(IsPatternSubPatternsTrap{label, dispatcher_.fetchLabel(subPattern)});

swift/extractor/visitors/SwiftVisitor.h

@@ -5,7 +5,6 @@
 #include "swift/extractor/visitors/ExprVisitor.h"
 #include "swift/extractor/visitors/StmtVisitor.h"
 #include "swift/extractor/visitors/TypeVisitor.h"
-#include "swift/extractor/visitors/TypeReprVisitor.h"
 #include "swift/extractor/visitors/PatternVisitor.h"
 
 namespace codeql {
@@ -26,13 +25,14 @@ class SwiftVisitor : private SwiftDispatcher {
   void visit(swift::CaseLabelItem* item) override { stmtVisitor.visitCaseLabelItem(item); }
   void visit(swift::Expr* expr) override { exprVisitor.visit(expr); }
   void visit(swift::Pattern* pattern) override { patternVisitor.visit(pattern); }
-  void visit(swift::TypeRepr* type) override { typeReprVisitor.visit(type); }
   void visit(swift::TypeBase* type) override { typeVisitor.visit(type); }
+  void visit(swift::TypeRepr* typeRepr, swift::Type type) override {
+    typeVisitor.visit(*typeRepr, type);
+  }
 
   DeclVisitor declVisitor{*this};
   ExprVisitor exprVisitor{*this};
   StmtVisitor stmtVisitor{*this};
-  TypeReprVisitor typeReprVisitor{*this};
   TypeVisitor typeVisitor{*this};
   PatternVisitor patternVisitor{*this};
 };

swift/extractor/visitors/TypeReprVisitor.cpp

@@ -8,6 +8,12 @@ void TypeVisitor::visit(swift::TypeBase* type) {
   dispatcher_.emit(TypesTrap{label, type->getString(), canonicalLabel});
 }
 
+void TypeVisitor::visit(const swift::TypeRepr& typeRepr, swift::Type type) {
+  auto entry = dispatcher_.createEntry(typeRepr);
+  entry.type = dispatcher_.fetchLabel(type);
+  dispatcher_.emit(entry);
+}
+
 void TypeVisitor::visitProtocolType(swift::ProtocolType* type) {
   auto label = dispatcher_.assignNewLabel(type);
   dispatcher_.emit(ProtocolTypesTrap{label});