[ownership] Replace ValueOwnershipKind::Trivial with ValueOwnershipKind::Any.

In a previous commit, I banned in the verifier any SILValue from producing
ValueOwnershipKind::Any in preparation for this.

This change arises out of discussions in between John, Andy, and I around
ValueOwnershipKind::Trivial. The specific realization was that this ownership
kind was an unnecessary conflation of the a type system idea (triviality) with
an ownership idea (@any, an ownership kind that is compatible with any other
ownership kind at value merge points and can only create). This caused the
ownership model to have to contort to handle the non-payloaded or trivial cases
of non-trivial enums. This is unnecessary if we just eliminate the any case and
in the verifier separately verify that trivial => @any (notice that we do not
verify that @any => trivial).

NOTE: This is technically an NFC intended change since I am just replacing
Trivial with Any. That is why if you look at the tests you will see that I
actually did not need to update anything except removing some @trivial ownership
since @any ownership is represented without writing @any in the parsed sil.

rdar://46294760

Author: gottesmm

include/swift/SIL/SILBuilder.h

@@ -2095,7 +2095,8 @@ class SILBuilder {
   /// lowering for the non-address value.
   void emitDestroyValueOperation(SILLocation Loc, SILValue v) {
     assert(!v->getType().isAddress());
-    if (v.getOwnershipKind() == ValueOwnershipKind::Trivial)
+    if (F->hasQualifiedOwnership() &&
+        v.getOwnershipKind() == ValueOwnershipKind::Any)
       return;
     auto &lowering = getTypeLowering(v->getType());
     lowering.emitDestroyValue(*this, Loc, v);

include/swift/SIL/SILCloner.h

@@ -2130,8 +2130,8 @@ void SILCloner<ImplClass>::visitUncheckedOwnershipConversionInst(
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
   ValueOwnershipKind Kind = SILValue(Inst).getOwnershipKind();
   if (getOpValue(Inst->getOperand()).getOwnershipKind() ==
-      ValueOwnershipKind::Trivial) {
-    Kind = ValueOwnershipKind::Trivial;
+      ValueOwnershipKind::Any) {
+    Kind = ValueOwnershipKind::Any;
   }
   recordClonedInstruction(Inst, getBuilder().createUncheckedOwnershipConversion(
                                     getOpLocation(Inst->getLoc()),

include/swift/SIL/SILInstruction.h

@@ -5023,7 +5023,7 @@ class EnumInst : public InstructionBase<SILInstructionKind::EnumInst,
       : InstructionBase(DebugLoc, ResultTy,
                         Operand
                             ? Operand.getOwnershipKind()
-                            : ValueOwnershipKind(ValueOwnershipKind::Trivial)),
+                            : ValueOwnershipKind(ValueOwnershipKind::Any)),
         Element(Element) {
     if (Operand) {
       OptionalOperand.emplace(this, Operand);

include/swift/SIL/SILValue.h

@@ -19,6 +19,7 @@
 
 #include "swift/Basic/Range.h"
 #include "swift/Basic/ArrayRefView.h"
+#include "swift/Basic/STLExtras.h"
 #include "swift/SIL/SILNode.h"
 #include "swift/SIL/SILType.h"
 #include "llvm/ADT/ArrayRef.h"
@@ -86,17 +87,6 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
 /// have.
 struct ValueOwnershipKind {
   enum innerty : uint8_t {
-    /// A SILValue with Trivial ownership kind is an independent value that can
-    /// not be owned. Ownership does not place any constraints on how a SILValue
-    /// with Trivial ownership kind can be used. Other side effects (e.g. Memory
-    /// dependencies) must still be respected. A SILValue with Trivial ownership
-    /// kind must be of Trivial SILType (i.e. SILType::isTrivial(SILModule &)
-    /// must return true).
-    ///
-    /// Some examples of SIL types with Trivial ownership are: Builtin.Int32,
-    /// Builtin.RawPointer, aggregates containing all trivial types.
-    Trivial,
-
     /// A SILValue with `Unowned` ownership kind is an independent value that
     /// has a lifetime that is only guaranteed to last until the next program
     /// visible side-effect. To maintain the lifetime of an unowned value, it
@@ -127,10 +117,11 @@ struct ValueOwnershipKind {
     /// instruction exactly once along any path through the program.
     Guaranteed,
 
-    /// A SILValue with undefined ownership. It can pair with /Any/ ownership
-    /// kinds. This means that it could take on /any/ ownership semantics. This
-    /// is meant only to model SILUndef and to express certain situations where
-    /// we use unqualified ownership. Expected to tighten over time.
+    /// A SILValue with Any ownership kind is an independent value outside of
+    /// the ownership system. It is used to model trivially typed values as well
+    /// as trivial cases of non-trivial enums. Naturally Any can be merged with
+    /// any ValueOwnershipKind allowing us to naturally model merge and branch
+    /// points in the SSA graph.
     Any,
 
     LastValueOwnershipKind = Any,
@@ -162,10 +153,6 @@ struct ValueOwnershipKind {
 
   Optional<ValueOwnershipKind> merge(ValueOwnershipKind RHS) const;
 
-  bool isTrivialOr(ValueOwnershipKind Kind) const {
-    return Value == Trivial || Value == Kind;
-  }
-
   /// Given that there is an aggregate value (like a struct or enum) with this
   /// ownership kind, and a subobject of type Proj is being projected from the
   /// aggregate, return Trivial if Proj has trivial type and the aggregate's
@@ -180,7 +167,6 @@ struct ValueOwnershipKind {
   /// kinds.
   UseLifetimeConstraint getForwardingLifetimeConstraint() const {
     switch (Value) {
-    case ValueOwnershipKind::Trivial:
     case ValueOwnershipKind::Any:
     case ValueOwnershipKind::Guaranteed:
     case ValueOwnershipKind::Unowned:
@@ -199,12 +185,16 @@ struct ValueOwnershipKind {
     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);
+  template <typename RangeTy>
+  static Optional<ValueOwnershipKind> merge(RangeTy &&r) {
+    auto initial = Optional<ValueOwnershipKind>(ValueOwnershipKind::Any);
+    return accumulate(
+        std::forward<RangeTy>(r), initial,
+        [](Optional<ValueOwnershipKind> acc, ValueOwnershipKind x) {
+          if (!acc)
+            return acc;
+          return acc.getValue().merge(x);
+        });
   }
 };
 

include/swift/Serialization/ModuleFormat.h

@@ -52,7 +52,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 469; // @_hasStorage
+const uint16_t SWIFTMODULE_VERSION_MINOR = 470; // Last change: Remove @trivial
 
 using DeclIDField = BCFixed<31>;
 

lib/IRGen/LoadableByAddress.cpp

@@ -1326,7 +1326,7 @@ SILArgument *LoadableStorageAllocation::replaceArgType(SILBuilder &argBuilder,
                    arg) == pass.largeLoadableArgs.end());
 
   arg = arg->getParent()->replaceFunctionArgument(
-      arg->getIndex(), newSILType, ValueOwnershipKind::Trivial, arg->getDecl());
+      arg->getIndex(), newSILType, ValueOwnershipKind::Any, arg->getDecl());
 
   copyArg->replaceAllUsesWith(arg);
   copyArg->eraseFromParent();
@@ -1352,7 +1352,7 @@ void LoadableStorageAllocation::insertIndirectReturnArgs() {
       ctx.getIdentifier("$return_value"),
       pass.F->getDeclContext());
   pass.F->begin()->insertFunctionArgument(0, resultStorageType.getAddressType(),
-                                          ValueOwnershipKind::Trivial, var);
+                                          ValueOwnershipKind::Any, var);
 }
 
 void LoadableStorageAllocation::convertIndirectFunctionArgs() {

lib/ParseSIL/ParseSIL.cpp

@@ -329,11 +329,12 @@ namespace {
     bool parseSILOwnership(ValueOwnershipKind &OwnershipKind) {
       // We parse here @ <identifier>.
       if (!P.consumeIf(tok::at_sign)) {
-        // Add error here.
-        return true;
+        // If we fail, we must have @any ownership.
+        OwnershipKind = ValueOwnershipKind::Any;
+        return false;
       }
 
-      StringRef AllOwnershipKinds[4] = {"trivial", "unowned", "owned",
+      StringRef AllOwnershipKinds[3] = {"unowned", "owned",
                                         "guaranteed"};
       return parseSILIdentifierSwitch(OwnershipKind, AllOwnershipKinds,
                                       diag::expected_sil_value_ownership_kind);