Merge pull request #80578 from eeckstein/isolated-conformance-opt-6.2

[6.2] CastOptimizer: handle isolated conformances

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyCheckedCast.swift

@@ -81,7 +81,9 @@ private extension UnconditionalCheckedCastInst {
       return
     }
     let conformance = sourceFormalType.instanceTypeOfMetatype.checkConformance(to: proto)
-    guard conformance.isValid else {
+    guard conformance.isValid,
+          conformance.matchesActorIsolation(in: parentFunction)
+    else {
       return
     }
 

SwiftCompilerSources/Sources/SIL/ASTExtensions.swift

@@ -54,3 +54,11 @@ extension SubstitutionMap {
     return SubstitutionMap(bridged: method.bridged.getMethodSubstitutions(bridged))
   }
 }
+
+extension Conformance {
+  /// Returns true if the conformance is not isolated or if its isolation matches
+  /// the isolation in `function`.
+  public func matchesActorIsolation(in function: Function) -> Bool {
+    return function.bridged.conformanceMatchesActorIsolation(bridged)
+  }
+}

include/swift/SIL/DynamicCasts.h

@@ -64,11 +64,15 @@ atBest(DynamicCastFeasibility feasibility, DynamicCastFeasibility bestCase) {
 /// Classify the feasibility of a dynamic cast.  The source and target
 /// types should be unlowered formal types.
 DynamicCastFeasibility classifyDynamicCast(
-    ModuleDecl *context,
+    SILFunction *function,
     CanType sourceType, CanType targetType,
     bool isSourceTypeExact = false,
     bool isWholeModuleOpts = false);
 
+/// Returns true if the conformance is not isolated or if its isolation matches
+/// the isolation `inFunction`.
+bool matchesActorIsolation(ProtocolConformanceRef conformance, SILFunction *inFunction);
+
 SILValue emitSuccessfulScalarUnconditionalCast(SILBuilder &B, SILLocation loc,
                                                SILDynamicCastInst inst);
 
@@ -386,7 +390,7 @@ struct SILDynamicCastInst {
 
   DynamicCastFeasibility classifyFeasibility(bool allowWholeModule) const {
     return swift::classifyDynamicCast(
-        getModule().getSwiftModule(),
+        getFunction(),
         getSourceFormalType(), getTargetFormalType(),
         isSourceTypeExact(), allowWholeModule && getModule().isWholeModule());
   }

include/swift/SIL/SILBridging.h

@@ -507,6 +507,7 @@ struct BridgedFunction {
   BRIDGED_INLINE BridgedLinkage getLinkage() const;
   BRIDGED_INLINE void setLinkage(BridgedLinkage linkage) const;
   BRIDGED_INLINE void setIsSerialized(bool isSerialized) const;
+  BRIDGED_INLINE bool conformanceMatchesActorIsolation(BridgedConformance conformance) const;
   bool isTrapNoReturn() const;
   bool isConvertPointerToPointerArgument() const;
   bool isAutodiffVJP() const;

include/swift/SIL/SILBridgingImpl.h

@@ -28,6 +28,7 @@
 #include "swift/Basic/BasicBridging.h"
 #include "swift/Basic/Nullability.h"
 #include "swift/SIL/ApplySite.h"
+#include "swift/SIL/DynamicCasts.h"
 #include "swift/SIL/InstWrappers.h"
 #include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/SILDefaultWitnessTable.h"
@@ -823,6 +824,10 @@ void BridgedFunction::setIsSerialized(bool isSerialized) const {
   getFunction()->setSerializedKind(isSerialized ? swift::IsSerialized : swift::IsNotSerialized);
 }
 
+bool BridgedFunction::conformanceMatchesActorIsolation(BridgedConformance conformance) const {
+  return swift::matchesActorIsolation(conformance.unbridged(), getFunction());
+}
+
 bool BridgedFunction::isResilientNominalDecl(BridgedDeclObj decl) const {
   return decl.getAs<swift::NominalTypeDecl>()->isResilient(getFunction()->getModule().getSwiftModule(),
                                                            getFunction()->getResilienceExpansion());

lib/SIL/Utils/DynamicCasts.cpp

@@ -93,7 +93,7 @@ static CanType unwrapExistential(CanType e) {
 /// into an existential type by performing a static check
 /// of protocol conformances if it is possible.
 static DynamicCastFeasibility
-classifyDynamicCastToProtocol(CanType source, CanType target,
+classifyDynamicCastToProtocol(SILFunction *function, CanType source, CanType target,
                               bool isWholeModuleOpts) {
   assert(target.isExistentialType() &&
          "target should be an existential type");
@@ -115,8 +115,12 @@ classifyDynamicCastToProtocol(CanType source, CanType target,
 
   // If checkConformance() returns a valid conformance, then all conditional
   // requirements were satisfied.
-  if (checkConformance(source, TargetProtocol))
+  if (auto conformance = checkConformance(source, TargetProtocol)) {
+    if (!matchesActorIsolation(conformance, function))
+      return DynamicCastFeasibility::MaySucceed;
+
     return DynamicCastFeasibility::WillSucceed;
+  }
 
   auto *SourceNominalTy = source.getAnyNominal();
   if (!SourceNominalTy)
@@ -468,7 +472,7 @@ static bool isCFBridgingConversion(CanType sourceFormalType,
 
 /// Try to classify the dynamic-cast relationship between two types.
 DynamicCastFeasibility
-swift::classifyDynamicCast(ModuleDecl *M,
+swift::classifyDynamicCast(SILFunction *function,
                            CanType source,
                            CanType target,
                            bool isSourceTypeExact,
@@ -481,19 +485,20 @@ swift::classifyDynamicCast(ModuleDecl *M,
 
   auto sourceObject = source.getOptionalObjectType();
   auto targetObject = target.getOptionalObjectType();
+  ModuleDecl *M = function->getModule().getSwiftModule();
 
   // A common level of optionality doesn't affect the feasibility,
   // except that we can't fold things to failure because nil inhabits
   // both types.
   if (sourceObject && targetObject) {
-    return atWorst(classifyDynamicCast(M, sourceObject, targetObject),
+    return atWorst(classifyDynamicCast(function, sourceObject, targetObject),
                    DynamicCastFeasibility::MaySucceed);
 
   // Casting to a more optional type follows the same rule unless we
   // know that the source cannot dynamically be an optional value,
   // in which case we'll always just cast and inject into an optional.
   } else if (targetObject) {
-    auto result = classifyDynamicCast(M, source, targetObject,
+    auto result = classifyDynamicCast(function, source, targetObject,
                                       /* isSourceTypeExact */ false,
                                       isWholeModuleOpts);
     if (canDynamicallyStoreOptional(source))
@@ -502,12 +507,12 @@ swift::classifyDynamicCast(ModuleDecl *M,
 
   // Casting to a less-optional type can always fail.
   } else if (sourceObject) {
-    auto result = atBest(classifyDynamicCast(M, sourceObject, target,
+    auto result = atBest(classifyDynamicCast(function, sourceObject, target,
                                              /* isSourceTypeExact */ false,
                                              isWholeModuleOpts),
                          DynamicCastFeasibility::MaySucceed);
     if (target.isExistentialType()) {
-      result = atWorst(result, classifyDynamicCastToProtocol(
+      result = atWorst(result, classifyDynamicCastToProtocol(function,
                                    source, target, isWholeModuleOpts));
     }
     return result;
@@ -522,7 +527,7 @@ swift::classifyDynamicCast(ModuleDecl *M,
     // Check conversions from non-protocol types into protocol types.
     if (!source.isExistentialType() &&
         target.isExistentialType())
-      return classifyDynamicCastToProtocol(source, target,
+      return classifyDynamicCastToProtocol(function, source, target,
                                            isWholeModuleOpts);
 
     // Check conversions from protocol types to non-protocol types.
@@ -552,7 +557,7 @@ swift::classifyDynamicCast(ModuleDecl *M,
       // Hashable is not actually a legal existential type right now, but
       // the check doesn't care about that.
       if (auto hashable = getHashableExistentialType(M)) {
-        return classifyDynamicCastToProtocol(source, hashable,
+        return classifyDynamicCastToProtocol(function, source, hashable,
                                              isWholeModuleOpts);
       }
     }
@@ -589,7 +594,7 @@ swift::classifyDynamicCast(ModuleDecl *M,
 
     if (targetMetatype.isAnyExistentialType() && target->isExistentialType()) {
       auto Feasibility =
-          classifyDynamicCastToProtocol(source, target, isWholeModuleOpts);
+          classifyDynamicCastToProtocol(function, source, target, isWholeModuleOpts);
       // Cast from existential metatype to existential metatype may still
       // succeed, even if we cannot prove anything statically.
       if (Feasibility != DynamicCastFeasibility::WillFail ||
@@ -699,7 +704,7 @@ swift::classifyDynamicCast(ModuleDecl *M,
 
         // Combine the result of prior elements with this element type.
         result = std::max(result,
-                          classifyDynamicCast(M,
+                          classifyDynamicCast(function,
                             sourceElt.getType()->getCanonicalType(),
                             targetElt.getType()->getCanonicalType(),
                             isSourceTypeExact,
@@ -758,7 +763,7 @@ swift::classifyDynamicCast(ModuleDecl *M,
       // question there.
       if (bridgedSource) source = bridgedSource;
       if (bridgedTarget) target = bridgedTarget;
-      return classifyDynamicCast(M, source, target, false, isWholeModuleOpts);
+      return classifyDynamicCast(function, source, target, false, isWholeModuleOpts);
     }
 
     // Casts from a class into a non-class can never succeed if the target must
@@ -833,7 +838,7 @@ swift::classifyDynamicCast(ModuleDecl *M,
     if (Type ObjCTy = M->getASTContext().getBridgedToObjC(M, source)) {
       // If the bridged ObjC type is known, check if
       // this type can be cast into target type.
-      return classifyDynamicCast(M,
+      return classifyDynamicCast(function,
           ObjCTy->getCanonicalType(),
           target,
           /* isSourceTypeExact */ false, isWholeModuleOpts);
@@ -861,16 +866,16 @@ swift::classifyDynamicCast(ModuleDecl *M,
         // Arrays and sets.
         if (sourceStruct->isArray() || sourceStruct->isSet()) {
           auto valueFeasibility =
-            classifyDynamicCast(M, sourceArgs[0], targetArgs[0]);
+            classifyDynamicCast(function, sourceArgs[0], targetArgs[0]);
           return atWorst(valueFeasibility,
                          DynamicCastFeasibility::MaySucceed);
 
         // Dictionaries.
         } else if (sourceStruct->isDictionary()) {
           auto keyFeasibility =
-            classifyDynamicCast(M, sourceArgs[0], targetArgs[0]);
+            classifyDynamicCast(function, sourceArgs[0], targetArgs[0]);
           auto valueFeasibility =
-            classifyDynamicCast(M, sourceArgs[1], targetArgs[1]);
+            classifyDynamicCast(function, sourceArgs[1], targetArgs[1]);
           return atWorst(atBest(keyFeasibility, valueFeasibility),
                          DynamicCastFeasibility::MaySucceed);
         }
@@ -881,6 +886,25 @@ swift::classifyDynamicCast(ModuleDecl *M,
   return DynamicCastFeasibility::WillFail;
 }
 
+bool swift::matchesActorIsolation(ProtocolConformanceRef conformance, SILFunction *inFunction) {
+  return !conformance.forEachIsolatedConformance([&](ProtocolConformanceRef isolatedConf) -> bool {
+    if (!isolatedConf.isConcrete())
+      return false;
+
+    ActorIsolation isolation = isolatedConf.getConcrete()->getIsolation();
+    if (isolation.isNonisolated())
+      return false;
+
+    if (isolation.isGlobalActor()) {
+      if (auto functionIsolation = inFunction->getActorIsolation()) {
+        if (isolation == functionIsolation.value())
+          return false;
+      }
+    }
+    return true;
+  });
+}
+
 static unsigned getOptionalDepth(CanType type) {
   unsigned depth = 0;
   while (CanType objectType = type.getOptionalObjectType()) {
@@ -1221,7 +1245,7 @@ swift::emitSuccessfulScalarUnconditionalCast(SILBuilder &B, ModuleDecl *M,
                                              CanType sourceFormalType,
                                              CanType targetFormalType,
                                              SILInstruction *existingCast) {
-  assert(classifyDynamicCast(M, sourceFormalType, targetFormalType)
+  assert(classifyDynamicCast(&B.getFunction(), sourceFormalType, targetFormalType)
            == DynamicCastFeasibility::WillSucceed);
 
   // Casts to/from existential types cannot be further improved.
@@ -1258,7 +1282,7 @@ bool swift::emitSuccessfulIndirectUnconditionalCast(
     SILBuilder &B, ModuleDecl *M, SILLocation loc, SILValue src,
     CanType sourceFormalType, SILValue dest, CanType targetFormalType,
     SILInstruction *existingCast) {
-  assert(classifyDynamicCast(M, sourceFormalType, targetFormalType)
+  assert(classifyDynamicCast(&B.getFunction(), sourceFormalType, targetFormalType)
            == DynamicCastFeasibility::WillSucceed);
 
   assert(src->getType().isAddress());

lib/SILOptimizer/Utils/CastOptimizer.cpp

@@ -1482,6 +1482,9 @@ static bool optimizeStaticallyKnownProtocolConformance(
     if (Conformance.isInvalid())
       return false;
 
+    if (!matchesActorIsolation(Conformance, Inst->getFunction()))
+      return false;
+
     auto layout = TargetType->getExistentialLayout();
     if (layout.getProtocols().size() != 1)
       return false;

lib/SILOptimizer/Utils/ConstExpr.cpp

@@ -1874,7 +1874,7 @@ ConstExprFunctionState::evaluateInstructionAndGetNext(
     CanType targetType = substituteGenericParamsAndSimplify(
         checkedCastInst->getTargetFormalType());
     DynamicCastFeasibility castResult = classifyDynamicCast(
-        inst->getModule().getSwiftModule(), sourceType, targetType);
+        inst->getFunction(), sourceType, targetType);
     if (castResult == DynamicCastFeasibility::MaySucceed) {
       return {std::nullopt, getUnknown(evaluator, inst->asSILNode(),
                                        UnknownReason::UnknownCastResult)};

lib/SILOptimizer/Utils/OptimizerBridging.cpp

@@ -530,10 +530,7 @@ BridgedDynamicCastResult classifyDynamicCastBridged(BridgedCanType sourceTy, Bri
   static_assert((int)DynamicCastFeasibility::WillFail    == (int)BridgedDynamicCastResult::willFail);
 
   return static_cast<BridgedDynamicCastResult>(
-    classifyDynamicCast(function.getFunction()->getModule().getSwiftModule(),
-                        sourceTy.unbridged(),
-                        destTy.unbridged(),
-                        sourceTypeIsExact));
+    classifyDynamicCast(function.getFunction(), sourceTy.unbridged(), destTy.unbridged(), sourceTypeIsExact));
 }
 
 BridgedDynamicCastResult classifyDynamicCastBridged(BridgedInstruction inst) {

test/SILOptimizer/constant_propagation_casts_ossa.sil

@@ -1,7 +1,14 @@
-// RUN: %target-sil-opt -enable-sil-verify-all %s -diagnostic-constant-propagation | %FileCheck %s
+// RUN: %target-sil-opt -enable-sil-verify-all %s -diagnostic-constant-propagation -enable-experimental-feature IsolatedConformances | %FileCheck %s
+
+// REQUIRES: swift_feature_IsolatedConformances
+// REQUIRES: concurrency
+
 sil_stage canonical
 
-//import Swift
+import Builtin
+import Swift
+import _Concurrency
+import SwiftShims
 
 class Klass {
 }
@@ -12,6 +19,15 @@ class SubKlass : Klass {
 class NoSubKlass {
 }
 
+protocol P {
+  func f() -> Int
+}
+
+struct X : @MainActor P {
+  func f() -> Int
+  init()
+}
+
 sil [noinline] @blackhole1 : $@convention(thin) (@guaranteed SubKlass) -> ()
 sil [noinline] @blackhole2 : $@convention(thin) (@guaranteed NoSubKlass) -> ()
 
@@ -94,3 +110,26 @@ bb3:
   return %r : $()
 }
 
+// CHECK-LABEL: sil [ossa] @isolated_conf_ucca :
+// CHECK:         unconditional_checked_cast_addr
+// CHECK-LABEL: } // end sil function 'isolated_conf_ucca'
+sil [ossa] @isolated_conf_ucca : $@convention(thin) (@in X) -> @out P {
+bb0(%0 : $*P, %1 : $*X):
+  unconditional_checked_cast_addr X in %1 to any P in %0
+  %2 = tuple ()
+  return %2
+}
+
+// CHECK-LABEL: sil [ossa] @isolated_conf_ccab :
+// CHECK:         checked_cast_addr_br
+// CHECK-LABEL: } // end sil function 'isolated_conf_ccab'
+sil [ossa] @isolated_conf_ccab : $@convention(thin) (@in X) -> @out P {
+bb0(%0 : $*P, %1 : $*X):
+  checked_cast_addr_br take_always X in %1 to any P in %0, bb1, bb2
+bb1:
+  %2 = tuple ()
+  return %2
+bb2:
+  unreachable
+}
+