[ABI] Store a ValueOwnership directly, not a manual encoding of it.

Author: huonw

include/swift/ABI/MetadataValues.h

@@ -644,32 +644,18 @@ using FunctionTypeFlags = TargetFunctionTypeFlags<size_t>;
 
 template <typename int_type>
 class TargetParameterTypeFlags {
-  enum : int_type {
-    InOutMask    = 1 << 0,
-    SharedMask   = 1 << 1,
-    OwnedMask    = 1 << 2,
-    VariadicMask = 1 << 3,
-  };
+  enum : int_type { ValueOwnershipMask = 0x7F, VariadicMask = 0x80 };
   int_type Data;
 
   constexpr TargetParameterTypeFlags(int_type Data) : Data(Data) {}
 
 public:
   constexpr TargetParameterTypeFlags() : Data(0) {}
 
-  constexpr TargetParameterTypeFlags<int_type> withInOut(bool isInOut) const {
-    return TargetParameterTypeFlags<int_type>((Data & ~InOutMask) |
-                                              (isInOut ? InOutMask : 0));
-  }
-
-  constexpr TargetParameterTypeFlags<int_type> withShared(bool isShared) const {
-    return TargetParameterTypeFlags<int_type>((Data & ~SharedMask) |
-                                              (isShared ? SharedMask : 0));
-  }
-
-  constexpr TargetParameterTypeFlags<int_type> withOwned(bool isOwned) const {
-    return TargetParameterTypeFlags<int_type>((Data & ~OwnedMask) |
-                                              (isOwned ? OwnedMask : 0));
+  constexpr TargetParameterTypeFlags<int_type>
+  withValueOwnership(ValueOwnership ownership) const {
+    return TargetParameterTypeFlags<int_type>((Data & ~ValueOwnershipMask) |
+                                              (int_type)ownership);
   }
 
   constexpr TargetParameterTypeFlags<int_type>
@@ -679,20 +665,10 @@ class TargetParameterTypeFlags {
   }
 
   bool isNone() const { return Data == 0; }
-  bool isInOut() const { return Data & InOutMask; }
-  bool isShared() const { return Data & SharedMask; }
-  bool isOwned() const { return Data & OwnedMask; }
   bool isVariadic() const { return Data & VariadicMask; }
 
   ValueOwnership getValueOwnership() const {
-    if (isInOut())
-      return ValueOwnership::InOut;
-    else if (isShared())
-      return ValueOwnership::Shared;
-    else if (isOwned())
-      return ValueOwnership::Owned;
-
-    return ValueOwnership::Default;
+    return (ValueOwnership)(Data & ValueOwnershipMask);
   }
 
   int_type getIntValue() const { return Data; }

include/swift/Demangling/TypeDecoder.h

@@ -56,9 +56,9 @@ class FunctionParam {
   void setType(BuiltType type) { Type = type; }
 
   void setVariadic() { Flags = Flags.withVariadic(true); }
-  void setShared() { Flags = Flags.withShared(true); }
-  void setOwned() { Flags = Flags.withOwned(true); }
-  void setInOut() { Flags = Flags.withInOut(true); }
+  void setValueOwnership(ValueOwnership ownership) {
+    Flags = Flags.withValueOwnership(ownership);
+  }
   void setFlags(ParameterFlags flags) { Flags = flags; };
 
   FunctionParam withLabel(StringRef label) const {
@@ -532,23 +532,23 @@ class TypeDecoder {
         [&](const Demangle::NodePointer &typeNode,
             FunctionParam<BuiltType> &param) -> bool {
       Demangle::NodePointer node = typeNode;
-      switch (node->getKind()) {
-      case NodeKind::InOut:
-        param.setInOut();
+
+      auto setOwnership = [&](ValueOwnership ownership) {
+        param.setValueOwnership(ownership);
         node = node->getFirstChild();
         hasParamFlags = true;
+      };
+      switch (node->getKind()) {
+      case NodeKind::InOut:
+        setOwnership(ValueOwnership::InOut);
         break;
 
       case NodeKind::Shared:
-        param.setShared();
-        hasParamFlags = true;
-        node = node->getFirstChild();
+        setOwnership(ValueOwnership::Shared);
         break;
 
       case NodeKind::Owned:
-        param.setOwned();
-        hasParamFlags = true;
-        node = node->getFirstChild();
+        setOwnership(ValueOwnership::Owned);
         break;
 
       default:

lib/IRGen/GenMeta.cpp

@@ -838,11 +838,10 @@ namespace {
               auto param = params[index];
               auto flags = param.getParameterFlags();
 
-              auto parameterFlags = ParameterFlags()
-                                        .withInOut(flags.isInOut())
-                                        .withShared(flags.isShared())
-                                        .withOwned(flags.isOwned())
-                                        .withVariadic(flags.isVariadic());
+              auto parameterFlags =
+                  ParameterFlags()
+                      .withValueOwnership(flags.getValueOwnership())
+                      .withVariadic(flags.isVariadic());
 
               processor(index, getFunctionParameterRef(param), parameterFlags);
             }

lib/RemoteAST/RemoteAST.cpp

@@ -350,10 +350,11 @@ class RemoteASTTypeBuilder {
 
       auto label = Ctx.getIdentifier(param.getLabel());
       auto flags = param.getFlags();
+      auto ownership = flags.getValueOwnership();
       auto parameterFlags = ParameterTypeFlags()
-                                .withInOut(flags.isInOut())
-                                .withShared(flags.isShared())
-                                .withOwned(flags.isOwned())
+                                .withInOut(ownership == ValueOwnership::InOut)
+                                .withShared(ownership == ValueOwnership::Shared)
+                                .withOwned(ownership == ValueOwnership::Owned)
                                 .withVariadic(flags.isVariadic());
 
       funcParams.push_back(AnyFunctionType::Param(type, label, parameterFlags));

unittests/Reflection/TypeRef.cpp

@@ -148,9 +148,10 @@ TEST(TypeRefTest, UniqueFunctionTypeRef) {
 
   // Test parameter with and without inout/shared/variadic and/or label.
   ParameterFlags paramFlags;
-  auto inoutFlags = paramFlags.withInOut(true);
+  auto inoutFlags = paramFlags.withValueOwnership(ValueOwnership::InOut);
   auto variadicFlags = paramFlags.withVariadic(true);
-  auto sharedFlags = paramFlags.withShared(true);
+  auto sharedFlags = paramFlags.withValueOwnership(ValueOwnership::Shared);
+  auto ownedFlags = paramFlags.withValueOwnership(ValueOwnership::Owned);
 
   auto F6 = Builder.createFunctionType({Param1.withFlags(inoutFlags)}, Result,
                                        FunctionTypeFlags());
@@ -170,17 +171,27 @@ TEST(TypeRefTest, UniqueFunctionTypeRef) {
                                          Result, FunctionTypeFlags());
   EXPECT_EQ(F8, F8_1);
 
-  auto F9 = Builder.createFunctionType({Param1}, Result, FunctionTypeFlags());
-  auto F9_1 = Builder.createFunctionType({Param1.withLabel("foo")}, Result,
+  auto F9 = Builder.createFunctionType({Param1.withFlags(ownedFlags)}, Result,
+                                       FunctionTypeFlags());
+  auto F9_1 = Builder.createFunctionType({Param1.withFlags(ownedFlags)},
+                                         Result, FunctionTypeFlags());
+  EXPECT_EQ(F9, F9_1);
+
+  auto F10 = Builder.createFunctionType({Param1}, Result, FunctionTypeFlags());
+  auto F10_1 = Builder.createFunctionType({Param1.withLabel("foo")}, Result,
                                          FunctionTypeFlags());
-  EXPECT_NE(F9, F9_1);
+  EXPECT_NE(F10, F10_1);
 
   EXPECT_NE(F6, F7);
   EXPECT_NE(F6, F8);
   EXPECT_NE(F6, F9);
+  EXPECT_NE(F6, F10);
   EXPECT_NE(F7, F8);
   EXPECT_NE(F7, F9);
+  EXPECT_NE(F7, F10);
   EXPECT_NE(F8, F9);
+  EXPECT_NE(F8, F10);
+  EXPECT_NE(F9, F10);
 
   auto VoidVoid1 =
       Builder.createFunctionType(VoidParams, VoidResult, FunctionTypeFlags());
@@ -191,14 +202,14 @@ TEST(TypeRefTest, UniqueFunctionTypeRef) {
   EXPECT_NE(VoidVoid1, F1);
 
   // Test escaping.
-  auto F10 = Builder.createFunctionType(Parameters1, Result,
-                                        FunctionTypeFlags().withEscaping(true));
   auto F11 = Builder.createFunctionType(Parameters1, Result,
                                         FunctionTypeFlags().withEscaping(true));
-  auto F12 = Builder.createFunctionType(
+  auto F12 = Builder.createFunctionType(Parameters1, Result,
+                                        FunctionTypeFlags().withEscaping(true));
+  auto F13 = Builder.createFunctionType(
       Parameters1, Result, FunctionTypeFlags().withEscaping(false));
-  EXPECT_EQ(F10, F11);
-  EXPECT_NE(F10, F12);
+  EXPECT_EQ(F11, F12);
+  EXPECT_NE(F11, F13);
 }
 
 TEST(TypeRefTest, UniqueProtocolTypeRef) {