Swift: extract parameter packs

Author: AlexDenisov

swift/extractor/infra/SwiftTagTraits.h

@@ -126,8 +126,8 @@ MAP(swift::Expr, ExprTag)
     MAP(swift::AutoClosureExpr, AutoClosureExprTag)
   MAP(swift::InOutExpr, InOutExprTag)
   MAP(swift::VarargExpansionExpr, VarargExpansionExprTag)
-  MAP(swift::PackExpansionExpr, void)  // TODO (introduced in 5.8)
-  MAP(swift::PackElementExpr, void)  // TODO (introduced in 5.8)
+  MAP(swift::PackExpansionExpr, PackExpansionExprTag)
+  MAP(swift::PackElementExpr, PackElementExprTag)
   MAP(swift::DynamicTypeExpr, DynamicTypeExprTag)
   MAP(swift::RebindSelfInConstructorExpr, RebindSelfInInitializerExprTag)
   MAP(swift::OpaqueValueExpr, OpaqueValueExprTag)
@@ -319,10 +319,10 @@ MAP(swift::TypeBase, TypeTag)
     MAP(swift::ArchetypeType, ArchetypeTypeTag)
       MAP(swift::PrimaryArchetypeType, PrimaryArchetypeTypeTag)
       MAP(swift::OpaqueTypeArchetypeType, OpaqueTypeArchetypeTypeTag)
-      MAP(swift::LocalArchetypeType, OpenedArchetypeTypeTag)  // TODO (introduced in 5.8)
+      MAP(swift::LocalArchetypeType, LocalArchetypeTypeTag)
         MAP(swift::OpenedArchetypeType, OpenedArchetypeTypeTag)
-        MAP(swift::ElementArchetypeType, void)  // TODO (introduced in 5.8)
-      MAP(swift::PackArchetypeType, void)  // TODO (introduced in 5.8)
+        MAP(swift::ElementArchetypeType, ElementArchetypeTypeTag)
+      MAP(swift::PackArchetypeType, PackArchetypeTypeTag)
     MAP(swift::GenericTypeParamType, GenericTypeParamTypeTag)
   MAP(swift::DependentMemberType, DependentMemberTypeTag)
   MAP(swift::AnyFunctionType, AnyFunctionTypeTag)
@@ -341,11 +341,9 @@ MAP(swift::TypeBase, TypeTag)
   MAP(swift::ExistentialType, ExistentialTypeTag)
   MAP(swift::LValueType, LValueTypeTag)
   MAP(swift::InOutType, InOutTypeTag)
-  MAP(swift::PackType, void)  // experimental variadic generics
-  MAP(swift::PackExpansionType, void)  // experimental variadic generics
-#if CODEQL_SWIFT_VERSION_GE(5, 9)
-  MAP(swift::PackElementType, void) // TODO: (introduced in 5.9)
-#endif
+  MAP(swift::PackType, PackTypeTag)
+  MAP(swift::PackExpansionType, PackExpansionTypeTag)
+  MAP(swift::PackElementType, PackElementTypeTag)
   MAP(swift::TypeVariableType, void)  // created during type checking and only used for constraint checking
   MAP(swift::SugarType, SugarTypeTag)
     MAP(swift::ParenType, ParenTypeTag)

swift/extractor/mangler/SwiftMangler.cpp

