[move-only] Implement the borrow-gep to destructure transform.

This enables us to emit the appropriate error for consuming uses of fields and
also causes us to eliminate copies exposed by using fields of a move only type
in a non-consuming way.

rdar://103271138

Author: gottesmm

include/swift/AST/DiagnosticsSIL.def

@@ -743,7 +743,13 @@ ERROR(sil_moveonlychecker_value_consumed_in_a_loop, none,
       "'%0' consumed by a use in a loop", (StringRef))
 ERROR(sil_moveonlychecker_exclusivity_violation, none,
       "'%0' has consuming use that cannot be eliminated due to a tight exclusivity scope", (StringRef))
+ERROR(sil_moveonlychecker_moveonly_field_consumed, none,
+      "'%0' has a move only field that was consumed before later uses", (StringRef))
 
+NOTE(sil_moveonlychecker_moveonly_field_consumed_here, none,
+     "move only field consumed here", ())
+NOTE(sil_moveonlychecker_boundary_use, none,
+     "boundary use here", ())
 NOTE(sil_moveonlychecker_consuming_use_here, none,
      "consuming use", ())
 NOTE(sil_moveonlychecker_consuming_closure_use_here, none,

include/swift/SILOptimizer/PassManager/Passes.def

@@ -460,6 +460,9 @@ PASS(MovedAsyncVarDebugInfoPropagator, "sil-moved-async-var-dbginfo-propagator",
      "Propagate debug info from moved async vars after coroutine funclet boundaries")
 PASS(MoveOnlyDeinitInsertion, "sil-move-only-deinit-insertion",
      "After running move only checking, convert last destroy_values to deinit calls")
+PASS(MoveOnlyBorrowToDestructureTransform, "sil-move-only-borrow-to-destructure",
+     "Utility pass that is used to test the borrow to destructure transform "
+     "independently of the move only object/address checkers")
 PASS(PruneVTables, "prune-vtables",
      "Mark class methods that do not require vtable dispatch")
 PASS_RANGE(AllPasses, AADumper, PruneVTables)

lib/SILOptimizer/Mandatory/CMakeLists.txt

@@ -24,10 +24,12 @@ target_sources(swiftSILOptimizer PRIVATE
   MovedAsyncVarDebugInfoPropagator.cpp
   MoveKillsCopyableAddressesChecker.cpp
   MoveKillsCopyableValuesChecker.cpp
-  MoveOnlyDiagnostics.cpp
-  MoveOnlyObjectChecker.cpp
   MoveOnlyAddressChecker.cpp
+  MoveOnlyBorrowToDestructureTransform.cpp
   MoveOnlyDeinitInsertion.cpp
+  MoveOnlyDiagnostics.cpp
+  MoveOnlyObjectChecker.cpp
+  MoveOnlyUtils.cpp
   NestedSemanticFunctionCheck.cpp
   OptimizeHopToExecutor.cpp
   PerformanceDiagnostics.cpp

lib/SILOptimizer/Mandatory/MoveOnlyAddressChecker.cpp

@@ -869,8 +869,7 @@ struct MoveOnlyChecker {
           instToDelete->eraseFromParent();
         })));
     canonicalizer.init(fn, accessBlockAnalysis, domTree, deleter);
-    diagnosticEmitter.fn = fn;
-    diagnosticEmitter.canonicalizer = &canonicalizer;
+    diagnosticEmitter.init(fn, &canonicalizer);
   }
 
   /// Search through the current function for candidate mark_must_check

lib/SILOptimizer/Mandatory/MoveOnlyBorrowToDestructureTransform.cpp

