improve the DI diagnostic for uses of self in a non-delegating protocol initializer,

which is most likely because someone forgot to chain to self.init completely.



Swift SVN r30187

Author: lattner

include/swift/AST/DiagnosticsSIL.def

@@ -117,6 +117,9 @@ ERROR(self_use_before_fully_init,sil_analysis,none,
       "super.init initializes self}2", (Identifier, bool, bool))
 ERROR(use_of_self_before_fully_init,sil_analysis,none,
       "'self' used before all stored properties are initialized", ())
+ERROR(use_of_self_before_fully_init_protocol,sil_analysis,none,
+      "'self' used before chaining to another self.init requirement", ())
+
 
 NOTE(stored_property_not_initialized,sil_analysis,none,
      "'%0' not initialized", (StringRef))

lib/SILPasses/DIMemoryUseCollector.cpp

@@ -711,9 +711,10 @@ void ElementUseCollector::collectUses(SILValue Pointer, unsigned BaseEltNo) {
         // individual sub-member is passed as inout, then we model that as an
         // inout use.
         auto Kind = DIUseKind::InOutUse;
-        if (TheMemory.isStructInitSelf() && Pointer == TheMemory.getAddress())
+        if ((TheMemory.isStructInitSelf() || TheMemory.isProtocolInitSelf()) &&
+            Pointer == TheMemory.getAddress())
           Kind = DIUseKind::Escape;
-          
+ 
         addElementUses(BaseEltNo, PointeeType, User, Kind);
         continue;
       }

lib/SILPasses/DefiniteInitialization.cpp

