[Concurrency] isolated fixes; ban Array<T> and handle Self in actor (#70955)

Author: ktoso

lib/Sema/TypeCheckType.cpp

@@ -4506,22 +4506,27 @@ TypeResolver::resolveIsolatedTypeRepr(IsolatedTypeRepr *repr,
     return ErrorType::get(getASTContext());
   }
 
+  // Keep the `type` to be returned, while we unwrap and inspect the inner
+  // type for whether it can be isolated on.
   Type type = resolveType(repr->getBase(), options);
+  Type unwrappedType = type;
 
-  if (auto ty = dyn_cast<DynamicSelfType>(type)) {
-    type = ty->getSelfType();
+  // Optional actor types are fine - `nil` represents `nonisolated`.
+  auto allowOptional = getASTContext().LangOpts
+                           .hasFeature(Feature::OptionalIsolatedParameters);
+  if (allowOptional) {
+    if (auto wrappedOptionalType = unwrappedType->getOptionalObjectType()) {
+      unwrappedType = wrappedOptionalType;
+    }
+  }
+  if (auto dynamicSelfType = dyn_cast<DynamicSelfType>(unwrappedType)) {
+    unwrappedType = dynamicSelfType->getSelfType();
   }
 
   // isolated parameters must be of actor type
-  if (!type->hasTypeParameter() && !type->isAnyActorType() && !type->hasError()) {
-    // Optional actor types are fine - `nil` represents `nonisolated`.
-    auto wrapped = type->getOptionalObjectType();
-    auto allowOptional = getASTContext().LangOpts
-        .hasFeature(Feature::OptionalIsolatedParameters);
-    if (allowOptional && wrapped && wrapped->isAnyActorType()) {
-      return type;
-    }
-
+  if (!unwrappedType->isTypeParameter() &&
+      !unwrappedType->isAnyActorType() &&
+      !unwrappedType->hasError()) {
     diagnoseInvalid(
         repr, repr->getSpecifierLoc(), diag::isolated_parameter_not_actor, type);
     return ErrorType::get(type);

test/Concurrency/isolated_parameters.swift

@@ -356,8 +356,12 @@ func isolated_generic_bad_2<T: Equatable>(_ t: isolated T) {}
 func isolated_generic_bad_3<T: AnyActor>(_ t: isolated T) {}
 // expected-error@-1 {{'isolated' parameter 'T' must conform to 'Actor' or 'DistributedActor' protocol}}
 
+func isolated_generic_bad_4<T>(_ t: isolated Array<T>) {}
+// expected-error@-1 {{'isolated' parameter has non-actor type 'Array<T>'}}
+
 func isolated_generic_ok_1<T: Actor>(_ t: isolated T) {}
 
+
 class NotSendable {} // expected-complete-note 5 {{class 'NotSendable' does not conform to the 'Sendable' protocol}}
 
 func optionalIsolated(_ ns: NotSendable, to actor: isolated (any Actor)?) async {}
@@ -396,9 +400,19 @@ nonisolated func callFromNonisolated(ns: NotSendable) async {
   // expected-complete-warning@-3 {{passing argument of non-sendable type 'NotSendable' into actor-isolated context may introduce data races}}
 }
 
-actor A2 {}
-extension A2 {
-  nonisolated func f() async {
+// TODO: Consider making an actor's Self behave like in a struct, removing this special casing.
+//       We could consider changing this, so that self is always Self because we don't allow inheritance of actors.
+//       See: https://github.com/apple/swift/issues/70954 and rdar://121091417
+actor A2 {
+  nonisolated func f1() async {
+    await { (self: isolated Self) in }(self)
+    // expected-error@-1 {{cannot convert value of type 'A2' to expected argument type 'Self'}}
+    await { (self: isolated Self?) in }(self)
+    // expected-error@-1 {{cannot convert value of type 'A2' to expected argument type 'Self?'}}
+  }
+  nonisolated func f2() async -> Self {
     await { (self: isolated Self) in }(self)
+    await { (self: isolated Self?) in }(self)
+    return self
   }
 }