[Sema] InitAccessors: Diagnose situations when memberwise init cannot be synthesized

If some of the properties with init accessors have out of order
accesses diagnose that while checking whether memberwise init
could be synthesized.

Author: xedin

include/swift/AST/DiagnosticsSema.def

@@ -7304,6 +7304,13 @@ ERROR(init_accessor_invalid_member_ref,none,
       "refer to instance properties listed in 'initializes' and "
       "'accesses' attributes",
       (DeclNameRef))
+ERROR(cannot_synthesize_memberwise_due_to_property_init_order,none,
+      "cannot synthesize memberwise initializer",
+      ())
+NOTE(out_of_order_access_in_init_accessor,none,
+     "init accessor for %0 cannot access stored property %1 because it "
+     "is called before %1 is initialized",
+     (Identifier, Identifier))
 
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

lib/Sema/CodeSynthesis.cpp

@@ -1317,17 +1317,78 @@ HasMemberwiseInitRequest::evaluate(Evaluator &evaluator,
   if (hasUserDefinedDesignatedInit(evaluator, decl))
     return false;
 
+  std::multimap<VarDecl *, VarDecl *> initializedViaAccessor;
+  decl->collectPropertiesInitializableByInitAccessors(initializedViaAccessor);
+
+  llvm::SmallPtrSet<VarDecl *, 4> initializedProperties;
+  llvm::SmallVector<std::pair<VarDecl *, Identifier>> invalidOrderings;
+
   for (auto *member : decl->getMembers()) {
     if (auto *var = dyn_cast<VarDecl>(member)) {
       // If this is a backing storage property for a property wrapper,
       // skip it.
       if (var->getOriginalWrappedProperty())
         continue;
 
-      if (var->isMemberwiseInitialized(/*preferDeclaredProperties=*/true))
+      if (!var->isMemberwiseInitialized(/*preferDeclaredProperties=*/true))
+        continue;
+
+      // If init accessors are not involved, we are done.
+      if (initializedViaAccessor.empty())
         return true;
+
+      if (!initializedViaAccessor.count(var)) {
+        initializedProperties.insert(var);
+        continue;
+      }
+
+      // Check whether use of init accessors results in access to uninitialized
+      // properties.
+
+      for (auto iter = initializedViaAccessor.find(var);
+           iter != initializedViaAccessor.end(); ++iter) {
+        auto *initializerProperty = iter->second;
+        auto *initAccessor =
+            initializerProperty->getAccessor(AccessorKind::Init);
+
+        // Make sure that all properties accessed by init accessor
+        // are previously initialized.
+        if (auto accessAttr =
+                initAccessor->getAttrs().getAttribute<AccessesAttr>()) {
+          for (auto *property : accessAttr->getPropertyDecls(initAccessor)) {
+            if (!initializedProperties.count(property))
+              invalidOrderings.push_back(
+                  {initializerProperty, property->getName()});
+          }
+        }
+
+        // Record all of the properties initialized by calling init accessor.
+        if (auto initAttr =
+                initAccessor->getAttrs().getAttribute<InitializesAttr>()) {
+          auto properties = initAttr->getPropertyDecls(initAccessor);
+          initializedProperties.insert(properties.begin(), properties.end());
+        }
+      }
     }
   }
+
+  if (invalidOrderings.empty())
+    return !initializedProperties.empty();
+
+  {
+    auto &diags = decl->getASTContext().Diags;
+
+    diags.diagnose(
+        decl, diag::cannot_synthesize_memberwise_due_to_property_init_order);
+
+    for (const auto &invalid : invalidOrderings) {
+      auto *accessor = invalid.first->getAccessor(AccessorKind::Init);
+      diags.diagnose(accessor->getLoc(),
+                     diag::out_of_order_access_in_init_accessor,
+                     invalid.first->getName(), invalid.second);
+    }
+  }
+
   return false;
 }
 

test/decl/var/init_accessors.swift

@@ -50,6 +50,7 @@ func test_use_of_initializes_accesses_on_non_inits() {
       }
 
       get { x }
+      set { }
     }
 
     var _y: String {
@@ -63,6 +64,11 @@ func test_use_of_initializes_accesses_on_non_inits() {
       set(initialValue) accesses(x) {}
       // expected-error@-1 {{accesses(...) attribute could only be used with init accessors}}
     }
+
+    init(x: Int, y: String) {
+      self.y = y
+      self._x = x
+    }
   }
 }
 
@@ -103,6 +109,13 @@ func test_assignment_to_let_properties() {
         self.x = initialValue.0 // Ok
         self.y = initialValue.1 // Ok
       }
+
+      get { (x, y) }
+      set { }
+    }
+
+    init(x: Int, y: Int) {
+      self.point = (x, y)
     }
   }
 }
@@ -116,6 +129,12 @@ func test_duplicate_and_computed_lazy_properties() {
       init(initialValue) initializes(_b, _a) accesses(_a) {
         // expected-error@-1 {{property '_a' cannot be both initialized and accessed}}
       }
+
+      get { _a }
+      set { }
+    }
+
+    init() {
     }
   }
 
@@ -219,6 +238,8 @@ func test_invalid_references() {
     }
 
     func test() -> Int? { 42 }
+
+    init() {}
   }
 }
 
@@ -335,3 +356,19 @@ func test_memberwise_with_overlaps() {
 
   _ = Test3(a: "a", triple: ("b", 2, [1.0, 2.0]), b: 0, c: [1.0]) // Ok
 }
+
+func test_invalid_memberwise() {
+  struct Test1 { // expected-error {{cannot synthesize memberwise initializer}}
+    var _a: Int
+    var _b: Int
+
+    var a: Int {
+      init(initialValue) initializes(_a) accesses(_b) {
+        // expected-note@-1 {{init accessor for 'a' cannot access stored property '_b' because it is called before '_b' is initialized}}
+        _a = initialValue
+      }
+
+      get { _a }
+    }
+  }
+}