[DI] Support definite initialization for composed property wrappers.

Use the newly-introduced property wrapper backing initializer function
in definite initialization (DI) to form the assign_by_wrapper
instruction, rather than forming a reference to the (only) property
wrapper's `init(wrappedValue:)`. This allows DI to work on properties
that have multiple, composed property wrappers applied to them.

Author: DougGregor

lib/SILGen/SILGenApply.cpp

@@ -5006,30 +5006,6 @@ RValue SILGenFunction::emitApplyMethod(SILLocation loc, ConcreteDeclRef declRef,
   return emission.apply(C);
 }
 
-RValue SILGenFunction::emitApplyPropertyWrapperAllocator(SILLocation loc,
-                                                          SubstitutionMap subs,
-                                                          SILDeclRef ctorRef,
-                                                          Type wrapperTy,
-                                                    CanAnyFunctionType funcTy) {
-  Callee callee = Callee::forDirect(*this, ctorRef, subs, loc);
-
-  MetatypeType *MTty = MetatypeType::get(wrapperTy);
-  auto metatypeVal = B.createMetatype(loc, getLoweredType(MTty));
-  ManagedValue mtManagedVal = ManagedValue::forUnmanaged(metatypeVal);
-  RValue metatypeRVal(*this, loc, MTty->getCanonicalType(), mtManagedVal);
-
-  ArgumentSource ArgSrc(loc, std::move(metatypeRVal));
-  FormalEvaluationScope writebacks(*this);
-  CallEmission emission(*this, std::move(callee), std::move(writebacks));
-
-  AnyFunctionType::Param selfParam((Type(MTty)), Identifier(),
-                                   ParameterTypeFlags());
-  emission.addSelfParam(loc, std::move(ArgSrc), selfParam, funcTy.getResult());
-
-  RValue RV = emission.apply();
-  return RV;
-}
-
 /// Emit a literal that applies the various initializers.
 RValue SILGenFunction::emitLiteral(LiteralExpr *literal, SGFContext C) {
   ConcreteDeclRef builtinInit;

lib/SILGen/SILGenFunction.h

@@ -1492,12 +1492,6 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                          ArgumentSource &&self, PreparedArguments &&args,
                          SGFContext C);
 
