DI: Fix crash when value_metatype was used with a non-class 'self' type

In a constructor, SILGen lowers type(of: self) to a value_metatype
instruction, but 'self' might not have been initialized yet if
this is a convenience initializer, so we replace it with a use of
the 'self' metatype argument.

However getDynamicSelfMetadata() asserts if 'self' is a non-class
type. Since we know we're inside of a proper method here and not a
closure that captured 'self', we can use getSelfArgument() instead.

Fixes https://bugs.swift.org/browse/SR-12665 / rdar://problem/62481587.

Author: slavapestov

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -850,7 +850,7 @@ void LifetimeChecker::handleLoadForTypeOfSelfUse(DIMemoryUse &Use) {
         break;
     }
     assert(valueMetatype);
-    SILValue metatypeArgument = load->getFunction()->getDynamicSelfMetadata();
+    SILValue metatypeArgument = load->getFunction()->getSelfArgument();
 
     // SILFunction parameter types never have a DynamicSelfType, since it only
     // makes sense in the context of a given method's body. Since the

test/SILOptimizer/definite_init_type_of_self_in_convenience_init.swift

@@ -1,5 +1,5 @@
-// RUN: %target-swift-emit-sil -swift-version 4 -verify %s
-// RUN: %target-swift-emit-sil -swift-version 5 -verify %s
+// RUN: %target-swift-emit-sil -swift-version 4 -verify %s | %FileCheck %s
+// RUN: %target-swift-emit-sil -swift-version 5 -verify %s | %FileCheck %s
 
 // Integration test to ensure that `type(of: self)` keeps working in
 // class convenience initializers, even though they are now implemented as
@@ -46,3 +46,63 @@ class C {
     self.init()
   }
 }
+
+protocol P {
+  static var n: Int { get }
+  init(_: Int)
+}
+
+extension P {
+  // FIXME: SILGen inserts an unnecessary copy when 'self' is
+  // address-only.
+  /* init(selfInit: ()) {
+    self.init(type(of: self).n)
+  }
+
+  init(selfAssign: ()) {
+    self = type(of: self).init(0)
+  } */
+}
+
+protocol PA : AnyObject {
+  static var n: Int { get }
+  init(_: Int)
+}
+
+extension PA {
+  init(selfInit: ()) {
+    // This is OK; we can get the type of 'self' from the self metatype
+    // argument.
+    self.init(type(of: self).n)
+  }
+
+  // FIXME: Not yet supported, but should be
+  /* init(selfAssign: ()) {
+    self = type(of: self).init(0)
+  } */
+}
+
+class CC {
+  class var n: Int { 0 }
+  required init(_: Int) {}
+}
+
+protocol PC : CC {}
+
+extension PC {
+  // CHECK-LABEL: sil hidden @$s042definite_init_type_of_self_in_convenience_B02PCPAAE0E4Initxyt_tcfC : $@convention(method) <Self where Self : PC> (@thick Self.Type) -> @owned Self {
+  init(selfInit: ()) {
+    // This is OK; we can get the type of 'self' from the self metatype
+    // argument.
+    self.init(type(of: self).n)
+
+    // CHECK: [[SELF:%.*]] = upcast %0 : $@thick Self.Type to $@thick CC.Type
+    // CHECK: [[INIT:%.*]] = class_method [[SELF]] : $@thick CC.Type, #CC.init!allocator : (CC.Type) -> (Int) -> CC, $@convention(method) (Int, @thick CC.Type) -> @owned CC
+    // CHECK: apply [[INIT]]({{.*}}, [[SELF]]) : $@convention(method) (Int, @thick CC.Type) -> @owned CC
+  }
+
+  // FIXME: Not yet supported, but should be
+  /* init(selfAssign: ()) {
+    self = type(of: self).init(0)
+  } */
+}