Add @_unsafeMainActor corresponding to @mainactor

Author: DougGregor

include/swift/AST/Attr.def

@@ -642,6 +642,11 @@ CONTEXTUAL_SIMPLE_DECL_ATTR(_unsafeSendable, UnsafeSendable,
   ABIStableToAdd | ABIStableToRemove | APIBreakingToAdd | APIStableToRemove,
   113)
 
+CONTEXTUAL_SIMPLE_DECL_ATTR(_unsafeMainActor, UnsafeMainActor,
+  OnParam | UserInaccessible |
+  ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIBreakingToRemove,
+  114)
+
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS
 #undef CONTEXTUAL_DECL_ATTR_ALIAS

include/swift/AST/Expr.h

@@ -3983,7 +3983,7 @@ class ClosureExpr : public AbstractClosureExpr {
         UnsafeConcurrencyBits::MainActor;
   }
 
-  void setContextuallyConcurrent(bool sendable, bool forMainActor) {
+  void setUnsafeConcurrent(bool sendable, bool forMainActor) {
     uint8_t bits = 0;
     if (sendable)
       bits |= UnsafeConcurrencyBits::Sendable;

include/swift/AST/Types.h

@@ -3344,6 +3344,7 @@ struct ParameterListInfo {
   SmallBitVector acceptsUnlabeledTrailingClosures;
   SmallBitVector propertyWrappers;
   SmallBitVector unsafeSendable;
+  SmallBitVector unsafeMainActor;
 
 public:
   ParameterListInfo() { }
@@ -3367,6 +3368,11 @@ struct ParameterListInfo {
   /// 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;
+
   /// Retrieve the number of non-defaulted parameters.
   unsigned numNonDefaultedParameters() const {
     return defaultArguments.count();

lib/AST/Type.cpp

@@ -942,6 +942,7 @@ ParameterListInfo::ParameterListInfo(
   defaultArguments.resize(params.size());
   propertyWrappers.resize(params.size());
   unsafeSendable.resize(params.size());
+  unsafeMainActor.resize(params.size());
 
   // No parameter owner means no parameter list means no default arguments
   // - hand back the zeroed bitvector.
@@ -997,6 +998,10 @@ ParameterListInfo::ParameterListInfo(
     if (isParamUnsafeSendable(param)) {
       unsafeSendable.set(i);
     }
+
+    if (param->getAttrs().hasAttribute<UnsafeMainActorAttr>()) {
+      unsafeMainActor.set(i);
+    }
   }
 }
 
@@ -1021,6 +1026,12 @@ bool ParameterListInfo::isUnsafeSendable(unsigned paramIdx) const {
       : false;
 }
 
+bool ParameterListInfo::isUnsafeMainActor(unsigned paramIdx) const {
+  return paramIdx < unsafeMainActor.size()
+      ? unsafeMainActor[paramIdx]
+      : false;
+}
+
 /// Turn a param list into a symbolic and printable representation that does not
 /// include the types, something like (_:, b:, c:)
 std::string swift::getParamListAsString(ArrayRef<AnyFunctionType::Param> params) {

lib/ClangImporter/ImportType.cpp

@@ -1711,7 +1711,8 @@ static Type applyToFunctionType(
 }
 
 Type ClangImporter::Implementation::applyParamAttributes(
-    const clang::ParmVarDecl *param, Type type, bool &isUnsafeSendable) {
+    const clang::ParmVarDecl *param, Type type, bool &isUnsafeSendable,
+    bool &isUnsafeMainActor) {
   if (!param->hasAttrs())
     return type;
 
@@ -1754,6 +1755,12 @@ Type ClangImporter::Implementation::applyParamAttributes(
       isUnsafeSendable = true;
       continue;
     }
+
+    // Map @_unsafeMainActor.
+    if (swiftAttr->getAttribute() == "@_unsafeMainActor") {
+      isUnsafeMainActor = true;
+      continue;
+    }
   }
 
   return type;
@@ -1935,7 +1942,9 @@ ParameterList *ClangImporter::Implementation::importFunctionParameterList(
 
     // Apply attributes to the type.
     bool isUnsafeSendable = false;
-    swiftParamTy = applyParamAttributes(param, swiftParamTy, isUnsafeSendable);
+    bool isUnsafeMainActor = false;
+    swiftParamTy = applyParamAttributes(
+        param, swiftParamTy, isUnsafeSendable, isUnsafeMainActor);
 
     // Figure out the name for this parameter.
     Identifier bodyName = importFullName(param, CurrentVersion)
@@ -1956,7 +1965,8 @@ ParameterList *ClangImporter::Implementation::importFunctionParameterList(
     paramInfo->setSpecifier(ParamSpecifier::Default);
     paramInfo->setInterfaceType(swiftParamTy);
     recordImplicitUnwrapForDecl(paramInfo, isParamTypeImplicitlyUnwrapped);
-    recordUnsafeSendableForDecl(paramInfo, isUnsafeSendable);
+    recordUnsafeConcurrencyForDecl(
+        paramInfo, isUnsafeSendable, isUnsafeMainActor);
     parameters.push_back(paramInfo);
     ++index;
   }
@@ -2435,7 +2445,9 @@ ImportedType ClangImporter::Implementation::importMethodParamsAndReturnType(
 
     // Apply Clang attributes to the parameter type.
     bool isUnsafeSendable = false;
-    swiftParamTy = applyParamAttributes(param, swiftParamTy, isUnsafeSendable);
+    bool isUnsafeMainActor = false;
+    swiftParamTy = applyParamAttributes(
+        param, swiftParamTy, isUnsafeSendable, isUnsafeMainActor);
 
     // Figure out the name for this parameter.
     Identifier bodyName = importFullName(param, CurrentVersion)
@@ -2459,7 +2471,8 @@ ImportedType ClangImporter::Implementation::importMethodParamsAndReturnType(
     paramInfo->setSpecifier(ParamSpecifier::Default);
     paramInfo->setInterfaceType(swiftParamTy);
     recordImplicitUnwrapForDecl(paramInfo, paramIsIUO);
-    recordUnsafeSendableForDecl(paramInfo, isUnsafeSendable);
+    recordUnsafeConcurrencyForDecl(
+        paramInfo, isUnsafeSendable, isUnsafeMainActor);
 
     // Determine whether we have a default argument.
     if (kind == SpecialMethodKind::Regular ||

lib/ClangImporter/ImporterImpl.h

@@ -683,12 +683,17 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
     decl->setImplicitlyUnwrappedOptional(true);
   }
 
-  void recordUnsafeSendableForDecl(ValueDecl *decl, bool isUnsafeSendable) {
-    if (!isUnsafeSendable)
-      return;
+  void recordUnsafeConcurrencyForDecl(
+      ValueDecl *decl, bool isUnsafeSendable, bool isUnsafeMainActor) {
+    if (isUnsafeSendable) {
+      decl->getAttrs().add(
+          new (SwiftContext) UnsafeSendableAttr(/*implicit=*/true));
+    }
 
-    decl->getAttrs().add(
-        new (SwiftContext) UnsafeSendableAttr(/*implicit=*/true));
+    if (isUnsafeMainActor) {
+      decl->getAttrs().add(
+          new (SwiftContext) UnsafeMainActorAttr(/*implicit=*/true));
+    }
   }
 
   /// Retrieve the Clang AST context.
@@ -842,7 +847,7 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
                         const clang::ObjCContainerDecl *NewContext = nullptr);
 
   Type applyParamAttributes(const clang::ParmVarDecl *param, Type type,
-                            bool &isUnsafeSendable);
+                            bool &isUnsafeSendable, bool &isUnsafeMainActor);
 
   /// If we already imported a given decl, return the corresponding Swift decl.
   /// Otherwise, return nullptr.

lib/Sema/CSApply.cpp

@@ -5709,15 +5709,15 @@ static bool hasCurriedSelf(ConstraintSystem &cs, ConcreteDeclRef callee,
 }
 
 /// Apply the contextually Sendable flag to the given expression,
-static void applyContextuallyConcurrent(
+static void applyUnsafeConcurrent(
       Expr *expr, bool sendable, bool forMainActor) {
   if (auto closure = dyn_cast<ClosureExpr>(expr)) {
-    closure->setContextuallyConcurrent(sendable, forMainActor);
+    closure->setUnsafeConcurrent(sendable, forMainActor);
     return;
   }
 
   if (auto captureList = dyn_cast<CaptureListExpr>(expr)) {
-    applyContextuallyConcurrent(
+    applyUnsafeConcurrent(
         captureList->getClosureBody(), sendable, forMainActor);
   }
 }
@@ -5972,18 +5972,14 @@ Expr *ExprRewriter::coerceCallArguments(
     // Save the original label location.
     newLabelLocs.push_back(getLabelLoc(argIdx));
 
-    // If the parameter is contextually Sendable and we are in a
-    // context that has adopted concurrency, apply contextual Sendable
-    // to the closure (if there is one).
-    if (paramInfo.isUnsafeSendable(paramIdx)) {
-      bool forMainActor = false;
-      if (apply) {
-        forMainActor = isMainDispatchQueue(apply->getFn());
-      }
-
-      applyContextuallyConcurrent(
-          arg, contextUsesConcurrencyFeatures(dc), forMainActor);
-    }
+    // Determine whether the parameter is unsafe Sendable or MainActor, and
+    // record it as such.
+    bool isUnsafeSendable = paramInfo.isUnsafeSendable(paramIdx);
+    bool isMainActor = paramInfo.isUnsafeMainActor(paramIdx) ||
+        (isUnsafeSendable && apply && isMainDispatchQueue(apply->getFn()));
+    applyUnsafeConcurrent(
+        arg, isUnsafeSendable && contextUsesConcurrencyFeatures(dc),
+        isMainActor);
 
     // If the types exactly match, this is easy.
     auto paramType = param.getOldType();

lib/Sema/TypeCheckAttr.cpp

@@ -136,6 +136,7 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
   IGNORED_ATTR(AtRethrows)
   IGNORED_ATTR(AtReasync)
   IGNORED_ATTR(UnsafeSendable)
+  IGNORED_ATTR(UnsafeMainActor)
 #undef IGNORED_ATTR
 
   void visitAlignmentAttr(AlignmentAttr *attr) {

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1545,6 +1545,7 @@ namespace  {
     UNINTERESTING_ATTR(AtReasync)
     UNINTERESTING_ATTR(Nonisolated)
     UNINTERESTING_ATTR(UnsafeSendable)
+    UNINTERESTING_ATTR(UnsafeMainActor)
 
 #undef UNINTERESTING_ATTR
 

test/ClangImporter/objc_async.swift

@@ -72,6 +72,13 @@ func testSlowServerSynchronous(slowServer: SlowServer) {
     print(s)
     onlyOnMainActor() // okay because runOnMainThread has a @MainActor closure
   }
+
+  slowServer.overridableButRunsOnMainThread { s in
+    print(s)
+    onlyOnMainActor() // okay because parameter has @_unsafeMainActor
+  }
+
+  let _: Int = slowServer.overridableButRunsOnMainThread // expected-error{{cannot convert value of type '(((String) -> Void)?) -> Void' to specified type 'Int'}}
 }
 
 func testSlowServerOldSchool(slowServer: SlowServer) {