[DI] InitAccessors: Start marking initializes(...) properties as "out"

Adjust DI to recognize that "out" location without uses is uninitialized.

Author: xedin

include/swift/AST/DiagnosticsSIL.def

@@ -189,6 +189,9 @@ ERROR(ivar_not_initialized_at_superinit,none,
 ERROR(ivar_not_initialized_at_implicit_superinit,none,
       "property '%0' not initialized at implicitly generated super.init call",
       (StringRef, bool))
+ERROR(ivar_not_initialized_by_init_accessor,none,
+      "property %0 not initialized by init accessor",
+      (DeclName))
 
 ERROR(self_use_before_fully_init,none,
       "'self' used in %select{method call|property access}1 %0 before "

lib/SILOptimizer/Mandatory/DIMemoryUseCollector.cpp

@@ -31,6 +31,10 @@ using namespace ownership;
 //                                  Utility
 //===----------------------------------------------------------------------===//
 
+static bool isVariableOrResult(MarkUninitializedInst *MUI) {
+  return MUI->isVar() || MUI->isOut();
+}
+
 static void gatherDestroysOfContainer(const DIMemoryObjectInfo &memoryInfo,
                                       DIElementUseInfo &useInfo) {
   auto *uninitMemory = memoryInfo.getUninitializedValue();
@@ -106,7 +110,7 @@ computeMemorySILType(MarkUninitializedInst *MUI, SILValue Address) {
 
   // If this is a let variable we're initializing, remember this so we don't
   // allow reassignment.
-  if (!MUI->isVar())
+  if (!isVariableOrResult(MUI))
     return {MemorySILType, false};
 
   auto *VDecl = MUI->getLoc().getAsASTNode<VarDecl>();
@@ -459,7 +463,7 @@ DIMemoryObjectInfo::getPathStringToElement(unsigned Element,
 
   // If we are analyzing a variable, we can generally get the decl associated
   // with it.
-  if (MemoryInst->isVar())
+  if (isVariableOrResult(MemoryInst))
     return MemoryInst->getLoc().getAsASTNode<VarDecl>();
 
   // Otherwise, we can't.
@@ -516,7 +520,7 @@ SingleValueInstruction *DIMemoryObjectInfo::findUninitializedSelfValue() const {
       // If instruction is not a local variable, it could only
       // be some kind of `self` (root, delegating, derived etc.)
       // see \c MarkUninitializedInst::Kind for more details.
-      if (!MUI->isVar())
+      if (!isVariableOrResult(MUI))
         return ::getUninitializedValue(MUI);
     }
   }
@@ -525,7 +529,7 @@ SingleValueInstruction *DIMemoryObjectInfo::findUninitializedSelfValue() const {
 
 ConstructorDecl *DIMemoryObjectInfo::getActorInitSelf() const {
   // is it 'self'?
-  if (!MemoryInst->isVar())
+  if (!isVariableOrResult(MemoryInst)) {
     if (auto decl =
         dyn_cast_or_null<ClassDecl>(getASTType()->getAnyNominal()))
       // is it for an actor?
@@ -535,6 +539,7 @@ ConstructorDecl *DIMemoryObjectInfo::getActorInitSelf() const {
           if (auto *ctor = dyn_cast_or_null<ConstructorDecl>(
                             silFn->getDeclContext()->getAsDecl()))
             return ctor;
+  }
 
   return nullptr;
 }

lib/SILOptimizer/Mandatory/DIMemoryUseCollector.h

@@ -116,7 +116,9 @@ class DIMemoryObjectInfo {
   unsigned getNumElements() const { return NumElements; }
 
   /// Return true if this is 'self' in any kind of initializer.
-  bool isAnyInitSelf() const { return !MemoryInst->isVar(); }
+  bool isAnyInitSelf() const {
+    return !MemoryInst->isVar() && !MemoryInst->isOut();
+  }
 
   /// Return uninitialized value of 'self' if current memory object
   /// is located in an initializer (of any kind).
@@ -150,7 +152,7 @@ class DIMemoryObjectInfo {
     if (MemoryInst->isDelegatingSelf())
       return false;
 
-    if (!MemoryInst->isVar()) {
+    if (!MemoryInst->isVar() && !MemoryInst->isOut()) {
       if (auto decl = getASTType()->getAnyNominal()) {
         if (isa<ClassDecl>(decl)) {
           return true;
@@ -223,6 +225,8 @@ class DIMemoryObjectInfo {
     return MemoryInst->isDelegatingSelfAllocated();
   }
 
+  bool isOut() const { return MemoryInst->isOut(); }
+
   enum class EndScopeKind { Borrow, Access };
 
   /// Given an element number (in the flattened sense) return a pointer to a

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -1152,6 +1152,18 @@ void LifetimeChecker::doIt() {
     return;
   }
 
+  // All of the indirect results marked as "out" have to be fully initialized
+  // before their lifetime ends.
+  if (TheMemory.isOut() && Uses.empty()) {
+    auto loc = TheMemory.getLoc();
+
+    std::string propertyName;
+    auto *property = TheMemory.getPathStringToElement(0, propertyName);
+    diagnose(Module, F.getLocation(),
+             diag::ivar_not_initialized_by_init_accessor, property->getName());
+    EmittedErrorLocs.push_back(loc);
+  }
+
   // If the memory object has nontrivial type, then any destroy/release of the
   // memory object will destruct the memory.  If the memory (or some element
   // thereof) is not initialized on some path, the bad things happen.  Process

test/SILOptimizer/init_accessor_definite_init_diagnostics.swift

@@ -0,0 +1,117 @@
+// RUN: %target-swift-frontend -enable-experimental-feature InitAccessors -enable-copy-propagation=requested-passes-only -emit-sil -primary-file %s -o /dev/null -verify
+
+// REQUIRES: asserts
+
+struct Test1 {
+  var x: Int // expected-note {{variable defined here}}
+  var y: Int // expected-note {{variable defined here}}
+  var full: (Int, Int)
+
+  var test1: (Int, Int) {
+    init(initialValue) initializes(y full) accesses(x) {
+      self.full = (self.x, self.y) // expected-error {{variable 'y' used before being initialized}}
+    }
+
+    get { full }
+    set { self.full = newValue }
+  }
+
+  var pointY: Int {
+    init(initialValue) initializes(y) {
+      self.y = initialValue // Ok
+    }
+  }
+
+  var errorPoint1: (Int, Int) {
+    init(initialValue) initializes(x y) {
+      // expected-error@-1 {{property 'x' not initialized by init accessor}}
+      // expected-error@-2 {{property 'y' not initialized by init accessor}}
+    }
+  }
+
+  var errorPoint2: (Int, Int) {
+    init(initialValue) initializes(x y) {
+      // expected-error@-1 {{property 'y' not initialized by init accessor}}
+      self.x = initialValue.0
+    }
+  }
+
+  var errorPoint3: (Int, Int) {
+    init(initialValue) initializes(x y) {
+      self.y = initialValue.1
+      print(y) // Ok
+      print(x) // expected-error {{variable 'x' used before being initialized}}
+    }
+  }
+}
+
+struct TestPartial {
+  var x: Int
+  var y: Int
+
+  var point: (Int, Int) {
+    init(initialValue) initializes(x y) {
+      self.x = initialValue.0
+      self.y = initialValue.1
+    }
+
+    get { (x, y) }
+    set { }
+  }
+
+  init(x: Int, y: Int) {
+    self.x = x
+    self.point = (x, y) // expected-error {{'self' used before all stored properties are initialized}}
+  }
+
+  init(_ x: Int, _ y: Int) {
+    self.x = x
+    self.y = y
+    self.point = (x, y) // Ok (calls a setter)
+  }
+}
+
+struct TestDoubleInit1 {
+  let x: Int // expected-note {{change 'let' to 'var' to make it mutable}}
+
+  var invalidPointX: Int {
+    init(initialValue) initializes(x) {
+      self.x = initialValue
+      self.x = 42 // expected-error {{immutable value 'x' may only be initialized once}}
+    }
+  }
+}
+
+struct TestDoubleInit2 {
+  let x: Int
+
+  var pointX: Int {
+    init(initialValue) initializes(x) {
+      self.x = initialValue
+    }
+  }
+
+  init(x: Int) {
+    self.pointX = x
+    self.x = 0 // FIXME: should be an error because `x` is a `let` property
+  }
+}
+
+struct TestAccessBeforeInit {
+  var _x: Int
+  var x: Int {
+    init(initialValue) initializes(_x) accesses(y) {
+      _x = initialValue
+    }
+
+    get { _x }
+    set {}
+  }
+
+  var y: Int
+
+  init(x: Int, y: Int) {
+    self.x = x // expected-error {{variable 'self.y' used before being initialized}}
+    self.y = y
+  }
+}