Memberwise initializer synthesis for properties with attached delegates.

Author: DougGregor

include/swift/AST/Decl.h

@@ -2141,11 +2141,7 @@ class PatternBindingDecl final : public Decl,
 
   /// Determines whether this binding either has an initializer expression, or is
   /// default initialized, without performing any type checking on it.
-  ///
-  /// This is only valid to check for bindings which have storage.
   bool isDefaultInitializable() const {
-    assert(hasStorage());
-
     for (unsigned i = 0, e = getNumPatternEntries(); i < e; ++i)
       if (!isDefaultInitializable(i))
         return false;
@@ -4914,12 +4910,19 @@ class VarDecl : public AbstractStorageDecl {
     return nullptr;
   }
 
+  /// Whether there exists an initializer for this \c VarDecl.
+  bool isParentInitialized() const {
+    if (auto *PBD = getParentPatternBinding())
+      return PBD->getPatternEntryForVarDecl(this).isInitialized();
+    return false;
+  }
+
   // Return whether this VarDecl has an initial value, either by checking
   // if it has an initializer in its parent pattern binding or if it has
   // the @_hasInitialValue attribute.
   bool hasInitialValue() const {
     return getAttrs().hasAttribute<HasInitialValueAttr>() ||
-           getParentInitializer();
+           isParentInitialized();
   }
 
   VarDecl *getOverriddenDecl() const {

lib/AST/Decl.cpp

@@ -1536,7 +1536,7 @@ bool PatternBindingDecl::isDefaultInitializable(unsigned i) const {
   const auto entry = getPatternList()[i];
 
   // If it has an initializer expression, this is trivially true.
-  if (entry.getInit())
+  if (entry.isInitialized())
     return true;
 
   if (entry.getPattern()->isNeverDefaultInitializable())
@@ -4922,7 +4922,7 @@ bool VarDecl::isSettable(const DeclContext *UseDC,
 
   // If the decl has an explicitly written initializer with a pattern binding,
   // then it isn't settable.
-  if (getParentInitializer() != nullptr)
+  if (isParentInitialized())
     return false;
 
   // Normal lets (e.g. globals) are only mutable in the context of the
@@ -5218,6 +5218,9 @@ StaticSpellingKind AbstractStorageDecl::getCorrectStaticSpelling() const {
 
 CustomAttr *VarDecl::getAttachedPropertyDelegate() const {
   auto &ctx = getASTContext();
+  if (!ctx.getLazyResolver())
+    return nullptr;
+
   auto mutableThis = const_cast<VarDecl *>(this);
   return evaluateOrDefault(ctx.evaluator,
                            AttachedPropertyDelegateRequest{mutableThis},
@@ -5241,6 +5244,9 @@ PropertyDelegateTypeInfo VarDecl::getAttachedPropertyDelegateTypeInfo() const {
 
 Type VarDecl::getAttachedPropertyDelegateType() const {
   auto &ctx = getASTContext();
+  if (!ctx.getLazyResolver())
+    return nullptr;
+
   auto mutableThis = const_cast<VarDecl *>(this);
   return evaluateOrDefault(ctx.evaluator,
                            AttachedPropertyDelegateTypeRequest{mutableThis},
@@ -5249,6 +5255,9 @@ Type VarDecl::getAttachedPropertyDelegateType() const {
 
 Type VarDecl::getPropertyDelegateBackingPropertyType() const {
   ASTContext &ctx = getASTContext();
+  if (!ctx.getLazyResolver())
+    return nullptr;
+
   auto mutableThis = const_cast<VarDecl *>(this);
   return evaluateOrDefault(
       ctx.evaluator, PropertyDelegateBackingPropertyTypeRequest{mutableThis},
@@ -5257,6 +5266,9 @@ Type VarDecl::getPropertyDelegateBackingPropertyType() const {
 
 VarDecl *VarDecl::getPropertyDelegateBackingProperty() const {
   auto &ctx = getASTContext();
+  if (!ctx.getLazyResolver())
+    return nullptr;
+
   auto mutableThis = const_cast<VarDecl *>(this);
   return evaluateOrDefault(ctx.evaluator,
                            PropertyDelegateBackingPropertyRequest{mutableThis},

lib/Sema/CodeSynthesis.cpp

@@ -1464,7 +1464,7 @@ PropertyDelegateBackingPropertyRequest::evaluate(Evaluator &evaluator,
   VarDecl *backingVar = new (ctx) VarDecl(/*IsStatic=*/var->isStatic(),
                                           VarDecl::Specifier::Var,
                                           /*IsCaptureList=*/false,
-                                          SourceLoc(),
+                                          var->getLoc(),
                                           name, dc);
   backingVar->setInterfaceType(storageInterfaceType);
   backingVar->setType(storageType);
@@ -1856,10 +1856,6 @@ static void maybeAddMemberwiseDefaultArg(ParamDecl *arg, VarDecl *var,
   if (!var->getParentPattern()->getSingleVar())
     return;
 
-  // If this property has a delegate, don't give it a default argument.
-  if (var->getAttachedPropertyDelegate())
-    return;
-
   // If we don't have an expression initializer or silgen can't assign a default
   // initializer, then we can't generate a default value. An example of where
   // silgen can assign a default is var x: Int? where the default is nil.
@@ -1882,7 +1878,7 @@ static void maybeAddMemberwiseDefaultArg(ParamDecl *arg, VarDecl *var,
   // the type will always be a sugared T? because we don't default init an
   // explicit Optional<T>.
   if ((isa<OptionalType>(var->getValueInterfaceType().getPointer()) &&
-      !var->getParentInitializer()) ||
+      !var->isParentInitialized()) ||
       var->getAttrs().hasAttribute<LazyAttr>()) {
     arg->setDefaultArgumentKind(DefaultArgumentKind::NilLiteral);
     return;
@@ -1909,7 +1905,7 @@ bool swift::isMemberwiseInitialized(VarDecl *var) {
   // Initialized 'let' properties have storage, but don't get an argument
   // to the memberwise initializer since they already have an initial
   // value that cannot be overridden.
-  if (var->isLet() && var->getParentInitializer())
+  if (var->isLet() && var->isParentInitialized())
     return false;
 
   return true;

lib/Sema/DebuggerTestingTransform.cpp

@@ -177,7 +177,7 @@ class DebuggerTestingTransform : public ASTWalker {
 
     // Don't capture variables which aren't default-initialized.
     if (auto *VD = dyn_cast<VarDecl>(DstDecl))
-      if (!VD->getParentInitializer() && !VD->isInOut())
+      if (!VD->isParentInitialized() && !VD->isInOut())
         return {true, OriginalExpr};
 
     // Rewrite the original expression into this:

lib/Sema/DerivedConformanceCodable.cpp

@@ -223,7 +223,7 @@ static bool validateCodingKeysEnum(DerivedConformance &derived,
           continue;
       }
 
-      if (varDecl->getParentInitializer())
+      if (varDecl->isParentInitialized())
         continue;
 
       // The var was not default initializable, and did not have an explicit
@@ -870,7 +870,7 @@ static void deriveBodyDecodable_init(AbstractFunctionDecl *initDecl, void *) {
           lookupVarDeclForCodingKeysCase(conformanceDC, elt, targetDecl);
 
       // Don't output a decode statement for a var let with a default value.
-      if (varDecl->isLet() && varDecl->getParentInitializer() != nullptr)
+      if (varDecl->isLet() && varDecl->isParentInitialized())
         continue;
 
       auto methodName =

lib/Sema/TypeCheckDecl.cpp

@@ -4990,6 +4990,31 @@ static void diagnoseClassWithoutInitializers(TypeChecker &tc,
     }
   }
 
+  // Lazily construct a mapping from backing storage properties to the
+  // declared properties.
+  bool computedBackingToOriginalVars = false;
+  llvm::SmallDenseMap<VarDecl *, VarDecl *> backingToOriginalVars;
+  auto getOriginalVar = [&](VarDecl *var) -> VarDecl * {
+    // If we haven't computed the mapping yet, do so now.
+    if (!computedBackingToOriginalVars) {
+      for (auto member : classDecl->getMembers()) {
+        if (auto var = dyn_cast<VarDecl>(member)) {
+          if (auto backingVar = var->getPropertyDelegateBackingProperty()) {
+            backingToOriginalVars[backingVar] = var;
+          }
+        }
+      }
+
+      computedBackingToOriginalVars = true;
+    }
+
+    auto known = backingToOriginalVars.find(var);
+    if (known == backingToOriginalVars.end())
+      return nullptr;
+
+    return known->second;
+  };
+
   for (auto member : classDecl->getMembers()) {
     auto pbd = dyn_cast<PatternBindingDecl>(member);
     if (!pbd)
@@ -5000,12 +5025,19 @@ static void diagnoseClassWithoutInitializers(TypeChecker &tc,
       continue;
 
     for (auto entry : pbd->getPatternList()) {
-      if (entry.getInit()) continue;
+      if (entry.isInitialized()) continue;
 
       SmallVector<VarDecl *, 4> vars;
       entry.getPattern()->collectVariables(vars);
       if (vars.empty()) continue;
 
+      // Replace the variables we found with the originals for diagnostic
+      // purposes.
+      for (auto &var : vars) {
+        if (auto originalVar = getOriginalVar(var))
+          var = originalVar;
+      }
+
       auto varLoc = vars[0]->getLoc();
 
       Optional<InFlightDiagnostic> diag;
@@ -5235,6 +5267,7 @@ void TypeChecker::addImplicitConstructors(NominalTypeDecl *decl) {
     }
 
   } else {
+    SmallPtrSet<VarDecl *, 4> backingStorageVars;
     for (auto member : decl->getMembers()) {
       if (auto ctor = dyn_cast<ConstructorDecl>(member)) {
         // Initializers that were synthesized to fulfill derived conformances
@@ -5259,16 +5292,22 @@ void TypeChecker::addImplicitConstructors(NominalTypeDecl *decl) {
       if (auto var = dyn_cast<VarDecl>(member)) {
         // If this variable has a property delegate, go validate it to ensure
         // that we create the backing storage property.
-        if (var->getAttachedPropertyDelegate()) {
+        if (auto backingVar = var->getPropertyDelegateBackingProperty()) {
           validateDecl(var);
           maybeAddAccessorsToStorage(var);
+
+          backingStorageVars.insert(backingVar);
         }
 
+        // Ignore the backing storage for properties with attached delegates.
+        if (backingStorageVars.count(var) > 0)
+          continue;
+
         if (isMemberwiseInitialized(var)) {
           // Initialized 'let' properties have storage, but don't get an argument
           // to the memberwise initializer since they already have an initial
           // value that cannot be overridden.
-          if (var->isLet() && var->getParentInitializer()) {
+          if (var->isLet() && var->isParentInitialized()) {
 
             // We cannot handle properties like:
             //   let (a,b) = (1,2)
@@ -5295,7 +5334,7 @@ void TypeChecker::addImplicitConstructors(NominalTypeDecl *decl) {
       if (auto pbd = dyn_cast<PatternBindingDecl>(member)) {
         if (pbd->hasStorage() && !pbd->isStatic()) {
           for (auto entry : pbd->getPatternList()) {
-            if (entry.getInit()) continue;
+            if (entry.isInitialized()) continue;
 
             // If one of the bound variables is @NSManaged, go ahead no matter
             // what.

test/decl/var/property_delegates.swift

@@ -510,3 +510,72 @@ func testBox(ub: UseBox) {
   mutableUB.y = 20
   mutableUB = ub
 }
+
+// ---------------------------------------------------------------------------
+// Memberwise initializers
+// ---------------------------------------------------------------------------
+struct MemberwiseInits<T> {
+  @Wrapper
+  var x: Bool
+
+  @WrapperWithInitialValue
+  var y: T
+}
+
+func testMemberwiseInits() {
+  // expected-error@+1{{type '(Wrapper<Bool>, Double) -> MemberwiseInits<Double>'}}
+  let _: Int = MemberwiseInits<Double>.init
+
+  _ = MemberwiseInits(x: Wrapper(value: true), y: 17)
+}
+
+struct DefaultedMemberwiseInits {
+  @Wrapper(value: true)
+  var x: Bool
+
+  @WrapperWithInitialValue
+  var y: Int = 17
+}
+
+func testDefaultedMemberwiseInits() {
+  _ = DefaultedMemberwiseInits()
+  _ = DefaultedMemberwiseInits(x: Wrapper(value: false), y: 42)
+
+  _ = DefaultedMemberwiseInits(y: 42)
+  _ = DefaultedMemberwiseInits(x: Wrapper(value: false))
+}
+
+// ---------------------------------------------------------------------------
+// Default initializers
+// ---------------------------------------------------------------------------
+struct DefaultInitializerStruct {
+  @Wrapper(value: true)
+  var x
+
+  @WrapperWithInitialValue
+  var y: Int = 10
+}
+
+struct NoDefaultInitializerStruct { // expected-note{{'init(x:)' declared here}}
+  @Wrapper
+  var x: Bool
+}
+
+class DefaultInitializerClass {
+  @Wrapper(value: true)
+  final var x
+
+  @WrapperWithInitialValue
+  final var y: Int = 10
+}
+
+class NoDefaultInitializerClass { // expected-error{{class 'NoDefaultInitializerClass' has no initializers}}
+  @Wrapper
+  final var x: Bool  // expected-note{{stored property 'x' without initial value prevents synthesized initializers}}
+}
+
+func testDefaultInitializers() {
+  _ = DefaultInitializerStruct()
+  _ = DefaultInitializerClass()
+  _ = NoDefaultInitializerStruct() // expected-error{{missing argument for parameter 'x' in call}}
+}