[sil-opaque-values] Fix ownership of enum values.

This involved a bit of cleanup in both ownership classification and
verification. Trivial argument types now have trivial ownership. Also, the
verifier allows

- enums with non-trivial ownership to be passed to trivial arguments as long as
  it can verify that all payloads are trivial.

- enums with trivial ownership to be passed as owned arguments. Preventing this
  didn't make sense.

Author: atrick

lib/SIL/SILOwnershipVerifier.cpp

@@ -371,7 +371,7 @@ class OwnershipCompatibilityUseChecker
   OwnershipUseCheckerResult visitTransformingTerminatorInst(TermInst *TI);
 
   OwnershipUseCheckerResult
-  visitNonTrivialEnum(EnumDecl *E, ValueOwnershipKind RequiredConvention);
+  visitEnumArgument(EnumDecl *E, ValueOwnershipKind RequiredConvention);
   OwnershipUseCheckerResult
   visitApplyParameter(ValueOwnershipKind RequiredConvention,
                       UseLifetimeConstraint Requirement);
@@ -790,7 +790,7 @@ OwnershipCompatibilityUseChecker::checkTerminatorArgumentMatchesDestBB(
     return {matches, lifetimeConstraint};
   }
 
-  return visitNonTrivialEnum(E, DestBlockArgOwnershipKind);
+  return visitEnumArgument(E, DestBlockArgOwnershipKind);
 }
 
 OwnershipUseCheckerResult
