[region-isolation] Reuse ActorInstance::lookThroughInsts when computing the actor instance for SILIsolationInfo purposes.

We are already using this routine in other parts of TransferNonSendable to
ensure that we look through common insts that SILGen inserts that do not change
the actual underlying actor instance that we are using. In this case, I added
support for casts, optional formation, optional extraction, existential ref
initialization.

As an example of where this came up is the following test case where we fail to
look through an init_existential_ref.

```swift
public actor MyActor {
  private var intDict: [Int: Int] = [:]

  public func test() async {
    await withTaskGroup(of: Void.self) { taskGroup in
      for (_, _) in intDict {}
      await taskGroup.waitForAll() // Isolation merge failure happens here
    }
  }
}
```

I also added the ability to at the SIL level actual test out this merge
condition using the analysis test runner. I used this to validate that this
functionality works as expected in a precise way.

rdar://130113744

Author: gottesmm

include/swift/SILOptimizer/Utils/SILIsolationInfo.h

@@ -485,6 +485,10 @@ class SILDynamicMergedIsolationInfo {
   SWIFT_DEBUG_DUMPER(dumpForDiagnostics()) {
     innerInfo.dumpForDiagnostics();
   }
+
+  void printForOneLineLogging(llvm::raw_ostream &os) const {
+    innerInfo.printForOneLineLogging(os);
+  }
 };
 
 } // namespace swift

lib/SILOptimizer/Utils/SILIsolationInfo.cpp

@@ -364,49 +364,47 @@ SILIsolationInfo SILIsolationInfo::get(SILInstruction *inst) {
     }
 
     if (auto *isolatedOp = fas.getIsolatedArgumentOperandOrNullPtr()) {
-      // First see if we have an enum inst.
-      if (auto *ei = dyn_cast<EnumInst>(isolatedOp->get())) {
-        if (ei->getElement()->getParentEnum()->isOptionalDecl()) {
-          // Pattern match from global actors being passed as isolated
-          // parameters. This gives us better type information. If we can
-          // pattern match... we should!
-          if (ei->hasOperand()) {
-            if (auto *ieri =
-                    dyn_cast<InitExistentialRefInst>(ei->getOperand())) {
-              CanType selfASTType = ieri->getFormalConcreteType();
-
-              if (auto *nomDecl = selfASTType->getAnyActor()) {
-                // The SILValue() parameter doesn't matter until we have
-                // isolation history.
-                if (nomDecl->isGlobalActor())
-                  return SILIsolationInfo::getGlobalActorIsolated(SILValue(),
-                                                                  nomDecl);
-              }
-            }
-          } else {
-            // In this case, we have a .none so we are attempting to use the
-            // global queue. In such a case, we need to not use the enum as our
-            // value and instead need to grab the isolation of our apply.
-            if (auto isolationInfo = get(fas.getCallee())) {
-              return isolationInfo;
-            }
-          }
+      // First look through ActorInstance agnostic values so we can find the
+      // type of the actual underlying actor (e.x.: copy_value,
+      // init_existential_ref, begin_borrow, etc).
+      auto actualIsolatedValue =
+          ActorInstance::lookThroughInsts(isolatedOp->get());
+
+      // First see if we have a .none enum inst. In such a case, we are actually
+      // on the nonisolated global queue.
+      if (auto *ei = dyn_cast<EnumInst>(actualIsolatedValue)) {
+        if (ei->getElement()->getParentEnum()->isOptionalDecl() &&
+            !ei->hasOperand()) {
+          // In this case, we have a .none so we are attempting to use the
+          // global queue. This means that the isolation effect of the
+          // function is disconnected since we are treating the function as
+          // nonisolated.
+          return SILIsolationInfo::getDisconnected(false);
         }
       }
 
-      // If we did not find an AST type, just see if we can find a value by
-      // looking through all optional types. This is conservatively correct.
-      CanType selfASTType = isolatedOp->get()->getType().getASTType();
+      // Then using that value, grab the AST type from the actual isolated
+      // value.
+      CanType selfASTType = actualIsolatedValue->getType().getASTType();
+
+      // Then look through optional types since in cases like where we have a
+      // function argument that is an Optional actor... like an optional actor
+      // returned from a function, we still need to be able to lookup the actor
+      // as being the underlying type.
       selfASTType =
           selfASTType->lookThroughAllOptionalTypes()->getCanonicalType();
-
       if (auto *nomDecl = selfASTType->getAnyActor()) {
+        // Then see if we have a global actor. This pattern matches the output
+        // for doing things like GlobalActor.shared.
+        if (nomDecl->isGlobalActor()) {
+          return SILIsolationInfo::getGlobalActorIsolated(SILValue(), nomDecl);
+        }
+
         // TODO: We really should be doing this based off of an Operand. Then
         // we would get the SILValue() for the first element. Today this can
         // only mess up isolation history.
-
         return SILIsolationInfo::getActorInstanceIsolated(
-            SILValue(), isolatedOp->get(), nomDecl);
+            SILValue(), actualIsolatedValue, nomDecl);
       }
     }
 
@@ -1147,11 +1145,33 @@ SILValue ActorInstance::lookThroughInsts(SILValue value) {
         isa<MoveValueInst>(svi) || isa<ExplicitCopyValueInst>(svi) ||
         isa<BeginBorrowInst>(svi) ||
         isa<CopyableToMoveOnlyWrapperValueInst>(svi) ||
-        isa<MoveOnlyWrapperToCopyableValueInst>(svi)) {
+        isa<MoveOnlyWrapperToCopyableValueInst>(svi) ||
+        isa<InitExistentialRefInst>(svi) || isa<UncheckedRefCastInst>(svi) ||
+        isa<UnconditionalCheckedCastInst>(svi)) {
       value = lookThroughInsts(svi->getOperand(0));
       continue;
     }
 
+    // Look Through extracting from optionals.
+    if (auto *uedi = dyn_cast<UncheckedEnumDataInst>(svi)) {
+      if (uedi->getEnumDecl() ==
+          uedi->getFunction()->getASTContext().getOptionalDecl()) {
+        value = lookThroughInsts(uedi->getOperand());
+        continue;
+      }
+    }
+
+    // Look Through wrapping in an enum.
+    if (auto *ei = dyn_cast<EnumInst>(svi)) {
+      if (ei->hasOperand()) {
+        if (ei->getElement()->getParentEnum() ==
+            ei->getFunction()->getASTContext().getOptionalDecl()) {
+          value = lookThroughInsts(ei->getOperand());
+          continue;
+        }
+      }
+    }
+
     break;
   }
 
