Refactor compatibleOwnershipKind, trivialOrCompatibleOwnershipKinds onto ValueOwnershipKind instead of being free functions.

I have a bunch of work that I have done on a side branch some time ago to split
determining what value ownership kinds are able to be associated with a specific
operand.

This PR just upstreams a small part of the larger change.

Author: gottesmm

include/swift/SIL/SILValue.h

@@ -146,6 +146,23 @@ struct ValueOwnershipKind {
   /// ownership kind otherwise.
   ValueOwnershipKind getProjectedOwnershipKind(SILModule &M,
                                                SILType Proj) const;
+
+  /// Returns true if \p Other can be merged successfully with this, implying
+  /// that the two ownership kinds are "compatibile".
+  ///
+  /// The reason why we do not compare directy is to allow for
+  /// ValueOwnershipKind::Any to merge into other forms of ValueOwnershipKind.
+  bool isCompatibleWith(ValueOwnershipKind other) const {
+    return merge(other).hasValue();
+  }
+
+  /// Returns true if \p Other is compatible with ValueOwnershipKind::Trivial or
+  /// this. See isCompatibleWith for more information on what "compatibility"
+  /// means.
+  bool isTrivialOrCompatibleWith(ValueOwnershipKind other) const {
+    return isCompatibleWith(ValueOwnershipKind::Trivial) ||
+           isCompatibleWith(other);
+  }
 };
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &os, ValueOwnershipKind Kind);

lib/SIL/SILOwnershipVerifier.cpp

@@ -170,20 +170,6 @@ template <> class PointerLikeTypeTraits<GeneralizedUser> {
 //                                  Utility
 //===----------------------------------------------------------------------===//
 
-static bool compatibleOwnershipKinds(ValueOwnershipKind K1,
-                                     ValueOwnershipKind K2) {
-  return K1.merge(K2).hasValue();
-}
-
-/// Returns true if \p Kind is trivial or if \p Kind is compatible with \p
-/// ComparisonKind.
-static bool
-trivialOrCompatibleOwnershipKinds(ValueOwnershipKind Kind,
-                                  ValueOwnershipKind ComparisonKind) {
-  return compatibleOwnershipKinds(Kind, ValueOwnershipKind::Trivial) ||
-         compatibleOwnershipKinds(Kind, ComparisonKind);
-}
-
 static bool isValueAddressOrTrivial(SILValue V, SILModule &M) {
   return V->getType().isAddress() ||
          V.getOwnershipKind() == ValueOwnershipKind::Trivial ||
@@ -333,7 +319,7 @@ class OwnershipCompatibilityUseChecker
   SILType getType() const { return Op.get()->getType(); }
 
   bool compatibleWithOwnership(ValueOwnershipKind Kind) const {
-    return compatibleOwnershipKinds(getOwnershipKind(), Kind);
+    return getOwnershipKind().isCompatibleWith(Kind);
   }
 
   bool hasExactOwnership(ValueOwnershipKind Kind) const {
@@ -1049,8 +1035,7 @@ OwnershipUseCheckerResult OwnershipCompatibilityUseChecker::visitEnumArgument(
   } else {
     lifetimeConstraint = UseLifetimeConstraint::MustBeLive;
   }
-  return {compatibleOwnershipKinds(ownership, RequiredKind),
-          lifetimeConstraint};
+  return {ownership.isCompatibleWith(RequiredKind), lifetimeConstraint};
 }
 
 // We allow for trivial cases of enums with non-trivial cases to be passed in
@@ -1805,14 +1790,14 @@ void SILValueOwnershipChecker::gatherUsers(
         // TODO: Add a flag that associates the terminator instruction with
         // needing to be verified. If it isn't verified appropriately, assert
         // when the verifier is destroyed.
-        if (!trivialOrCompatibleOwnershipKinds(BBArg->getOwnershipKind(),
-                                               OwnershipKind)) {
+        auto BBArgOwnershipKind = BBArg->getOwnershipKind();
+        if (!BBArgOwnershipKind.isTrivialOrCompatibleWith(OwnershipKind)) {
           // This is where the error would go.
           continue;
         }
 
         // If we have a trivial value, just continue.
-        if (BBArg->getOwnershipKind() == ValueOwnershipKind::Trivial)
+        if (BBArgOwnershipKind == ValueOwnershipKind::Trivial)
           continue;
 
         // Otherwise,