---

yaml
---
r: 349052
b: refs/heads/master
c: 370f47c
h: refs/heads/master

Author: theblixguy

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 7e31d7a7175df0e7750c86f2bab76bf7619881a8
+refs/heads/master: 370f47c27a80a12e8ddb73c586782825cd883c22
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/include/swift/AST/DiagnosticsSema.def

@@ -4533,8 +4533,6 @@ ERROR(property_wrapper_wrong_initial_value_init, none,
       (DeclName, Type, Type))
 ERROR(property_wrapper_failable_init, none,
       "%0 cannot be failable", (DeclName))
-ERROR(property_wrapper_ambiguous_default_value_init, none,
-  "property wrapper type %0 has multiple default-value initializers", (Type))
 ERROR(property_wrapper_type_requirement_not_accessible,none,
       "%select{private|fileprivate|internal|public|open}0 %1 %2 cannot have "
       "more restrictive access than its enclosing property wrapper type %3 "

trunk/include/swift/AST/PropertyWrappers.h

@@ -43,9 +43,12 @@ struct PropertyWrapperTypeInfo {
     HasInitialValueInit
   } wrappedValueInit = NoWrappedValueInit;
 
-  /// The initializer `init()` that will be called to default-initialize a
+  /// The initializer that will be called to default-initialize a
   /// value with an attached property wrapper.
-  ConstructorDecl *defaultInit = nullptr;
+  enum {
+    NoDefaultValueInit = 0,
+    HasDefaultValueInit
+  } defaultInit = NoDefaultValueInit;
 
   /// The property through which the projection value ($foo) will be accessed.
   ///

trunk/lib/Sema/TypeCheckPropertyWrapper.cpp

@@ -26,6 +26,16 @@
 #include "swift/AST/TypeCheckRequests.h"
 using namespace swift;
 
+/// The kind of property initializer to look for
+enum class PropertyWrapperInitKind {
+  /// An initial-value initializer (i.e. `init(initialValue:)`)
+  InitialValue,
+  /// An wrapped-value initializer (i.e. `init(wrappedValue:)`)
+  WrappedValue,
+  /// An default-value initializer (i.e. `init()` or `init(defaultArgs...)`)
+  Default
+};
+
 /// Find the named property in a property wrapper to which access will
 /// be delegated.
 static VarDecl *findValueProperty(ASTContext &ctx, NominalTypeDecl *nominal,
@@ -79,54 +89,71 @@ static VarDecl *findValueProperty(ASTContext &ctx, NominalTypeDecl *nominal,
   return var;
 }
 
-/// Determine whether we have a suitable wrapped-value initializer within
-/// a property wrapper type.
-static ConstructorDecl *findInitialValueInit(
-    ASTContext &ctx,
-    NominalTypeDecl *nominal,
-    VarDecl *valueVar,
-    Identifier argumentLabel) {
-  // Retrieve the type of the 'value' property.
-  Type valueVarType = valueVar->getValueInterfaceType();
-
+/// Determine whether we have a suitable initializer within a property wrapper
+/// type.
+static ConstructorDecl *
+findSuitableWrapperInit(ASTContext &ctx, NominalTypeDecl *nominal,
+                        VarDecl *valueVar, PropertyWrapperInitKind initKind) {
   enum class NonViableReason {
     Failable,
     ParameterTypeMismatch,
     Inaccessible,
   };
-  SmallVector<std::tuple<ConstructorDecl*, NonViableReason, Type>, 2> nonviable;
-  SmallVector<ConstructorDecl *, 2> initialValueInitializers;
 
+  SmallVector<std::tuple<ConstructorDecl *, NonViableReason, Type>, 2>
+      nonviable;
+  SmallVector<ConstructorDecl *, 2> viableInitializers;
   SmallVector<ValueDecl *, 2> decls;
+
+  Identifier argumentLabel;
+  switch (initKind) {
+  case PropertyWrapperInitKind::InitialValue:
+    argumentLabel = ctx.Id_initialValue;
+    break;
+  case PropertyWrapperInitKind::WrappedValue:
+    argumentLabel = ctx.Id_wrappedValue;
+    break;
+  case PropertyWrapperInitKind::Default:
+    break;
+  }
+
   nominal->lookupQualified(nominal, DeclBaseName::createConstructor(),
                            NL_QualifiedDefault, decls);
   for (const auto &decl : decls) {
     auto init = dyn_cast<ConstructorDecl>(decl);
-    if (!init || init->getDeclContext() != nominal || init->getGenericParams())
+    if (!init || init->getDeclContext() != nominal || init->isGeneric())
       continue;
 
+    ParamDecl *argumentParam = nullptr;
+    bool allArgsDefault = true;
     // Check whether every parameter meets one of the following criteria:
     //   (1) The parameter has a default argument, or
     //   (2) The parameter has the given argument label.
-    ParamDecl *wrappedValueParam = nullptr;
     for (auto param : *init->getParameters()) {
       // Recognize the first parameter with the requested argument label.
-      if (param->getArgumentName() == argumentLabel && !wrappedValueParam) {
-        wrappedValueParam = param;
+      if (param->getArgumentName() == argumentLabel && !argumentParam) {
+        argumentParam = param;
         continue;
       }
 
-      if (param->isDefaultArgument())
+      if (param->isDefaultArgument()) {
+        allArgsDefault &= true;
         continue;
-
-      // Forget we had a match.
-      wrappedValueParam = nullptr;
-      break;
+      } else {
+        // Forget we had a match.
+        allArgsDefault = false;
+        argumentParam = nullptr;
+        break;
+      }
     }
 
-    if (!wrappedValueParam)
+    if (initKind != PropertyWrapperInitKind::Default && !argumentParam)
       continue;
 
+    if (initKind == PropertyWrapperInitKind::Default && !allArgsDefault) {
+      continue;
+    }
+
     // Failable initializers cannot be used.
     if (init->isFailable()) {
       nonviable.push_back(
@@ -141,33 +168,37 @@ static ConstructorDecl *findInitialValueInit(
       continue;
     }
 
-    if (!wrappedValueParam->hasInterfaceType())
-      continue;
+    // Additional checks for initial-value and wrapped-value initializers
+    if (initKind != PropertyWrapperInitKind::Default) {
+      if (!argumentParam)
+        continue;
 
-    if (wrappedValueParam->isInOut() || wrappedValueParam->isVariadic())
-      continue;
+      if (!argumentParam->hasInterfaceType())
+        continue;
 
-    auto paramType = wrappedValueParam->getInterfaceType();
-    if (wrappedValueParam->isAutoClosure()) {
-      if (auto *fnType = paramType->getAs<FunctionType>())
-        paramType = fnType->getResult();
-    }
+      if (argumentParam->isInOut() || argumentParam->isVariadic())
+        continue;
 
-    // The parameter type must be the same as the type of `valueVar` or an
-    // autoclosure thereof.
-    if (!paramType->isEqual(valueVarType)) {
-      nonviable.push_back(
-          std::make_tuple(init, NonViableReason::ParameterTypeMismatch,
-                          paramType));
-      continue;
+      auto paramType = argumentParam->getInterfaceType();
+      if (argumentParam->isAutoClosure()) {
+        if (auto *fnType = paramType->getAs<FunctionType>())
+          paramType = fnType->getResult();
+      }
+
+      // The parameter type must be the same as the type of `valueVar` or an
+      // autoclosure thereof.
+      if (!paramType->isEqual(valueVarType)) {
+        nonviable.push_back(std::make_tuple(
+            init, NonViableReason::ParameterTypeMismatch, paramType));
+        continue;
+      }
     }
 
-    // Check the type
-    initialValueInitializers.push_back(init);
+    viableInitializers.push_back(init);
   }
 
   // If we found some nonviable candidates but no viable ones, complain.
-  if (initialValueInitializers.empty() && !nonviable.empty()) {
+  if (viableInitializers.empty() && !nonviable.empty()) {
     for (const auto &candidate : nonviable) {
       auto init = std::get<0>(candidate);
       auto reason = std::get<1>(candidate);
@@ -187,110 +218,15 @@ static ConstructorDecl *findInitialValueInit(
 
       case NonViableReason::ParameterTypeMismatch:
         init->diagnose(diag::property_wrapper_wrong_initial_value_init,
-                       init->getFullName(), paramType, valueVarType);
+                       init->getFullName(), paramType,
+                       valueVar->getValueInterfaceType());
         valueVar->diagnose(diag::decl_declared_here, valueVar->getFullName());
         break;
       }
     }
   }
 
-  return initialValueInitializers.empty() ? nullptr
-                                          : initialValueInitializers.front();
-}
-
-/// Determine whether we have a suitable init() within a property
-/// wrapper type.
-static ConstructorDecl *findDefaultInit(ASTContext &ctx,
-                                        NominalTypeDecl *nominal) {
-  SmallVector<ConstructorDecl *, 2> defaultValueInitializers;
-  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 || init->isGeneric())
-      continue;
-
-    assert(init->hasParameterList());
-    // 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.
-    //
-    // A constructor with no parameters will satisfy the check below.
-    bool allParamsHaveDefaultArg = llvm::all_of(
-        init->getParameters()->getArray(),
-        [](const ParamDecl *decl) { return decl->isDefaultArgument(); });
-
-    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;
-
-  case 1:
-    break;
-
-  default:
-    // Diagnose ambiguous default value initializers.
-    nominal->diagnose(diag::property_wrapper_ambiguous_default_value_init,
-                      nominal->getDeclaredType());
-    for (auto init : defaultValueInitializers) {
-      init->diagnose(diag::kind_declname_declared_here,
-                     init->getDescriptiveKind(), init->getFullName());
-    }
-    return nullptr;
-  }
-
-  // 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,
-                     init->getFormalAccess(), init->getDescriptiveKind(),
-                     init->getFullName(), nominal->getDeclaredType(),
-                     nominal->getFormalAccess());
-    return nullptr;
-  }
-
-  // The initializer must not be failable.
-  if (init->isFailable()) {
-    init->diagnose(diag::property_wrapper_failable_init, initName);
-    return nullptr;
-  }
-
-  return init;
+  return viableInitializers.empty() ? nullptr : viableInitializers.front();
 }
 
 /// Determine whether we have a suitable static subscript to which we
@@ -376,10 +312,11 @@ PropertyWrapperTypeInfoRequest::evaluate(
 
   PropertyWrapperTypeInfo result;
   result.valueVar = valueVar;
-  if (findInitialValueInit(ctx, nominal, valueVar, ctx.Id_wrappedValue))
+  if (findSuitableWrapperInit(ctx, nominal, valueVar,
+                              PropertyWrapperInitKind::WrappedValue))
     result.wrappedValueInit = PropertyWrapperTypeInfo::HasWrappedValueInit;
-  else if (auto init = findInitialValueInit(
-               ctx, nominal, valueVar, ctx.Id_initialValue)) {
+  else if (auto init = findSuitableWrapperInit(
+               ctx, nominal, valueVar, PropertyWrapperInitKind::InitialValue)) {
     result.wrappedValueInit = PropertyWrapperTypeInfo::HasInitialValueInit;
 
     if (init->getLoc().isValid()) {
@@ -396,7 +333,11 @@ PropertyWrapperTypeInfoRequest::evaluate(
     }
   }
 
-  result.defaultInit = findDefaultInit(ctx, nominal);
+  if (findSuitableWrapperInit(ctx, nominal, /*valueVar=*/nullptr,
+                              PropertyWrapperInitKind::Default)) {
+    result.defaultInit = PropertyWrapperTypeInfo::HasDefaultValueInit;
+  }
+
   result.projectedValueVar =
     findValueProperty(ctx, nominal, ctx.Id_projectedValue,
                       /*allowMissing=*/true);

trunk/test/decl/var/property_wrappers.swift

@@ -1730,7 +1730,7 @@ struct TestConcrete1 {
 // Two initializers that can default initialize the wrapper //
 
 @propertyWrapper
-struct SR_11477_W1 { // Okay, because we'll pick the best one here
+struct SR_11477_W1 { // Okay
   let name: String
 
   init() {
@@ -1749,12 +1749,14 @@ struct SR_11477_W1 { // Okay, because we'll pick the best one here
 // 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}}
+struct SR_11477_W2 { // Okay
   let name: String
 
-  init(anotherName: String = "DefaultParamInit") {} // expected-note {{initializer 'init(anotherName:)' declared here}}
+  init(anotherName: String = "DefaultParamInit1") {
+    self.name = anotherName
+  }
 
-  init(name: String = "DefaultParamInit") { // expected-note {{initializer 'init(name:)' declared here}}
+  init(name: String = "DefaultParamInit2") {
     self.name = name
   }