@@ -397,9 +397,11 @@ namespace {
 
     void handleStoreUse(unsigned UseID);
     void handleInOutUse(const DIMemoryUse &Use);
+    void handleEscapeUse(const DIMemoryUse &Use);
 
     void handleLoadUseFailure(const DIMemoryUse &InstInfo,
                               bool IsSuperInitComplete);
+
     void handleSuperInitUse(const DIMemoryUse &InstInfo);
     void handleSelfInitUse(DIMemoryUse &InstInfo);
     void updateInstructionForInitState(DIMemoryUse &InstInfo);
@@ -519,6 +521,13 @@ void LifetimeChecker::noteUninitializedMembers(const DIMemoryUse &Use) {
   assert(TheMemory.isAnyInitSelf() && !TheMemory.isDelegatingInit() &&
          "Not an designated initializer");
 
+  // Root protocol initializers (ones that reassign to self, not delegating to
+  // self.init) have no members to initialize and self itself has already been
+  // reported to be uninit in the primary diagnostic.
+  if (TheMemory.isProtocolInitSelf())
+    return;
+
+
   // Determine which members, specifically are uninitialized.
   AvailabilitySet Liveness =
     getLivenessAtInst(Use.Inst, Use.FirstElement, Use.NumElements);
@@ -666,47 +675,8 @@ void LifetimeChecker::doIt() {
     case DIUseKind::InOutUse:
       handleInOutUse(Use);
       break;
-
     case DIUseKind::Escape:
-      if (!isInitializedAtUse(Use)) {
-        Diag<StringRef> DiagMessage;
-
-        // This is a use of an uninitialized value.  Emit a diagnostic.
-        if (TheMemory.isDelegatingInit()) {
-          DiagMessage = diag::self_use_before_init_in_delegatinginit;
-          
-          // If this is a load with a single user that is a return, then this is
-          // a return before self.init.   Emit a specific diagnostic.
-          if (auto *LI = dyn_cast<LoadInst>(Inst))
-            if (LI->hasOneUse() &&
-                isa<ReturnInst>((*LI->use_begin())->getUser())) {
-              if (shouldEmitError(Inst))
-                diagnose(Module, Inst->getLoc(),
-                         diag::return_from_init_without_self_init);
-              break;
-            }
-          if (isa<ReturnInst>(Inst)) {
-            if (shouldEmitError(Inst))
-              diagnose(Module, Inst->getLoc(),
-                       diag::return_from_init_without_self_init);
-            break;
-          }
-        } else if (isa<ApplyInst>(Inst) && TheMemory.isStructInitSelf()) {
-          if (shouldEmitError(Inst)) {
-            diagnose(Module, Inst->getLoc(),
-                     diag::use_of_self_before_fully_init);
-            noteUninitializedMembers(Use);
-          }
-          break;
-        } else if (isa<MarkFunctionEscapeInst>(Inst))
-          DiagMessage = diag::global_variable_function_use_uninit;
-        else if (isa<AddressToPointerInst>(Inst))
-          DiagMessage = diag::variable_addrtaken_before_initialized;
-        else
-          DiagMessage = diag::variable_escape_before_initialized;
-
-        diagnoseInitError(Use, DiagMessage);
-      }
+      handleEscapeUse(Use);
       break;
     case DIUseKind::SuperInit:
       handleSuperInitUse(Use);
@@ -739,6 +709,7 @@ void LifetimeChecker::doIt() {
     handleConditionalDestroys(ControlVariable);
 }
 
+
 void LifetimeChecker::handleStoreUse(unsigned UseID) {
   DIMemoryUse &InstInfo = Uses[UseID];
 
@@ -912,6 +883,60 @@ void LifetimeChecker::handleInOutUse(const DIMemoryUse &Use) {
   }
 }
 
+void LifetimeChecker::handleEscapeUse(const DIMemoryUse &Use) {
+  // The value must be fully initialized at all escape points.  If not, diagnose
+  // the error.
+  if (isInitializedAtUse(Use))
+    return;
+
+  auto Inst = Use.Inst;
+
+  // This is a use of an uninitialized value.  Emit a diagnostic.
+  if (TheMemory.isDelegatingInit()) {
+    // If this is a load with a single user that is a return, then this is
+    // a return before self.init.   Emit a specific diagnostic.
+    if (auto *LI = dyn_cast<LoadInst>(Inst))
+      if (LI->hasOneUse() &&
+          isa<ReturnInst>((*LI->use_begin())->getUser())) {
+        if (!shouldEmitError(Inst)) return;
+        diagnose(Module, Inst->getLoc(),
+                 diag::return_from_init_without_self_init);
+        return;
+      }
+    if (isa<ReturnInst>(Inst)) {
+      if (!shouldEmitError(Inst)) return;
+      diagnose(Module, Inst->getLoc(),
+               diag::return_from_init_without_self_init);
+      return;
+    }
+
+    return diagnoseInitError(Use, diag::self_use_before_init_in_delegatinginit);
+  }
+
+  if (isa<ApplyInst>(Inst) && TheMemory.isAnyInitSelf() &&
+      !TheMemory.isClassInitSelf()) {
+    if (!shouldEmitError(Inst)) return;
+
+    auto diagID = diag::use_of_self_before_fully_init;
+    if (TheMemory.isProtocolInitSelf())
+      diagID = diag::use_of_self_before_fully_init_protocol;
+
+    diagnose(Module, Inst->getLoc(), diagID);
+    noteUninitializedMembers(Use);
+    return;
+  }
+
+  Diag<StringRef> DiagMessage;
+  if (isa<MarkFunctionEscapeInst>(Inst))
+    DiagMessage = diag::global_variable_function_use_uninit;
+  else if (isa<AddressToPointerInst>(Inst))
+    DiagMessage = diag::variable_addrtaken_before_initialized;
+  else
+    DiagMessage = diag::variable_escape_before_initialized;
+
+  diagnoseInitError(Use, DiagMessage);
+}
+
 
 /// Failable enum initializer produce a CFG for the return that looks like this,
 /// where the load is the use of 'self'.  Detect this pattern so we can consider
@@ -1170,12 +1195,16 @@ void LifetimeChecker::handleLoadUseFailure(const DIMemoryUse &Use,
     return;
   }
 
-  // If this is a load of self in a struct/enum initializer, then it must be a
-  // use of 'self' before all the stored properties are set up.
+  // If this is a load of self in a struct/enum/protocol initializer, then it
+  // must be a use of 'self' before all the stored properties are set up.
   if (isa<LoadInst>(Inst) && TheMemory.isAnyInitSelf() &&
       !TheMemory.isClassInitSelf()) {
     if (!shouldEmitError(Inst)) return;
-    diagnose(Module, Inst->getLoc(), diag::use_of_self_before_fully_init);
+
+    auto diagID = diag::use_of_self_before_fully_init;
+    if (TheMemory.isProtocolInitSelf())
+      diagID = diag::use_of_self_before_fully_init_protocol;
+    diagnose(Module, Inst->getLoc(), diagID);
     noteUninitializedMembers(Use);
     return;
   }

test/SILPasses/definite_init_diagnostics.swift

@@ -1275,6 +1275,8 @@ class DerivedThrowingInitializer : ThrowingInitializer {
 protocol ProtocolInitTest {
   init()
   init(a : Int)
+
+  var i: Int { get set }
 }
 
 extension ProtocolInitTest {
@@ -1284,6 +1286,20 @@ extension ProtocolInitTest {
   init(b : Float) {
     self.init(a: 42)  // ok
   }
-}
 
+  init(test1 ii: Int) {
+    i = ii         // expected-error {{use of 'self' in delegating initializer before self.init is called}}
+    self.init()
+  }
+
+  init(test2 ii: Int) {
+    self = unsafeBitCast(0, Self.self)
+    i = ii
+  }
+
+  init(test3 ii: Int) {
+    i = ii                // expected-error {{'self' used before chaining to another self.init requirement}}
+    self = unsafeBitCast(0, Self.self)
+  }
+}