Merge pull request swiftlang#37936 from hborla/reabstractable-wrapped-value

[SILGen] Fix a crash when a wrapped property initial value has a re-abstractable type.

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 { }
+}