Swift: Update to Swift 6.3

swift/extractor/infra/SwiftTagTraits.h

@@ -146,7 +146,6 @@ MAP(swift::Expr, ExprTag)
   MAP(swift::ImplicitConversionExpr, ImplicitConversionExprTag)
     MAP(swift::LoadExpr, LoadExprTag)
     MAP(swift::DestructureTupleExpr, DestructureTupleExprTag)
-    MAP(swift::UnresolvedTypeConversionExpr, UnresolvedTypeConversionExprTag)
     MAP(swift::FunctionConversionExpr, FunctionConversionExprTag)
     MAP(swift::CovariantFunctionConversionExpr, CovariantFunctionConversionExprTag)
     MAP(swift::CovariantReturnConversionExpr, CovariantReturnConversionExprTag)
@@ -267,8 +266,7 @@ MAP(swift::TypeRepr, TypeReprTag)
 MAP(swift::Type, TypeTag)
 MAP(swift::TypeBase, TypeTag)
   MAP(swift::ErrorType, ErrorTypeTag)
-  MAP(swift::UnresolvedType, UnresolvedTypeTag)
-  MAP(swift::PlaceholderType, void)  // appears in ambiguous types but are then transformed to UnresolvedType
+  MAP(swift::PlaceholderType, void)  // appears in ambiguous types but are then transformed to ErrorType
   MAP(swift::BuiltinType, BuiltinTypeTag)
     MAP(swift::AnyBuiltinIntegerType, AnyBuiltinIntegerTypeTag)
       MAP(swift::BuiltinIntegerType, BuiltinIntegerTypeTag)
@@ -285,7 +283,8 @@ MAP(swift::TypeBase, TypeTag)
     MAP(swift::BuiltinVectorType, BuiltinVectorTypeTag)
     MAP(swift::BuiltinPackIndexType, void)  // SIL type, cannot really appear in the frontend run
     MAP(swift::BuiltinNonDefaultDistributedActorStorageType, void)  // Does not appear in AST/SIL, only used during IRGen
-    MAP(swift::BuiltinFixedArrayType, BuiltinFixedArrayTypeTag)
+    MAP(swift::BuiltinGenericType, BuiltinGenericTypeTag)
+      MAP(swift::BuiltinFixedArrayType, BuiltinFixedArrayTypeTag)
     MAP(swift::BuiltinUnboundGenericType, void)  // Only used during type resolution
     MAP(swift::BuiltinImplicitActorType, void)  // SIL type
   MAP(swift::TupleType, TupleTypeTag)

swift/extractor/mangler/SwiftMangler.cpp

@@ -40,8 +40,8 @@ std::string_view getTypeKindStr(const swift::TypeBase* type) {
 
 }  // namespace
 
