[PropertyWrappers] Allow constructors with default arguments to be found by findDefaultInit()

Author: theblixguy

lib/Sema/TypeCheckPropertyWrapper.cpp

@@ -203,16 +203,31 @@ static ConstructorDecl *findInitialValueInit(
 static ConstructorDecl *findDefaultInit(ASTContext &ctx,
                                         NominalTypeDecl *nominal) {
   SmallVector<ConstructorDecl *, 2> defaultValueInitializers;
-  DeclName initName(ctx, DeclBaseName::createConstructor(),
-                    ArrayRef<Identifier>());
   SmallVector<ValueDecl *, 2> decls;
+  auto initName = DeclBaseName::createConstructor();
   nominal->lookupQualified(nominal, initName, NL_QualifiedDefault, decls);
   for (const auto &decl : decls) {
     auto init = dyn_cast<ConstructorDecl>(decl);
     if (!init || init->getDeclContext() != nominal)
       continue;
 
-    defaultValueInitializers.push_back(init);
+    // A constructor which does not have any parameters or where all the
+    // parameters have a default argument can be used to default initialize
+    // the property wrapper type.
+    assert(init->hasParameterList());
+    auto hasParams = init->getParameters()->size() > 0;
+    auto allParamsHaveDefaultArg = false;
+
+    if (hasParams) {
+      allParamsHaveDefaultArg = llvm::all_of(
+          init->getParameters()->getArray(),
+          [](const ParamDecl *decl) { return decl->isDefaultArgument(); });
+    }
+
+    // Skip synthesized default initializers
+    if (!hasParams || (allParamsHaveDefaultArg && !init->isImplicit())) {
+      defaultValueInitializers.push_back(init);
+    }
   }
 
   switch (defaultValueInitializers.size()) {

test/SILOptimizer/di_property_wrappers.swift

@@ -422,6 +422,33 @@ func testComposed() {
   // CHECK-NEXT: .. init Wrapper2<Int>(wrappedValue: 17)
 }
 
+// SR-11477
+
+@propertyWrapper
+struct SR_11477_W {
+  let name: String
+
+  init(name: String = "DefaultParamInit") {
+    self.name = name
+  }
+
+  var wrappedValue: Int {
+    get { return 0 }
+  }
+}
+
+struct SR_11477_C {
+  @SR_11477_W var property: Int
+  init() {}
+  func foo() { print(_property.name) }
+}
+
+func testWrapperInitWithDefaultArg() {
+  let use = SR_11477_C()
+  
+  use.foo()
+  // CHECK: DefaultParamInit
+}
 
 testIntStruct()
 testIntClass()
@@ -431,3 +458,4 @@ testDefaultInit()
 testOptIntStruct()
 testDefaultNilOptIntStruct()
 testComposed()
+testWrapperInitWithDefaultArg()

test/decl/var/property_wrappers.swift

@@ -1724,3 +1724,54 @@ struct TestConcrete1 {
     // ...
   }
 }
+
+// SR-11477
+
+// Two initializers that can default initialize the wrapper //
+
+@propertyWrapper
+struct SR_11477_W1 { // expected-error {{property wrapper type 'SR_11477_W1' has multiple default-value initializers}}
+  let name: String
+
+  init() {} // expected-note {{initializer 'init()' declared here}}
+
+  init(name: String = "DefaultParamInit") { // expected-note {{initializer 'init(name:)' declared here}}
+    self.name = name
+  }
+
+  var wrappedValue: Int {
+    get { return 0 }
+  }
+}
+
+// Two initializers with default arguments that can default initialize the wrapper //
+
+@propertyWrapper
+struct SR_11477_W2 { // expected-error {{property wrapper type 'SR_11477_W2' has multiple default-value initializers}}
+  let name: String
+
+  init(anotherName: String = "DefaultParamInit") {} // expected-note {{initializer 'init(anotherName:)' declared here}}
+
+  init(name: String = "DefaultParamInit") { // expected-note {{initializer 'init(name:)' declared here}}
+    self.name = name
+  }
+
+  var wrappedValue: Int {
+    get { return 0 }
+  }
+}
+
+// Single initializer that can default initialize the wrapper //
+
+@propertyWrapper
+struct SR_11477_W3 { // Okay
+  let name: String
+
+  init() {
+    self.name = "Init"
+  }
+
+  var wrappedValue: Int {
+    get { return 0 }
+  }
+}