[region-isolation] Eliminate CRTP for errors and just pass through an error struct instead.

This is going to let me just pass through the error struct to the diagnostic
rather than having the CRTP and then constructing an info object per CRTP.
Currently, to make it easier to refactor, I changed the code in
TransferNonSendable to just take in the new error and call the current CRTP
routines. In the next commit, I am going to refactor TransferNonSendable.cpp
itself. This just makes it easier to test that I did not break anything.

Author: gottesmm

include/swift/SILOptimizer/Utils/PartitionOpError.def

@@ -0,0 +1,63 @@
+//===--- PartitionOpError.def ----------------------------*- C++ -*--------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2024 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// This file contains macros for creating PartitionOpErrors for use with
+/// SendNonSendable. This just makes it easier to add these errors without
+/// needing to write so much boielr plate.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef PARTITION_OP_ERROR
+#define PARTITION_OP_ERROR(Name)
+#endif
+
+/// An error created if we discover a value was locally used after it
+/// was already sent.
+///
+/// The arguments in the type are:
+///
+/// 1. The PartitionOp that required the element to be alive.
+///
+/// 2. The element in the PartitionOp that was asked to be alive.
+///
+/// 3. The operand of the instruction that originally transferred the
+/// region. Can be used to get the immediate value transferred or the
+/// transferring instruction.
+PARTITION_OP_ERROR(LocalUseAfterSend)
+
+/// This is called if we detect a never sendable element that was actually sent.
+///
+/// E.x.: passing a main actor exposed value to a sending parameter.
+PARTITION_OP_ERROR(SentNeverSendable)
+
+/// This is emitted when a never sendable value is passed into a sending
+/// result. The sending result will be viewed in our caller as disconnected and
+/// able to be sent.
+PARTITION_OP_ERROR(AssignNeverSendableIntoSendingResult)
+
+/// This is emitted when an inout sending parameter has been sent in a function
+/// body but has not been reinitialized at the end of the function.
+PARTITION_OP_ERROR(InOutSendingNotInitializedAtExit)
+
+/// This is emitted when an inout sending parameter has been assigned a
+/// non-disconnected value (e.x.: a value exposed to main actor isolated code)
+/// at end of function without being reinitialized with something disconnected.
+PARTITION_OP_ERROR(InOutSendingNotDisconnectedAtExit)
+
+/// Used to signify an "unknown code pattern" has occured while performing
+/// dataflow.
+///
+/// DISCUSSION: Our dataflow cannot emit errors itself so this is a callback
+/// to our user so that we can emit that error as we process.
+PARTITION_OP_ERROR(UnknownCodePattern)
+
+#undef PARTITION_OP_ERROR