@@ -0,0 +1,149 @@
+//===--- MoveOnlyBorrowToDestructureTransform.cpp -------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file This is a utility pass that simulates how the move only object/address
+/// checker run the borrow to destructure transform. It is intended to be used
+/// only for testing purposes.
+///
+/// TODO: Once the BorrowToDestructureTransform moves to ./SILOptimizer/Utils,
+/// this should move to ./SILOptimizer/UtilityPasses
+///
+//===----------------------------------------------------------------------===//
+
+#define DEBUG_TYPE "sil-move-only-checker"
+
+#include "MoveOnlyDiagnostics.h"
+#include "MoveOnlyObjectChecker.h"
+
+#include "swift/Basic/Defer.h"
+#include "swift/SIL/SILInstruction.h"
+#include "swift/SILOptimizer/Analysis/Analysis.h"
+#include "swift/SILOptimizer/Analysis/DeadEndBlocksAnalysis.h"
+#include "swift/SILOptimizer/Analysis/PostOrderAnalysis.h"
+#include "swift/SILOptimizer/PassManager/Passes.h"
+#include "swift/SILOptimizer/PassManager/Transforms.h"
+#include "llvm/ADT/ArrayRef.h"
+
+using namespace swift;
+using namespace swift::siloptimizer;
+
+static bool runTester(SILFunction *fn,
+                      ArrayRef<MarkMustCheckInst *> moveIntroducersToProcess,
+                      PostOrderAnalysis *poa,
+                      DiagnosticEmitter &diagnosticEmitter) {
+  BorrowToDestructureTransform::IntervalMapAllocator allocator;
+  bool madeChange = false;
+  while (!moveIntroducersToProcess.empty()) {
+    auto *mmci = moveIntroducersToProcess.back();
+    moveIntroducersToProcess = moveIntroducersToProcess.drop_back();
+
+    StackList<BeginBorrowInst *> borrowWorklist(mmci->getFunction());
+
+    // If we failed to gather borrows due to the transform not understanding
+    // part of the SIL, fail and return false.
+    if (!BorrowToDestructureTransform::gatherBorrows(mmci, borrowWorklist))
+      return madeChange;
+
+    // If we do not have any borrows to process, continue and process the next
+    // instruction.
+    if (borrowWorklist.empty())
+      continue;
+
+    SmallVector<SILBasicBlock *, 8> discoveredBlocks;
+
+    // Now that we have found all of our borrows, we want to find struct_extract
+    // uses of our borrow as well as any operands that cannot use an owned
+    // value.
+    SWIFT_DEFER { discoveredBlocks.clear(); };
+    BorrowToDestructureTransform transform(allocator, mmci, diagnosticEmitter,
+                                           poa, discoveredBlocks);
+
+    // Attempt to gather uses. Return false if we saw something that we did not
+    // understand.
+    if (!transform.gatherUses(borrowWorklist))
+      return madeChange;
+
+    // Next make sure that any destructure needing instructions are on the
+    // boundary in a per bit field sensitive manner.
+    transform.checkDestructureUsesOnBoundary();
+
+    // If we emitted any diagnostic, break out. We return true since we actually
+    // succeeded in our processing by finding the error. We only return false if
+    // we want to tell the rest of the checker that there was an internal
+    // compiler error that we need to emit a "compiler doesn't understand
+    // error".
+    if (diagnosticEmitter.emittedAnyDiagnostics())
+      return madeChange;
+
+    // At this point, we know that all of our destructure requiring uses are on
+    // the boundary of our live range. Now we need to do the rewriting.
+    transform.blockToAvailableValues.emplace(transform.liveness);
+    transform.rewriteUses();
+
+    // Now that we have done our rewritting, we need to do a few cleanups.
+    transform.cleanup(borrowWorklist);
+  }
+
+  return madeChange;
+}
+
+//===----------------------------------------------------------------------===//
+//                            Top Level Entrypoint
+//===----------------------------------------------------------------------===//
+
+namespace {
+
+class MoveOnlyBorrowToDestructureTransformPass : public SILFunctionTransform {
+  void run() override {
+    auto *fn = getFunction();
+
+    // Only run this pass if the move only language feature is enabled.
+    if (!fn->getASTContext().LangOpts.Features.contains(Feature::MoveOnly))
+      return;
+
+    // Don't rerun diagnostics on deserialized functions.
+    if (getFunction()->wasDeserializedCanonical())
+      return;
+
+    assert(fn->getModule().getStage() == SILStage::Raw &&
+           "Should only run on Raw SIL");
+
+    LLVM_DEBUG(llvm::dbgs() << "===> MoveOnly Object Checker. Visiting: "
+                            << fn->getName() << '\n');
+
+    auto *postOrderAnalysis = getAnalysis<PostOrderAnalysis>();
+
+    SmallSetVector<MarkMustCheckInst *, 32> moveIntroducersToProcess;
+    DiagnosticEmitter emitter;
+
+    bool madeChange = searchForCandidateObjectMarkMustChecks(
+        getFunction(), moveIntroducersToProcess, emitter);
+    if (madeChange) {
+      invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
+    }
+
+    if (emitter.emittedAnyDiagnostics())
+      return;
+
+    auto introducers = llvm::makeArrayRef(moveIntroducersToProcess.begin(),
+                                          moveIntroducersToProcess.end());
+    if (runTester(fn, introducers, postOrderAnalysis, emitter)) {
+      invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
+    }
+  }
+};
+
+} // namespace
+
+SILTransform *swift::createMoveOnlyBorrowToDestructureTransform() {
+  return new MoveOnlyBorrowToDestructureTransformPass();
+}

lib/SILOptimizer/Mandatory/MoveOnlyDiagnostics.cpp

