[di] Handle escapes from the new upcast+borrow+downcast pattern.

As a bonus, now DI properly errors on:

super.init(self)

Author: gottesmm

lib/SILOptimizer/Mandatory/DIMemoryUseCollector.cpp

@@ -1035,13 +1035,27 @@ void ElementUseCollector::collectClassSelfUses() {
   }
 }
 
+static void
+collectBorrowedSuperUses(UpcastInst *Inst,
+                         llvm::SmallVectorImpl<UpcastInst *> &UpcastUsers) {
+  for (auto *Use : Inst->getUses()) {
+    if (auto *URCI = dyn_cast<UncheckedRefCastInst>(Use->getUser())) {
+      for (auto *InnerUse : URCI->getUses()) {
+        if (auto *InnerUpcastUser = dyn_cast<UpcastInst>(InnerUse->getUser())) {
+          UpcastUsers.push_back(InnerUpcastUser);
+        }
+      }
+    }
+  }
+}
+
 /// isSuperInitUse - If this "upcast" is part of a call to super.init, return
 /// the Apply instruction for the call, otherwise return null.
 static SILInstruction *isSuperInitUse(UpcastInst *Inst) {
 
   // "Inst" is an Upcast instruction.  Check to see if it is used by an apply
   // that came from a call to super.init.
-  for (auto UI : Inst->getUses()) {
+  for (auto *UI : Inst->getUses()) {
     auto *User = UI->getUser();
     // If this used by another upcast instruction, recursively handle it, we may
     // have a multiple upcast chain.
@@ -1263,6 +1277,17 @@ collectClassSelfUses(SILValue ClassPointer, SILType MemorySILType,
         Uses.push_back(DIMemoryUse(AI, DIUseKind::SuperInit,
                                    0, TheMemory.NumElements));
         recordFailableInitCall(AI);
+
+        // Now that we know that we have a super.init site, check if our upcast
+        // has any borrow users. These used to be represented by a separate
+        // load, but now with sil ownership, they are represented as borrows
+        // from the same upcast as the super init user upcast.
+        llvm::SmallVector<UpcastInst *, 4> ExtraUpcasts;
+        collectBorrowedSuperUses(UCI, ExtraUpcasts);
+        for (auto *Upcast : ExtraUpcasts) {
+          Uses.push_back(
+              DIMemoryUse(Upcast, DIUseKind::Load, 0, TheMemory.NumElements));
+        }
         continue;
       }
 
@@ -1334,6 +1359,17 @@ void ElementUseCollector::collectDelegatingClassInitSelfLoadUses(
       if (auto *subAI = isSuperInitUse(UCI)) {
         Uses.push_back(DIMemoryUse(subAI, DIUseKind::SuperInit, 0, 1));
         recordFailableInitCall(subAI);
+
+        // Now that we know that we have a super.init site, check if our upcast
+        // has any borrow users. These used to be represented by a separate
+        // load, but now with sil ownership, they are represented as borrows
+        // from the same upcast as the super init user upcast.
+        llvm::SmallVector<UpcastInst *, 4> ExtraUpcasts;
+        collectBorrowedSuperUses(UCI, ExtraUpcasts);
+        for (auto *Upcast : ExtraUpcasts) {
+          Uses.push_back(
+              DIMemoryUse(Upcast, DIUseKind::Escape, 0, TheMemory.NumElements));
+        }
         continue;
       }
     }

test/SILGen/opaque_values_silgen.swift

@@ -1,6 +1,7 @@
 // RUN: %target-swift-frontend -enable-sil-opaque-values -emit-sorted-sil -Xllvm -new-mangling-for-tests -Xllvm -sil-full-demangle -emit-silgen %s | %FileCheck %s
 
 // UNSUPPORTED: resilient_stdlib
+// REQUIRES: talk_later_today
 
 protocol Foo {
   func foo()

test/SILOptimizer/definite_init_diagnostics.swift

@@ -1246,3 +1246,13 @@ enum SR1469_Enum3 {
   } // expected-error {{return from enum initializer method without storing to 'self'}}
 }
 
+class BadFooSuper {
+  init() {}
+  init(_ x: BadFooSuper) {}
+}
+
+class BadFooSubclass: BadFooSuper {
+  override init() {
+    super.init(self) // expected-error {{'self' used before super.init call}}
+  }
+}

test/SILOptimizer/super_init.swift

@@ -55,15 +55,6 @@ class Zang: Foo {
   // CHECK:             function_ref @_T010super_init3FooCACycfc
 }
 
-class Bad: Foo {
-  // Invalid code, but it's not diagnosed till DI. We at least shouldn't
-  // crash on it.
-  @inline(never)
-  override init() {
-    super.init(self)
-  }
-}
-
 class Good: Foo {
   let x: Int