suppress notes from DI about @_compilerInitialized when reasonable

Since the only user of `@_compilerInitialized` is distributed
actors, I decided to make DI's diagnostics saying that such a
var was not initialized a second-tier note. If there is some other
var associated with the same Memory that is _not_ compiler initialized
AND is also _not_ initialized, then we suppress the suggestion to initialize
the @_compilerInitialized thing, because something else is problematic. Only
when there are @_compilerInitialized things that are still not initialized,
do we emit a note talking about that.

Author: kavon

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -689,6 +689,9 @@ void LifetimeChecker::noteUninitializedMembers(const DIMemoryUse &Use) {
   AvailabilitySet Liveness =
     getLivenessAtInst(Use.Inst, Use.FirstElement, Use.NumElements);
 
+  SmallVector<std::function<void()>, 2> delayedNotes;
+  bool emittedNote = false;
+
   for (unsigned i = Use.FirstElement, e = Use.FirstElement+Use.NumElements;
        i != e; ++i) {
     if (Liveness.get(i) == DIKind::Yes) continue;
@@ -701,13 +704,34 @@ void LifetimeChecker::noteUninitializedMembers(const DIMemoryUse &Use) {
     auto *Decl = TheMemory.getPathStringToElement(i, Name);
     SILLocation Loc = Use.Inst->getLoc();
 
-    // If we found a non-implicit declaration, use its source location.
-    if (Decl && !Decl->isImplicit())
-      Loc = SILLocation(Decl);
+    if (Decl) {
+      // If we found a non-implicit declaration, use its source location.
+      if (!Decl->isImplicit())
+        Loc = SILLocation(Decl);
+
+      // If it's marked @_compilerInitialized, delay emission of the note.
+      if (Decl->getAttrs().hasAttribute<CompilerInitializedAttr>()) {
+        delayedNotes.push_back([=](){
+          diagnose(Module, Loc, diag::stored_property_not_initialized,
+             StringRef(Name));
+        });
+        continue;
+      }
+    }
 
     diagnose(Module, Loc, diag::stored_property_not_initialized,
              StringRef(Name));
+    emittedNote = true;
   }
+
+  // Drop the notes for @_compilerInitialized decls if we emitted a note for
+  // other ones that do not have that attr.
+  if (emittedNote)
+    return;
+
+  // otherwise, emit delayed notes.
+  for (auto &emitter : delayedNotes)
+    emitter();
 }
 
 /// Given a use that has at least one uninitialized element in it, produce a

test/SILOptimizer/definite_init.swift

@@ -56,7 +56,23 @@ func tuple_test() -> Int {
 
 class CheckCompilerInitAttr {
   @_compilerInitialized let poster: Int
-  init() {
+  var whatever: Int // expected-note {{'self.whatever' not initialized}}
+
+  init(v1: Void) {
+    whatever = 0
     poster = 10 // expected-error {{illegal assignment to '@_compilerInitialized' storage}}
   }
+
+  // NB: this case is testing whether we only get a note for `whatever` and not `poster`
+  init(v2: Void) {} // expected-error {{return from initializer without initializing all stored properties}}
+}
+
+class AgainCheckCompilerInitAttr {
+  @_compilerInitialized let cleanup: Int // expected-note {{'self.cleanup' not initialized}}
+  var whenever: Int
+
+  // NB: this case ensures we still get a note for `cleanup` because no other properties are uninitialized
+  init() {
+    whenever = 0
+  } // expected-error {{return from initializer without initializing all stored properties}}
 }