@@ -16,6 +16,7 @@
 
 #include "swift/AST/DiagnosticsSIL.h"
 #include "swift/SIL/DebugUtils.h"
+#include "swift/SIL/FieldSensitivePrunedLiveness.h"
 #include "swift/SIL/SILArgument.h"
 #include "llvm/Support/Debug.h"
 
@@ -85,7 +86,7 @@ void DiagnosticEmitter::emitCheckerDoesntUnderstandDiagnostic(
     diagnose(fn->getASTContext(), markedValue->getLoc().getSourceLoc(),
              diag::sil_moveonlychecker_not_understand_moveonly);
   }
-  valuesWithDiagnostics.insert(markedValue);
+  registerDiagnosticEmitted(markedValue);
 }
 
 //===----------------------------------------------------------------------===//
@@ -104,7 +105,7 @@ void DiagnosticEmitter::emitObjectGuaranteedDiagnostic(
              diag::sil_moveonlychecker_guaranteed_value_captured_by_closure,
              varName);
     emitObjectDiagnosticsForPartialApplyUses();
-    valuesWithDiagnostics.insert(markedValue);
+    registerDiagnosticEmitted(markedValue);
   }
 
   // If we do not have any non-partial apply consuming uses... just exit early.
@@ -121,7 +122,7 @@ void DiagnosticEmitter::emitObjectGuaranteedDiagnostic(
                diag::sil_moveonlychecker_let_value_consumed_in_closure,
                varName);
       emitObjectDiagnosticsForFoundUses(true /*ignore partial apply uses*/);
-      valuesWithDiagnostics.insert(markedValue);
+      registerDiagnosticEmitted(markedValue);
       return;
     }
   }
@@ -131,7 +132,7 @@ void DiagnosticEmitter::emitObjectGuaranteedDiagnostic(
            diag::sil_moveonlychecker_guaranteed_value_consumed, varName);
 
   emitObjectDiagnosticsForFoundUses(true /*ignore partial apply uses*/);
