[SILGen] Never use a converting initialization when emitting member

initializers if the member is a property wrapper.

This code assumes that the initial value of the member and the result
of initialization are the same type (but differing in abstraction level).
This isn't true for property wrappers because the initial value can be
the wrapped value type, but the result is always the property wrapper
type. Property wrapper types are never reabstractable types anyway, so
the converting initialization isn't necessary.

Author: hborla

lib/SILGen/SILGenConstructor.cpp

@@ -1142,10 +1142,22 @@ void SILGenFunction::emitMemberInitializers(DeclContext *dc,
         // abstraction level. To undo this, we use a converting
         // initialization and rely on the peephole that optimizes
         // out the redundant conversion.
-        auto loweredResultTy = getLoweredType(origType, substType);
-        auto loweredSubstTy = getLoweredType(substType);
+        SILType loweredResultTy;
+        SILType loweredSubstTy;
+
+        // A converting initialization isn't necessary if the member is
+        // a property wrapper. Though the initial value can have a
+        // reabstractable type, the result of the initialization is
+        // always the property wrapper type, which is never reabstractable.
+        bool needsConvertingInit = false;
+        auto *singleVar = varPattern->getSingleVar();
+        if (!(singleVar && singleVar->getOriginalWrappedProperty())) {
+          loweredResultTy = getLoweredType(origType, substType);
+          loweredSubstTy = getLoweredType(substType);
+          needsConvertingInit = loweredResultTy != loweredSubstTy;
+        }
 
-        if (loweredResultTy != loweredSubstTy) {
+        if (needsConvertingInit) {
           Conversion conversion = Conversion::getSubstToOrig(
               origType, substType,
               loweredResultTy);

test/SILGen/property_wrappers.swift

@@ -967,3 +967,18 @@ struct TestAutoclosureComposition {
 
 // CHECK-LABEL: sil_vtable [serialized] TestMyWrapper
 // CHECK: #TestMyWrapper.$useMyWrapper!getter
+
+@propertyWrapper
+struct AutoclosureWrapper<T> {
+  init(wrappedValue: @autoclosure () -> T) {
+    self.wrappedValue = wrappedValue()
+  }
+  var wrappedValue: T
+}
+
+struct TestReabstractableWrappedValue<T1> {
+  struct S<T2> { }
+
+  @AutoclosureWrapper var v: S<T1> = S()
+  init() where T1 == Int { }
+}