[AST] NFC: Repack misc TypeVariableType bits

1) This saves 16 bytes per type variable.
2) Please note that the 'ID' was "32 - NumTypeBaseBits" just a few weeks
   ago, so this isn't a real change.

Author: davezarzycki

include/swift/AST/Types.h

@@ -318,7 +318,14 @@ class alignas(1 << TypeAlignInBits) TypeBase {
     unsigned : NumTypeBaseBits;
 
     /// \brief The unique number assigned to this type variable.
-    uint64_t ID : 64 - NumTypeBaseBits;
+    uint64_t ID : 32 - NumTypeBaseBits;
+
+    /// Type variable options.
+    unsigned Options : 3;
+
+    ///  Index into the list of type variables, as used by the
+    ///  constraint graph.
+    unsigned GraphIndex : 29;
   };
   NUMBITS(TypeVariableType, 64);
 

lib/Sema/ConstraintSystem.h

@@ -177,9 +177,6 @@ enum TypeVariableOptions {
 /// to, what specific types it might be and, eventually, the fixed type to
 /// which it is assigned.
 class TypeVariableType::Implementation {
-  /// Type variable options.
-  unsigned Options : 3;
-
   /// \brief The locator that describes where this type variable was generated.
   constraints::ConstraintLocator *locator;
 
@@ -191,45 +188,53 @@ class TypeVariableType::Implementation {
   /// The corresponding node in the constraint graph.
   constraints::ConstraintGraphNode *GraphNode = nullptr;
 
-  ///  Index into the list of type variables, as used by the
-  ///  constraint graph.
-  unsigned GraphIndex;
-
   friend class constraints::SavedTypeVariableBinding;
 
 public:
+  /// \brief Retrieve the type variable associated with this implementation.
+  TypeVariableType *getTypeVariable() {
+    return reinterpret_cast<TypeVariableType *>(this) - 1;
+  }
+
+  /// \brief Retrieve the type variable associated with this implementation.
+  const TypeVariableType *getTypeVariable() const {
+    return reinterpret_cast<const TypeVariableType *>(this) - 1;
+  }
+
   explicit Implementation(constraints::ConstraintLocator *locator,
                           unsigned options)
-    : Options(options), locator(locator),
-      ParentOrFixed(getTypeVariable()) { }
+    : locator(locator), ParentOrFixed(getTypeVariable()) {
+    getTypeVariable()->TypeVariableTypeBits.Options = options;
+  }
 
   /// \brief Retrieve the unique ID corresponding to this type variable.
   unsigned getID() const { return getTypeVariable()->getID(); }
 
+  unsigned getRawOptions() const {
+    return getTypeVariable()->TypeVariableTypeBits.Options;
+  }
+
+  void setRawOptions(unsigned bits) {
+    getTypeVariable()->TypeVariableTypeBits.Options = bits;
+    assert(getTypeVariable()->TypeVariableTypeBits.Options == bits
+           && "Trucation");
+  }
+
   /// Whether this type variable can bind to an lvalue type.
-  bool canBindToLValue() const { return Options & TVO_CanBindToLValue; }
+  bool canBindToLValue() const { return getRawOptions() & TVO_CanBindToLValue; }
 
   /// Whether this type variable can bind to an inout type.
-  bool canBindToInOut() const { return Options & TVO_CanBindToInOut; }
+  bool canBindToInOut() const { return getRawOptions() & TVO_CanBindToInOut; }
 
   /// Whether this type variable prefers a subtype binding over a supertype
   /// binding.
   bool prefersSubtypeBinding() const {
-    return Options & TVO_PrefersSubtypeBinding;
+    return getRawOptions() & TVO_PrefersSubtypeBinding;
   }
 
   bool mustBeMaterializable() const {
-    return !(Options & TVO_CanBindToInOut) && !(Options & TVO_CanBindToLValue);
-  }
-
-  /// \brief Retrieve the type variable associated with this implementation.
-  TypeVariableType *getTypeVariable() {
-    return reinterpret_cast<TypeVariableType *>(this) - 1;
-  }
-
-  /// \brief Retrieve the type variable associated with this implementation.
-  const TypeVariableType *getTypeVariable() const {
-    return reinterpret_cast<const TypeVariableType *>(this) - 1;
+    return !(getRawOptions() & TVO_CanBindToInOut) &&
+           !(getRawOptions() & TVO_CanBindToLValue);
   }
 
   /// Retrieve the corresponding node in the constraint graph.
@@ -243,11 +248,13 @@ class TypeVariableType::Implementation {
   /// Retrieve the index into the constraint graph's list of type variables.
   unsigned getGraphIndex() const { 
     assert(GraphNode && "Graph node isn't set");
-    return GraphIndex; 
+    return getTypeVariable()->TypeVariableTypeBits.GraphIndex; 
   }
 
   /// Set the index into the constraint graph's list of type variables.
-  void setGraphIndex(unsigned newIndex) { GraphIndex = newIndex; }
+  void setGraphIndex(unsigned newIndex) {
+    getTypeVariable()->TypeVariableTypeBits.GraphIndex = newIndex;
+  }
 
   /// \brief Check whether this type variable either has a representative that
   /// is not itself or has a fixed type binding.
@@ -339,8 +346,8 @@ class TypeVariableType::Implementation {
     if (!mustBeMaterializable() && otherRep->getImpl().mustBeMaterializable()) {
       if (record)
         recordBinding(*record);
-      Options &= ~TVO_CanBindToLValue;
-      Options &= ~TVO_CanBindToInOut;
+      getTypeVariable()->TypeVariableTypeBits.Options &= ~TVO_CanBindToLValue;
+      getTypeVariable()->TypeVariableTypeBits.Options &= ~TVO_CanBindToInOut;
     }
   }
 
@@ -381,8 +388,10 @@ class TypeVariableType::Implementation {
     if (!rep->getImpl().mustBeMaterializable()) {
       if (record)
         rep->getImpl().recordBinding(*record);
-      rep->getImpl().Options &= ~TVO_CanBindToLValue;
-      rep->getImpl().Options &= ~TVO_CanBindToInOut;
+      rep->getImpl().getTypeVariable()->TypeVariableTypeBits.Options
+        &= ~TVO_CanBindToLValue;
+      rep->getImpl().getTypeVariable()->TypeVariableTypeBits.Options
+        &= ~TVO_CanBindToInOut;
     }
   }
 

lib/Sema/TypeCheckConstraints.cpp

@@ -61,12 +61,12 @@ void TypeVariableType::Implementation::print(llvm::raw_ostream &OS) {
 }
 
 SavedTypeVariableBinding::SavedTypeVariableBinding(TypeVariableType *typeVar)
-  : TypeVarAndOptions(typeVar, typeVar->getImpl().Options),
+  : TypeVarAndOptions(typeVar, typeVar->getImpl().getRawOptions()),
     ParentOrFixed(typeVar->getImpl().ParentOrFixed) { }
 
 void SavedTypeVariableBinding::restore() {
   auto *typeVar = getTypeVariable();
-  typeVar->getImpl().Options = getOptions();
+  typeVar->getImpl().setRawOptions(getOptions());
   typeVar->getImpl().ParentOrFixed = ParentOrFixed;
 }