[region-isolation] Add a SILIsolationInfo::isNonSendableType API that takes CanTypes and use it to avoid needing to lower certain CanTypes before performing the query.

rdar://138667211

Author: gottesmm

include/swift/SILOptimizer/Utils/SILIsolationInfo.h

@@ -434,17 +434,21 @@ class SILIsolationInfo {
     return {};
   }
 
+  static bool isNonSendableType(SILType type, SILFunction *fn) {
+    return isNonSendableType(type.getASTType(), fn);
+  }
+
+  static bool isNonSendableType(SILValue value) {
+    return isNonSendableType(value->getType(), value->getFunction());
+  }
+
   /// A helper that is used to ensure that we treat certain builtin values as
   /// non-Sendable that the AST level otherwise thinks are non-Sendable.
   ///
   /// E.x.: Builtin.RawPointer and Builtin.NativeObject
   ///
   /// TODO: Fix the type checker.
-  static bool isNonSendableType(SILType type, SILFunction *fn);
-
-  static bool isNonSendableType(SILValue value) {
-    return isNonSendableType(value->getType(), value->getFunction());
-  }
+  static bool isNonSendableType(CanType type, SILFunction *fn);
 
   bool hasSameIsolation(ActorIsolation actorIsolation) const;
 

lib/SILOptimizer/Mandatory/SendNonSendable.cpp

@@ -1668,12 +1668,11 @@ bool SentNeverSendableDiagnosticInferrer::initForSendingPartialApply(
     auto *decl = capture.getDecl();
     auto type = decl->getInterfaceType()->getCanonicalType();
     type = pai->getFunction()->mapTypeIntoContext(type)->getCanonicalType();
-    auto silType = SILType::getPrimitiveObjectType(type);
-    if (!SILIsolationInfo::isNonSendableType(silType, pai->getFunction()))
+    if (!SILIsolationInfo::isNonSendableType(type, pai->getFunction()))
       continue;
 
     auto *fromDC = decl->getInnermostDeclContext();
-    auto *nom = silType.getNominalOrBoundGenericNominal();
+    auto *nom = type.getNominalOrBoundGenericNominal();
     if (nom && fromDC) {
       if (auto diagnosticBehavior =
               getConcurrencyDiagnosticBehaviorLimit(nom, fromDC)) {

lib/SILOptimizer/Utils/SILIsolationInfo.cpp

@@ -1215,18 +1215,18 @@ void SILIsolationInfo::printForOneLineLogging(llvm::raw_ostream &os) const {
 //
 // NOTE: We special case RawPointer and NativeObject to ensure they are
 // treated as non-Sendable and strict checking is applied to it.
-bool SILIsolationInfo::isNonSendableType(SILType type, SILFunction *fn) {
+bool SILIsolationInfo::isNonSendableType(CanType type, SILFunction *fn) {
   // Treat Builtin.NativeObject, Builtin.RawPointer, and Builtin.BridgeObject as
   // non-Sendable.
-  if (type.getASTType()->is<BuiltinNativeObjectType>() ||
-      type.getASTType()->is<BuiltinRawPointerType>() ||
-      type.getASTType()->is<BuiltinBridgeObjectType>()) {
+  if (type->is<BuiltinNativeObjectType>() ||
+      type->is<BuiltinRawPointerType>() ||
+      type->is<BuiltinBridgeObjectType>()) {
     return true;
   }
 
   // Treat Builtin.SILToken as Sendable. It cannot escape from the current
   // function. We should change isSendable to hardwire this.
-  if (type.getASTType()->is<SILTokenType>()) {
+  if (type->is<SILTokenType>()) {
     return false;
   }
 
@@ -1237,12 +1237,17 @@ bool SILIsolationInfo::isNonSendableType(SILType type, SILFunction *fn) {
   // getConcurrencyDiagnosticBehavior could cause us to prevent a
   // "preconcurrency" unneeded diagnostic when just using Sendable values. We
   // only want to trigger that if we analyze a non-Sendable type.
-  if (type.isSendable(fn))
+  if (type->isSendableType())
     return false;
 
   // Grab out behavior. If it is none, then we have a type that we want to treat
   // as non-Sendable.
-  auto behavior = type.getConcurrencyDiagnosticBehavior(fn);
+  auto declRef = fn->getDeclRef();
+  if (!declRef)
+    return {};
+
+  auto *fromDC = declRef.getInnermostDeclContext();
+  auto behavior = type->getConcurrencyDiagnosticBehaviorLimit(fromDC);
   if (!behavior)
     return true;
 

test/Concurrency/transfernonsendable.swift

@@ -1907,7 +1907,7 @@ func offByOneWithImplicitPartialApply() {
   }
 }
 
-protocol Progress {
+protocol Progress { // expected-note {{}}
   associatedtype AssocType
   var x: AssocType { get }
   func checkCancellation() throws
@@ -1923,3 +1923,17 @@ func testCaptureDiagnosticMapsTypeIntoContext<T : Progress>(_ x: NonSendableKlas
     }
   }
 }
+
+// We used to crash here since we were using an API that wanted a SIL Type and
+// we were creating a SILType from a CanType that needed to be lowered.
+func testUseCanTypeNonSendableCheckAPI(y: any Progress) async {
+  @Sendable func test() {
+    print(y) // expected-warning {{capture of 'y' with non-sendable type 'any Progress' in a `@Sendable` local function}}
+  }
+  await withTaskGroup(of: Void.self) { group in
+    group.addTask { // expected-tns-warning {{sending value of non-Sendable type '() async -> ()' risks causing data races}}
+      // expected-tns-note @-1 {{Passing task-isolated value of non-Sendable type '() async -> ()' as a 'sending' parameter to instance method 'addTask(priority:operation:)' risks causing races inbetween task-isolated uses and uses reachable from 'addTask(priority:operation:)'}}
+      test()
+    }
+  }
+}