@@ -1213,7 +1233,7 @@ SILDynamicMergedIsolationInfo::merge(SILIsolationInfo other) const {
 namespace swift::test {
 
 // Arguments:
-// - SILValue: value to emit a name for.
+// - SILValue: value to look up isolation for.
 // Dumps:
 // - The inferred isolation.
 static FunctionTest
@@ -1229,4 +1249,33 @@ static FunctionTest
                               llvm::outs() << "\n";
                             });
 
+// Arguments:
+// - SILValue: first value to merge
+// - SILValue: second value to merge
+// Dumps:
+// - The merged isolation.
+static FunctionTest IsolationMergeTest(
+    "sil-isolation-info-merged-inference",
+    [](auto &function, auto &arguments, auto &test) {
+      auto firstValue = arguments.takeValue();
+      auto secondValue = arguments.takeValue();
+      SILIsolationInfo firstValueInfo = SILIsolationInfo::get(firstValue);
+      SILIsolationInfo secondValueInfo = SILIsolationInfo::get(secondValue);
+      std::optional<SILDynamicMergedIsolationInfo> mergedInfo(firstValueInfo);
+      mergedInfo = mergedInfo->merge(secondValueInfo);
+      llvm::outs() << "First Value: " << *firstValue;
+      llvm::outs() << "First Isolation: ";
+      firstValueInfo.printForOneLineLogging(llvm::outs());
+      llvm::outs() << "\nSecond Value: " << *secondValue;
+      llvm::outs() << "Second Isolation: ";
+      secondValueInfo.printForOneLineLogging(llvm::outs());
+      llvm::outs() << "\nMerged Isolation: ";
+      if (mergedInfo) {
+        mergedInfo->printForOneLineLogging(llvm::outs());
+      } else {
+        llvm::outs() << "Merge failure!";
+      }
+      llvm::outs() << "\n";
+    });
+
 } // namespace swift::test

test/Concurrency/isolated_parameters.swift

