[Property Wrappers] Use autoclosure information from CSApply to compute

hborla · hborla · commit a6c33a96117e · 2020-07-13T17:22:29.000-07:00
`VarDecl::getPropertyWrapperInitValueInterfaceType`.
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -5221,10 +5221,6 @@ class VarDecl : public AbstractStorageDecl {
   /// a suitable `init(wrappedValue:)`.
   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.
   ///
diff --git a/include/swift/AST/Expr.h b/include/swift/AST/Expr.h
@@ -4165,16 +4165,20 @@ class PropertyWrapperValuePlaceholderExpr : public Expr {
   SourceRange Range;
   OpaqueValueExpr *Placeholder;
   Expr *WrappedValue;
+  bool IsAutoClosure = false;
 
   PropertyWrapperValuePlaceholderExpr(SourceRange Range, Type Ty,
                                       OpaqueValueExpr *placeholder,
-                                      Expr *wrappedValue)
+                                      Expr *wrappedValue,
+                                      bool isAutoClosure)
       : Expr(ExprKind::PropertyWrapperValuePlaceholder, /*Implicit=*/true, Ty),
-        Range(Range), Placeholder(placeholder), WrappedValue(wrappedValue) {}
+        Range(Range), Placeholder(placeholder), WrappedValue(wrappedValue),
+        IsAutoClosure(isAutoClosure) {}
 
 public:
   static PropertyWrapperValuePlaceholderExpr *
-  create(ASTContext &ctx, SourceRange range, Type ty, Expr *wrappedValue);
+  create(ASTContext &ctx, SourceRange range, Type ty, Expr *wrappedValue,
+         bool isAutoClosure = false);
 
   /// The original wrappedValue initialization expression provided via
   /// \c = on a proprety with attached property wrappers.
@@ -4196,6 +4200,8 @@ class PropertyWrapperValuePlaceholderExpr : public Expr {
     Placeholder = placeholder;
   }
 
+  bool isAutoClosure() const { return IsAutoClosure; }
+
   SourceRange getSourceRange() const { return Range; }
 
   static bool classof(const Expr *E) {
diff --git a/include/swift/AST/PropertyWrappers.h b/include/swift/AST/PropertyWrappers.h
@@ -43,10 +43,6 @@ 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 {
@@ -153,37 +149,24 @@ struct PropertyWrapperBackingPropertyInfo {
   /// '$foo' from `backingVar`.
   VarDecl *storageWrapperVar = nullptr;
 
-  /// When the original default value is specified in terms of an '='
-  /// initializer on the initial property, e.g.,
-  ///
-  /// \code
-  /// @Lazy var i = 17
-  /// \endcode
-  ///
-  /// This is the specified initial value (\c 17), which is suitable for
-  /// embedding in the expression \c initializeFromOriginal.
-  Expr *originalInitialValue = nullptr;
-
   /// An expression that initializes the backing property from a value of
   /// the original property's type (e.g., via `init(wrappedValue:)`), or
   /// \c NULL if the backing property can only be initialized directly.
   Expr *initializeFromOriginal = nullptr;
 
   /// When \c initializeFromOriginal is non-NULL, the opaque value that
   /// is used as a stand-in for a value of the original property's type.
-  OpaqueValueExpr *underlyingValue = nullptr;
+  PropertyWrapperValuePlaceholderExpr *wrappedValuePlaceholder = nullptr;
 
   PropertyWrapperBackingPropertyInfo() { }
   
   PropertyWrapperBackingPropertyInfo(VarDecl *backingVar,
-                                      VarDecl *storageWrapperVar,
-                                      Expr *originalInitialValue,
-                                      Expr *initializeFromOriginal,
-                                      OpaqueValueExpr *underlyingValue)
+                                     VarDecl *storageWrapperVar,
+                                     Expr *initializeFromOriginal,
+                                     PropertyWrapperValuePlaceholderExpr *placeholder)
     : backingVar(backingVar), storageWrapperVar(storageWrapperVar),
-      originalInitialValue(originalInitialValue),
       initializeFromOriginal(initializeFromOriginal),
-      underlyingValue(underlyingValue) { }
+      wrappedValuePlaceholder(placeholder) { }
 
   /// Whether this is a valid property wrapper.
   bool isValid() const {
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -6067,21 +6067,14 @@ bool VarDecl::isPropertyMemberwiseInitializedWithWrappedType() const {
   return allAttachedPropertyWrappersHaveWrappedValueInit();
 }
 
-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();
+  auto wrapperInfo = getPropertyWrapperBackingPropertyInfo();
+  if (!wrapperInfo || !wrapperInfo.wrappedValuePlaceholder)
+    return Type();
 
-  if (isInnermostPropertyWrapperInitUsesEscapingAutoClosure())
-    return FunctionType::get({}, valueInterfaceTy);
+  Type valueInterfaceTy = wrapperInfo.wrappedValuePlaceholder->getType();
+  if (valueInterfaceTy->hasArchetype())
+    valueInterfaceTy = valueInterfaceTy->mapTypeOutOfContext();
 
   return valueInterfaceTy;
 }
diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
@@ -1463,13 +1463,13 @@ static ValueDecl *getCalledValue(Expr *E) {
 
 PropertyWrapperValuePlaceholderExpr *
 PropertyWrapperValuePlaceholderExpr::create(ASTContext &ctx, SourceRange range,
-                                            Type ty, Expr *wrappedValue) {
+                                            Type ty, Expr *wrappedValue,
+                                            bool isAutoClosure) {
   auto *placeholder =
       new (ctx) OpaqueValueExpr(range, ty, /*isPlaceholder=*/true);
 
-  return new (ctx) PropertyWrapperValuePlaceholderExpr(range, ty,
-                                                       placeholder,
-                                                       wrappedValue);
+  return new (ctx) PropertyWrapperValuePlaceholderExpr(
+      range, ty, placeholder, wrappedValue, isAutoClosure);
 }
 
 const ParamDecl *DefaultArgumentExpr::getParamDecl() const {
diff --git a/lib/SILGen/SILGen.cpp b/lib/SILGen/SILGen.cpp
@@ -772,8 +772,8 @@ static void emitDelayedFunction(SILGenModule &SGM,
               ->isPropertyMemberwiseInitializedWithWrappedType()) {
         auto wrapperInfo =
             originalProperty->getPropertyWrapperBackingPropertyInfo();
-        assert(wrapperInfo.originalInitialValue);
-        init = wrapperInfo.originalInitialValue;
+        assert(wrapperInfo.wrappedValuePlaceholder->getOriginalWrappedValue());
+        init = wrapperInfo.wrappedValuePlaceholder->getOriginalWrappedValue();
       }
     }
 
diff --git a/lib/SILGen/SILGenConstructor.cpp b/lib/SILGen/SILGenConstructor.cpp
@@ -230,8 +230,9 @@ static void emitImplicitValueConstructor(SILGenFunction &SGF,
         // the property wrapper backing initializer.
         if (auto *wrappedVar = field->getOriginalWrappedProperty()) {
           auto wrappedInfo = wrappedVar->getPropertyWrapperBackingPropertyInfo();
-          if (wrappedInfo.originalInitialValue) {
-            auto arg = SGF.emitRValue(wrappedInfo.originalInitialValue);
+          auto *placeholder = wrappedInfo.wrappedValuePlaceholder;
+          if (placeholder && placeholder->getOriginalWrappedValue()) {
+            auto arg = SGF.emitRValue(placeholder->getOriginalWrappedValue());
             maybeEmitPropertyWrapperInitFromValue(SGF, Loc, field, subs,
                                                   std::move(arg))
               .forwardInto(SGF, Loc, init.get());
@@ -274,8 +275,9 @@ static void emitImplicitValueConstructor(SILGenFunction &SGF,
       // memberwise initialized, use the original wrapped value if it exists.
       if (auto *wrappedVar = field->getOriginalWrappedProperty()) {
         auto wrappedInfo = wrappedVar->getPropertyWrapperBackingPropertyInfo();
-        if (wrappedInfo.originalInitialValue) {
-          init = wrappedInfo.originalInitialValue;
+        auto *placeholder = wrappedInfo.wrappedValuePlaceholder;
+        if (placeholder && placeholder->getOriginalWrappedValue()) {
+          init = placeholder->getOriginalWrappedValue();
         }
       }
 
diff --git a/lib/SILGen/SILGenFunction.cpp b/lib/SILGen/SILGenFunction.cpp
@@ -852,7 +852,8 @@ void SILGenFunction::emitGeneratorFunction(SILDeclRef function, Expr *value,
       auto var = cast<VarDecl>(function.getDecl());
       auto wrappedInfo = var->getPropertyWrapperBackingPropertyInfo();
       auto param = params->get(0);
-      opaqueValue.emplace(*this, wrappedInfo.underlyingValue,
+      auto *placeholder = wrappedInfo.wrappedValuePlaceholder;
+      opaqueValue.emplace(*this, placeholder->getOpaqueValuePlaceholder(),
                           maybeEmitValueOfLocalVarDecl(param));
 
       assert(value == wrappedInfo.initializeFromOriginal);
diff --git a/lib/SILGen/SILGenLValue.cpp b/lib/SILGen/SILGenLValue.cpp
@@ -1335,10 +1335,7 @@ namespace {
         // the argument types of the setter and initializer shall be
         // different, so we don't rewrite an assignment into an
         // initialization.
-        if (VD->isInnermostPropertyWrapperInitUsesEscapingAutoClosure())
-          return false;
-
-        return true;
+        return !wrapperInfo.wrappedValuePlaceholder->isAutoClosure();
       }
 
       return false;
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
@@ -5489,8 +5489,10 @@ Expr *ExprRewriter::coerceCallArguments(Expr *arg, AnyFunctionType *funcType,
      target->shouldInjectWrappedValuePlaceholder(apply);
 
   auto injectWrappedValuePlaceholder = [&](Expr *arg) -> Expr * {
-    auto *placeholder = PropertyWrapperValuePlaceholderExpr::create(ctx,
-        arg->getSourceRange(), cs.getType(arg), arg);
+    auto *placeholder = PropertyWrapperValuePlaceholderExpr::create(
+        ctx, arg->getSourceRange(), cs.getType(arg),
+        target->propertyWrapperHasInitialWrappedValue() ? arg : nullptr,
+        isa<AutoClosureExpr>(arg));
     cs.cacheType(placeholder);
     cs.cacheType(placeholder->getOpaqueValuePlaceholder());
     shouldInjectWrappedValuePlaceholder = false;
@@ -5690,19 +5692,15 @@ Expr *ExprRewriter::coerceCallArguments(Expr *arg, AnyFunctionType *funcType,
           locator.withPathElement(ConstraintLocator::AutoclosureResult));
 
       if (shouldInjectWrappedValuePlaceholder) {
-        // If init(wrappedValue:) takes an escaping autoclosure, then we want
+        // If init(wrappedValue:) takes an autoclosure, then we want
         // the effect of autoclosure forwarding of the placeholder
         // autoclosure. The only way to do this is to call the placeholder
         // autoclosure when passing it to the init.
-        if (!closureType->isNoEscape()) {
-          auto *placeholder = injectWrappedValuePlaceholder(
-              cs.buildAutoClosureExpr(arg, closureType));
-          arg = CallExpr::createImplicit(ctx, placeholder, {}, {});
-          arg->setType(closureType->getResult());
-          cs.cacheType(arg);
-        } else {
-          arg = injectWrappedValuePlaceholder(arg);
-        }
+        auto *placeholder = injectWrappedValuePlaceholder(
+            cs.buildAutoClosureExpr(arg, closureType));
+        arg = CallExpr::createImplicit(ctx, placeholder, {}, {});
+        arg->setType(closureType->getResult());
+        cs.cacheType(arg);
       }
 
       convertedArg = cs.buildAutoClosureExpr(arg, closureType);
diff --git a/lib/Sema/CodeSynthesis.cpp b/lib/Sema/CodeSynthesis.cpp
@@ -253,8 +253,9 @@ static ConstructorDecl *createImplicitConstructor(NominalTypeDecl *decl,
         // type.
         if (var->isPropertyMemberwiseInitializedWithWrappedType()) {
           varInterfaceType = var->getPropertyWrapperInitValueInterfaceType();
-          isAutoClosure =
-            var->isInnermostPropertyWrapperInitUsesEscapingAutoClosure();
+
+          auto wrapperInfo = var->getPropertyWrapperBackingPropertyInfo();
+          isAutoClosure = wrapperInfo.wrappedValuePlaceholder->isAutoClosure();
         } else {
           varInterfaceType = backingPropertyType;
         }
diff --git a/lib/Sema/ConstraintSystem.cpp b/lib/Sema/ConstraintSystem.cpp
@@ -4539,8 +4539,9 @@ SolutionApplicationTarget::SolutionApplicationTarget(
   expression.contextualPurpose = contextualPurpose;
   expression.convertType = convertType;
   expression.pattern = nullptr;
-  expression.wrappedVar = nullptr;
-  expression.innermostWrappedValueInit = nullptr;
+  expression.propertyWrapper.wrappedVar = nullptr;
+  expression.propertyWrapper.innermostWrappedValueInit = nullptr;
+  expression.propertyWrapper.hasInitialWrappedValue = false;
   expression.isDiscarded = isDiscarded;
   expression.bindPatternVarsOneWay = false;
   expression.initialization.patternBinding = nullptr;
@@ -4564,11 +4565,14 @@ void SolutionApplicationTarget::maybeApplyPropertyWrapper() {
   auto outermostWrapperAttr = wrapperAttrs.front();
   Expr *backingInitializer;
   if (Expr *initializer = expression.expression) {
+    if (!isa<PropertyWrapperValuePlaceholderExpr>(initializer)) {
+      expression.propertyWrapper.hasInitialWrappedValue = true;
+    }
     // Form init(wrappedValue:) call(s).
     Expr *wrappedInitializer = buildPropertyWrapperWrappedValueCall(
         singleVar, Type(), initializer, /*ignoreAttributeArgs=*/false,
         [&](ApplyExpr *innermostInit) {
-          expression.innermostWrappedValueInit = innermostInit;
+          expression.propertyWrapper.innermostWrappedValueInit = innermostInit;
         });
     if (!wrappedInitializer)
       return;
@@ -4609,7 +4613,7 @@ void SolutionApplicationTarget::maybeApplyPropertyWrapper() {
 
   // Note that we have applied to property wrapper, so we can adjust
   // the initializer type later.
-  expression.wrappedVar = singleVar;
+  expression.propertyWrapper.wrappedVar = singleVar;
   expression.expression = backingInitializer;
   expression.convertType = {outermostWrapperAttr->getTypeRepr(),
                             outermostWrapperAttr->getType()};
diff --git a/lib/Sema/ConstraintSystem.h b/lib/Sema/ConstraintSystem.h
@@ -1382,13 +1382,19 @@ class SolutionApplicationTarget {
       /// pattern.
       Pattern *pattern;
 
-      /// The variable to which property wrappers have been applied, if
-      /// this is an initialization involving a property wrapper.
-      VarDecl *wrappedVar;
+      struct {
+        /// The variable to which property wrappers have been applied, if
+        /// this is an initialization involving a property wrapper.
+        VarDecl *wrappedVar;
 
-      /// The innermost call to \c init(wrappedValue:), if this is an
-      /// initialization involving a property wrapper.
-      ApplyExpr *innermostWrappedValueInit;
+        /// The innermost call to \c init(wrappedValue:), if this is an
+        /// initialization involving a property wrapper.
+        ApplyExpr *innermostWrappedValueInit;
+
+        /// Whether this property wrapper has an initial wrapped value specified
+        /// via \c = .
+        bool hasInitialWrappedValue;
+      } propertyWrapper;
 
       /// Whether the expression result will be discarded at the end.
       bool isDiscarded;
@@ -1618,19 +1624,26 @@ class SolutionApplicationTarget {
         expression.contextualPurpose != CTP_Initialization)
       return false;
 
-    auto *wrappedVar = expression.wrappedVar;
+    auto *wrappedVar = expression.propertyWrapper.wrappedVar;
     if (!wrappedVar || wrappedVar->isStatic())
       return false;
 
-    return expression.innermostWrappedValueInit == apply;
+    return expression.propertyWrapper.innermostWrappedValueInit == apply;
+  }
+
+  /// Whether this target is for initialization of a property wrapper
+  /// with an initial wrapped value specified via \c = .
+  bool propertyWrapperHasInitialWrappedValue() const {
+    return (kind == Kind::expression &&
+            expression.propertyWrapper.hasInitialWrappedValue);
   }
 
   /// Retrieve the wrapped variable when initializing a pattern with a
   /// property wrapper.
   VarDecl *getInitializationWrappedVar() const {
     assert(kind == Kind::expression);
     assert(expression.contextualPurpose == CTP_Initialization);
-    return expression.wrappedVar;
+    return expression.propertyWrapper.wrappedVar;
   }
 
   PatternBindingDecl *getInitializationPatternBindingDecl() const {
diff --git a/lib/Sema/TypeCheckPropertyWrapper.cpp b/lib/Sema/TypeCheckPropertyWrapper.cpp
diff --git a/lib/Sema/TypeCheckStorage.cpp b/lib/Sema/TypeCheckStorage.cpp
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp
diff --git a/test/SILGen/property_wrapper_autoclosure.swift b/test/SILGen/property_wrapper_autoclosure.swift
diff --git a/test/SILGen/property_wrappers.swift b/test/SILGen/property_wrappers.swift

Original file line number	Diff line number	Diff line change
`@@ -772,8 +772,8 @@ static void emitDelayedFunction(SILGenModule &SGM,`
`772`	`772`	`->isPropertyMemberwiseInitializedWithWrappedType()) {`
`773`	`773`	`auto wrapperInfo =`
`774`	`774`	`originalProperty->getPropertyWrapperBackingPropertyInfo();`
`775`		`- assert(wrapperInfo.originalInitialValue);`
`776`		`- init = wrapperInfo.originalInitialValue;`
	`775`	`+ assert(wrapperInfo.wrappedValuePlaceholder->getOriginalWrappedValue());`
	`776`	`+ init = wrapperInfo.wrappedValuePlaceholder->getOriginalWrappedValue();`
`777`	`777`	`}`
`778`	`778`	`}`
`779`	`779`