[Property wrappers] Allow default initialization to infer a type.

Property wrappers are allowed to infer the type of a variable, but this
only worked when the property wrapper was provided with an explicit
initialization, e.g.,

    @WrapsAnInt() var x   // infers type Int from WrapsAnInt.wrappedValue

However, when default initialization is supported by the property wrapper,
dropping the parentheses would produce an error about the missing type
annotation

    @WrapsAnInt var x

Make this second case behave like the first, so that default initialization
works consistently with the explicitly-specified version.
Fixes rdar://problem/59471019.

Author: DougGregor

include/swift/AST/Decl.h

@@ -2186,6 +2186,9 @@ class PatternBindingDecl final : public Decl,
   /// Can the pattern at index i be default initialized?
   bool isDefaultInitializable(unsigned i) const;
 
+  /// Can the property wrapper be used to provide default initialization?
+  bool isDefaultInitializableViaPropertyWrapper(unsigned i) const;
+
   /// Does this pattern have a user-provided initializer expression?
   bool isExplicitlyInitialized(unsigned i) const;
 

lib/AST/Decl.cpp

@@ -1855,6 +1855,17 @@ bool Pattern::isNeverDefaultInitializable() const {
   return result;
 }
 
+bool PatternBindingDecl::isDefaultInitializableViaPropertyWrapper(unsigned i) const {
+  if (auto singleVar = getSingleVar()) {
+    if (auto wrapperInfo = singleVar->getAttachedPropertyWrapperTypeInfo(0)) {
+      if (wrapperInfo.defaultInit)
+        return true;
+    }
+  }
+
+  return false;
+}
+
 bool PatternBindingDecl::isDefaultInitializable(unsigned i) const {
   const auto entry = getPatternList()[i];
 
@@ -1864,13 +1875,13 @@ bool PatternBindingDecl::isDefaultInitializable(unsigned i) const {
 
   // If the outermost attached property wrapper vends an `init()`, use that
   // for default initialization.
+  if (isDefaultInitializableViaPropertyWrapper(i))
+    return true;
+
+  // If one of the attached wrappers is missing an initialValue
+  // initializer, cannot default-initialize.
   if (auto singleVar = getSingleVar()) {
     if (auto wrapperInfo = singleVar->getAttachedPropertyWrapperTypeInfo(0)) {
-      if (wrapperInfo.defaultInit)
-        return true;
-
-      // If one of the attached wrappers is missing an initialValue
-      // initializer, cannot default-initialize.
       if (!singleVar->allAttachedPropertyWrappersHaveInitialValueInit())
         return false;
     }

lib/AST/Pattern.cpp

@@ -516,8 +516,10 @@ PatternBindingDecl *ContextualPattern::getPatternBindingDecl() const {
 }
 
 bool ContextualPattern::allowsInference() const {
-  if (auto pbd = getPatternBindingDecl())
-    return pbd->isInitialized(index);
+  if (auto pbd = getPatternBindingDecl()) {
+    return pbd->isInitialized(index) ||
+        pbd->isDefaultInitializableViaPropertyWrapper(index);
+  }
 
   return true;
 }

lib/Sema/ConstraintSystem.cpp

@@ -4188,12 +4188,21 @@ void SolutionApplicationTarget::maybeApplyPropertyWrapper() {
       return;
 
     backingInitializer = wrappedInitializer;
-  } else if (auto outermostArg = outermostWrapperAttr->getArg()) {
+  } else {
     Type outermostWrapperType =
         singleVar->getAttachedPropertyWrapperType(0);
     if (!outermostWrapperType)
       return;
 
+    // Retrieve the outermost wrapper argument. If there isn't one, we're
+    // performing default initialization.
+    auto outermostArg = outermostWrapperAttr->getArg();
+    if (!outermostArg) {
+      SourceLoc fakeParenLoc = outermostWrapperAttr->getRange().End;
+      outermostArg = TupleExpr::createEmpty(
+          ctx, fakeParenLoc, fakeParenLoc, /*Implicit=*/true);
+    }
+
     auto typeExpr = TypeExpr::createImplicitHack(
         outermostWrapperAttr->getTypeLoc().getLoc(),
         outermostWrapperType, ctx);
@@ -4203,8 +4212,6 @@ void SolutionApplicationTarget::maybeApplyPropertyWrapper() {
         outermostWrapperAttr->getArgumentLabelLocs(),
         /*hasTrailingClosure=*/false,
         /*implicit=*/false);
-  } else {
-    llvm_unreachable("No initializer anywhere?");
   }
   wrapperAttrs[0]->setSemanticInit(backingInitializer);
 

test/decl/var/property_wrappers.swift

@@ -1877,7 +1877,7 @@ open class OpenPropertyWrapperWithPublicInit {
   public init(wrappedValue: String) { // Okay
     self.wrappedValue = wrappedValue
   }
-  
+
   open var wrappedValue: String = "Hello, world"
 }
 
@@ -1895,3 +1895,28 @@ func sr_11654_generic_func<T>(_ argument: T?) -> T? {
 
 let sr_11654_c = SR_11654_C()
 _ = sr_11654_generic_func(sr_11654_c.property) // Okay
+
+// rdar://problem/59471019 - property wrapper initializer requires empty parens
+// for default init
+@propertyWrapper
+struct DefaultableIntWrapper {
+  var wrappedValue: Int
+
+  init() {
+    self.wrappedValue = 0
+  }
+}
+
+struct TestDefaultableIntWrapper {
+  @DefaultableIntWrapper var x
+  @DefaultableIntWrapper() var y
+  @DefaultableIntWrapper var z: Int
+
+  mutating func test() {
+    x = y
+    y = z
+  }
+}
+
+
+