@@ -439,8 +439,9 @@ nonisolated func callFromNonisolated(ns: NotSendable) async {
   let myActor = A()
 
   await optionalIsolated(ns, to: myActor)
-  // expected-complete-warning@-1 {{passing argument of non-sendable type 'NotSendable' into actor-isolated context may introduce data races}}
-  // expected-tns-warning @-2 {{pattern that the region based isolation checker does not understand how to check. Please file a bug}}
+  // expected-complete-warning @-1 {{passing argument of non-sendable type 'NotSendable' into actor-isolated context may introduce data races}}
+  // expected-tns-warning @-2 {{sending 'ns' risks causing data races}}
+  // expected-tns-note @-3 {{sending task-isolated 'ns' to actor-isolated global function 'optionalIsolated(_:to:)' risks causing data races between actor-isolated and task-isolated uses}}
 
 #if ALLOW_TYPECHECKER_ERRORS
   optionalIsolatedSync(ns, to: myActor)
@@ -456,13 +457,14 @@ nonisolated func callFromNonisolated(ns: NotSendable) async {
   // expected-tns-warning @-2 {{sending 'ns' risks causing data races}}
   // expected-tns-note @-3 {{sending main actor-isolated 'ns' to nonisolated global function 'optionalIsolated(_:to:)' risks causing data races between nonisolated and main actor-isolated uses}}
 
-  optionalIsolatedSync(ns, to: nil) // expected-tns-warning {{pattern that the region based isolation checker does not understand how to check. Please file a bug}}
+  optionalIsolatedSync(ns, to: nil)
 
   let myActor = A()
 
   await optionalIsolated(ns, to: myActor)
   // expected-complete-warning@-1 {{passing argument of non-sendable type 'NotSendable' into actor-isolated context may introduce data races}}
-  // expected-tns-warning @-2 {{pattern that the region based isolation checker does not understand how to check. Please file a bug}}
+  // expected-tns-warning @-2 {{sending 'ns' risks causing data races}}
+  // expected-tns-note @-3 {{sending main actor-isolated 'ns' to actor-isolated global function 'optionalIsolated(_:to:)' risks causing data races between actor-isolated and main actor-isolated uses}}
 
 #if ALLOW_TYPECHECKER_ERRORS
   optionalIsolatedSync(ns, to: myActor)
@@ -567,3 +569,14 @@ public func useDefaultIsolationWithoutIsolatedParam(
   useDefaultIsolation()
   useDefaultIsolationWithoutIsolatedParam()
 }
+
+public actor MyActorIsolatedParameterMerge {
+  private var inProgressIndexTasks: [Int: Int] = [:]
+
+  public func test() async {
+    await withTaskGroup(of: Void.self) { taskGroup in
+      for (_, _) in inProgressIndexTasks {}
+      await taskGroup.waitForAll()
+    }
+  }
+}

test/Concurrency/silisolationinfo_inference.sil

@@ -23,6 +23,8 @@ class NonSendableKlass {
 
 actor MyActor {
   var ns: NonSendableKlass
+
+  func doSomething() async -> NonSendableKlass
 }
 
 sil @transferNonSendableKlass : $@convention(thin) @async (@guaranteed NonSendableKlass) -> ()
@@ -33,6 +35,7 @@ sil @constructNonSendableKlassIndirectAsync : $@convention(thin) @async () -> @o
 sil @useUnmanagedNonSendableKlass : $@convention(thin) (@guaranteed @sil_unmanaged NonSendableKlass) -> ()
 
 sil @useActor : $@convention(thin) (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
+sil @useOptionalActor : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
 
 ///////////////////////
 // MARK: Basic Tests //
@@ -721,3 +724,98 @@ bb0(%0 : @owned $MyActor):
   destroy_value %1b : $MyActor
   return %3 : $NonSendableKlass
 }
+
+// CHECK-LABEL: begin running test 1 of 1 on isolated_variable_test_1: sil-isolation-info-inference with: @trace[0]
+// CHECK-NEXT: Input Value:   %2 = apply %1(%0) : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
+// CHECK-NEXT: Isolation: disconnected
+// CHECK-NEXT: end running test 1 of 1 on isolated_variable_test_1: sil-isolation-info-inference with: @trace[0]
+sil [ossa] @isolated_variable_test_1 : $@convention(thin) @async () -> () {
+bb0:
+  specify_test "sil-isolation-info-inference @trace[0]"
+  %0 = enum $Optional<MyActor>, #Optional.none
+  %1 = function_ref @useOptionalActor : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
+  %2 = apply %1(%0) : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
+  //debug_value [trace] %1 : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
+  debug_value [trace] %2 : $NonSendableKlass
+  destroy_value %2 : $NonSendableKlass
+  %9999 = tuple ()
+  return %9999 : $()
+}
+
+sil @$s5infer7MyActorC11doSomethingAA16NonSendableKlassCyYaF : $@convention(method) @async (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
+
+// CHECK-LABEL: begin running test 1 of 1 on isolated_variable_test_2:
+// CHECK-NEXT: First Value:   %3 = apply %2(%0) : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
+// CHECK-NEXT: First Isolation: 'self'-isolated
+// CHECK-NEXT: Second Value:   %6 = apply %4(%5) : $@convention(method) @async (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
+// CHECK-NEXT: Second Isolation: 'self'-isolated
+// CHECK-NEXT: Merged Isolation: 'self'-isolated
+// CHECK-NEXT: end running test 1 of 1 on isolated_variable_test_2: sil-isolation-info-merged-inference with: @trace[0], @trace[1]
+sil [ossa] @isolated_variable_test_2 : $@convention(thin) @async (@guaranteed Optional<MyActor>) -> () {
+bb0(%0 : @guaranteed $Optional<MyActor>):
+  debug_value %0 : $Optional<MyActor>, let, name "self"
+  specify_test "sil-isolation-info-merged-inference @trace[0] @trace[1]"
+  %1 = function_ref @useOptionalActor : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
+  %2 = apply %1(%0) : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
+  %3 = function_ref @$s5infer7MyActorC11doSomethingAA16NonSendableKlassCyYaF : $@convention(method) @async (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
+  %0a = unchecked_enum_data %0 : $Optional<MyActor>, #Optional.some!enumelt
+  %4 = apply %3(%0a) : $@convention(method) @async (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
+  debug_value [trace] %2 : $NonSendableKlass
+  debug_value [trace] %4 : $NonSendableKlass
+  destroy_value %2 : $NonSendableKlass
+  destroy_value %4 : $NonSendableKlass
+  %9999 = tuple ()
+  return %9999 : $()
+}
+
+// CHECK-LABEL: begin running test 1 of 1 on isolated_variable_test_3:
+// CHECK-NEXT: First Value:   %4 = apply %2(%3) : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
+// CHECK-NEXT: First Isolation: 'self'-isolated
+// CHECK-NEXT: Second Value:   %6 = apply %5(%0) : $@convention(method) @async (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
+// CHECK-NEXT: Second Isolation: 'self'-isolated
+// CHECK-NEXT: Merged Isolation: 'self'-isolated
+// CHECK-NEXT: end running test 1 of 1 on isolated_variable_test_3: sil-isolation-info-merged-inference with: @trace[0], @trace[1]
+sil [ossa] @isolated_variable_test_3 : $@convention(thin) @async (@guaranteed MyActor) -> () {
+bb0(%0 : @guaranteed $MyActor):
+  debug_value %0 : $MyActor, let, name "self"
+  specify_test "sil-isolation-info-merged-inference @trace[0] @trace[1]"
+  %1 = function_ref @useOptionalActor : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
+  %0a = enum $Optional<MyActor>, #Optional.some!enumelt, %0 : $MyActor
+  %2 = apply %1(%0a) : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
+  %3 = function_ref @$s5infer7MyActorC11doSomethingAA16NonSendableKlassCyYaF : $@convention(method) @async (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
+  %4 = apply %3(%0) : $@convention(method) @async (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
+  debug_value [trace] %2 : $NonSendableKlass
+  debug_value [trace] %4 : $NonSendableKlass
+  destroy_value %2 : $NonSendableKlass
+  destroy_value %4 : $NonSendableKlass
+  %9999 = tuple ()
+  return %9999 : $()
+}
+
+// CHECK-LABEL: begin running test 1 of 1 on isolated_variable_test_4:
+// CHECK-NEXT: First Value:   %8 = apply %2(%7) : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
+// CHECK-NEXT: First Isolation: 'self'-isolated
+// CHECK-NEXT: Second Value:   %10 = apply %9(%0) : $@convention(method) @async (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
+// CHECK-NEXT: Second Isolation: 'self'-isolated
+// CHECK-NEXT: Merged Isolation: 'self'-isolated
+// CHECK-NEXT: end running test 1 of 1 on isolated_variable_test_4: sil-isolation-info-merged-inference with: @trace[0], @trace[1]
+sil [ossa] @isolated_variable_test_4 : $@convention(thin) @async (@guaranteed MyActor) -> () {
+bb0(%0 : @guaranteed $MyActor):
+  debug_value %0 : $MyActor, let, name "self"
+  specify_test "sil-isolation-info-merged-inference @trace[0] @trace[1]"
+  %1 = function_ref @useOptionalActor : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
+  %0a = init_existential_ref %0 : $MyActor : $MyActor, $AnyObject
+  %0b = unconditional_checked_cast %0a : $AnyObject to MyActor
+  %0c = unchecked_ref_cast %0b : $MyActor to $AnyObject
+  %0d = unchecked_ref_cast %0c : $AnyObject to $MyActor
+  %0e = enum $Optional<MyActor>, #Optional.some!enumelt, %0d : $MyActor
+  %2 = apply %1(%0e) : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
+  %3 = function_ref @$s5infer7MyActorC11doSomethingAA16NonSendableKlassCyYaF : $@convention(method) @async (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
+  %4 = apply %3(%0) : $@convention(method) @async (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
+  debug_value [trace] %2 : $NonSendableKlass
+  debug_value [trace] %4 : $NonSendableKlass
+  destroy_value %2 : $NonSendableKlass
+  destroy_value %4 : $NonSendableKlass
+  %9999 = tuple ()
+  return %9999 : $()
+}