DI: Fix transformation of value_metatype inside convenience init in Swift 5 mode

In Swift 5 mode, 'self' in a convenience init has a DynamicSelfType, so
the value_metatype instruction returns a DynamicSelfType metatype.

However, the metatype argument to the constructor is a plain class metatype
because it's an interface type, so we have to "open" it by bitcasting it
to a DynamicSelfType.

Fixes <https://bugs.swift.org/browse/SR-9430>, <rdar://problem/46982573>.

Author: slavapestov

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -834,7 +834,30 @@ void LifetimeChecker::handleLoadForTypeOfSelfUse(const DIMemoryUse &Use) {
         break;
     }
     assert(valueMetatype);
-    auto metatypeArgument = load->getFunction()->getSelfMetadataArgument();
+    SILValue metatypeArgument = load->getFunction()->getSelfMetadataArgument();
+
+    // SILFunction parameter types never have a DynamicSelfType, since it only
+    // makes sense in the context of a given method's body. Since the
+    // value_metatype instruction might produce a DynamicSelfType we have to
+    // cast the metatype argument.
+    //
+    // FIXME: Semantically, we're "opening" the class metatype here to produce
+    // the "opened" DynamicSelfType. Ideally it would be modeled as an opened
+    // archetype associated with the original metatype or class instance value,
+    // instead of as a "global" type.
+    auto metatypeSelfType = metatypeArgument->getType()
+        .castTo<MetatypeType>().getInstanceType();
+    auto valueSelfType = valueMetatype->getType()
+        .castTo<MetatypeType>().getInstanceType();
+    if (metatypeSelfType != valueSelfType) {
+      assert(metatypeSelfType ==
+             cast<DynamicSelfType>(valueSelfType).getSelfType());
+
+      SILBuilderWithScope B(valueMetatype);
+      metatypeArgument = B.createUncheckedTrivialBitCast(
+          valueMetatype->getLoc(), metatypeArgument,
+          valueMetatype->getType());
+    }
     replaceAllSimplifiedUsesAndErase(valueMetatype, metatypeArgument,
                                      [](SILInstruction*) { });
   }

test/SILOptimizer/definite_init_type_of_self_in_convenience_init.swift

@@ -1,12 +1,13 @@
-// RUN: %target-swift-emit-sil -verify %s
+// RUN: %target-swift-emit-sil -swift-version 4 -verify %s
+// RUN: %target-swift-emit-sil -swift-version 5 -verify %s
 
 // Integration test to ensure that `type(of: self)` keeps working in
 // class convenience initializers, even though they are now implemented as
 // allocating entry points.
 
 class C {
-  init() { }
-  init(throwingDesignated: ()) throws {}
+  required init() { }
+  required init(throwingDesignated: ()) throws {}
 
   convenience init(normal: ()) {
     _ = (type(of: self), type(of: self))
@@ -37,4 +38,11 @@ class C {
     }
     _ = (type(of: self), type(of: self))
   }
+
+  convenience init(closureCapture: ()) {
+    let t = type(of: self)
+    let fn = { t.init() }
+    _ = fn()
+    self.init()
+  }
 }