[Property wrappers] Fix handling of @autoclosure in init(wrappedValue:)

If the 'wrappedValue:' parameter is an escaping autoclosure, and a
struct property is marked with that property wrapper, the memberwise
initializer of the struct is now synthesized with an escaping
autoclosure for that property.

Author: roop

Diff for: include/swift/AST/Decl.h

@@ -5191,6 +5191,18 @@ class VarDecl : public AbstractStorageDecl {
   /// a suitable `init(initialValue:)`.
   bool isPropertyMemberwiseInitializedWithWrappedType() const;
 
+  /// Whether the innermost property wrapper's initializer's 'wrappedValue' parameter
+  /// is marked with '@autoclosure' and '@escaping'.
+  bool isInnermostPropertyWrapperInitUsesEscapingAutoClosure() const;
+
+  /// Return the interface type of the value used for the 'wrappedValue:'
+  /// parameter when initializing a property wrapper.
+  ///
+  /// If the property has an attached property wrapper and the 'wrappedValue:'
+  /// parameter is an autoclosure, return a function type returning the stored
+  /// value. Otherwise, return the interface type of the stored value.
+  Type getPropertyWrapperInitValueInterfaceType() const;
+
   /// If this property is the backing storage for a property with an attached
   /// property wrapper, return the original property.
   ///

Diff for: include/swift/AST/PropertyWrappers.h

@@ -43,6 +43,10 @@ struct PropertyWrapperTypeInfo {
     HasInitialValueInit
   } wrappedValueInit = NoWrappedValueInit;
 
+  /// Whether the init(wrappedValue:), if it exists, has the wrappedValue
+  /// argument as an escaping autoclosure.
+  bool isWrappedValueInitUsingEscapingAutoClosure = false;
+
   /// The initializer that will be called to default-initialize a
   /// value with an attached property wrapper.
   enum {

Diff for: lib/AST/Decl.cpp

@@ -5930,6 +5930,25 @@ bool VarDecl::isPropertyMemberwiseInitializedWithWrappedType() const {
   return allAttachedPropertyWrappersHaveInitialValueInit();
 }
 
+bool VarDecl::isInnermostPropertyWrapperInitUsesEscapingAutoClosure() const {
+  auto customAttrs = getAttachedPropertyWrappers();
+  if (customAttrs.empty())
+    return false;
+
+  unsigned innermostWrapperIndex = customAttrs.size() - 1;
+  auto typeInfo = getAttachedPropertyWrapperTypeInfo(innermostWrapperIndex);
+  return typeInfo.isWrappedValueInitUsingEscapingAutoClosure;
+}
+
+Type VarDecl::getPropertyWrapperInitValueInterfaceType() const {
+  Type valueInterfaceTy = getValueInterfaceType();
+
+  if (isInnermostPropertyWrapperInitUsesEscapingAutoClosure())
+    return FunctionType::get({}, valueInterfaceTy);
+
+  return valueInterfaceTy;
+}
+
 Identifier VarDecl::getObjCPropertyName() const {
   if (auto attr = getAttrs().getAttribute<ObjCAttr>()) {
     if (auto name = attr->getName())
@@ -6368,8 +6387,11 @@ Expr *swift::findOriginalPropertyWrapperInitialValue(VarDecl *var,
   if (initArg) {
     initArg = initArg->getSemanticsProvidingExpr();
     if (auto autoclosure = dyn_cast<AutoClosureExpr>(initArg)) {
-      initArg =
-          autoclosure->getSingleExpressionBody()->getSemanticsProvidingExpr();
+      if (!var->isInnermostPropertyWrapperInitUsesEscapingAutoClosure()) {
+        // Remove the autoclosure part only for non-escaping autoclosures
+        initArg =
+            autoclosure->getSingleExpressionBody()->getSemanticsProvidingExpr();
+      }
     }
   }
   return initArg;

Diff for: lib/SIL/TypeLowering.cpp

@@ -1895,8 +1895,10 @@ static CanAnyFunctionType getStoredPropertyInitializerInterfaceType(
   // wrapper that was initialized with '=', the stored property initializer
   // will be in terms of the original property's type.
   if (auto originalProperty = VD->getOriginalWrappedProperty()) {
-    if (originalProperty->isPropertyMemberwiseInitializedWithWrappedType())
-      resultTy = originalProperty->getValueInterfaceType()->getCanonicalType();
+    if (originalProperty->isPropertyMemberwiseInitializedWithWrappedType()) {
+      resultTy = originalProperty->getPropertyWrapperInitValueInterfaceType()
+                                     ->getCanonicalType();
+    }
   }
 
   auto sig = DC->getGenericSignatureOfContext();
@@ -1915,8 +1917,7 @@ static CanAnyFunctionType getPropertyWrapperBackingInitializerInterfaceType(
 
   auto *DC = VD->getInnermostDeclContext();
   CanType inputType =
-    VD->getParentPattern()->getType()->mapTypeOutOfContext()
-          ->getCanonicalType();
+    VD->getPropertyWrapperInitValueInterfaceType()->getCanonicalType();
 
   auto sig = DC->getGenericSignatureOfContext();
 

Diff for: lib/SILGen/SILGenConstructor.cpp

@@ -930,7 +930,7 @@ static Type getInitializationTypeInContext(
   if (auto singleVar = pattern->getSingleVar()) {
     if (auto originalProperty = singleVar->getOriginalWrappedProperty()) {
       if (originalProperty->isPropertyMemberwiseInitializedWithWrappedType())
-        interfaceType = originalProperty->getValueInterfaceType();
+        interfaceType = originalProperty->getPropertyWrapperInitValueInterfaceType();
     }
   }
 

Diff for: lib/SILGen/SILGenExpr.cpp

@@ -2397,9 +2397,32 @@ RValue RValueEmitter::visitCaptureListExpr(CaptureListExpr *E, SGFContext C) {
   return visit(E->getClosureBody(), C);
 }
 
+static OpaqueValueExpr *opaqueValueExprToSubstituteForAutoClosure(
+    const AbstractClosureExpr *e) {
+  // When we find an autoclosure that just calls an opaque closure,
+  // this is a case where we've created the opaque closure as a
+  // stand-in for the autoclosure itself. Such an opaque closure is
+  // created when we have a property wrapper's 'init(wrappedValue:)'
+  // taking an autoclosure argument.
+  if (auto ace = dyn_cast<AutoClosureExpr>(e)) {
+    if (auto ce = dyn_cast<CallExpr>(ace->getSingleExpressionBody())) {
+      if (auto ove = dyn_cast<OpaqueValueExpr>(ce->getFn())) {
+        if (!ace->isImplicit() || !ove->isImplicit() || !ove->isPlaceholder())
+          return nullptr;
+
+        if (ace->getType()->isEqual(ove->getType()))
+          return ove;
+      }
+    }
+  }
+  return nullptr;
+}
 
 RValue RValueEmitter::visitAbstractClosureExpr(AbstractClosureExpr *e,
                                                SGFContext C) {
+  if (auto ove = opaqueValueExprToSubstituteForAutoClosure(e))
+    return visitOpaqueValueExpr(ove, C);
+
   // Emit the closure body.
   SGF.SGM.emitClosure(e);
 

Diff for: lib/SILGen/SILGenFunction.cpp

@@ -750,7 +750,8 @@ void SILGenFunction::emitGeneratorFunction(SILDeclRef function, Expr *value,
                                      ctx.getIdentifier("$input_value"),
                                      dc);
     param->setSpecifier(ParamSpecifier::Owned);
-    param->setInterfaceType(function.getDecl()->getInterfaceType());
+    auto vd = cast<VarDecl>(function.getDecl());
+    param->setInterfaceType(vd->getPropertyWrapperInitValueInterfaceType());
 
     params = ParameterList::create(ctx, SourceLoc(), {param}, SourceLoc());
   }
@@ -800,7 +801,7 @@ void SILGenFunction::emitGeneratorFunction(SILDeclRef function, VarDecl *var) {
   // will be in terms of the original property's type.
   if (auto originalProperty = var->getOriginalWrappedProperty()) {
     if (originalProperty->isPropertyMemberwiseInitializedWithWrappedType()) {
-      interfaceType = originalProperty->getValueInterfaceType();
+      interfaceType = originalProperty->getPropertyWrapperInitValueInterfaceType();
     }
   }
 

Diff for: lib/Sema/CodeSynthesis.cpp

@@ -206,6 +206,7 @@ static ConstructorDecl *createImplicitConstructor(NominalTypeDecl *decl,
       accessLevel = std::min(accessLevel, var->getFormalAccess());
 
       auto varInterfaceType = var->getValueInterfaceType();
+      bool isAutoClosure = false;
 
       if (var->getAttrs().hasAttribute<LazyAttr>()) {
         // If var is a lazy property, its value is provided for the underlying
@@ -221,7 +222,11 @@ static ConstructorDecl *createImplicitConstructor(NominalTypeDecl *decl,
         // accept a value of the original property type. Otherwise, the
         // memberwise initializer will be in terms of the backing storage
         // type.
-        if (!var->isPropertyMemberwiseInitializedWithWrappedType()) {
+        if (var->isPropertyMemberwiseInitializedWithWrappedType()) {
+          varInterfaceType = var->getPropertyWrapperInitValueInterfaceType();
+          isAutoClosure =
+            var->isInnermostPropertyWrapperInitUsesEscapingAutoClosure();
+        } else {
           varInterfaceType = backingPropertyType;
         }
       }
@@ -233,6 +238,7 @@ static ConstructorDecl *createImplicitConstructor(NominalTypeDecl *decl,
       arg->setSpecifier(ParamSpecifier::Default);
       arg->setInterfaceType(varInterfaceType);
       arg->setImplicit();
+      arg->setAutoClosure(isAutoClosure);
 
       // Don't allow the parameter to accept temporary pointer conversions.
       arg->setNonEphemeralIfPossible();

Diff for: lib/Sema/TypeCheckPropertyWrapper.cpp

@@ -291,6 +291,42 @@ static SubscriptDecl *findEnclosingSelfSubscript(ASTContext &ctx,
   return subscript;
 }
 
+/// Whether the argument with label 'argumentLabel' in the initializer 'init'
+/// is an escaping autoclosure argument.
+static bool isEscapingAutoclosureArgument(const ConstructorDecl *init,
+                                          Identifier argumentLabel) {
+  if (!init)
+    return false;
+
+  Optional<size_t> parameterIndex = None;
+  auto params = init->getParameters();
+  for (size_t i = 0; i < params->size(); i++) {
+    if (params->get(i)->getArgumentName() == argumentLabel) {
+      parameterIndex = i;
+      break;
+    }
+  }
+
+  if (!parameterIndex.hasValue())
+    return false;
+
+  size_t paramIndex = parameterIndex.getValue();
+  if (!params->get(paramIndex)->isAutoClosure())
+    return false;
+
+  if (auto initTy = init->getInterfaceType()->getAs<AnyFunctionType>()) {
+    if (auto funcTy = initTy->getResult()->getAs<FunctionType>()) {
+      if (funcTy->getNumParams() > paramIndex) {
+        Type paramTy = funcTy->getParams()[paramIndex].getPlainType();
+        if (auto paramFuncTy = paramTy->getAs<FunctionType>())
+          return !paramFuncTy->isNoEscape();
+      }
+    }
+  }
+
+  return false;
+}
+
 llvm::Expected<PropertyWrapperTypeInfo>
 PropertyWrapperTypeInfoRequest::evaluate(
     Evaluator &eval, NominalTypeDecl *nominal) const {
@@ -313,12 +349,16 @@ PropertyWrapperTypeInfoRequest::evaluate(
 
   PropertyWrapperTypeInfo result;
   result.valueVar = valueVar;
-  if (findSuitableWrapperInit(ctx, nominal, valueVar,
-                              PropertyWrapperInitKind::WrappedValue))
+  if (auto init = findSuitableWrapperInit(ctx, nominal, valueVar,
+                              PropertyWrapperInitKind::WrappedValue)) {
     result.wrappedValueInit = PropertyWrapperTypeInfo::HasWrappedValueInit;
-  else if (auto init = findSuitableWrapperInit(
+    result.isWrappedValueInitUsingEscapingAutoClosure =
+      isEscapingAutoclosureArgument(init, ctx.Id_wrappedValue);
+  } else if (auto init = findSuitableWrapperInit(
                ctx, nominal, valueVar, PropertyWrapperInitKind::InitialValue)) {
     result.wrappedValueInit = PropertyWrapperTypeInfo::HasInitialValueInit;
+    result.isWrappedValueInitUsingEscapingAutoClosure =
+      isEscapingAutoclosureArgument(init, ctx.Id_initialValue);
 
     if (init->getLoc().isValid()) {
       auto diag = init->diagnose(diag::property_wrapper_init_initialValue);
@@ -632,13 +672,32 @@ Type swift::computeWrappedValueType(VarDecl *var, Type backingStorageType,
   return wrappedValueType;
 }
 
+static bool isOpaquePlaceholderClosure(const Expr *value) {
+  auto ove = dyn_cast<OpaqueValueExpr>(value);
+  if (!ove || !ove->isPlaceholder())
+    return false;
+
+  if (auto valueFnTy = ove->getType()->getAs<FunctionType>()) {
+    return (valueFnTy->getNumParams() == 0);
+  }
+
+  return false;
+}
+
 Expr *swift::buildPropertyWrapperInitialValueCall(
     VarDecl *var, Type backingStorageType, Expr *value,
     bool ignoreAttributeArgs) {
   // From the innermost wrapper type out, form init(wrapperValue:) calls.
   ASTContext &ctx = var->getASTContext();
   auto wrapperAttrs = var->getAttachedPropertyWrappers();
   Expr *initializer = value;
+  if (var->isInnermostPropertyWrapperInitUsesEscapingAutoClosure() &&
+      isOpaquePlaceholderClosure(value)) {
+    // We can't pass the opaque closure directly as an autoclosure arg.
+    // So we instead pass a CallExpr calling the opaque closure, which
+    // the type checker shall wrap in an AutoClosureExpr.
+    initializer = CallExpr::createImplicit(ctx, value, {}, {});
+  }
   for (unsigned i : llvm::reverse(indices(wrapperAttrs))) {
     Type wrapperType =
       backingStorageType ? computeWrappedValueType(var, backingStorageType, i)

Diff for: lib/Sema/TypeCheckStorage.cpp

@@ -2485,8 +2485,11 @@ PropertyWrapperBackingPropertyInfoRequest::evaluate(Evaluator &evaluator,
 
   // Form the initialization of the backing property from a value of the
   // original property's type.
+  Type origValueInterfaceType = var->getPropertyWrapperInitValueInterfaceType();
+  Type origValueType =
+    var->getDeclContext()->mapTypeIntoContext(origValueInterfaceType);
   OpaqueValueExpr *origValue =
-      new (ctx) OpaqueValueExpr(var->getSourceRange(), var->getType(),
+      new (ctx) OpaqueValueExpr(var->getSourceRange(), origValueType,
                                 /*isPlaceholder=*/true);
   Expr *initializer = buildPropertyWrapperInitialValueCall(
       var, storageType, origValue,