Merge branch 'main' of github.com:apple/swift into maxd/main-merge

# Conflicts:
#	CMakeLists.txt

Author: MaxDesiatov

CHANGELOG.md

@@ -84,6 +84,21 @@ Swift 5.5
 
 ### 2021-09-20 (Xcode 13.0)
 
+* [SE-0323][]:
+
+  The main function is executed with `MainActor` isolation applied, so functions
+  and variables with `MainActor` isolation may be called and modified
+  synchronously from the main function. If the main function is annotated with a
+  global actor explicitly, it must be the main actor or an error is emitted. If
+  no global actor annotation is present, the main function is implicitly run on
+  the main actor.
+
+  The main function is executed synchronously up to the first suspension point.
+  Any tasks enqueued by initializers in Objective-C or C++ will run after the
+  main function runs to the first suspension point. At the suspension point, the
+  main function suspends and the tasks are executed according to the Swift
+  concurrency mechanisms.
+
 * [SE-0313][]:
 
   Parameters of actor type can be declared as `isolated`, which means that they
@@ -8745,6 +8760,7 @@ Swift 1.0
 [SE-0315]: <https://github.com/apple/swift-evolution/blob/main/proposals/0315-placeholder-types.md>
 [SE-0316]: <https://github.com/apple/swift-evolution/blob/main/proposals/0316-global-actors.md>
 [SE-0324]: <https://github.com/apple/swift-evolution/blob/main/proposals/0324-c-lang-pointer-arg-conversion.md>
+[SE-0323]: <https://github.com/apple/swift-evolution/blob/main/proposals/0323-async-main-semantics.md>
 
 [SR-75]: <https://bugs.swift.org/browse/SR-75>
 [SR-106]: <https://bugs.swift.org/browse/SR-106>

CMakeLists.txt

@@ -405,6 +405,18 @@ option(SWIFT_REPORT_STATISTICS
     "Create json files which contain internal compilation statistics"
     FALSE)
 
