[PropertyWrappers] Try to find the best default value initializer if we have multiple inits, before diagnosing them as ambiguous

Author: theblixguy

lib/Sema/TypeCheckPropertyWrapper.cpp

@@ -221,12 +221,41 @@ static ConstructorDecl *findDefaultInit(ASTContext &ctx,
         init->getParameters()->getArray(),
         [](const ParamDecl *decl) { return decl->isDefaultArgument(); });
 
-    // Only add non-synthesized initializers.
-    if (allParamsHaveDefaultArg && !init->isImplicit()) {
+    if (allParamsHaveDefaultArg) {
       defaultValueInitializers.push_back(init);
     }
   }
 
+  if (defaultValueInitializers.size() > 1) {
+    // Let's find the single most specialized init. If we don't have one, then
+    // we'll diagnose later.
+    if (auto TC = static_cast<TypeChecker *>(ctx.getLazyResolver())) {
+      Optional<unsigned> bestIdx;
+      for (unsigned i = 1, n = defaultValueInitializers.size(); i != n; ++i) {
+        auto bestOrPrevIdx = bestIdx ? bestIdx.getValue() : i - 1;
+        auto firstInit =
+            cast<ValueDecl>(defaultValueInitializers[bestOrPrevIdx]);
+        auto secondInit = cast<ValueDecl>(defaultValueInitializers[i]);
+
+        switch (TC->compareDeclarations(nominal, firstInit, secondInit)) {
+        case Comparison::Better:
+          bestIdx = bestOrPrevIdx;
+          break;
+        case Comparison::Worse:
+          bestIdx = i;
+          break;
+        case Comparison::Unordered:
+          break;
+        }
+      }
+
+      if (bestIdx.hasValue()) {
+        auto bestInit = defaultValueInitializers[bestIdx.getValue()];
+        defaultValueInitializers = {bestInit};
+      }
+    }
+  }
+
   switch (defaultValueInitializers.size()) {
   case 0:
     return nullptr;
@@ -235,7 +264,7 @@ static ConstructorDecl *findDefaultInit(ASTContext &ctx,
     break;
 
   default:
-    // Diagnose ambiguous init() initializers.
+    // Diagnose ambiguous default value initializers.
     nominal->diagnose(diag::property_wrapper_ambiguous_default_value_init,
                       nominal->getDeclaredType());
     for (auto init : defaultValueInitializers) {
@@ -245,7 +274,7 @@ static ConstructorDecl *findDefaultInit(ASTContext &ctx,
     return nullptr;
   }
 
-  // 'init()' must be as accessible as the nominal type.
+  // The initializer must be as accessible as the nominal type.
   auto init = defaultValueInitializers.front();
   if (init->getFormalAccess() < nominal->getFormalAccess()) {
     init->diagnose(diag::property_wrapper_type_requirement_not_accessible,

test/decl/var/property_wrappers.swift

@@ -1730,12 +1730,14 @@ struct TestConcrete1 {
 // 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}}
+struct SR_11477_W1 { // Okay, because we'll pick the best one here
   let name: String
 
-  init() {} // expected-note {{initializer 'init()' declared here}}
+  init() {
+    self.name = "Init"
+  }
 
-  init(name: String = "DefaultParamInit") { // expected-note {{initializer 'init(name:)' declared here}}
+  init(name: String = "DefaultParamInit") {
     self.name = name
   }