CanonicalOSSALifetime: Add convertExtractToDestructure utility

struct_extract and tuple_extract do not belong in OSSA (except to
workaround certain extreme cases). They completely defeat
simplification that OSSA provides for optimizing owned lifetimes.

Copy propagation uses this utility to canonicalize owned values before
canonicalizing their lifetime.

Author: atrick

include/swift/SILOptimizer/Utils/CanonicalOSSALifetime.h

@@ -103,6 +103,18 @@
 
 namespace swift {
 
+/// Convert this struct_extract into a copy+destructure. Return the destructured
+/// result or invalid SILValue. The caller must delete the extract and its
+/// now-dead copy use.
+///
+// If a copied-def is a struct-extract, attempt a destructure conversion
+//   %extract = struct_extract %... : $TypeWithSingleOwnershipValue
+//   %copy = copy_value %extract : $OwnershipValue
+// To:
+//   %copy = copy_value %extract : $TypeWithSingleOwnershipValue
+//   (%extracted,...) = destructure %copy : $TypeWithSingleOwnershipValue
+SILValue convertExtractToDestructure(StructExtractInst *extract);
+
 /// Information about consumes on the extended-lifetime boundary. Consuming uses
 /// within the lifetime are not included--they will consume a copy after
 /// rewriting. For borrowed def values, the consumes do not include the end of

lib/SILOptimizer/Transforms/CopyPropagation.cpp

@@ -100,13 +100,50 @@ void CopyPropagation::run() {
       }
     }
   }
+  // Push copy_value instructions above their struct_extract operands by
+  // inserting destructures.
+  //
+  // copiedDefs be be modified, but it never shrinks
+  for (unsigned idx = 0; idx < copiedDefs.size(); ++idx) {
+    SILValue def = copiedDefs[idx];
+    auto *copy = dyn_cast<CopyValueInst>(def);
+    if (!copy)
+      continue;
+
+    auto *extract = dyn_cast<StructExtractInst>(copy->getOperand());
+    if (!extract
+        || SILValue(extract).getOwnershipKind() != OwnershipKind::Guaranteed)
+      continue;
+
+    if (SILValue destructuredResult = convertExtractToDestructure(extract)) {
+      // Remove to-be-deleted instructions from copiedDeds. The extract cannot
+      // be in the copiedDefs set since getCanonicalCopiedDef does not allow a
+      // guaranteed projection to be a canonical def.
+      copiedDefs.remove(copy);
+      --idx; // point back to the current element, which was erased.
+
+      // TODO: unfortunately SetVector has no element replacement.
+      copiedDefs.insert(destructuredResult);
+
+      auto *destructure = cast<DestructureStructInst>(
+          destructuredResult.getDefiningInstruction());
+      auto *newCopy = cast<CopyValueInst>(destructure->getOperand());
+      copiedDefs.insert(
+          CanonicalizeOSSALifetime::getCanonicalCopiedDef(newCopy));
+
+      LLVM_DEBUG(llvm::dbgs() << "Destructure Conversion:\n"
+                              << *extract << "  to " << *destructure);
+      // Delete both the copy and the extract.
+      InstructionDeleter().recursivelyDeleteUsersIfDead(extract);
+    }
+  }
   // Perform copy propgation for each copied value.
   CanonicalizeOSSALifetime canonicalizer(pruneDebug, poisonRefs,
                                          accessBlockAnalysis,
                                          dominanceAnalysis,
                                          deBlocksAnalysis->get(f));
   // Cleanup dead copies. If getCanonicalCopiedDef returns a copy (because the
-  // copy's source operand is unrecgonized), then the copy is itself treated
+  // copy's source operand is unrecgonized), then thecan copy is itself treated
   // like a def and may be dead after canonicalization.
   llvm::SmallVector<CopyValueInst *, 4> deadCopies;
   for (auto &def : copiedDefs) {

lib/SILOptimizer/Utils/CanonicalOSSALifetime.cpp

@@ -114,6 +114,32 @@ static void copyLiveUse(Operand *use) {
   LLVM_DEBUG(llvm::dbgs() << "  Copying at last use " << *copy);
 }
 
+// TODO: generalize this to handle multiple nondebug uses of the struct_extract.
+SILValue swift::convertExtractToDestructure(StructExtractInst *extract) {
+  if (!hasOneNonDebugUse(extract))
+    return nullptr;
+
+  if (!extract->isFieldOnlyNonTrivialField())
+    return nullptr;
+
+  auto *extractCopy =
+      dyn_cast<CopyValueInst>(getNonDebugUses(extract).begin()->getUser());
+  if (!extractCopy)
+    return nullptr;
+
+  SILBuilderWithScope builder(extract);
+  auto loc = extract->getLoc();
+  auto *copy = builder.createCopyValue(loc, extract->getOperand());
+  auto *destructure = builder.createDestructureStruct(loc, copy);
+
+  SILValue nonTrivialResult = destructure->getResult(extract->getFieldIndex());
+  assert(!nonTrivialResult->getType().isTrivial(*destructure->getFunction())
+         && "field idx mismatch");
+
+  extractCopy->replaceAllUsesWith(nonTrivialResult);
+  return nonTrivialResult;
+}
+
 //===----------------------------------------------------------------------===//
 //                        MARK: Rewrite borrow scopes
 //===----------------------------------------------------------------------===//