@@ -138,7 +138,12 @@ void SwiftMangler::indexExtensions(llvm::ArrayRef<swift::Decl*> siblings) {
 }
 
 SwiftMangledName SwiftMangler::visitGenericTypeParamDecl(const swift::GenericTypeParamDecl* decl) {
-  return visitValueDecl(decl, /*force=*/true) << '_' << decl->getDepth() << '_' << decl->getIndex();
+  auto ret = visitValueDecl(decl, /*force=*/true);
+  if (decl->isParameterPack()) {
+    ret << "each_";
+  }
+  ret << '_' << decl->getDepth() << '_' << decl->getIndex();
+  return ret;
 }
 
 SwiftMangledName SwiftMangler::visitAssociatedTypeDecl(const swift::AssociatedTypeDecl* decl) {
@@ -259,6 +264,9 @@ SwiftMangledName SwiftMangler::visitGenericFunctionType(const swift::GenericFunc
 
 SwiftMangledName SwiftMangler::visitGenericTypeParamType(const swift::GenericTypeParamType* type) {
   auto ret = initMangled(type);
+  if (type->isParameterPack()) {
+    ret << "each_";
+  }
   if (auto decl = type->getDecl()) {
     ret << fetch(decl);
   } else {
@@ -376,6 +384,33 @@ SwiftMangledName SwiftMangler::visitParametrizedProtocolType(
   return ret;
 }
 
+SwiftMangledName SwiftMangler::visitPackArchetypeType(const swift::PackArchetypeType* type) {
+  return visitArchetypeType(type) << "...";
+}
+
+SwiftMangledName SwiftMangler::visitPackType(const swift::PackType* type) {
+  auto ret = initMangled(type);
+  for (auto element : type->getElementTypes()) {
+    ret << fetch(element);
+  }
+  return ret;
+}
+
+SwiftMangledName SwiftMangler::visitPackElementType(const swift::PackElementType* type) {
+  auto ret = initMangled(type);
+  ret << fetch(type->getPackType());
+  ret << '_' << type->getLevel();
+  return ret;
+}
+
+SwiftMangledName SwiftMangler::visitPackExpansionType(const swift::PackExpansionType* type) {
+  auto ret = initMangled(type);
+  ret << fetch(type->getPatternType());
+  ret << '_';
+  ret << fetch(type->getCountType());
+  return ret;
+}
+
 namespace {
 template <typename E>
 UntypedTrapLabel fetchLabel(SwiftDispatcher& dispatcher, const E* e) {

swift/extractor/mangler/SwiftMangler.h

@@ -100,6 +100,10 @@ class SwiftMangler : private swift::TypeVisitor<SwiftMangler, SwiftMangledName>,
   SwiftMangledName visitUnboundGenericType(const swift::UnboundGenericType* type);
   SwiftMangledName visitReferenceStorageType(const swift::ReferenceStorageType* type);
   SwiftMangledName visitParametrizedProtocolType(const swift::ParameterizedProtocolType* type);
+  SwiftMangledName visitPackArchetypeType(const swift::PackArchetypeType* type);
+  SwiftMangledName visitPackType(const swift::PackType* type);
+  SwiftMangledName visitPackElementType(const swift::PackElementType* type);
+  SwiftMangledName visitPackExpansionType(const swift::PackExpansionType* type);
 
  private:
   std::unordered_map<const swift::Decl*, unsigned> preloadedExtensionIndexes;

swift/extractor/translators/ExprTranslator.cpp

@@ -643,4 +643,18 @@ codeql::SingleValueStmtExpr ExprTranslator::translateSingleValueStmtExpr(
   return entry;
 }
 
+codeql::PackExpansionExpr ExprTranslator::translatePackExpansionExpr(
+    const swift::PackExpansionExpr& expr) {
+  auto entry = createExprEntry(expr);
+  entry.pattern_expr = dispatcher.fetchLabel(expr.getPatternExpr());
+  return entry;
+}
+
+codeql::PackElementExpr ExprTranslator::translatePackElementExpr(
+    const swift::PackElementExpr& expr) {
+  auto entry = createExprEntry(expr);
+  entry.sub_expr = dispatcher.fetchLabel(expr.getPackRefExpr());
+  return entry;
+}
+
 }  // namespace codeql

swift/extractor/translators/ExprTranslator.h

@@ -120,6 +120,8 @@ class ExprTranslator : public AstTranslatorBase<ExprTranslator> {
       const swift::AppliedPropertyWrapperExpr& expr);
   codeql::RegexLiteralExpr translateRegexLiteralExpr(const swift::RegexLiteralExpr& expr);
   codeql::SingleValueStmtExpr translateSingleValueStmtExpr(const swift::SingleValueStmtExpr& expr);
+  codeql::PackExpansionExpr translatePackExpansionExpr(const swift::PackExpansionExpr& expr);
+  codeql::PackElementExpr translatePackElementExpr(const swift::PackElementExpr& expr);
 
  private:
   void fillClosureExpr(const swift::AbstractClosureExpr& expr, codeql::ClosureExpr& entry);

swift/extractor/translators/TypeTranslator.cpp

@@ -267,4 +267,40 @@ codeql::ParameterizedProtocolType TypeTranslator::translateParameterizedProtocol
   entry.args = dispatcher.fetchRepeatedLabels(type.getArgs());
   return entry;
 }
+
+codeql::PackArchetypeType TypeTranslator::translatePackArchetypeType(
+    const swift::PackArchetypeType& type) {
+  auto entry = createTypeEntry(type);
+  fillArchetypeType(type, entry);
+  return entry;
+}
+
+codeql::ElementArchetypeType TypeTranslator::translateElementArchetypeType(
+    const swift::ElementArchetypeType& type) {
+  auto entry = createTypeEntry(type);
+  fillArchetypeType(type, entry);
+  return entry;
+}
+
+codeql::PackType TypeTranslator::translatePackType(const swift::PackType& type) {
+  auto entry = createTypeEntry(type);
+  entry.elements = dispatcher.fetchRepeatedLabels(type.getElementTypes());
+  return entry;
+}
+
+codeql::PackElementType TypeTranslator::translatePackElementType(
+    const swift::PackElementType& type) {
+  auto entry = createTypeEntry(type);
+  entry.pack_type = dispatcher.fetchLabel(type.getPackType());
+  return entry;
+}
+
+codeql::PackExpansionType TypeTranslator::translatePackExpansionType(
+    const swift::PackExpansionType& type) {
+  auto entry = createTypeEntry(type);
+  entry.pattern_type = dispatcher.fetchLabel(type.getPatternType());
+  entry.count_type = dispatcher.fetchLabel(type.getCountType());
+  return entry;
+}
+
 }  // namespace codeql

swift/extractor/translators/TypeTranslator.h

@@ -77,6 +77,12 @@ class TypeTranslator : public TypeTranslatorBase<TypeTranslator> {
   codeql::UnresolvedType translateUnresolvedType(const swift::UnresolvedType& type);
   codeql::ParameterizedProtocolType translateParameterizedProtocolType(
       const swift::ParameterizedProtocolType& type);
+  codeql::PackArchetypeType translatePackArchetypeType(const swift::PackArchetypeType& type);
+  codeql::ElementArchetypeType translateElementArchetypeType(
+      const swift::ElementArchetypeType& type);
+  codeql::PackType translatePackType(const swift::PackType& type);
+  codeql::PackElementType translatePackElementType(const swift::PackElementType& type);
+  codeql::PackExpansionType translatePackExpansionType(const swift::PackExpansionType& type);
 
  private:
   void fillType(const swift::TypeBase& type, codeql::Type& entry);