-  valuesWithDiagnostics.insert(markedValue);
+  registerDiagnosticEmitted(markedValue);
 }
 
 void DiagnosticEmitter::emitObjectOwnedDiagnostic(
@@ -145,7 +146,7 @@ void DiagnosticEmitter::emitObjectOwnedDiagnostic(
            varName);
 
   emitObjectDiagnosticsForFoundUses();
-  valuesWithDiagnostics.insert(markedValue);
+  registerDiagnosticEmitted(markedValue);
 }
 
 void DiagnosticEmitter::emitObjectDiagnosticsForFoundUses(
@@ -245,8 +246,7 @@ void DiagnosticEmitter::emitAddressExclusivityHazardDiagnostic(
     MarkMustCheckInst *markedValue, SILInstruction *consumingUse) {
   if (!useWithDiagnostic.insert(consumingUse).second)
     return;
-
-  valuesWithDiagnostics.insert(markedValue);
+  registerDiagnosticEmitted(markedValue);
 
   auto &astContext = markedValue->getFunction()->getASTContext();
   StringRef varName = getVariableNameForValue(markedValue);
@@ -269,8 +269,7 @@ void DiagnosticEmitter::emitAddressDiagnostic(MarkMustCheckInst *markedValue,
                                               bool isInOutEndOfFunction) {
   if (!useWithDiagnostic.insert(violatingUse).second)
     return;
-
-  valuesWithDiagnostics.insert(markedValue);
+  registerDiagnosticEmitted(markedValue);
 
   auto &astContext = markedValue->getFunction()->getASTContext();
   StringRef varName = getVariableNameForValue(markedValue);
@@ -360,8 +359,7 @@ void DiagnosticEmitter::emitInOutEndOfFunctionDiagnostic(
     MarkMustCheckInst *markedValue, SILInstruction *violatingUse) {
   if (!useWithDiagnostic.insert(violatingUse).second)
     return;
-
-  valuesWithDiagnostics.insert(markedValue);
+  registerDiagnosticEmitted(markedValue);
 
   assert(cast<SILFunctionArgument>(markedValue->getOperand())
              ->getArgumentConvention()
@@ -418,5 +416,39 @@ void DiagnosticEmitter::emitAddressDiagnosticNoCopy(
            diag::sil_moveonlychecker_guaranteed_value_consumed, varName);
   diagnose(astContext, consumingUse->getLoc().getSourceLoc(),
            diag::sil_moveonlychecker_consuming_use_here);
-  valuesWithDiagnostics.insert(markedValue);
+  registerDiagnosticEmitted(markedValue);
+}
+
+void DiagnosticEmitter::emitObjectDestructureNeededWithinBorrowBoundary(
+    MarkMustCheckInst *markedValue, SILInstruction *destructureNeedingUse,
+    TypeTreeLeafTypeRange destructureSpan,
+    FieldSensitivePrunedLivenessBoundary &boundary) {
+  if (!useWithDiagnostic.insert(destructureNeedingUse).second)
+    return;
+
+  auto &astContext = markedValue->getFunction()->getASTContext();
+  StringRef varName = getVariableNameForValue(markedValue);
+
+  LLVM_DEBUG(llvm::dbgs() << "Emitting destructure can't be created error!\n");
+  LLVM_DEBUG(llvm::dbgs() << "    Mark: " << *markedValue);
+  LLVM_DEBUG(llvm::dbgs() << "    Destructure Needing Use: "
+                          << *destructureNeedingUse);
+
+  diagnose(astContext,
+           markedValue->getDefiningInstruction()->getLoc().getSourceLoc(),
+           diag::sil_moveonlychecker_moveonly_field_consumed, varName);
+  diagnose(astContext, destructureNeedingUse->getLoc().getSourceLoc(),
+           diag::sil_moveonlychecker_moveonly_field_consumed_here);
+  // Only emit errors for last users that overlap with our needed destructure
+  // bits.
+  for (auto pair : boundary.getLastUsers()) {
+    if (llvm::any_of(destructureSpan.getRange(),
+                     [&](unsigned index) { return pair.second.test(index); })) {
+      LLVM_DEBUG(llvm::dbgs()
+                 << "    Destructure Boundary Use: " << *pair.first);
+      diagnose(astContext, pair.first->getLoc().getSourceLoc(),
+               diag::sil_moveonlychecker_boundary_use);
+    }
+  }
+  registerDiagnosticEmitted(markedValue);
 }

lib/SILOptimizer/Mandatory/MoveOnlyDiagnostics.h

@@ -21,11 +21,16 @@
 
 #include "MoveOnlyObjectChecker.h"
 #include "swift/Basic/NullablePtr.h"
+#include "swift/SIL/FieldSensitivePrunedLiveness.h"
+#include "swift/SIL/SILInstruction.h"
 
 namespace swift {
+
+class FieldSensitivePrunedLivenessBoundary;
+
 namespace siloptimizer {
 
-struct DiagnosticEmitter {
+class DiagnosticEmitter {
   SILFunction *fn;
 
   /// The canonicalizer that contains the final consuming uses and consuming
@@ -40,6 +45,14 @@ struct DiagnosticEmitter {
   // multiple diagnostics for the same use.
   SmallPtrSet<SILInstruction *, 8> useWithDiagnostic;
 
+  unsigned diagnosticCount = 0;
+
+public:
+  void init(SILFunction *inputFn, OSSACanonicalizer *inputCanonicalizer) {
+    fn = inputFn;
+    canonicalizer = inputCanonicalizer;
+  }
+
   /// Clear our cache of uses that we have diagnosed for a specific
   /// mark_must_check.
   void clearUsesWithDiagnostic() { useWithDiagnostic.clear(); }
@@ -48,6 +61,8 @@ struct DiagnosticEmitter {
     return *canonicalizer.get();
   }
 
+  unsigned getDiagnosticCount() const { return diagnosticCount; }
+
   void emitCheckerDoesntUnderstandDiagnostic(MarkMustCheckInst *markedValue);
   void emitObjectGuaranteedDiagnostic(MarkMustCheckInst *markedValue);
   void emitObjectOwnedDiagnostic(MarkMustCheckInst *markedValue);
@@ -68,6 +83,10 @@ struct DiagnosticEmitter {
                                    SILInstruction *consumingUse);
   void emitAddressExclusivityHazardDiagnostic(MarkMustCheckInst *markedValue,
                                               SILInstruction *consumingUse);
+  void emitObjectDestructureNeededWithinBorrowBoundary(
+      MarkMustCheckInst *markedValue, SILInstruction *destructureNeedingUse,
+      TypeTreeLeafTypeRange destructureNeededBits,
+      FieldSensitivePrunedLivenessBoundary &boundary);
 
 private:
   /// Emit diagnostics for the final consuming uses and consuming uses needing
@@ -76,6 +95,11 @@ struct DiagnosticEmitter {
   /// the caller processed it correctly. false, then we continue to process it.
   void emitObjectDiagnosticsForFoundUses(bool ignorePartialApply = false) const;
   void emitObjectDiagnosticsForPartialApplyUses() const;
+
+  void registerDiagnosticEmitted(MarkMustCheckInst *value) {
+    ++diagnosticCount;
+    valuesWithDiagnostics.insert(value);
+  }
 };
 
 } // namespace siloptimizer