Merge pull request swiftlang#36177 from DougGregor/global-actor-unsafe

Author: DougGregor

include/swift/AST/Attr.h

@@ -1663,6 +1663,7 @@ class CustomAttr final : public DeclAttribute,
 
   unsigned hasArgLabelLocs : 1;
   unsigned numArgLabels : 16;
+  mutable unsigned isArgUnsafeBit : 1;
 
   CustomAttr(SourceLoc atLoc, SourceRange range, TypeExpr *type,
              PatternBindingInitializer *initContext, Expr *arg,
@@ -1696,6 +1697,11 @@ class CustomAttr final : public DeclAttribute,
   Expr *getArg() const { return arg; }
   void setArg(Expr *newArg) { arg = newArg; }
 
+  /// Determine whether the argument is '(unsafe)', a special subexpression
+  /// used by global actors.
+  bool isArgUnsafe() const;
+  void setArgIsUnsafe(bool unsafe) { isArgUnsafeBit = unsafe; }
+
   Expr *getSemanticInit() const { return semanticInit; }
   void setSemanticInit(Expr *expr) { semanticInit = expr; }
 

include/swift/AST/DiagnosticsSema.def

@@ -4410,7 +4410,9 @@ ERROR(global_actor_on_local_variable,none,
       "local variable %0 cannot have a global actor", (DeclName))
 ERROR(global_actor_on_struct_property,none,
       "stored property %0 of a struct cannot have a global actor", (DeclName))
-
+ERROR(global_actor_non_unsafe_init,none,
+      "global actor attribute %0 argument can only be '(unsafe)'", (Type))
+      
 ERROR(actor_isolation_multiple_attr,none,
       "%0 %1 has multiple actor-isolation attributes ('%2' and '%3')",
       (DescriptiveDeclKind, DeclName, StringRef, StringRef))

lib/AST/Attr.cpp

@@ -1020,6 +1020,8 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
       type.print(Printer, Options);
     else
       attr->getTypeRepr()->print(Printer, Options);
+    if (attr->isArgUnsafe())
+      Printer << "(unsafe)";
     Printer.printNamePost(PrintNameContext::Attribute);
     break;
   }
@@ -1933,6 +1935,7 @@ CustomAttr::CustomAttr(SourceLoc atLoc, SourceRange range, TypeExpr *type,
   assert(type);
   hasArgLabelLocs = !argLabelLocs.empty();
   numArgLabels = argLabels.size();
+  isArgUnsafeBit = false;
   initializeCallArguments(argLabels, argLabelLocs);
 }
 
@@ -1975,6 +1978,26 @@ void CustomAttr::setType(Type ty) {
   typeExpr->setType(MetatypeType::get(ty));
 }
 
