Allow @isolated(any) mismatches in witness matching.

Fixes rdar://125394096

Author: rjmccall

lib/Sema/CSSimplify.cpp

@@ -5578,25 +5578,47 @@ bool ConstraintSystem::repairFailures(
     return false;
   }
 
+  // Be a little lax in protocol requirement matching.
   if (auto *VD = getAsDecl<ValueDecl>(anchor)) {
-    // Matching a witness to a ObjC protocol requirement.
-    if (VD->isObjC() && VD->isProtocolRequirement() &&
-        path[0].is<LocatorPathElt::Witness>() && 
+    if (VD->isProtocolRequirement() &&
+        path[0].is<LocatorPathElt::Witness>() &&
         // Note that the condition below is very important,
         // we need to wait until the very last moment to strip
         // the concurrency annotations from the inner most type.
         conversionsOrFixes.empty()) {
-      // Allow requirements to introduce `swift_attr` annotations
-      // (note that `swift_attr` in type contexts weren't supported
-      // before) and for witnesses to adopt them gradually by matching
-      // with a warning in non-strict concurrency mode.
-      if (!(Context.isSwiftVersionAtLeast(6) ||
+      bool hasAdjustments = false;
+      Type strippedLHS = lhs;
+      Type strippedRHS = rhs;
+
+      // When matching to an ObjC protocol requirement, allow requirements
+      // to introduce `swift_attr` annotations (note that `swift_attr` in
+      // type contexts weren't supported before) and for witnesses to
+      // adopt them gradually by matching with a warning in non-strict
+      // concurrency mode.
+      if (VD->isObjC() &&
+          !(Context.isSwiftVersionAtLeast(6) ||
             Context.LangOpts.StrictConcurrencyLevel ==
                 StrictConcurrency::Complete)) {
-        auto strippedLHS = lhs->stripConcurrency(/*resursive=*/true,
-                                                 /*dropGlobalActor=*/true);
-        auto strippedRHS = rhs->stripConcurrency(/*resursive=*/true,
-                                                 /*dropGlobalActor=*/true);
+        strippedLHS = lhs->stripConcurrency(/*recursive=*/true,
+                                            /*dropGlobalActor=*/true);
+        strippedRHS = rhs->stripConcurrency(/*recursive=*/true,
+                                            /*dropGlobalActor=*/true);
+        hasAdjustments = true;
+      }
+
+      // Always allow @isolated(any) mismatches.
+      auto maybeRemoveIsolatedAny = [&](Type &ty) {
+        if (auto fnType = ty->getAs<AnyFunctionType>();
+              fnType && fnType->getIsolation().isErased()) {
+          ty = fnType->withExtInfo(fnType->getExtInfo()
+                 .withIsolation(FunctionTypeIsolation::forNonIsolated()));
+          hasAdjustments = true;
+        }
+      };
+      maybeRemoveIsolatedAny(strippedLHS);
+      maybeRemoveIsolatedAny(strippedRHS);
+
+      if (hasAdjustments) {
         auto result = matchTypes(strippedLHS, strippedRHS, matchKind,
                                  flags | TMF_ApplyingFix, locator);
         if (!result.isFailure()) {

test/SILGen/isolated_any_conformance.swift

@@ -0,0 +1,46 @@
+// RUN: %target-swift-frontend -emit-silgen -enable-experimental-feature IsolatedAny %s -module-name test -swift-version 6 -disable-availability-checking | %FileCheck %s
+// REQUIRES: concurrency
+// REQUIRES: asserts
+
+// rdar://125394096.  This was a source compatibility failure in which adding
+// @isolated(any) to TaskGroup.addTask caused problems with a project that
+// introduced a protocol for different task group types.
+
+struct A<T> {
+  func enqueue(operation: @escaping @isolated(any) () async -> T) {}
+}
+
+protocol Enqueuer {
+  associatedtype Result
+  func enqueue(operation: @escaping @Sendable () async -> Result)
+}
+
+extension A : Enqueuer {}
+
+// CHECK-LABEL: sil private [transparent] [thunk] [ossa] @$s4test1AVyxGAA8EnqueuerA2aEP7enqueue9operationy6ResultQzyYaYbc_tFTW :
+// CHECK:       bb0(%0 : @guaranteed $@Sendable @async @callee_guaranteed @substituted <τ_0_0> () -> @out τ_0_0 for <τ_0_0>, %1 : $*A<τ_0_0>):
+// CHECK-NEXT:  [[CONVERTED_FN:%.*]] = convert_function %0 : $@Sendable @async @callee_guaranteed @substituted <τ_0_0> () -> @out τ_0_0 for <τ_0_0> to $@Sendable @async @callee_guaranteed () -> @out τ_0_0
+// CHECK-NEXT:  [[ISOLATION:%.*]] = enum $Optional<any Actor>, #Optional.none
+// CHECK-NEXT:  [[FN_COPY:%.*]] = copy_value [[CONVERTED_FN]] : $@Sendable @async @callee_guaranteed () -> @out τ_0_0
+// CHECK-NEXT:  // function_ref
+// CHECK-NEXT:  [[THUNK:%.*]] = function_ref @$sxIeghHr_xIeAghHr_lTR
+// CHECK-NEXT:  partial_apply [callee_guaranteed] [isolated_any] [[THUNK]]<τ_0_0>([[ISOLATION]], [[FN_COPY]])
+
+// For completeness, test that we allow mismatches in the opposite
+// direction as well.
+
+struct B<T> {
+  func enqueue(operation: @escaping @Sendable () async -> T) {}
+}
+
+protocol AnnotatedEnqueuer {
+  associatedtype Result
+  func enqueue(operation: @escaping @isolated(any) () async -> Result)
+}
+
+extension B : AnnotatedEnqueuer {}
+
+// CHECK-LABEL: sil private [transparent] [thunk] [ossa] @$s4test1BVyxGAA17AnnotatedEnqueuerA2aEP7enqueue9operationy6ResultQzyYaYbYAc_tFTW
+// CHECK:       bb0(%0 : @guaranteed $@isolated(any) @Sendable @async @callee_guaranteed @substituted <τ_0_0> () -> @out τ_0_0 for <τ_0_0>, %1 : $*B<τ_0_0>):
+// CHECK-NEXT:    [[FN_COPY:%.*]] = copy_value %0
+// CHECK-NEXT:    convert_function [[FN_COPY]] : $@isolated(any) @Sendable @async @callee_guaranteed @substituted <τ_0_0> () -> @out τ_0_0 for <τ_0_0> to $@Sendable @async @callee_guaranteed @substituted <τ_0_0> () -> @out τ_0_0 for <τ_0_0>