[region-isolation] When inferring AST arg nums from SIL operand numbers, ignoring indirect operands.

Otherwise, we get off by one errors.

NOTE: I removed the assert that this originally hit since it is possible for us
to perhaps hit other issues and it would be better to just emit a suboptimal
error than crashing. With time, I will probably make it so if we miss we emit a
"compiler couldn't understand error".

rdar://124478890

Author: gottesmm

include/swift/SIL/ApplySite.h

@@ -811,6 +811,15 @@ class FullApplySite : public ApplySite {
     }
   }
 
+  /// Return the applied argument without indirect results.
+  unsigned getAppliedArgIndexWithoutIndirectResult(const Operand &oper) const {
+    assert(oper.getUser() == **this);
+    assert(isArgumentOperand(oper));
+
+    return oper.getOperandNumber() - getOperandIndexOfFirstArgument() -
+           getNumIndirectSILResults() - getNumIndirectSILErrorResults();
+  }
+
   static FullApplySite getFromOpaqueValue(void *p) { return FullApplySite(p); }
 
   static bool classof(const SILInstruction *inst) {

lib/SILOptimizer/Analysis/RegionAnalysis.cpp

@@ -957,10 +957,18 @@ void InferredCallerArgumentTypeInfo::initForApply(const Operand *op,
     unsigned argNum = [&]() -> unsigned {
       if (fai.isCalleeOperand(*op))
         return op->getOperandNumber();
-      return fai.getAppliedArgIndex(*op);
+      return fai.getAppliedArgIndexWithoutIndirectResult(*op);
     }();
-    assert(argNum < sourceApply->getArgs()->size());
-    foundExpr = getFoundExprForParam(sourceApply, argNum);
+
+    // If something funny happened and we get an arg num that is larger than our
+    // num args... just return nullptr so we emit an error using our initial
+    // foundExpr.
+    //
+    // TODO: We should emit a "I don't understand error" so this gets reported
+    // to us.
+    if (argNum < sourceApply->getArgs()->size()) {
+      foundExpr = getFoundExprForParam(sourceApply, argNum);
+    }
   }
 
   auto inferredArgType =

lib/SILOptimizer/Mandatory/TransferNonSendable.cpp

@@ -72,9 +72,13 @@ static Expr *inferArgumentExprFromApplyExpr(ApplyExpr *sourceApply,
     unsigned argNum = [&]() -> unsigned {
       if (fai.isCalleeOperand(*op))
         return op->getOperandNumber();
-      return fai.getAppliedArgIndex(*op);
+      return fai.getAppliedArgIndexWithoutIndirectResult(*op);
     }();
-    assert(argNum < sourceApply->getArgs()->size());
+
+    // Something happened that we do not understand.
+    if (argNum >= sourceApply->getArgs()->size()) {
+      return nullptr;
+    }
 
     foundExpr = sourceApply->getArgs()->getExpr(argNum);
 

test/Concurrency/transfernonsendable_global_actor.swift

@@ -147,3 +147,23 @@ private struct StructContainingValue { // expected-complete-note 2{{}}
 
   useValue(x)
 }
+
+struct Clock {
+  public func measure<T>(
+    _ work: () async throws -> T
+  ) async rethrows -> T {
+    try await work()
+  }
+
+  public func sleep<T>() async throws -> T { fatalError() }
+}
+
+// We used to crash when inferring the type for the diagnostic below.
+@MainActor func testIndirectParametersHandledCorrectly() async {
+  let c = Clock()
+  let _: Int = await c.measure { // expected-tns-warning {{main actor-isolated value of type '() async -> Int' transferred to nonisolated context}}
+    // expected-complete-warning @-1 {{passing argument of non-sendable type '() async -> Int' outside of main actor-isolated context may introduce data races}}
+    // expected-complete-note @-2 {{a function type must be marked '@Sendable' to conform to 'Sendable'}}
+    try! await c.sleep()
+  }
+}