Merge pull request #2540 from nubbel/pr/sr-1469

[SilOptimizer] SR-1469: Issue diagnostic for `init?` at early return statement

Author: lattner

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -481,6 +481,9 @@ namespace {
     bool isInitializedAtUse(const DIMemoryUse &Use,
                             bool *SuperInitDone = nullptr,
                             bool *FailedSelfUse = nullptr);
+    
+    bool hasUninitializedMemberAtInst(SILInstruction *Inst, unsigned FirstElt,
+                                      unsigned NumElts);
 
     void handleStoreUse(unsigned UseID);
     void handleInOutUse(const DIMemoryUse &Use);
@@ -1329,13 +1332,23 @@ void LifetimeChecker::handleLoadUseFailure(const DIMemoryUse &Use,
     return;
   }
 
+  SILLocation Loc = Inst->getLoc();
+  
+  // Try to find the return location
+  auto TermLoc = Inst->getParent()->getTerminator()->getLoc();
+  if (TermLoc.getKind() == SILLocation::ReturnKind) {
+    Loc = TermLoc;
+  }
+    
   // If this is a load with a single user that is a return (and optionally a
   // retain_value for non-trivial structs/enums), then this is a return in the
   // enum/struct init case, and we haven't stored to self.   Emit a specific
   // diagnostic.
   if (auto *LI = dyn_cast<LoadInst>(Inst)) {
     bool hasReturnUse = false, hasUnknownUses = false;
 
+    auto *LoadBB = LI->getParent();
+    
     for (auto LoadUse : LI->getUses()) {
       auto *User = LoadUse->getUser();
 
@@ -1349,6 +1362,18 @@ void LifetimeChecker::handleLoadUseFailure(const DIMemoryUse &Use,
 
       if (auto *EI = dyn_cast<EnumInst>(User))
         if (isFailableInitReturnUseOfEnum(EI)) {
+          // Try to find the return location
+          for (auto Pred : LoadBB->getPreds()) {
+            auto *TI = Pred->getTerminator();
+            auto TermLoc = TI->getLoc();
+            
+            // Check if this is an early return with uninitialized members
+            if (TermLoc.getKind() == SILLocation::ReturnKind &&
+                hasUninitializedMemberAtInst(TI, Use.FirstElement,
+                                             Use.NumElements))
+              Loc = TermLoc;
+          }
+
           hasReturnUse = true;
           continue;
         }
@@ -1360,13 +1385,13 @@ void LifetimeChecker::handleLoadUseFailure(const DIMemoryUse &Use,
     if (hasReturnUse && !hasUnknownUses) {
       if (TheMemory.isEnumInitSelf()) {
         if (!shouldEmitError(Inst)) return;
-        diagnose(Module, Inst->getLoc(),
+        diagnose(Module, Loc,
                  diag::return_from_init_without_initing_self);
         return;
       } else if (TheMemory.isAnyInitSelf() && !TheMemory.isClassInitSelf() &&
                  !TheMemory.isDelegatingInit()) {
         if (!shouldEmitError(Inst)) return;
-        diagnose(Module, Inst->getLoc(),
+        diagnose(Module, Loc,
                  diag::return_from_init_without_initing_stored_properties);
         noteUninitializedMembers(Use);
         return;
@@ -2446,6 +2471,21 @@ bool LifetimeChecker::isInitializedAtUse(const DIMemoryUse &Use,
   return true;
 }
 
+bool LifetimeChecker::hasUninitializedMemberAtInst(SILInstruction *Inst,
+                                                   unsigned FirstElt,
+                                                   unsigned NumElts) {
+  // Determine the liveness states of the elements that we care about.
+  AvailabilitySet Liveness =
+  getLivenessAtInst(Inst, FirstElt, NumElts);
+  
+  // Find unintialized member
+  for (unsigned i = FirstElt, e = i+NumElts;
+       i != e; ++i)
+    if (Liveness.get(i) != DIKind::Yes)
+      return true;
+  
+  return false;
+}
 
 
 

test/SILOptimizer/definite_init_diagnostics.swift

@@ -1215,3 +1215,71 @@ class r23013334Derived : rdar16119509_Base {
 
 }
 
+// sr-1469
+struct SR1469_Struct1 {
+  let a: Int
+  let b: Int // expected-note {{'self.b' not initialized}}
+  
+  init?(x: Int, y: Int) {
+    self.a = x
+    if y == 42 {
+      return // expected-error {{return from initializer without initializing all stored properties}}
+    }
+    // many lines later
+    self.b = y
+  }
+}
+
+struct SR1469_Struct2 {
+  let a: Int
+  let b: Int // expected-note {{'self.b' not initialized}}
+  
+  init?(x: Int, y: Int) {
+    self.a = x
+    return // expected-error {{return from initializer without initializing all stored properties}}
+  }
+}
+
+struct SR1469_Struct3 {
+  let a: Int
+  let b: Int // expected-note {{'self.b' not initialized}}
+  
+  init?(x: Int, y: Int) {
+    self.a = x
+    if y == 42 {
+      self.b = y
+      return
+    }
+  } // expected-error {{return from initializer without initializing all stored properties}}
+}
+
+enum SR1469_Enum1 {
+  case A, B
+  
+  init?(x: Int) {
+    if x == 42 {
+      return // expected-error {{return from enum initializer method without storing to 'self'}}
+    }
+    // many lines later
+    self = .A
+  }
+}
+
+enum SR1469_Enum2 {
+  case A, B
+  
+  init?() {
+    return // expected-error {{return from enum initializer method without storing to 'self'}}
+  }
+}
+enum SR1469_Enum3 {
+  case A, B
+  
+  init?(x: Int) {
+    if x == 42 {
+      self = .A
+      return
+    }
+  } // expected-error {{return from enum initializer method without storing to 'self'}}
+}
+