Optimizer: use formal types instead of SIL types for classifying dynamic casts.

Casts always work with formal rather than lowered types.
This fixes a potential bug when lowered types are different than formal types, like function types.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBuiltin.swift

@@ -269,10 +269,8 @@ private func typesOfValuesAreEqual(_ lhs: Value, _ rhs: Value, in function: Func
     return nil
   }
 
-  let lhsMetatype = lhsExistential.metatype.type
-  let rhsMetatype = rhsExistential.metatype.type
-  let lhsTy = lhsMetatype.loweredInstanceTypeOfMetatype(in: function)
-  let rhsTy = rhsMetatype.loweredInstanceTypeOfMetatype(in: function)
+  let lhsTy = lhsExistential.metatype.type.canonicalType.instanceTypeOfMetatype
+  let rhsTy = rhsExistential.metatype.type.canonicalType.instanceTypeOfMetatype
   if lhsTy.isDynamicSelf != rhsTy.isDynamicSelf {
     return nil
   }
@@ -288,14 +286,20 @@ private func typesOfValuesAreEqual(_ lhs: Value, _ rhs: Value, in function: Func
     //   ((Int, Int) -> ())
     //   (((Int, Int)) -> ())
     //
-    if lhsMetatype == rhsMetatype {
+    if lhsTy == rhsTy {
       return true
     }
     // Comparing types of different classes which are in a sub-class relation is not handled by the
     // cast optimizer (below).
     if lhsTy.isClass && rhsTy.isClass && lhsTy.nominal != rhsTy.nominal {
       return false
     }
+
+    // Failing function casts are not supported by the cast optimizer (below).
+    // (Reason: "Be conservative about function type relationships we may add in the future.")
+    if lhsTy.isFunction && rhsTy.isFunction && lhsTy != rhsTy && !lhsTy.hasArchetype && !rhsTy.hasArchetype {
+      return false
+    }
   }
 
   // If casting in either direction doesn't work, the types cannot be equal.

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -899,7 +899,9 @@ func getGlobalInitialization(
   return nil
 }
 
-func canDynamicallyCast(from sourceType: Type, to destType: Type, in function: Function, sourceTypeIsExact: Bool) -> Bool? {
+func canDynamicallyCast(from sourceType: CanonicalType, to destType: CanonicalType,
+                        in function: Function, sourceTypeIsExact: Bool
+) -> Bool? {
   switch classifyDynamicCastBridged(sourceType.bridged, destType.bridged, function.bridged, sourceTypeIsExact) {
     case .willSucceed: return true
     case .maySucceed:  return nil

include/swift/SILOptimizer/OptimizerBridging.h

@@ -403,7 +403,7 @@ enum class BridgedDynamicCastResult {
   willFail
 };
 
-BridgedDynamicCastResult classifyDynamicCastBridged(BridgedType sourceTy, BridgedType destTy,
+BridgedDynamicCastResult classifyDynamicCastBridged(BridgedCanType sourceTy, BridgedCanType destTy,
                                                     BridgedFunction function,
                                                     bool sourceTypeIsExact);
 

lib/SILOptimizer/PassManager/PassManager.cpp

@@ -2120,7 +2120,7 @@ bool BeginApply_canInline(BridgedInstruction beginApply) {
   return swift::SILInliner::canInlineBeginApply(beginApply.getAs<BeginApplyInst>());
 }
 
-BridgedDynamicCastResult classifyDynamicCastBridged(BridgedType sourceTy, BridgedType destTy,
+BridgedDynamicCastResult classifyDynamicCastBridged(BridgedCanType sourceTy, BridgedCanType destTy,
                                                     BridgedFunction function,
                                                     bool sourceTypeIsExact) {
   static_assert((int)DynamicCastFeasibility::WillSucceed == (int)BridgedDynamicCastResult::willSucceed);
@@ -2129,8 +2129,8 @@ BridgedDynamicCastResult classifyDynamicCastBridged(BridgedType sourceTy, Bridge
 
   return static_cast<BridgedDynamicCastResult>(
     classifyDynamicCast(function.getFunction()->getModule().getSwiftModule(),
-                        sourceTy.unbridged().getASTType(),
-                        destTy.unbridged().getASTType(),
+                        sourceTy.unbridged(),
+                        destTy.unbridged(),
                         sourceTypeIsExact));
 }
 

test/SILOptimizer/simplify_builtin.sil

@@ -273,7 +273,7 @@ bb0:
 }
 
 // CHECK-LABEL: sil @different_function_metatype2
-// CHECK:         [[R:%.*]] = builtin "is_same_metatype"
+// CHECK:         [[R:%.*]] = integer_literal $Builtin.Int1, 0
 // CHECK:         return [[R]]
 // CHECK:       } // end sil function 'different_function_metatype2'
 sil @different_function_metatype2 : $@convention(thin) () -> Builtin.Int1 {
@@ -286,6 +286,34 @@ bb0:
   return %4 : $Builtin.Int1
 }
 
+// CHECK-LABEL: sil @unknown_function_metatype1 :
+// CHECK:         [[R:%.*]] = builtin "is_same_metatype"
+// CHECK:         return [[R]]
+// CHECK:       } // end sil function 'unknown_function_metatype1'
+sil @unknown_function_metatype1 : $@convention(thin) <T> () -> Builtin.Int1 {
+bb0:
+  %0 = metatype $@thick ((T) -> Bool).Type
+  %1 = metatype $@thick ((Int) -> Bool).Type
+  %2 = init_existential_metatype %0, $@thick Any.Type
+  %3 = init_existential_metatype %1, $@thick Any.Type
+  %4 = builtin "is_same_metatype"(%2, %3) : $Builtin.Int1
+  return %4 : $Builtin.Int1
+}
+
+// CHECK-LABEL: sil @unknown_function_metatype2 :
+// CHECK:         [[R:%.*]] = builtin "is_same_metatype"
+// CHECK:         return [[R]]
+// CHECK:       } // end sil function 'unknown_function_metatype2'
+sil @unknown_function_metatype2 : $@convention(thin) <T> () -> Builtin.Int1 {
+bb0:
+  %0 = metatype $@thick ((Int) -> Bool).Type
+  %1 = metatype $@thick ((T) -> Bool).Type
+  %2 = init_existential_metatype %0, $@thick Any.Type
+  %3 = init_existential_metatype %1, $@thick Any.Type
+  %4 = builtin "is_same_metatype"(%2, %3) : $Builtin.Int1
+  return %4 : $Builtin.Int1
+}
+
 // CHECK-LABEL: sil @same_metatype_dynamic_self
 // CHECK:         [[R:%.*]] = integer_literal $Builtin.Int1, -1
 // CHECK-NEXT:    return [[R]]