+# Only Darwin platforms enable ObjC interop by default.
+if("${SWIFT_HOST_VARIANT_SDK}" MATCHES "(OSX|IOS*|TVOS*|WATCHOS*)")
+  set(SWIFT_STDLIB_ENABLE_OBJC_INTEROP_default TRUE)
+else()
+  set(SWIFT_STDLIB_ENABLE_OBJC_INTEROP_default FALSE)
+endif()
+
+# Used by stdlib/toolchain as well, so this cannot be in stdlib/CMakeLists.txt
+option(SWIFT_STDLIB_ENABLE_OBJC_INTEROP
+       "Should stdlib be built with Obj-C interop."
+       "${SWIFT_STDLIB_ENABLE_OBJC_INTEROP_default}")
+
 # FIXME(wasm) Reflection tests are temporalily disabled due to lack of linker features
 option(SWIFTWASM_DISABLE_REFLECTION_TEST
     "Disable building swift-reflection-test for WebAssembly build"

include/swift/ABI/Task.h

@@ -480,27 +480,42 @@ class AsyncTask : public Job {
       return resultType;
     }
 
-    /// Retrieve a pointer to the storage of result.
+    /// Retrieve a pointer to the storage of the result.
     OpaqueValue *getStoragePtr() {
-      return reinterpret_cast<OpaqueValue *>(
-          reinterpret_cast<char *>(this) + storageOffset(resultType));
+      // The result storage starts at the first aligned offset following
+      // the fragment header.  This offset will agree with the abstract
+      // calculation for `resultOffset` in the fragmentSize function below
+      // because the entire task is aligned to at least the target
+      // alignment (because it's aligned to MaxAlignment), which means
+      // `this` must have the same value modulo that alignment as
+      // `fragmentOffset` has in that function.
+      char *fragmentAddr = reinterpret_cast<char *>(this);
+      uintptr_t alignment = resultType->vw_alignment();
+      char *resultAddr = fragmentAddr + sizeof(FutureFragment);
+      uintptr_t unalignedResultAddrInt =
+        reinterpret_cast<uintptr_t>(resultAddr);
+      uintptr_t alignedResultAddrInt =
+        (unalignedResultAddrInt + alignment - 1) & ~(alignment - 1);
+      // We could just cast alignedResultAddrInt back to a pointer, but
+      // doing pointer arithmetic is more strictly conformant and less
+      // likely to annoy the optimizer.
+      resultAddr += (alignedResultAddrInt - unalignedResultAddrInt);
+      return reinterpret_cast<OpaqueValue *>(resultAddr);
     }
 
     /// Retrieve the error.
     SwiftError *&getError() { return error; }
 
-    /// Compute the offset of the storage from the base of the future
-    /// fragment.
-    static size_t storageOffset(const Metadata *resultType)  {
-      size_t offset = sizeof(FutureFragment);
+    /// Determine the size of the future fragment given the result type
+    /// of the future.
+    static size_t fragmentSize(size_t fragmentOffset,
+                               const Metadata *resultType) {
+      assert((fragmentOffset & (alignof(FutureFragment) - 1)) == 0);
       size_t alignment = resultType->vw_alignment();
-      return (offset + alignment - 1) & ~(alignment - 1);
-    }
-
-    /// Determine the size of the future fragment given a particular future
-    /// result type.
-    static size_t fragmentSize(const Metadata *resultType) {
-      return storageOffset(resultType) + resultType->vw_size();
+      size_t resultOffset = fragmentOffset + sizeof(FutureFragment);
+      resultOffset = (resultOffset + alignment - 1) & ~(alignment - 1);
+      size_t endOffset = resultOffset + resultType->vw_size();
+      return (endOffset - fragmentOffset);
     }
   };
 

include/swift/AST/Decl.h

@@ -6265,14 +6265,6 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   Optional<unsigned> findPotentialCompletionHandlerParam(
       const AbstractFunctionDecl *asyncAlternative = nullptr) const;
 
-  /// Determine whether this function is implicitly known to have its
-  /// parameters of function type be @_unsafeSendable.
-  ///
-  /// This hard-codes knowledge of a number of functions that will
-  /// eventually have @_unsafeSendable and, eventually, @Sendable,
-  /// on their parameters of function type.
-  bool hasKnownUnsafeSendableFunctionParams() const;
-
   using DeclContext::operator new;
   using DeclContext::operator delete;
   using Decl::getASTContext;

include/swift/AST/DiagnosticsDriver.def

@@ -166,6 +166,14 @@ ERROR(error_darwin_only_supports_libcxx, none,
       "The only C++ standard library supported on Apple platforms is libc++",
       ())
 
+ERROR(error_hermetic_seal_cannot_have_library_evolution, none,
+      "Cannot use -experimental-hermetic-seal-at-link with -enable-library-evolution",
+      ())
+
+ERROR(error_hermetic_seal_requires_lto, none,
+      "-experimental-hermetic-seal-at-link requires -lto=llvm-full or -lto=llvm-thin",
+      ())
+
 WARNING(warn_drv_darwin_sdk_invalid_settings, none,
     "SDK settings were ignored because 'SDKSettings.json' could not be parsed",
     ())

include/swift/AST/Expr.h

@@ -3683,12 +3683,6 @@ class ClosureExpr : public AbstractClosureExpr {
     SeparatelyTypeChecked,
   };
 
-  /// Bits used to indicate contextual information that is concurrency-specific.
-  enum UnsafeConcurrencyBits {
-    Sendable = 1 << 0,
-    MainActor = 1 << 1
-  };
-
 private:
   /// The attributes attached to the closure.
   DeclAttributes Attributes;
@@ -3703,10 +3697,7 @@ class ClosureExpr : public AbstractClosureExpr {
   /// the CaptureListExpr which would normally maintain this sort of
   /// information about captured variables), we need to have some way to access
   /// this information directly on the ClosureExpr.
-  ///
-  /// The integer indicates how the closure is contextually concurrent.
-  llvm::PointerIntPair<VarDecl *, 2, uint8_t>
-      CapturedSelfDeclAndUnsafeConcurrent;
+  VarDecl *CapturedSelfDecl;
 
   /// The location of the "async", if present.
   SourceLoc AsyncLoc;
@@ -3736,7 +3727,7 @@ class ClosureExpr : public AbstractClosureExpr {
     : AbstractClosureExpr(ExprKind::Closure, Type(), /*Implicit=*/false,
                           discriminator, parent),
       Attributes(attributes), BracketRange(bracketRange),
-      CapturedSelfDeclAndUnsafeConcurrent(capturedSelfDecl, 0),
+      CapturedSelfDecl(capturedSelfDecl),
       AsyncLoc(asyncLoc), ThrowsLoc(throwsLoc), ArrowLoc(arrowLoc),
       InLoc(inLoc),
       ExplicitResultTypeAndBodyState(explicitResultType, BodyState::Parsed),
@@ -3864,27 +3855,7 @@ class ClosureExpr : public AbstractClosureExpr {
 
   /// VarDecl captured by this closure under the literal name \c self , if any.
   VarDecl *getCapturedSelfDecl() const {
-    return CapturedSelfDeclAndUnsafeConcurrent.getPointer();
-  }
-
-  bool isUnsafeSendable() const {
-    return CapturedSelfDeclAndUnsafeConcurrent.getInt() &
-        UnsafeConcurrencyBits::Sendable;
-  }
-
-  bool isUnsafeMainActor() const {
-    return CapturedSelfDeclAndUnsafeConcurrent.getInt() &
-        UnsafeConcurrencyBits::MainActor;
-  }
-
-  void setUnsafeConcurrent(bool sendable, bool forMainActor) {
-    uint8_t bits = 0;
-    if (sendable)
-      bits |= UnsafeConcurrencyBits::Sendable;
-    if (forMainActor)
-      bits |= UnsafeConcurrencyBits::MainActor;
-
-    CapturedSelfDeclAndUnsafeConcurrent.setInt(bits);
+    return CapturedSelfDecl;
   }
 
   /// Get the type checking state of this closure's body.

include/swift/AST/GenericParamList.h

@@ -203,8 +203,6 @@ class RequirementRepr {
   void print(ASTPrinter &Printer) const;
 };
 
-using GenericParamSource = PointerUnion<GenericContext *, GenericParamList *>;
-
 /// GenericParamList - A list of generic parameters that is part of a generic
 /// function or type, along with extra requirements placed on those generic
 /// parameters and types derived from them.

include/swift/AST/TypeCheckRequests.h

@@ -459,6 +459,8 @@ struct WhereClauseOwner {
                      SpecializeAttr *, DifferentiableAttr *>
       source;
 
+  WhereClauseOwner() : dc(nullptr) {}
+
   WhereClauseOwner(GenericContext *genCtx);
   WhereClauseOwner(AssociatedTypeDecl *atd);
 
@@ -480,6 +482,10 @@ struct WhereClauseOwner {
     return llvm::hash_value(owner.source.getOpaqueValue());
   }
 
+  operator bool() const {
+    return dc != nullptr;
+  }
+
   friend bool operator==(const WhereClauseOwner &lhs,
                          const WhereClauseOwner &rhs) {
     return lhs.source.getOpaqueValue() == rhs.source.getOpaqueValue();
@@ -1437,11 +1443,12 @@ class AbstractGenericSignatureRequest :
 class InferredGenericSignatureRequest :
     public SimpleRequest<InferredGenericSignatureRequest,
                          GenericSignature (ModuleDecl *,
-                                            const GenericSignatureImpl *,
-                                            GenericParamSource,
-                                            SmallVector<Requirement, 2>,
-                                            SmallVector<TypeLoc, 2>,
-                                            bool),
+                                           const GenericSignatureImpl *,
+                                           GenericParamList *,
+                                           WhereClauseOwner,
+                                           SmallVector<Requirement, 2>,
+                                           SmallVector<TypeLoc, 2>,
+                                           bool),
                          RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -1452,9 +1459,10 @@ class InferredGenericSignatureRequest :
   // Evaluation.
   GenericSignature
   evaluate(Evaluator &evaluator,
-           ModuleDecl *module,
+           ModuleDecl *parentModule,
            const GenericSignatureImpl *baseSignature,
-           GenericParamSource paramSource,
+           GenericParamList *genericParams,
+           WhereClauseOwner whereClause,
            SmallVector<Requirement, 2> addedRequirements,
            SmallVector<TypeLoc, 2> inferenceSources,
            bool allowConcreteGenericParams) const;

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -131,10 +131,12 @@ SWIFT_REQUEST(TypeChecker, HasImplementationOnlyImportsRequest,
 SWIFT_REQUEST(TypeChecker, ModuleLibraryLevelRequest,
               LibraryLevel(ModuleDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, InferredGenericSignatureRequest,
-              GenericSignature (ModuleDecl *, const GenericSignatureImpl *,
-                                 GenericParamSource,
-                                 SmallVector<Requirement, 2>,
-                                 SmallVector<TypeLoc, 2>, bool),
+              GenericSignature (ModuleDecl *,
+                                const GenericSignatureImpl *,
+                                GenericParamList *,
+                                WhereClauseOwner,
+                                SmallVector<Requirement, 2>,
+                                SmallVector<TypeLoc, 2>, bool),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, DistributedModuleIsAvailableRequest,
               bool(ModuleDecl *), Cached, NoLocationInfo)

include/swift/AST/Types.h

@@ -3395,8 +3395,6 @@ struct ParameterListInfo {
   SmallBitVector defaultArguments;
   SmallBitVector acceptsUnlabeledTrailingClosures;
   SmallBitVector propertyWrappers;
-  SmallBitVector unsafeSendable;
-  SmallBitVector unsafeMainActor;
   SmallBitVector implicitSelfCapture;
   SmallBitVector inheritActorContext;
 
@@ -3417,16 +3415,6 @@ struct ParameterListInfo {
   /// property wrapper.
   bool hasExternalPropertyWrapper(unsigned paramIdx) const;
 
-  /// Whether the given parameter is unsafe Sendable, meaning that
-  /// we will treat it as Sendable in a context that has adopted concurrency
-  /// features.
-  bool isUnsafeSendable(unsigned paramIdx) const;
-
-  /// Whether the given parameter is unsafe MainActor, meaning that
-  /// we will treat it as being part of the main actor but that it is not
-  /// part of the type system.
-  bool isUnsafeMainActor(unsigned paramIdx) const;
-
   /// Whether the given parameter is a closure that should allow capture of
   /// 'self' to be implicit, without requiring "self.".
   bool isImplicitSelfCapture(unsigned paramIdx) const;