-  RValue emitApplyPropertyWrapperAllocator(SILLocation loc,
-                                            SubstitutionMap subs,
-                                            SILDeclRef ctorRef,
-                                            Type wrapperTy,
-                                            CanAnyFunctionType funcTy);
-
   CleanupHandle emitBeginApply(SILLocation loc, ManagedValue fn,
                                SubstitutionMap subs, ArrayRef<ManagedValue> args,
                                CanSILFunctionType substFnType,

lib/SILGen/SILGenLValue.cpp

@@ -1295,29 +1295,26 @@ namespace {
 
     bool hasPropertyWrapper() const {
       if (auto *VD = dyn_cast<VarDecl>(Storage)) {
-        // FIXME: Handle composition of property wrappers.
-        if (VD->getAttachedPropertyWrappers().size() == 1) {
-          auto wrapperInfo = VD->getAttachedPropertyWrapperTypeInfo(0);
-          
-          // If there is no init(wrapperValue:), we cannot rewrite an
-          // assignment into an initialization.
-          if (!wrapperInfo.wrappedValueInit)
-            return false;
-
-          // If we have a nonmutating setter on a value type, the call
-          // captures all of 'self' and we cannot rewrite an assignment
-          // into an initialization.
-          if (!VD->isSetterMutating() &&
-              VD->getDeclContext()->getSelfNominalTypeDecl() &&
-              VD->isInstanceMember() &&
-              !VD->getDeclContext()->getDeclaredInterfaceType()
-                  ->hasReferenceSemantics()) {
-            return false;
-          }
-
-          return true;
+        // If this is not a wrapper property that can be initialized from
+        // a value of the wrapped type, we can't perform the initialization.
+        auto wrapperInfo = VD->getPropertyWrapperBackingPropertyInfo();
+        if (!wrapperInfo.initializeFromOriginal)
+          return false;
+
+        // If we have a nonmutating setter on a value type, the call
+        // captures all of 'self' and we cannot rewrite an assignment
+        // into an initialization.
+        if (!VD->isSetterMutating() &&
+            VD->getDeclContext()->getSelfNominalTypeDecl() &&
+            VD->isInstanceMember() &&
+            !VD->getDeclContext()->getDeclaredInterfaceType()
+                ->hasReferenceSemantics()) {
+          return false;
         }
+
+        return true;
       }
+
       return false;
     }
 
@@ -1404,25 +1401,32 @@ namespace {
           proj = std::move(SEC).project(SGF, loc, base);
         }
 
-        // Create the allocating initializer function. It captures the metadata.
-        // FIXME: Composition.
-        assert(field->getAttachedPropertyWrappers().size() == 1);
-        auto wrapperInfo = field->getAttachedPropertyWrapperTypeInfo(0);
-        auto ctor = wrapperInfo.wrappedValueInit;
-        SubstitutionMap subs = ValType->getMemberSubstitutionMap(
-                        SGF.getModule().getSwiftModule(), ctor);
-
-        Type ity = ctor->getInterfaceType();
-        AnyFunctionType *substIty =
-          ity.subst(subs)->getCanonicalType()->castTo<AnyFunctionType>();
-
-        auto initRef = SILDeclRef(ctor, SILDeclRef::Kind::Allocator)
-          .asForeign(requiresForeignEntryPoint(ctor));
-        RValue initFuncRV =
-          SGF.emitApplyPropertyWrapperAllocator(loc, subs,initRef,
-                                                ValType,
-                                                CanAnyFunctionType(substIty));
-        ManagedValue initFn = std::move(initFuncRV).getAsSingleValue(SGF, loc);
+        // The property wrapper backing initializer forms an instance of
+        // the backing storage type from a wrapped value.
+        SILDeclRef initConstant(
+            field, SILDeclRef::Kind::PropertyWrapperBackingInitializer);
+        SILValue initFRef = SGF.emitGlobalFunctionRef(loc, initConstant);
+
+        SubstitutionMap initSubs;
+        if (auto genericSig = field->getInnermostDeclContext()
+                ->getGenericSignatureOfContext()) {
+          initSubs = SubstitutionMap::get(
+              genericSig,
+              [&](SubstitutableType *type) {
+                if (auto gp = type->getAs<GenericTypeParamType>()) {
+                  return SGF.F.mapTypeIntoContext(gp);
+                }
+
+                return Type(type);
+              },
+              LookUpConformanceInModule(SGF.SGM.M.getSwiftModule()));
+        }
+
+        PartialApplyInst *initPAI =
+          SGF.B.createPartialApply(loc, initFRef,
+                                   initSubs, ArrayRef<SILValue>(),
+                                   ParameterConvention::Direct_Guaranteed);
+        ManagedValue initFn = SGF.emitManagedRValueWithCleanup(initPAI);
 
         // Create the allocating setter function. It captures the base address.
         auto setterInfo = SGF.getConstantInfo(setter);

test/SILOptimizer/di_property_wrappers.swift

@@ -380,10 +380,43 @@ func testDefaultNilOptIntStruct() {
   // CHECK-NEXT:   .. init nil
 }
 
+@propertyWrapper
+struct Wrapper2<T> {
+  var wrappedValue: T {
+    didSet {
+      print("  .. secondSet \(wrappedValue)")
+    }
+  }
+
+  init(wrappedValue initialValue: T) {
+    print("  .. secondInit \(initialValue)")
+    self.wrappedValue = initialValue
+  }
+}
+
+struct HasComposed {
+  @Wrapper @Wrapper2 var x: Int
+
+  init() {
+    self.x = 17
+  }
+}
+
+func testComposed() {
+  // CHECK: ## Composed
+  print("\n## Composed")
+  _ = HasComposed()
+
+  // CHECK-NEXT: .. secondInit 17
+  // CHECK-NEXT: .. init Wrapper2<Int>(wrappedValue: 17)
+}
+
+
 testIntStruct()
 testIntClass()
 testRefStruct()
 testGenericClass()
 testDefaultInit()
 testOptIntStruct()
 testDefaultNilOptIntStruct()
+testComposed()