Merge remote-tracking branch 'origin/main' into rebranch

Author: swift-ci

.editorconfig

@@ -6,3 +6,6 @@ root = true
 indent_style = space
 indent_size = 2
 insert_final_newline = true
+
+[*.py]
+indent_size = 4

include/swift/AST/DiagnosticsSema.def

@@ -8735,11 +8735,6 @@ ERROR(execution_behavior_incompatible_isolated_parameter,none,
       "an isolated parameter: %2",
       (DeclAttribute, ValueDecl *, ValueDecl *))
 
-ERROR(execution_behavior_incompatible_dynamically_isolated_parameter,none,
-      "cannot use %0 on %kind1 because it has "
-      "a dynamically isolated parameter: %2",
-      (DeclAttribute, ValueDecl *, ValueDecl *))
-
 ERROR(execution_behavior_attr_incompatible_with_global_isolation,none,
       "cannot use %0 because function type is isolated to a global actor %1",
       (DeclAttribute, Type))

lib/Sema/TypeCheckAttr.cpp

@@ -230,17 +230,6 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
             attr, decl, P);
         return;
       }
-
-      if (auto *attrType = dyn_cast<AttributedTypeRepr>(repr)) {
-        if (attrType->has(TypeAttrKind::Isolated)) {
-          diagnoseAndRemoveAttr(
-              attr,
-              diag::
-                  execution_behavior_incompatible_dynamically_isolated_parameter,
-              attr, decl, P);
-          return;
-        }
-      }
     }
   }
 

lib/Sema/TypeCheckConcurrency.cpp

