[TypeChecker] InitAccessors: Fix handling of defaultable init accessor properties during default init synthesis

Default initializable init properties shouldn't prevent default
init synthesis and such properties without anything to initialize
should be considered by it.

Author: xedin

lib/Sema/CodeSynthesis.cpp

@@ -877,12 +877,19 @@ bool AreAllStoredPropertiesDefaultInitableRequest::evaluate(
               if (llvm::any_of(initAccessorProperties, [&](const auto &entry) {
                     auto *property =
                         entry.second->getParentPatternBinding();
-                    return property->isInitialized(0);
+                    return property->isInitialized(0) ||
+                           property->isDefaultInitializable();
                   }))
                 return;
 
               if (VD->hasStorageOrWrapsStorage())
                 HasStorage = true;
+
+              // Treat an init accessor property that doesn't initialize other
+              // properties  as stored for initialization purposes.
+              if (auto *initAccessor = VD->getAccessor(AccessorKind::Init)) {
+                HasStorage |= initAccessor->getInitializedProperties().empty();
+              }
             });
 
         if (!HasStorage) continue;

test/Interpreter/init_accessors.swift

@@ -801,3 +801,49 @@ do {
 }
 // CHECK: Person(name: P)
 // CHECK-NEXT: Person(name: O)
+
+do {
+  struct TestDefaultInitializable : CustomStringConvertible {
+    var description: String {
+      "TestDefaultInitializable(a: \(a))"
+    }
+
+    var _a: Int?
+    var a: Int? {
+      @storageRestrictions(initializes: _a)
+      init { _a = newValue }
+      get { _a }
+    }
+  }
+
+  print(TestDefaultInitializable())
+  print(TestDefaultInitializable(a: 42))
+
+  struct TestMixedDefaultInitalizable : CustomStringConvertible {
+    var description: String {
+      "TestMixedDefaultInitalizable(a: \(a), b: \(b))"
+    }
+
+    var a: Int? {
+      init {}
+      get { nil }
+    }
+
+    var _b: String
+    var b: String? {
+      @storageRestrictions(initializes: _b)
+      init { self._b = (newValue ?? "") }
+      get { _b }
+      set { _b = newValue ?? "" }
+    }
+  }
+
+  print(TestMixedDefaultInitalizable())
+  print(TestMixedDefaultInitalizable(b: "Hello"))
+  print(TestMixedDefaultInitalizable(a: 42))
+}
+// CHECK: TestDefaultInitializable(a: nil)
+// CHECK-NEXT: TestDefaultInitializable(a: Optional(42))
+// CHECK-NEXT: TestMixedDefaultInitalizable(a: nil, b: Optional(""))
+// CHECK-NEXT: TestMixedDefaultInitalizable(a: nil, b: Optional("Hello"))
+// CHECK-NEXT: TestMixedDefaultInitalizable(a: nil, b: Optional(""))

test/decl/var/init_accessors.swift

@@ -530,7 +530,7 @@ extension TestStructPropWithoutSetter {
 }
 
 do {
-  class TestClassPropWithoutSetter {
+  class TestClassPropWithoutSetter { // expected-error {{class 'TestClassPropWithoutSetter' has no initializers}}
     var x: Int {
       init {
       }
@@ -539,6 +539,44 @@ do {
     }
   }
 
+  // This should generate only memberwise initializer because `a` doesn't have a default
+  struct TestStructWithoutSetter { // expected-note {{'init(a:)' declared here}}
+    var a: Int {
+      init {
+      }
+      get { 0 }
+    }
+  }
+
+  _ = TestStructWithoutSetter() // expected-error {{missing argument for parameter 'a' in call}}
+  _ = TestStructWithoutSetter(a: 42) // Ok
+
+  struct TestDefaultInitializable {
+    var a: Int? {
+      init {}
+      get { nil }
+    }
+  }
+
+  _ = TestDefaultInitializable() // Ok (`a` is initialized to `nil`)
+
+  struct TestMixedDefaultInitializable {
+    var a: Int? {
+      init {}
+      get { nil }
+    }
+
+    var _b: String
+    var b: String? {
+      @storageRestrictions(initializes: _b)
+      init { _b = newValue ?? "" }
+      get { _b }
+      set { _b = newValue ?? "" }
+    }
+  }
+
+  _ = TestMixedDefaultInitializable() // Ok (both `a` and `b` are initialized to `nil`)
+
   class SubTestPropWithoutSetter : TestClassPropWithoutSetter {
     init(otherV: Int) {
       x = otherV // Ok