+bool CustomAttr::isArgUnsafe() const {
+  if (isArgUnsafeBit)
+    return true;
+
+  auto arg = getArg();
+  if (!arg)
+    return false;
+
+  if (auto parenExpr = dyn_cast<ParenExpr>(arg)) {
+    if (auto declRef =
+            dyn_cast<UnresolvedDeclRefExpr>(parenExpr->getSubExpr())) {
+      if (declRef->getName().isSimpleName("unsafe")) {
+        isArgUnsafeBit = true;
+      }
+    }
+  }
+
+  return isArgUnsafeBit;
+}
+
 void swift::simple_display(llvm::raw_ostream &out, const DeclAttribute *attr) {
   if (attr)
     attr->print(out);

lib/ClangImporter/ImportDecl.cpp

@@ -8159,10 +8159,16 @@ void ClangImporter::Implementation::importAttributes(
       // FIXME: Hard-core @MainActor and @UIActor, because we don't have a
       // point at which to do name lookup for imported entities.
       if (swiftAttr->getAttribute() == "@MainActor" ||
+          swiftAttr->getAttribute() == "@MainActor(unsafe)" ||
           swiftAttr->getAttribute() == "@UIActor") {
+        bool isUnsafe = swiftAttr->getAttribute() == "@MainActor(unsafe)" ||
+            !C.LangOpts.isSwiftVersionAtLeast(6);
         if (Type mainActorType = getMainActorType()) {
           auto typeExpr = TypeExpr::createImplicit(mainActorType, SwiftContext);
           auto attr = CustomAttr::create(SwiftContext, SourceLoc(), typeExpr);
+          attr->setArgIsUnsafe(isUnsafe);
+          if (isUnsafe)
+            attr->setImplicit();
           MappedDecl->getAttrs().add(attr);
         }
 

lib/Sema/TypeCheckConcurrency.cpp

@@ -2016,6 +2016,20 @@ static Optional<ActorIsolation> getIsolationFromAttributes(
     if (!globalActorType || globalActorType->hasError())
       return ActorIsolation::forUnspecified();
 
+    // Handle @<global attribute type>(unsafe).
+    bool isUnsafe = globalActorAttr->first->isArgUnsafe();
+    if (globalActorAttr->first->getArg() && !isUnsafe) {
+      ctx.Diags.diagnose(
+          globalActorAttr->first->getLocation(),
+          diag::global_actor_non_unsafe_init, globalActorType);
+    }
+
+    // TODO: Model as unsafe from the actor-isolation perspective, which
+    // disables all checking. We probably want to model this as a separate kind
+    // of actor isolation to emit warnings.
+    if (isUnsafe)
+      return ActorIsolation::forIndependent(ActorIndependentKind::Unsafe);
+
     return ActorIsolation::forGlobalActor(
         globalActorType->mapTypeOutOfContext());
   }
@@ -2287,6 +2301,12 @@ void swift::checkOverrideActorIsolation(ValueDecl *value) {
   if (isolation == overriddenIsolation)
     return;
 
+  // If the overridden declaration is @actorIndependent(unsafe) and the
+  // overriding declaration has been placed in a global actor, allow it.
+  if (overriddenIsolation.getKind() == ActorIsolation::IndependentUnsafe &&
+      isolation.getKind() == ActorIsolation::GlobalActor)
+    return;
+
   // If the overridden declaration is from Objective-C with no actor annotation,
   // and the overriding declaration has been placed in a global actor, allow it.
   if (overridden->hasClangNode() && !overriddenIsolation &&

lib/Sema/TypeCheckProtocol.cpp

@@ -2777,8 +2777,11 @@ bool ConformanceChecker::checkActorIsolation(
     break;
   }
 
-  case ActorIsolation::Independent:
   case ActorIsolation::IndependentUnsafe:
+    // The requirement is explicitly unsafe; allow it.
+    return false;
+
+  case ActorIsolation::Independent:
   case ActorIsolation::Unspecified:
     break;
   }

lib/Serialization/Deserialization.cpp

@@ -4396,9 +4396,10 @@ llvm::Error DeclDeserializer::deserializeDeclAttributes() {
 
       case decls_block::Custom_DECL_ATTR: {
         bool isImplicit;
+        bool isArgUnsafe;
         TypeID typeID;
         serialization::decls_block::CustomDeclAttrLayout::readRecord(
-          scratch, isImplicit, typeID);
+          scratch, isImplicit, typeID, isArgUnsafe);
 
         Expected<Type> deserialized = MF.getTypeChecked(typeID);
         if (!deserialized) {
@@ -4412,7 +4413,9 @@ llvm::Error DeclDeserializer::deserializeDeclAttributes() {
             return deserialized.takeError();
         } else {
           auto *TE = TypeExpr::createImplicit(deserialized.get(), ctx);
-          Attr = CustomAttr::create(ctx, SourceLoc(), TE, isImplicit);
+          auto custom = CustomAttr::create(ctx, SourceLoc(), TE, isImplicit);
+          custom->setArgIsUnsafe(isArgUnsafe);
+          Attr = custom;
         }
         break;
       }

lib/Serialization/ModuleFormat.h

@@ -56,7 +56,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 599; // has-async-alternative
+const uint16_t SWIFTMODULE_VERSION_MINOR = 600; // custom attr (unsafe)
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -1943,9 +1943,9 @@ namespace decls_block {
   using CustomDeclAttrLayout = BCRecordLayout<
     Custom_DECL_ATTR,
     BCFixed<1>,  // implicit flag
-    TypeIDField // type referenced by this custom attribute
+    TypeIDField, // type referenced by this custom attribute
+    BCFixed<1>   // is the argument (unsafe)
   >;
-
 }
 
 /// Returns the encoding kind for the given decl.

lib/Serialization/Serialization.cpp

@@ -2532,7 +2532,8 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
       auto theAttr = cast<CustomAttr>(DA);
       CustomDeclAttrLayout::emitRecord(S.Out, S.ScratchRecord, abbrCode,
                                        theAttr->isImplicit(),
-                                       S.addTypeRef(theAttr->getType()));
+                                       S.addTypeRef(theAttr->getType()),
+                                       theAttr->isArgUnsafe());
       return;
     }
 

test/ClangImporter/objc_async.swift

@@ -77,7 +77,7 @@ func testSlowServerOldSchool(slowServer: SlowServer) {
 func globalAsync() async { }
 
 actor MySubclassCheckingSwiftAttributes : ProtocolWithSwiftAttributes {
-  func syncMethod() { } // expected-note 2{{calls to instance method 'syncMethod()' from outside of its actor context are implicitly asynchronous}}
+  func syncMethod() { } // expected-note {{calls to instance method 'syncMethod()' from outside of its actor context are implicitly asynchronous}}
 
   func independentMethod() {
     syncMethod() // expected-error{{ctor-isolated instance method 'syncMethod()' can not be referenced from an '@actorIndependent' context}}
@@ -88,7 +88,7 @@ actor MySubclassCheckingSwiftAttributes : ProtocolWithSwiftAttributes {
   }
 
   func mainActorMethod() {
-    syncMethod() // expected-error{{actor-isolated instance method 'syncMethod()' can not be referenced from context of global actor 'MainActor'}}
+    syncMethod()
   }
 
   func uiActorMethod() { }