Opaque archetypes specializer: Fix cast of nested types

Author: aschwaighofer

lib/SILOptimizer/Transforms/SpecializeOpaqueArchetypes.cpp

@@ -326,8 +326,19 @@ class OpaqueSpecializerCloner
           loc, opd, type, /*withoutActuallyEscaping*/ false);
     } else if (opd->getType().isTrivial(CurFn)) {
       return getBuilder().createUncheckedTrivialBitCast(loc, opd, type);
-    } else {
+    } else if (opd->getType().isObject()) {
       return getBuilder().createUncheckedRefCast(loc, opd, type);
+    } else {
+      // This could be improved upon by recursively recomposing the type.
+      auto *stackLoc = getBuilder().createAllocStack(loc, type);
+      auto *addr =
+          getBuilder().createUncheckedAddrCast(loc, stackLoc, opd->getType());
+      getBuilder().createTrivialStoreOr(loc, addr, opd,
+                                        StoreOwnershipQualifier::Init);
+      SILValue res = getBuilder().createTrivialLoadOr(
+          loc, addr, LoadOwnershipQualifier::Take);
+      getBuilder().createDeallocStack(loc, stackLoc);
+      return res;
     }
   }
 
@@ -394,24 +405,7 @@ void OpaqueSpecializerCloner::insertOpaqueToConcreteAddressCasts(
       auto argIdx = apply.getCalleeArgIndex(opd);
       auto argType = substConv.getSILArgumentType(argIdx);
       if (argType.getASTType() != opd.get()->getType().getASTType()) {
-        if (argConv.isIndirectConvention()) {
-          auto cast = getBuilder().createUncheckedAddrCast(apply.getLoc(),
-                                                           opd.get(), argType);
-          opd.set(cast);
-        } else if (argType.is<SILFunctionType>()) {
-          auto cast = getBuilder().createConvertFunction(
-              apply.getLoc(), opd.get(), argType,
-              /*withoutActuallyEscaping*/ false);
-          opd.set(cast);
-        } else if (argType.isTrivial(getBuilder().getFunction())) {
-          auto cast = getBuilder().createUncheckedTrivialBitCast(
-              apply.getLoc(), opd.get(), argType);
-          opd.set(cast);
-        } else {
-          auto cast = getBuilder().createUncheckedRefCast(apply.getLoc(),
-                                                          opd.get(), argType);
-          opd.set(cast);
-        }
+        opd.set(createCast(apply.getLoc(), opd.get(), argType));
       }
       ++idx;
     }

test/SILOptimizer/specialize_opaque_type_archetypes.swift

@@ -374,16 +374,30 @@ public func testResilientInlinablePropertyCallsResilientInlinable() {
 // RESILIENT:  apply [[FUN]]([[RES]], %0)
 
 
-protocol P4 {
+public protocol P4 {
   associatedtype AT
   func foo(_ x: Int64) -> AT
+  func test()
 }
+
 struct PA : P4 {
   func foo(_ x: Int64)  -> some P {
     return Int64(x)
   }
 }
 
+// CHECK-LABEL: sil private [transparent] [thunk] @$s1A2PAVAA2P4A2aDP4testyyFTW
+// CHECK:   [[V:%.*]] = load %0 : $*PA
+// CHECK:   [[F:%.*]] = function_ref @$s1A2PAV4testyyF
+// CHECK:   apply [[F]]([[V]])
+
+// CHECK-LABEL: sil hidden @$s1A2PAV4testyyF : $@convention(method) (PA) -> ()
+// CHECK:   [[V:%.*]] = integer_literal $Builtin.Int64, 5
+// CHECK:   [[I:%.*]] = struct $Int64 ([[V]] : $Builtin.Int64)
+// CHECK:   [[F:%.*]] = function_ref @$s1A4usePyyxAA1PRzlFs5Int64V_Tg5
+// CHECK:   apply [[F]]([[I]]) : $@convention(thin) (Int64) -> ()
+// CHECK:   apply [[F]]([[I]]) : $@convention(thin) (Int64) -> ()
+
 @inline(never)
 func testIt<T>(cl: (Int64) throws -> T) {
  do {
@@ -443,3 +457,11 @@ public func testTuple() {
   useP(t.0)
   useP(t.1)
 }
+
+extension PA {
+  func test() {
+    var p = (foo, foo)
+    useP(p.0(5))
+    useP(p.1(5))
+  }
+}