Sema: Optimize Constraint layout to save 16 bytes

The largest union member was for SyntacticElement constraints;
let's tail-allocate the ContextualTypeInfo instead of storing
one in every constraint.

Author: slavapestov

include/swift/Sema/Constraint.h

@@ -336,16 +336,22 @@ class Constraint final : public llvm::ilist_node<Constraint>,
     private llvm::TrailingObjects<Constraint,
                                   TypeVariableType *,
                                   ConstraintFix *,
+                                  ContextualTypeInfo,
                                   OverloadChoice> {
   friend TrailingObjects;
 
   /// The kind of constraint.
   ConstraintKind Kind : 8;
 
   /// The kind of restriction placed on this constraint.
-  ConversionRestrictionKind Restriction : 8;
+  ConversionRestrictionKind Restriction : 5;
 
-  /// Whether we have a fix.
+  /// The number of type variables referenced by this constraint.
+  ///
+  /// The type variables themselves are tail-allocated.
+  unsigned NumTypeVariables : 11;
+
+  /// Whether we have a tail-allocated fix.
   unsigned HasFix : 1;
 
   /// Whether the \c Restriction field is valid.
@@ -375,14 +381,17 @@ class Constraint final : public llvm::ilist_node<Constraint>,
   /// the rest of the constraint system. Currently only applies to conjunctions.
   unsigned IsIsolated : 1;
 
-  /// The number of type variables referenced by this constraint.
-  ///
-  /// The type variables themselves are tail-allocated.
-  unsigned NumTypeVariables : 11;
-
   /// The kind of function reference, for member references.
   unsigned TheFunctionRefInfo : 3;
 
+  /// The trailing closure matching for an applicable function constraint,
+  /// if any. 0 = None, 1 = Forward, 2 = Backward.
+  unsigned trailingClosureMatching : 2;
+
+  /// For a SyntacticElement constraint, identify whether the result of this
+  /// node is unused.
+  unsigned isDiscarded : 1;
+
   union {
     struct {
       /// The first type.
@@ -433,10 +442,6 @@ class Constraint final : public llvm::ilist_node<Constraint>,
     struct {
       /// The node itself.
       ASTNode Element;
-      /// Contextual information associated with the element (if any).
-      ContextualTypeInfo Context;
-      /// Identifies whether result of this node is unused.
-      bool IsDiscarded;
     } SyntacticElement;
 
     struct {
@@ -447,9 +452,6 @@ class Constraint final : public llvm::ilist_node<Constraint>,
       /// The type being called, primarily a function type, but could
       /// be a metatype, a tuple or a nominal type.
       Type Callee;
-      /// The trailing closure matching for an applicable function constraint,
-      /// if any. 0 = None, 1 = Forward, 2 = Backward.
-      unsigned TrailingClosureMatching : 2;
       /// The declaration context in which the application appears.
       DeclContext *UseDC;
     } Apply;
@@ -527,6 +529,10 @@ class Constraint final : public llvm::ilist_node<Constraint>,
     return HasFix ? 1 : 0;
   }
 
+  size_t numTrailingObjects(OverloadToken<ContextualTypeInfo>) const {
+    return Kind == ConstraintKind::SyntacticElement ? 1 : 0;
+  }
+
   size_t numTrailingObjects(OverloadToken<OverloadChoice>) const {
     return Kind == ConstraintKind::BindOverload ? 1 : 0;
   }
@@ -604,15 +610,15 @@ class Constraint final : public llvm::ilist_node<Constraint>,
       DeclContext *useDC, ConstraintLocator *locator);
 
   static Constraint *createSyntacticElement(ConstraintSystem &cs,
-                                              ASTNode node,
-                                              ConstraintLocator *locator,
-                                              bool isDiscarded = false);
+                                            ASTNode node,
+                                            ConstraintLocator *locator,
+                                            bool isDiscarded = false);
 
   static Constraint *createSyntacticElement(ConstraintSystem &cs,
-                                              ASTNode node,
-                                              ContextualTypeInfo context,
-                                              ConstraintLocator *locator,
-                                              bool isDiscarded = false);
+                                            ASTNode node,
+                                            ContextualTypeInfo context,
+                                            ConstraintLocator *locator,
+                                            bool isDiscarded = false);
 
   /// Determine the kind of constraint.
   ConstraintKind getKind() const { return Kind; }
@@ -903,13 +909,13 @@ class Constraint final : public llvm::ilist_node<Constraint>,
   }
 
   ContextualTypeInfo getElementContext() const {
-    assert(Kind == ConstraintKind::SyntacticElement);
-    return SyntacticElement.Context;
+    ASSERT(Kind == ConstraintKind::SyntacticElement);
+    return *getTrailingObjects<ContextualTypeInfo>();
   }
 
   bool isDiscardedElement() const {
     assert(Kind == ConstraintKind::SyntacticElement);
-    return SyntacticElement.IsDiscarded;
+    return isDiscarded;
   }
 
   /// For an applicable function constraint, retrieve the trailing closure