-std::unordered_map<const swift::Decl*, SwiftMangler::ExtensionIndex>
-    SwiftMangler::preloadedExtensionIndexes;
+std::unordered_map<const swift::Decl*, SwiftMangler::ExtensionOrFilePrivateValueIndex>
+    SwiftMangler::preloadedExtensionOrFilePrivateValueIndexes;
 
 SwiftMangledName SwiftMangler::initMangled(const swift::TypeBase* type) {
   return {getTypeKindStr(type), '_'};
@@ -75,6 +75,12 @@ SwiftMangledName SwiftMangler::visitValueDecl(const swift::ValueDecl* decl, bool
   if (decl->isStatic()) {
     ret << "|static";
   }
+  if (decl->getFormalAccess() == swift::AccessLevel::FilePrivate) {
+    auto parent = getParent(decl);
+    auto index = getExtensionOrFilePrivateValueIndex(decl, parent);
+    ret << "|fileprivate" << index.index
+        << (index.kind == ExtensionOrFilePrivateValueKind::clang ? "_clang" : "");
+  }
   return ret;
 }
 
@@ -105,51 +111,63 @@ SwiftMangledName SwiftMangler::visitExtensionDecl(const swift::ExtensionDecl* de
 
   auto parent = getParent(decl);
   auto target = decl->getExtendedType();
-  auto index = getExtensionIndex(decl, parent);
+  auto index = getExtensionOrFilePrivateValueIndex(decl, parent);
   return initMangled(decl) << fetch(target) << index.index
-                           << (index.kind == ExtensionKind::clang ? "_clang" : "");
+                           << (index.kind == ExtensionOrFilePrivateValueKind::clang ? "_clang"
+                                                                                    : "");
 }
 
-SwiftMangler::ExtensionIndex SwiftMangler::getExtensionIndex(const swift::ExtensionDecl* decl,
-                                                             const swift::Decl* parent) {
-  // to avoid iterating multiple times on the parent of multiple extensions, we preload extension
-  // indexes once for each encountered parent into the `preloadedExtensionIndexes` mapping.
-  if (auto found = SwiftMangler::preloadedExtensionIndexes.find(decl);
-      found != SwiftMangler::preloadedExtensionIndexes.end()) {
+SwiftMangler::ExtensionOrFilePrivateValueIndex SwiftMangler::getExtensionOrFilePrivateValueIndex(
+    const swift::Decl* decl,
+    const swift::Decl* parent) {
+  // to avoid iterating multiple times on the parent, we preload the indexes once for each
+  // encountered parent.
+  if (auto found = SwiftMangler::preloadedExtensionOrFilePrivateValueIndexes.find(decl);
+      found != SwiftMangler::preloadedExtensionOrFilePrivateValueIndexes.end()) {
     return found->second;
   }
   if (auto parentModule = llvm::dyn_cast<swift::ModuleDecl>(parent)) {
     llvm::SmallVector<swift::Decl*> siblings;
     parentModule->getTopLevelDecls(siblings);
-    indexExtensions(siblings);
+    indexExtensionsAndFilePrivateValues(siblings);
     if (auto clangModule = parentModule->findUnderlyingClangModule()) {
-      indexClangExtensions(clangModule, decl->getASTContext().getClangModuleLoader());
+      indexClangExtensionsAndFilePrivateValues(clangModule,
+                                               decl->getASTContext().getClangModuleLoader());
     }
   } else if (auto iterableParent = llvm::dyn_cast<swift::IterableDeclContext>(parent)) {
-    indexExtensions(iterableParent->getAllMembers());
+    indexExtensionsAndFilePrivateValues(iterableParent->getAllMembers());
   } else {
     // TODO use a generic logging handle for Swift entities here, once it's available
     CODEQL_ASSERT(false, "non-local context must be module or iterable decl context");
   }
-  auto found = SwiftMangler::preloadedExtensionIndexes.find(decl);
+  auto found = SwiftMangler::preloadedExtensionOrFilePrivateValueIndexes.find(decl);
   // TODO use a generic logging handle for Swift entities here, once it's available
-  CODEQL_ASSERT(found != SwiftMangler::preloadedExtensionIndexes.end(),
-                "extension not found within parent");
+  CODEQL_ASSERT(found != SwiftMangler::preloadedExtensionOrFilePrivateValueIndexes.end(),
+                "declaration not found within parent");
   return found->second;
 }
 
-void SwiftMangler::indexExtensions(llvm::ArrayRef<swift::Decl*> siblings) {
+bool SwiftMangler::isExtensionOrFilePrivateValue(const swift::Decl* decl) {
+  return decl->getKind() == swift::DeclKind::Extension ||
+         (swift::isa<swift::ValueDecl>(decl) &&
+          swift::dyn_cast<swift::ValueDecl>(decl)->getFormalAccess() ==
+              swift::AccessLevel::FilePrivate);
+}
+
+void SwiftMangler::indexExtensionsAndFilePrivateValues(llvm::ArrayRef<swift::Decl*> siblings) {
   auto index = 0u;
   for (auto sibling : siblings) {
-    if (sibling->getKind() == swift::DeclKind::Extension) {
-      SwiftMangler::preloadedExtensionIndexes.try_emplace(sibling, ExtensionKind::swift, index);
+    if (isExtensionOrFilePrivateValue(sibling)) {
+      SwiftMangler::preloadedExtensionOrFilePrivateValueIndexes.try_emplace(
+          sibling, ExtensionOrFilePrivateValueKind::swift, index);
       index++;
     }
   }
 }
 
-void SwiftMangler::indexClangExtensions(const clang::Module* clangModule,
-                                        swift::ClangModuleLoader* moduleLoader) {
+void SwiftMangler::indexClangExtensionsAndFilePrivateValues(
+    const clang::Module* clangModule,
+    swift::ClangModuleLoader* moduleLoader) {
   if (!moduleLoader) {
     return;
   }
@@ -160,8 +178,9 @@ void SwiftMangler::indexClangExtensions(const clang::Module* clangModule,
       llvm::SmallVector<swift::Decl*> children;
       swiftSubmodule->getTopLevelDecls(children);
       for (const auto child : children) {
-        if (child->getKind() == swift::DeclKind::Extension) {
-          SwiftMangler::preloadedExtensionIndexes.try_emplace(child, ExtensionKind::clang, index);
+        if (isExtensionOrFilePrivateValue(child)) {
+          SwiftMangler::preloadedExtensionOrFilePrivateValueIndexes.try_emplace(
+              child, ExtensionOrFilePrivateValueKind::clang, index);
           index++;
         }
       }
@@ -202,6 +221,14 @@ SwiftMangledName SwiftMangler::visitBuiltinType(const swift::BuiltinType* type)
   return initMangled(type) << type->getTypeName(buffer, /* prependBuiltinNamespace= */ false);
 }
 
+SwiftMangledName SwiftMangler::visitBuiltinFixedArrayType(
+    const swift::BuiltinFixedArrayType* type) {
+  auto ret = visitBuiltinType(type);
+  ret << fetch(type->getSize());
+  ret << fetch(type->getElementType());
+  return ret;
+}
+
 SwiftMangledName SwiftMangler::visitAnyGenericType(const swift::AnyGenericType* type) {
   auto ret = initMangled(type);
   auto decl = type->getDecl();
@@ -240,9 +267,6 @@ SwiftMangledName SwiftMangler::visitAnyFunctionType(const swift::AnyFunctionType
     if (flags.isNonEphemeral()) {
       ret << "_nonephermeral";
     }
-    if (flags.isIsolated()) {
-      ret << "_isolated";
-    }
     if (flags.isSending()) {
       ret << "_sending";
     }
@@ -309,9 +333,13 @@ SwiftMangledName SwiftMangler::visitAnyFunctionType(const swift::AnyFunctionType
   if (type->hasGlobalActor()) {
     ret << "_actor" << fetch(type->getGlobalActor());
   }
-  if (type->getIsolation().isErased()) {
+  const auto& isolation = type->getIsolation();
+  if (isolation.isErased()) {
     ret << "_isolated";
   }
+  if (isolation.isNonIsolatedCaller()) {
+    ret << "_nonisolatednonsending";
+  }
   // TODO: see if this needs to be used in identifying types, if not it needs to be removed from
   // type printing in the Swift compiler code
   assert(type->hasExtInfo() && "type must have ext info");

swift/extractor/mangler/SwiftMangler.h

@@ -71,6 +71,7 @@ class SwiftMangler : private swift::TypeVisitor<SwiftMangler, SwiftMangledName>,
   SwiftMangledName visitModuleType(const swift::ModuleType* type);
   SwiftMangledName visitTupleType(const swift::TupleType* type);
   SwiftMangledName visitBuiltinType(const swift::BuiltinType* type);
+  SwiftMangledName visitBuiltinFixedArrayType(const swift::BuiltinFixedArrayType* type);
   SwiftMangledName visitAnyGenericType(const swift::AnyGenericType* type);
 
   // shouldn't be required, but they forgot to link `NominalType` to its direct superclass
@@ -106,26 +107,29 @@ class SwiftMangler : private swift::TypeVisitor<SwiftMangler, SwiftMangledName>,
   SwiftMangledName visitPackExpansionType(const swift::PackExpansionType* type);
 
  private:
-  enum class ExtensionKind : bool {
+  enum class ExtensionOrFilePrivateValueKind : bool {
     swift,
     clang,
   };
 
-  struct ExtensionIndex {
-    const ExtensionKind kind : 1;
+  struct ExtensionOrFilePrivateValueIndex {
+    const ExtensionOrFilePrivateValueKind kind : 1;
     const uint32_t index : 31;
   };
 
-  static std::unordered_map<const swift::Decl*, ExtensionIndex> preloadedExtensionIndexes;
+  static std::unordered_map<const swift::Decl*, ExtensionOrFilePrivateValueIndex>
+      preloadedExtensionOrFilePrivateValueIndexes;
 
   virtual SwiftMangledName fetch(const swift::Decl* decl) = 0;
   virtual SwiftMangledName fetch(const swift::TypeBase* type) = 0;
   SwiftMangledName fetch(swift::Type type) { return fetch(type.getPointer()); }
 
-  void indexExtensions(llvm::ArrayRef<swift::Decl*> siblings);
-  void indexClangExtensions(const clang::Module* clangModule,
-                            swift::ClangModuleLoader* moduleLoader);
-  ExtensionIndex getExtensionIndex(const swift::ExtensionDecl* decl, const swift::Decl* parent);
+  bool isExtensionOrFilePrivateValue(const swift::Decl* decl);
+  void indexExtensionsAndFilePrivateValues(llvm::ArrayRef<swift::Decl*> siblings);
+  void indexClangExtensionsAndFilePrivateValues(const clang::Module* clangModule,
+                                                swift::ClangModuleLoader* moduleLoader);
+  ExtensionOrFilePrivateValueIndex getExtensionOrFilePrivateValueIndex(const swift::Decl* decl,
+                                                                       const swift::Decl* parent);
   static SwiftMangledName initMangled(const swift::TypeBase* type);
   SwiftMangledName initMangled(const swift::Decl* decl);
   SwiftMangledName visitTypeDiscriminatedValueDecl(const swift::ValueDecl* decl);

swift/extractor/translators/StmtTranslator.cpp

@@ -137,7 +137,7 @@ codeql::CaseStmt StmtTranslator::translateCaseStmt(const swift::CaseStmt& stmt)
   auto entry = dispatcher.createEntry(stmt);
   entry.body = dispatcher.fetchLabel(stmt.getBody());
   entry.labels = dispatcher.fetchRepeatedLabels(stmt.getCaseLabelItems());
-  entry.variables = dispatcher.fetchRepeatedLabels(stmt.getCaseBodyVariablesOrEmptyArray());
+  entry.variables = dispatcher.fetchRepeatedLabels(stmt.getCaseBodyVariables());
   return entry;
 }
 

swift/extractor/translators/TypeTranslator.cpp

@@ -233,6 +233,14 @@ codeql::BuiltinIntegerType TypeTranslator::translateBuiltinIntegerType(
   return entry;
 }
 
+codeql::BuiltinFixedArrayType TypeTranslator::translateBuiltinFixedArrayType(
+    const swift::BuiltinFixedArrayType& type) {
+  // currently the translate dispatching mechanism does not go up more than one step in the
+  // hierarchy so we need to put this explicitly here, as BuiltinFixedArrayType derives from
+  // BuiltinGenericType which then derives from BuiltinType
+  return translateBuiltinType(type);
+}
+
 codeql::ExistentialArchetypeType TypeTranslator::translateExistentialArchetypeType(
     const swift::ExistentialArchetypeType& type) {
   auto entry = createTypeEntry(type);
@@ -258,10 +266,6 @@ codeql::ErrorType TypeTranslator::translateErrorType(const swift::ErrorType& typ
   return createTypeEntry(type);
 }
 
-codeql::UnresolvedType TypeTranslator::translateUnresolvedType(const swift::UnresolvedType& type) {
-  return createTypeEntry(type);
-}
-
 codeql::ParameterizedProtocolType TypeTranslator::translateParameterizedProtocolType(
     const swift::ParameterizedProtocolType& type) {
   auto entry = createTypeEntry(type);

swift/extractor/translators/TypeTranslator.h

@@ -69,13 +69,14 @@ class TypeTranslator : public TypeTranslatorBase<TypeTranslator> {
   codeql::BuiltinIntegerLiteralType translateBuiltinIntegerLiteralType(
       const swift::BuiltinIntegerLiteralType& type);
   codeql::BuiltinIntegerType translateBuiltinIntegerType(const swift::BuiltinIntegerType& type);
+  codeql::BuiltinFixedArrayType translateBuiltinFixedArrayType(
+      const swift::BuiltinFixedArrayType& type);
   codeql::ExistentialArchetypeType translateExistentialArchetypeType(
       const swift::ExistentialArchetypeType& type);
   codeql::ModuleType translateModuleType(const swift::ModuleType& type);
   codeql::OpaqueTypeArchetypeType translateOpaqueTypeArchetypeType(
       const swift::OpaqueTypeArchetypeType& type);
   codeql::ErrorType translateErrorType(const swift::ErrorType& type);
-  codeql::UnresolvedType translateUnresolvedType(const swift::UnresolvedType& type);
   codeql::ParameterizedProtocolType translateParameterizedProtocolType(
       const swift::ParameterizedProtocolType& type);
   codeql::PackArchetypeType translatePackArchetypeType(const swift::PackArchetypeType& type);