Merge pull request #4142 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

include/swift/ABI/Metadata.h

@@ -1061,7 +1061,21 @@ void *allocateMemoryForDecl(AllocatorTy &allocator, size_t baseSize,
 class alignas(8) _GenericContext {
 // Not really public. See GenericContext.
 public:
-  llvm::PointerIntPair<GenericParamList *, 1, bool> GenericParamsAndBit;
+  /// The state of the generic parameters.
+  enum class GenericParamsState: uint8_t {
+    /// The stored generic parameters represent parsed generic parameters,
+    /// written in the source.
+    Parsed = 0,
+    /// The stored generic parameters represent generic parameters that are
+    /// synthesized by the type checker but were not written in the source.
+    TypeChecked = 1,
+    /// The stored generic parameters represent both the parsed and
+    /// type-checked generic parameters.
+    ParsedAndTypeChecked = 2,
+  };
+
+  llvm::PointerIntPair<GenericParamList *, 2, GenericParamsState>
+      GenericParamsAndState;
 
   /// The trailing where clause.
   ///
@@ -2015,6 +2029,9 @@ class TopLevelCodeDecl : public DeclContext, public Decl {
   SourceLoc getStartLoc() const;
   SourceRange getSourceRange() const;
 
+  LLVM_READONLY
+  ASTContext &getASTContext() const { return DeclContext::getASTContext(); }
+
   static bool classof(const Decl *D) {
     return D->getKind() == DeclKind::TopLevelCode;
   }

include/swift/AST/Decl.h

@@ -393,6 +393,9 @@ namespace swift {
     /// cases.
     bool EnableNonFrozenEnumExhaustivityDiagnostics = false;
 
+    /// Enable making top-level code support concurrency
+    bool EnableExperimentalAsyncTopLevel = false;
+
     /// Regex for the passes that should report passed and missed optimizations.
     ///
     /// These are shared_ptrs so that this class remains copyable.

include/swift/Basic/LangOptions.h

@@ -301,6 +301,10 @@ def enable_experimental_pairwise_build_block :
 
 def enable_resilience : Flag<["-"], "enable-resilience">,
      HelpText<"Deprecated, use -enable-library-evolution instead">;
+
+def enable_experimental_async_top_level :
+  Flag<["-"], "enable-experimental-async-top-level">,
+  HelpText<"Enable experimental concurrency in top-level code">;
 }
 
 // HIDDEN FLAGS

include/swift/Option/FrontendOptions.td

@@ -168,6 +168,8 @@ class MetadataReader {
   using StoredPointer = typename Runtime::StoredPointer;
   using StoredSignedPointer = typename Runtime::StoredSignedPointer;
   using StoredSize = typename Runtime::StoredSize;
+  using TargetClassMetadata =
+      typename Runtime::template TargetClassMetadata<Runtime>;
 
 private:
   /// The maximum number of bytes to read when reading metadata. Anything larger
@@ -502,7 +504,7 @@ class MetadataReader {
     if (!meta || meta->getKind() != MetadataKind::Class)
       return StoredPointer();
 
-    auto classMeta = cast<TargetClassMetadata<Runtime>>(meta);
+    auto classMeta = cast<TargetClassMetadata>(meta);
     return stripSignedPointer(classMeta->Superclass);
   }
 
@@ -514,39 +516,39 @@ class MetadataReader {
     if (!meta || meta->getKind() != MetadataKind::Class)
       return None;
 
-#if SWIFT_OBJC_INTEROP
-    // The following algorithm only works on the non-fragile Apple runtime.
-
-    // Grab the RO-data pointer.  This part is not ABI.
-    StoredPointer roDataPtr = readObjCRODataPtr(MetadataAddress);
-    if (!roDataPtr)
-      return None;
-
-    // Get the address of the InstanceStart field.
-    auto address = roDataPtr + sizeof(uint32_t) * 1;
+    if (Runtime::ObjCInterop) {
+      // The following algorithm only works on the non-fragile Apple runtime.
 
-    unsigned start;
-    if (!Reader->readInteger(RemoteAddress(address), &start))
-      return None;
+      // Grab the RO-data pointer.  This part is not ABI.
+      StoredPointer roDataPtr = readObjCRODataPtr(MetadataAddress);
+      if (!roDataPtr)
+        return None;
 
-    return start;
-#else
-    // All swift class instances start with an isa pointer,
-    // followed by the retain counts (which are the size of a long long).
-    size_t isaAndRetainCountSize = sizeof(StoredSize) + sizeof(long long);
-    size_t start = isaAndRetainCountSize;
+      // Get the address of the InstanceStart field.
+      auto address = roDataPtr + sizeof(uint32_t) * 1;
 
-    auto classMeta = cast<TargetClassMetadata<Runtime>>(meta);
-    while (stripSignedPointer(classMeta->Superclass)) {
-      classMeta = cast<TargetClassMetadata<Runtime>>(
-          readMetadata(stripSignedPointer(classMeta->Superclass)));
+      unsigned start;
+      if (!Reader->readInteger(RemoteAddress(address), &start))
+        return None;
 
-      // Subtract the size contribution of the isa and retain counts from 
-      // the super class.
-      start += classMeta->InstanceSize - isaAndRetainCountSize;
+      return start;
+    } else {
+      // All swift class instances start with an isa pointer,
+      // followed by the retain counts (which are the size of a long long).
+      size_t isaAndRetainCountSize = sizeof(StoredSize) + sizeof(long long);
+      size_t start = isaAndRetainCountSize;
+
+      auto classMeta = cast<TargetClassMetadata>(meta);
+      while (stripSignedPointer(classMeta->Superclass)) {
+        classMeta = cast<TargetClassMetadata>(
+            readMetadata(stripSignedPointer(classMeta->Superclass)));
+
+        // Subtract the size contribution of the isa and retain counts from
+        // the super class.
+        start += classMeta->InstanceSize - isaAndRetainCountSize;
+      }
+      return start;
     }
-    return start;
-#endif
   }
 
   /// Given a pointer to the metadata, attempt to read the value
@@ -588,7 +590,7 @@ class MetadataReader {
     if (!Meta)
       return None;
 
-    if (auto ClassMeta = dyn_cast<TargetClassMetadata<Runtime>>(Meta)) {
+    if (auto ClassMeta = dyn_cast<TargetClassMetadata>(Meta)) {
       if (ClassMeta->isPureObjC()) {
         // If we can determine the Objective-C class name, this is probably an
         // error existential with NSError-compatible layout.
@@ -719,34 +721,36 @@ class MetadataReader {
       Demangler &dem,
       Resolver resolver) {
 #if SWIFT_OBJC_INTEROP
-    // Check whether we have an Objective-C protocol.
-    if (ProtocolAddress.isObjC()) {
-      auto Name = readObjCProtocolName(ProtocolAddress.getObjCProtocol());
-      StringRef NameStr(Name);
-
-      // If this is a Swift-defined protocol, demangle it.
-      if (NameStr.startswith("_TtP")) {
-        auto Demangled = dem.demangleSymbol(NameStr);
-        if (!Demangled)
-          return resolver.failure();
-
-        // FIXME: This appears in _swift_buildDemanglingForMetadata().
-        while (Demangled->getKind() == Node::Kind::Global ||
-               Demangled->getKind() == Node::Kind::TypeMangling ||
-               Demangled->getKind() == Node::Kind::Type ||
-               Demangled->getKind() == Node::Kind::ProtocolList ||
-               Demangled->getKind() == Node::Kind::TypeList ||
-               Demangled->getKind() == Node::Kind::Type) {
-          if (Demangled->getNumChildren() != 1)
+    if (Runtime::ObjCInterop) {
+      // Check whether we have an Objective-C protocol.
+      if (ProtocolAddress.isObjC()) {
+        auto Name = readObjCProtocolName(ProtocolAddress.getObjCProtocol());
+        StringRef NameStr(Name);
+
+        // If this is a Swift-defined protocol, demangle it.
+        if (NameStr.startswith("_TtP")) {
+          auto Demangled = dem.demangleSymbol(NameStr);
+          if (!Demangled)
             return resolver.failure();
-          Demangled = Demangled->getFirstChild();
+
+          // FIXME: This appears in _swift_buildDemanglingForMetadata().
+          while (Demangled->getKind() == Node::Kind::Global ||
+                 Demangled->getKind() == Node::Kind::TypeMangling ||
+                 Demangled->getKind() == Node::Kind::Type ||
+                 Demangled->getKind() == Node::Kind::ProtocolList ||
+                 Demangled->getKind() == Node::Kind::TypeList ||
+                 Demangled->getKind() == Node::Kind::Type) {
+            if (Demangled->getNumChildren() != 1)
+              return resolver.failure();
+            Demangled = Demangled->getFirstChild();
+          }
+
+          return resolver.swiftProtocol(Demangled);
         }
 
-        return resolver.swiftProtocol(Demangled);
+        // Otherwise, this is an imported protocol.
+        return resolver.objcProtocol(NameStr);
       }
-
-      // Otherwise, this is an imported protocol.
-      return resolver.objcProtocol(NameStr);
     }
 #endif
 
@@ -1419,7 +1423,7 @@ class MetadataReader {
           return readMetadataBoundsOfSuperclass(superclass);
         },
         [&](MetadataRef metadata) -> llvm::Optional<ClassMetadataBounds> {
-          auto cls = dyn_cast<TargetClassMetadata<Runtime>>(metadata);
+          auto cls = dyn_cast<TargetClassMetadata>(metadata);
           if (!cls)
             return None;
 
@@ -1659,6 +1663,10 @@ class MetadataReader {
     return Reader->readString(RemoteAddress(namePtr), className);
   }
 
+  template <typename T>
+  using TargetClassMetadataT =
+      typename Runtime::template TargetClassMetadata<T>;
+
   MetadataRef readMetadata(StoredPointer address) {
     auto cached = MetadataCache.find(address);
     if (cached != MetadataCache.end())
@@ -1672,7 +1680,9 @@ class MetadataReader {
 
     switch (getEnumeratedMetadataKind(KindValue)) {
       case MetadataKind::Class:
-        return _readMetadata<TargetClassMetadata>(address);
+
+        return _readMetadata<TargetClassMetadataT>(address);
+
       case MetadataKind::Enum:
         return _readMetadata<TargetEnumMetadata>(address);
       case MetadataKind::ErrorObject:
@@ -1779,7 +1789,7 @@ class MetadataReader {
                                      bool skipArtificialSubclasses = false) {
     switch (metadata->getKind()) {
     case MetadataKind::Class: {
-      auto classMeta = cast<TargetClassMetadata<Runtime>>(metadata);
+      auto classMeta = cast<TargetClassMetadata>(metadata);
       while (true) {
         if (!classMeta->isTypeMetadata())
           return 0;
@@ -1801,7 +1811,7 @@ class MetadataReader {
         if (!superMeta)
           return 0;
 
-        auto superclassMeta = dyn_cast<TargetClassMetadata<Runtime>>(superMeta);
+        auto superclassMeta = dyn_cast<TargetClassMetadata>(superMeta);
         if (!superclassMeta)
           return 0;
 
@@ -2692,7 +2702,7 @@ class MetadataReader {
 
   BuiltType readNominalTypeFromClassMetadata(MetadataRef origMetadata,
                                        bool skipArtificialSubclasses = false) {
-    auto classMeta = cast<TargetClassMetadata<Runtime>>(origMetadata);
+    auto classMeta = cast<TargetClassMetadata>(origMetadata);
     if (classMeta->isTypeMetadata())
       return readNominalTypeFromMetadata(origMetadata, skipArtificialSubclasses);
 
@@ -2715,6 +2725,10 @@ class MetadataReader {
     return BuiltObjCClass;
   }
 
+  using TargetClassMetadataObjCInterop =
+      swift::TargetClassMetadata<Runtime,
+                                 TargetAnyClassMetadataObjCInterop<Runtime>>;
+
   /// Given that the remote process is running the non-fragile Apple runtime,
   /// grab the ro-data from a class pointer.
   StoredPointer readObjCRODataPtr(StoredPointer classAddress) {
@@ -2723,9 +2737,10 @@ class MetadataReader {
 
 #if SWIFT_OBJC_INTEROP
     StoredPointer dataPtr;
-    if (!Reader->readInteger(RemoteAddress(classAddress +
-                               TargetClassMetadata<Runtime>::offsetToData()),
-                             &dataPtr))
+    if (!Reader->readInteger(
+            RemoteAddress(classAddress +
+                          TargetClassMetadataObjCInterop::offsetToData()),
+            &dataPtr))
       return StoredPointer();
 
     // Apply the data-pointer mask.

include/swift/Remote/MetadataReader.h

@@ -240,10 +240,14 @@ struct SILDeclRef {
   /// Produces a SILDeclRef for the entry-point of a main FileUnit.
   static SILDeclRef getMainFileEntryPoint(FileUnit *file);
 
+  /// Produces a SILDeclRef for the entry-point of an async main FileUnit.
+  static SILDeclRef getAsyncMainFileEntryPoint(FileUnit *file);
+
   bool isNull() const { return loc.isNull(); }
   explicit operator bool() const { return !isNull(); }
-  
+
   bool hasDecl() const { return loc.is<ValueDecl *>(); }
+  bool hasFileUnit() const { return loc.is<FileUnit *>(); }
   bool hasClosureExpr() const;
   bool hasAutoClosureExpr() const;
   bool hasFuncDecl() const;
@@ -260,11 +264,14 @@ struct SILDeclRef {
     return loc.get<FileUnit *>();
   }
 
+  /// Get ModuleDecl that contains the SILDeclRef
+  ModuleDecl *getModuleContext() const;
+
   /// Retrieves the ASTContext from the underlying AST node being stored.
   ASTContext &getASTContext() const;
 
   llvm::Optional<AnyFunctionRef> getAnyFunctionRef() const;
-  
+
   SILLocation getAsRegularLocation() const;
 
   enum class ManglingKind {

include/swift/SIL/SILDeclRef.h

@@ -985,7 +985,7 @@ GenericContext::GenericContext(DeclContextKind Kind, DeclContext *Parent,
     : _GenericContext(), DeclContext(Kind, Parent) {
   if (Params) {
     Params->setDeclContext(this);
-    GenericParamsAndBit.setPointerAndInt(Params, false);
+    GenericParamsAndState.setPointerAndInt(Params, GenericParamsState::Parsed);
   }
 }
 
@@ -1006,9 +1006,14 @@ GenericParamList *GenericContext::getGenericParams() const {
 }
 
 GenericParamList *GenericContext::getParsedGenericParams() const {
-  if (GenericParamsAndBit.getInt())
+  switch (GenericParamsAndState.getInt()) {
+  case GenericParamsState::Parsed:
+  case GenericParamsState::ParsedAndTypeChecked:
+    return GenericParamsAndState.getPointer();
+
+  case GenericParamsState::TypeChecked:
     return nullptr;
-  return GenericParamsAndBit.getPointer();
+  }
 }
 
 bool GenericContext::hasComputedGenericSignature() const {

lib/AST/Decl.cpp

@@ -1221,14 +1221,15 @@ bool DeclContext::isClassConstrainedProtocolExtension() const {
 bool DeclContext::isAsyncContext() const {
   switch (getContextKind()) {
   case DeclContextKind::Initializer:
-  case DeclContextKind::TopLevelCodeDecl:
   case DeclContextKind::EnumElementDecl:
   case DeclContextKind::ExtensionDecl:
   case DeclContextKind::SerializedLocal:
   case DeclContextKind::Module:
-  case DeclContextKind::FileUnit:
   case DeclContextKind::GenericTypeDecl:
     return false;
+  case DeclContextKind::FileUnit:
+  case DeclContextKind::TopLevelCodeDecl:
+    return getASTContext().LangOpts.EnableExperimentalAsyncTopLevel;
   case DeclContextKind::AbstractClosureExpr:
     return cast<AbstractClosureExpr>(this)->isBodyAsync();
   case DeclContextKind::AbstractFunctionDecl: {

lib/AST/DeclContext.cpp

@@ -2597,7 +2597,9 @@ GenericParamListRequest::evaluate(Evaluator &evaluator, GenericContext *value) c
       outerParams->setDepth(depth--);
 
     return genericParams;
-  } else if (auto *proto = dyn_cast<ProtocolDecl>(value)) {
+  }
+
+  if (auto *proto = dyn_cast<ProtocolDecl>(value)) {
     // The generic parameter 'Self'.
     auto &ctx = value->getASTContext();
     auto selfId = ctx.Id_Self;
@@ -2615,7 +2617,8 @@ GenericParamListRequest::evaluate(Evaluator &evaluator, GenericContext *value) c
                                            SourceLoc());
     return result;
   }
-  return nullptr;
+
+  return value->getParsedGenericParams();
 }
 
 NominalTypeDecl *