@@ -923,7 +923,7 @@ OwnershipCompatibilityUseChecker::visitReturnInst(ReturnInst *RI) {
   }
 
   if (auto *E = getType().getEnumOrBoundGenericEnum()) {
-    return visitNonTrivialEnum(E, Base);
+    return visitEnumArgument(E, Base);
   }
 
   return {compatibleWithOwnership(Base),
@@ -1011,42 +1011,31 @@ OwnershipUseCheckerResult OwnershipCompatibilityUseChecker::visitCallee(
   llvm_unreachable("Unhandled ParameterConvention in switch.");
 }
 
-OwnershipUseCheckerResult OwnershipCompatibilityUseChecker::visitNonTrivialEnum(
+// Visit an enum value that is passed at argument position, including block
+// arguments, apply arguments, and return values.
+//
+// The operand definition's ownership kind may be known to be "trivial",
+// but it is still valid to pass that enum to a argument nontrivial type.
+// For example:
+//
+// %val = enum $Optional<SomeClass>, #Optional.none // trivial ownership
+// apply %f(%val) : (@owned Optional<SomeClass>)    // owned argument
+OwnershipUseCheckerResult OwnershipCompatibilityUseChecker::visitEnumArgument(
     EnumDecl *E, ValueOwnershipKind RequiredKind) {
-  // Otherwise, first see if the enum is completely trivial. In such a case, we
-  // need an argument with a trivial convention. If we have an enum with at
-  // least 1 non-trivial case, then we need an argument with a non-trivial
-  // convention. If our parameter is trivial, then we just let it through in
-  // such a case. Otherwise we need to make sure that the non-trivial ownership
-  // convention matches the one on the argument parameter.
-
-  // Check if this enum has at least one case that is non-trivially typed.
-  bool HasNonTrivialCase =
-      llvm::any_of(E->getAllElements(), [this](EnumElementDecl *E) -> bool {
-        if (!E->hasAssociatedValues())
-          return false;
-        SILType EnumEltType = getType().getEnumElementType(E, Mod);
-        return !EnumEltType.isTrivial(Mod);
-      });
-
-  // If we have all trivial cases, make sure we are compatible with a trivial
-  // ownership kind.
-  if (!HasNonTrivialCase) {
-    return {compatibleWithOwnership(ValueOwnershipKind::Trivial),
-            UseLifetimeConstraint::MustBeLive};
-  }
-
-  // Otherwise, if this value is a trivial ownership kind, return.
+  // If this value is already categorized as a trivial ownership kind, it is
+  // safe to pass to any argument convention.
   if (compatibleWithOwnership(ValueOwnershipKind::Trivial)) {
     return {true, UseLifetimeConstraint::MustBeLive};
   }
 
-  // And finally finish by making sure that if we have a non-trivial ownership
-  // kind that it matches the argument's convention.
-  auto lifetimeConstraint = hasExactOwnership(ValueOwnershipKind::Owned)
+  // The operand has a non-trivial ownership kind. It must match the argument
+  // convention.
+  auto ownership = getOwnershipKind();
+  auto lifetimeConstraint = (ownership == ValueOwnershipKind::Owned)
                                 ? UseLifetimeConstraint::MustBeInvalidated
                                 : UseLifetimeConstraint::MustBeLive;
-  return {compatibleWithOwnership(RequiredKind), lifetimeConstraint};
+  return {compatibleOwnershipKinds(ownership, RequiredKind),
+          lifetimeConstraint};
 }
 
 // We allow for trivial cases of enums with non-trivial cases to be passed in
@@ -1060,7 +1049,7 @@ OwnershipUseCheckerResult OwnershipCompatibilityUseChecker::visitApplyParameter(
   if (!E) {
     return {compatibleWithOwnership(Kind), Requirement};
   }
-  return visitNonTrivialEnum(E, Kind);
+  return visitEnumArgument(E, Kind);
 }
 
 // Handle Apply and TryApply.

lib/SIL/SILValue.cpp

@@ -91,6 +91,13 @@ SILModule *ValueBase::getModule() const {
 ValueOwnershipKind::ValueOwnershipKind(SILModule &M, SILType Type,
                                        SILArgumentConvention Convention)
     : Value() {
+  // Trivial types can be passed using a variety of conventions. They always
+  // have trivial ownership.
+  if (Type.isTrivial(M)) {
+    Value = ValueOwnershipKind::Trivial;
+    return;
+  }
+
   switch (Convention) {
   case SILArgumentConvention::Indirect_In:
   case SILArgumentConvention::Indirect_In_Constant:
@@ -112,8 +119,7 @@ ValueOwnershipKind::ValueOwnershipKind(SILModule &M, SILType Type,
     Value = ValueOwnershipKind::Owned;
     return;
   case SILArgumentConvention::Direct_Unowned:
-    Value = Type.isTrivial(M) ? ValueOwnershipKind::Trivial
-                              : ValueOwnershipKind::Unowned;
+    Value = ValueOwnershipKind::Unowned;
     return;
   case SILArgumentConvention::Direct_Guaranteed:
     Value = ValueOwnershipKind::Guaranteed;

test/SILGen/opaque_ownership.swift

@@ -3,8 +3,9 @@
 
 public typealias AnyObject = Builtin.AnyObject
 
-precedencegroup CastingPrecedence {}
 precedencegroup AssignmentPrecedence {}
+precedencegroup CastingPrecedence {}
+precedencegroup ComparisonPrecedence {}
 
 public protocol _ObjectiveCBridgeable {}
 
@@ -58,6 +59,117 @@ public func unsafeBitCast<T, U>(_ x: T, to type: U.Type) -> U {
   return Builtin.reinterpretCast(x)
 }
 
+// A lot of standard library support is necessary to support raw enums.
+// --------------------------------------------------------------------
+
+infix operator  == : ComparisonPrecedence
+infix operator  ~= : ComparisonPrecedence
+
+public struct Bool {
+  var _value: Builtin.Int1
+
+  public init() {
+    let zero: Int64 = 0
+    self._value = Builtin.trunc_Int64_Int1(zero._value)
+  }
+
+  internal init(_ v: Builtin.Int1) { self._value = v }
+
+  public init(_ value: Bool) {
+    self = value
+  }
+}
+
+extension Bool {
+  public func _getBuiltinLogicValue() -> Builtin.Int1 {
+    return _value
+  }
+}
+
+public protocol Equatable {
+  /// Returns a Boolean value indicating whether two values are equal.
+  ///
+  /// Equality is the inverse of inequality. For any values `a` and `b`,
+  /// `a == b` implies that `a != b` is `false`.
+  ///
+  /// - Parameters:
+  ///   - lhs: A value to compare.
+  ///   - rhs: Another value to compare.
+  static func == (lhs: Self, rhs: Self) -> Bool
+}
+
+public func ~= <T : Equatable>(a: T, b: T) -> Bool {
+  return a == b
+}
+
+public protocol RawRepresentable {
+  associatedtype RawValue
+
+  init?(rawValue: RawValue)
+
+  var rawValue: RawValue { get }
+}
+
+public func == <T : RawRepresentable>(lhs: T, rhs: T) -> Bool
+  where T.RawValue : Equatable {
+  return lhs.rawValue == rhs.rawValue
+}
+
+public typealias _MaxBuiltinIntegerType = Builtin.Int2048
+
+public protocol _ExpressibleByBuiltinIntegerLiteral {
+  init(_builtinIntegerLiteral value: _MaxBuiltinIntegerType)
+}
+
+public protocol ExpressibleByIntegerLiteral {
+  associatedtype IntegerLiteralType : _ExpressibleByBuiltinIntegerLiteral
+
+  init(integerLiteral value: IntegerLiteralType)
+}
+
+extension ExpressibleByIntegerLiteral
+  where Self : _ExpressibleByBuiltinIntegerLiteral {
+  @_transparent
+  public init(integerLiteral value: Self) {
+    self = value
+  }
+}
+
+public protocol ExpressibleByStringLiteral {}
+public protocol ExpressibleByFloatLiteral {}
+public protocol ExpressibleByUnicodeScalarLiteral {}
+public protocol ExpressibleByExtendedGraphemeClusterLiteral {}
+
+public struct Int64 : ExpressibleByIntegerLiteral, _ExpressibleByBuiltinIntegerLiteral, Equatable {
+  public var _value: Builtin.Int64
+  public init(_builtinIntegerLiteral x: _MaxBuiltinIntegerType) {
+    _value = Builtin.s_to_s_checked_trunc_Int2048_Int64(x).0
+  }
+  public typealias IntegerLiteralType = Int64
+  public init(integerLiteral value: Int64) {
+    self = value
+  }
+  public static func ==(_ lhs: Int64, rhs: Int64) -> Bool {
+    return Bool(Builtin.cmp_eq_Int64(lhs._value, rhs._value))
+  }
+}
+
+// Test ownership of multi-case Enum values in the context of @trivial to @in thunks.
+// ---
+// CHECK-LABEL: sil private [transparent] [thunk] @_T0s17FloatingPointSignOs9EquatablessACP2eeoiSbx_xtFZTW : $@convention(witness_method) (@in FloatingPointSign, @in FloatingPointSign, @thick FloatingPointSign.Type) -> Bool {
+// CHECK: bb0(%0 : @trivial $FloatingPointSign, %1 : @trivial $FloatingPointSign, %2 : @trivial $@thick FloatingPointSign.Type):
+// CHECK:   %3 = function_ref @_T0s2eeoiSbx_xts16RawRepresentableRzs9Equatable0B5ValueRpzlF : $@convention(thin) <τ_0_0 where τ_0_0 : RawRepresentable, τ_0_0.RawValue : Equatable> (@in τ_0_0, @in τ_0_0) -> Bool
+// CHECK:   %4 = apply %3<FloatingPointSign, Int64>(%0, %1) : $@convention(thin) <τ_0_0 where τ_0_0 : RawRepresentable, τ_0_0.RawValue : Equatable> (@in τ_0_0, @in τ_0_0) -> Bool
+// CHECK:   return %4 : $Bool
+// CHECK-LABEL: } // end sil function '_T0s17FloatingPointSignOs9EquatablessACP2eeoiSbx_xtFZTW'
+public enum FloatingPointSign: Int64 {
+  /// The sign for a positive value.
+  case plus
+
+  /// The sign for a negative value.
+  case minus
+}
+
 #if os(OSX)
 // Test open_existential_value used in a conversion context.
 // (the actual bridging call is dropped because we don't import Swift).