Merge pull request swiftlang#20855 from gottesmm/pr-94ee6e6c6e2d268f47f17dead77e4feb169c24e6

[ownership] Replace ValueOwnershipKind::Trivial with ValueOwnershipKi…

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);