@@ -1052,11 +1052,17 @@ bool swift::diagnoseNonSendableTypes(
     Type type, SendableCheckContext fromContext,
     Type inDerivedConformance, SourceLoc loc,
     llvm::function_ref<bool(Type, DiagnosticBehavior)> diagnose) {
+  auto &ctx = type->getASTContext();
+
   // If the Sendable protocol is missing, do nothing.
-  auto proto = type->getASTContext().getProtocol(KnownProtocolKind::Sendable);
+  auto proto = ctx.getProtocol(KnownProtocolKind::Sendable);
   if (!proto)
     return false;
 
+  // Unwrap pack expansions here to allow packs of Sendable type.
+  if (auto *expansion = type->getAs<PackExpansionType>())
+    type = PackType::get(ctx, {expansion});
+
   // FIXME: More detail for unavailable conformances.
   auto conformance = lookupConformance(type, proto, /*allowMissing=*/true);
   if (conformance.isInvalid() || conformance.hasUnavailableConformance()) {
@@ -3055,12 +3061,6 @@ namespace {
             ->mapTypeIntoContext(decl->getInterfaceType())
             ->getReferenceStorageReferent();
 
-        // Pack expansions are okay to capture as long as the pattern
-        // type is Sendable.
-        if (auto *expansion = type->getAs<PackExpansionType>()) {
-          type = expansion->getPatternType();
-        }
-
         if (type->hasError())
           continue;
 

stdlib/public/core/SIMDFloatConcreteOperations.swift.gyb

@@ -122,7 +122,7 @@ compares = [
   ///   result[i] = (a[i] ${op} b)
   /// }
   /// ```
-  @_alwaysEmitIntoClient @_transparent
+  @_alwaysEmitIntoClient @_transparent @_disfavoredOverload
   public static func .${op}(a: Self, b: Scalar) -> SIMDMask<MaskStorage> {
     a .${op} Self(repeating: b)
   }
@@ -139,7 +139,7 @@ compares = [
   ///   result[i] = (a ${op} b[i])
   /// }
   /// ```
-  @_alwaysEmitIntoClient @_transparent
+  @_alwaysEmitIntoClient @_transparent @_disfavoredOverload
   public static func .${op}(a: Scalar, b: Self) -> SIMDMask<MaskStorage> {
     Self(repeating: a) .${op} b
   }

test/Concurrency/sendable_checking.swift

@@ -534,3 +534,27 @@ func test(value: (_: Int, _: () -> Void)) {
   takesSendable(value.1) // Ok
   // expected-warning@-1 {{converting non-Sendable function value to '@Sendable () -> Void' may introduce data races}}
 }
+
+// Don't forget about parameter packs -- https://github.com/swiftlang/swift/issues/82614
+
+@available(SwiftStdlib 5.1, *)
+protocol PackProto {
+  func foo<each A: Sendable>(_ a: repeat each A) async
+  func bar<each A>(_ a: repeat each A) async
+  // expected-note@-1 {{consider making generic parameter 'each A' conform to the 'Sendable' protocol}}
+}
+
+@available(SwiftStdlib 5.1, *)
+actor PackActor: PackProto {
+  func foo<each A: Sendable>(_ a: repeat each A) async {
+    for b in repeat (each a) {
+      print(b)
+    }
+  }
+  func bar<each A>(_ a: repeat each A) async {
+  // expected-warning@-1 {{non-Sendable parameter type 'repeat each A' cannot be sent from caller of protocol requirement 'bar' into actor-isolated implementation; this is an error in the Swift 6 language mode}}
+    for b in repeat (each a) {
+      print(b)
+    }
+  }
+}

test/IRGen/ptrauth-protocols.sil

@@ -75,7 +75,7 @@ bb0:
 //   Fetch T.Assoc : P.
 // CHECK-NEXT:    %T.Assoc.P = call swiftcc ptr @swift_getAssociatedConformanceWitness(ptr %T.Q, ptr %T, ptr [[T_ASSOC]]
 //   Fetch T.Assoc.foo
-// CHECK-NEXT:    [[T0:%.*]] = getelementptr inbounds ptr, ptr %T.Assoc.P, i32 1
+// CHECK:         [[T0:%.*]] = getelementptr inbounds ptr, ptr %T.Assoc.P, i32 1
 // CHECK-NEXT:    [[T1:%.*]] = load ptr, ptr [[T0]], align 8
 // CHECK-NEXT:    [[T2:%.*]] = ptrtoint ptr [[T0]] to i64
 // CHECK-NEXT:    [[DISC:%.*]] = call i64 @llvm.ptrauth.blend(i64 [[T2]], i64 53700)

test/SILGen/execution_attr.swift

@@ -5,7 +5,7 @@
 // REQUIRES: swift_feature_NonisolatedNonsendingByDefault
 
 // Validate that both with and without the experimental flag we properly codegen
-// execution(caller) and execution(concurrent).
+// `@concurrent` and `nonisolated(nonsending)`
 
 // CHECK-LABEL: // executionCaller()
 // CHECK-NEXT: // Isolation: caller_isolation_inheriting
@@ -62,3 +62,36 @@ extension S {
   // CHECK: sil hidden [ossa] @$s14execution_attr1SV0A17CallerFieldMethodyyyyYaYCXEF : $@convention(method) (@guaranteed @noescape @async @callee_guaranteed (@sil_isolated @sil_implicit_leading_param @guaranteed Optional<any Actor>) -> (), @guaranteed S) -> () {
   func executionCallerFieldMethod(_ x: nonisolated(nonsending) () async -> ()) {}
 }
+
+// CHECK-LABEL: sil hidden [ossa] @$s14execution_attr24testWithDynamicIsolation2fnyyyYAXE_tYaF : $@convention(thin) @async (@guaranteed @isolated(any) @noescape @callee_guaranteed () -> ()) -> () {
+// CHECK: bb0([[PARAM_FN:%.*]] : @guaranteed $@isolated(any) @noescape @callee_guaranteed () -> ()):
+// CHECK:   [[GENERIC_EXEC:%.*]] = enum $Optional<Builtin.Executor>, #Optional.none!enumelt
+// CHECK-NEXT:   hop_to_executor [[GENERIC_EXEC]]
+// CHECK-NEXT:   [[FN:%.*]] = copy_value [[PARAM_FN]]
+// CHECK-NEXT:   [[BORROWED_FN:%.*]] = begin_borrow [[FN]]
+// CHECK-NEXT:   [[FN_ISOLATION:%.*]] = function_extract_isolation [[BORROWED_FN]]
+// CHECK-NEXT:   hop_to_executor [[FN_ISOLATION]]
+// CHECK-NEXT:   [[BORROWED_FN:%.*]] = begin_borrow [[FN]]
+// CHECK-NEXT:   apply [[BORROWED_FN]]()
+// CHECK: hop_to_executor [[GENERIC_EXEC]]
+// CHECK: } // end sil function '$s14execution_attr24testWithDynamicIsolation2fnyyyYAXE_tYaF'
+@concurrent
+func testWithDynamicIsolation(fn: @isolated(any) () -> Void) async {
+  await fn()
+}
+
+// CHECK-LABEL: sil hidden [ossa] @$s14execution_attr38testCallerIsolatedWithDynamicIsolation2fnyyyYAXE_tYaF : $@convention(thin) @async (@sil_isolated @sil_implicit_leading_param @guaranteed Optional<any Actor>, @guaranteed @isolated(any) @noescape @callee_guaranteed () -> ()) -> () {
+// CHECK: bb0([[ISOLATION:%.*]] : @guaranteed $Optional<any Actor>, [[PARAM_FN:%.*]] : @guaranteed $@isolated(any) @noescape @callee_guaranteed () -> ()):
+// CHECK:   hop_to_executor [[ISOLATION]]
+// CHECK-NEXT:   [[FN:%.*]] = copy_value [[PARAM_FN]]
+// CHECK-NEXT:   [[BORROWED_FN:%.*]] = begin_borrow [[FN]]
+// CHECK-NEXT:   [[FN_ISOLATION:%.*]] = function_extract_isolation [[BORROWED_FN]]
+// CHECK-NEXT:   hop_to_executor [[FN_ISOLATION]]
+// CHECK-NEXT:   [[BORROWED_FN:%.*]] = begin_borrow [[FN]]
+// CHECK-NEXT:   apply [[BORROWED_FN]]()
+// CHECK: hop_to_executor [[ISOLATION]]
+// CHECK: } // end sil function '$s14execution_attr38testCallerIsolatedWithDynamicIsolation2fnyyyYAXE_tYaF'
+nonisolated(nonsending)
+func testCallerIsolatedWithDynamicIsolation(fn: @isolated(any) () -> Void) async {
+  await fn()
+}

test/attr/execution_behavior_attrs.swift

@@ -94,9 +94,7 @@ struct TestAttributeCollisions {
   }
 
   @concurrent func testIsolationAny(arg: @isolated(any) () -> Void) async {}
-  // expected-error@-1 {{cannot use @concurrent on instance method 'testIsolationAny(arg:)' because it has a dynamically isolated parameter: 'arg'}}
   @concurrent subscript(testIsolationAny arg: @isolated(any) () -> Void) -> Int {
-  // expected-error@-1 {{cannot use @concurrent on subscript 'subscript(testIsolationAny:)' because it has a dynamically isolated parameter: 'arg'}}
     get async {}
   }
 
@@ -158,3 +156,13 @@ do {
     })
   }
 }
+
+do {
+  nonisolated(nonsending)
+  func testOnDecl(_: @isolated(any) () -> Void) async {} // Ok
+
+  func testOnType1(_: nonisolated(nonsending) @isolated(any) () async -> Void) {}
+  // expected-error@-1 {{cannot use 'nonisolated(nonsending)' together with '@isolated(any)'}}
+  func testOnType2(_: @concurrent @isolated(any) () async -> Void) {}
+  // expected-error@-1 {{cannot use '@concurrent' together with '@isolated(any)'}}
+}