[DI] Given x' = load x; (apply (class_method x') x'), check the apply for DI violations, not class_method.

This is working around an additional use-list DI ordering issue that I exposed
when implementing High Level Memory Operations. Specifically, DI started to
error on:

  (class_method x)

instead of on:

  (apply (class_method x) x)

We would also try to emit an error on the apply, but we would squelch the apply
error (which is more accuracte) since we had already emitted the class_method
error.

This commit conservatively checks for this condition and skips the class method
so we can emit the more descriptive error on the apply.

Author: gottesmm

lib/SILOptimizer/Mandatory/DIMemoryUseCollector.cpp

@@ -1157,6 +1157,27 @@ static bool isSelfInitUse(SILArgument *Arg) {
   return isSelfInitUse(Pred->getTerminator());
 }
 
+/// Returns true if \p Method is a callee of a full apply site that takes in \p
+/// Pointer as an argument. In such a case, we want to ignore the class method
+/// use and allow for the use by the apply inst to take precedence.
+static bool shouldIgnoreClassMethodUseError(
+    ClassMethodInst *Method, SILValue Pointer) {
+
+  // In order to work around use-list ordering issues, if this method is called
+  // by an apply site that has I as an argument, we want to process the apply
+  // site for errors to emit, not the class method. If we do not obey these
+  // conditions, then continue to treat the class method as an escape.
+  auto CheckFullApplySite = [&](Operand *Op) -> bool {
+    FullApplySite FAS(Op->getUser());
+    if (!FAS || (FAS.getCallee() != Method))
+      return false;
+    return llvm::any_of(
+        FAS.getArgumentsWithoutIndirectResults(),
+        [&](SILValue Arg) -> bool { return Arg == Pointer; });
+  };
+
+  return llvm::any_of(Method->getUses(), CheckFullApplySite);
+}
 
 void ElementUseCollector::
 collectClassSelfUses(SILValue ClassPointer, SILType MemorySILType,
@@ -1197,6 +1218,12 @@ collectClassSelfUses(SILValue ClassPointer, SILType MemorySILType,
       continue;
     }
 
+    if (auto *Method = dyn_cast<ClassMethodInst>(User)) {
+      if (shouldIgnoreClassMethodUseError(Method, ClassPointer)){
+        continue;
+      }
+    }
+
     // If this is an upcast instruction, it is a conversion of self to the base.
     // This is either part of a super.init sequence, or a general superclass
     // access.
@@ -1324,23 +1351,29 @@ void ElementUseCollector::collectDelegatingClassInitSelfUses() {
           continue;
         }
 
-        // class_method that refers to an initializing constructor is a method
-        // lookup for delegation, which is ignored.
-        if (auto Method = dyn_cast<ClassMethodInst>(User)) {
+        if (auto *Method = dyn_cast<ClassMethodInst>(User)) {
+          // class_method that refers to an initializing constructor is a method
+          // lookup for delegation, which is ignored.
           if (Method->getMember().kind == SILDeclRef::Kind::Initializer)
             continue;
+
+          /// Returns true if \p Method used by an apply in a way that we know
+          /// will cause us to emit a better error.
+          if (shouldIgnoreClassMethodUseError(Method, LI))
+            continue;
         }
 
         // If this is an upcast instruction, it is a conversion of self to the
         // base.  This is either part of a super.init sequence, or a general
         // superclass access.  We special case super.init calls since they are
         // part of the object lifecycle.
-        if (auto *UCI = dyn_cast<UpcastInst>(User))
+        if (auto *UCI = dyn_cast<UpcastInst>(User)) {
           if (auto *subAI = isSuperInitUse(UCI)) {
             Uses.push_back(DIMemoryUse(subAI, DIUseKind::SuperInit, 0, 1));
             recordFailableInitCall(subAI);
             continue;
           }
+        }
 
         // We only track two kinds of uses for delegating initializers:
         // calls to self.init, and "other", which we choose to model as escapes.