[GSB] Improve handling of layout constraints

include/swift/AST/LayoutConstraint.h

@@ -40,10 +40,16 @@ enum class LayoutConstraintKind : unsigned char {
   TrivialOfAtMostSize,
   // It is a layout constraint representing a trivial type of an unknown size.
   Trivial,
+  // It is a layout constraint representing a reference counted class instance.
+  Class,
+  // It is a layout constraint representing a reference counted native class
+  // instance.
+  NativeClass,
   // It is a layout constraint representing a reference counted object.
   RefCountedObject,
   // It is a layout constraint representing a native reference counted object.
   NativeRefCountedObject,
+  LastLayout = NativeRefCountedObject,
 };
 
 /// This is a class representing the layout constraint.
@@ -108,6 +114,22 @@ class LayoutConstraintInfo : public llvm::FoldingSetNode {
     return isNativeRefCountedObject(Kind);
   }
 
+  bool isClass() const {
+    return isClass(Kind);
+  }
+
+  bool isNativeClass() const {
+    return isNativeClass(Kind);
+  }
+
+  bool isRefCounted() const {
+    return isRefCounted(Kind);
+  }
+
+  bool isNativeRefCounted() const {
+    return isNativeRefCounted(Kind);
+  }
+
   unsigned getTrivialSizeInBytes() const {
     assert(isKnownSizeTrivial());
     return (SizeInBits + 7) / 8;
@@ -170,6 +192,16 @@ class LayoutConstraintInfo : public llvm::FoldingSetNode {
 
   static bool isNativeRefCountedObject(LayoutConstraintKind Kind);
 
+  static bool isAnyRefCountedObject(LayoutConstraintKind Kind);
+
+  static bool isClass(LayoutConstraintKind Kind);
+
+  static bool isNativeClass(LayoutConstraintKind Kind);
+
+  static bool isRefCounted(LayoutConstraintKind Kind);
+
+  static bool isNativeRefCounted(LayoutConstraintKind Kind);
+
   /// Uniquing for the LayoutConstraintInfo.
   void Profile(llvm::FoldingSetNodeID &ID) {
     Profile(ID, Kind, SizeInBits, Alignment);
@@ -189,6 +221,14 @@ class LayoutConstraintInfo : public llvm::FoldingSetNode {
   void *operator new(size_t bytes, const ASTContext &ctx,
                      AllocationArena arena, unsigned alignment = 8);
   void *operator new(size_t Bytes, void *Mem) throw() { return Mem; }
+
+  // Representation of the non-parametrized layouts.
+  static LayoutConstraintInfo UnknownLayoutConstraintInfo;
+  static LayoutConstraintInfo RefCountedObjectConstraintInfo;
+  static LayoutConstraintInfo NativeRefCountedObjectConstraintInfo;
+  static LayoutConstraintInfo ClassConstraintInfo;
+  static LayoutConstraintInfo NativeClassConstraintInfo;
+  static LayoutConstraintInfo TrivialConstraintInfo;
 };
 
 /// A wrapper class containing a reference to the actual LayoutConstraintInfo
@@ -204,19 +244,25 @@ class LayoutConstraint {
   static LayoutConstraint getLayoutConstraint(LayoutConstraintKind Kind,
                                               ASTContext &C);
 
+  static LayoutConstraint getLayoutConstraint(LayoutConstraintKind Kind);
+
   static LayoutConstraint getLayoutConstraint(LayoutConstraintKind Kind,
                                               unsigned SizeInBits,
                                               unsigned Alignment,
                                               ASTContext &C);
 
-  static LayoutConstraint getUnknownLayout(ASTContext &C);
+  static LayoutConstraint getUnknownLayout();
 
   LayoutConstraintInfo *getPointer() const { return Ptr; }
 
   bool isNull() const { return Ptr == 0; }
 
   LayoutConstraintInfo *operator->() const { return Ptr; }
 
+  /// Merge these two constraints and return a more specific one
+  /// or fail if they’re incompatible and return an unknown constraint.
+  LayoutConstraint merge(LayoutConstraint Other);
+
   explicit operator bool() const { return Ptr != 0; }
 
   void dump() const;

lib/AST/ASTContext.cpp

@@ -4074,6 +4074,12 @@ LayoutConstraint LayoutConstraint::getLayoutConstraint(LayoutConstraintKind Kind
                                                       unsigned SizeInBits,
                                                       unsigned Alignment,
                                                       ASTContext &C) {
+  if (!LayoutConstraintInfo::isKnownSizeTrivial(Kind)) {
+    assert(SizeInBits == 0);
+    assert(Alignment == 0);
+    return getLayoutConstraint(Kind);
+  }
+
   // Check to see if we've already seen this tuple before.
   llvm::FoldingSetNodeID ID;
   LayoutConstraintInfo::Profile(ID, Kind, SizeInBits, Alignment);
@@ -4094,7 +4100,4 @@ LayoutConstraint LayoutConstraint::getLayoutConstraint(LayoutConstraintKind Kind
   return LayoutConstraint(New);
 }
 
-LayoutConstraint LayoutConstraint::getUnknownLayout(ASTContext &C) {
-  return getLayoutConstraint(LayoutConstraintKind::UnknownLayout, 0, 0, C);
-}
 

lib/AST/GenericSignatureBuilder.cpp

@@ -2079,9 +2079,14 @@ bool GenericSignatureBuilder::addLayoutRequirement(
   equivClass->layoutConstraints.push_back({PAT, Layout, Source});
 
   // Update the layout in the equivalence class, if we didn't have one already.
-  // FIXME: Layouts can probably be merged sensibly.
   if (!equivClass->layout)
     equivClass->layout = Layout;
+  else {
+    // Try to merge layout constraints.
+    auto mergedLayout = equivClass->layout.merge(Layout);
+    if (mergedLayout->isKnownLayout() && mergedLayout != equivClass->layout)
+      equivClass->layout = mergedLayout;
+  }
 
   return false;
 }
@@ -2120,6 +2125,16 @@ bool GenericSignatureBuilder::updateSuperclass(
   if (!equivClass->superclass) {
     equivClass->superclass = superclass;
     updateSuperclassConformances();
+    // Presence of a superclass constraint implies a _Class layout
+    // constraint.
+    auto layoutReqSource = source->viaSuperclass(*this, nullptr);
+    addLayoutRequirement(T,
+                         LayoutConstraint::getLayoutConstraint(
+                             superclass->getClassOrBoundGenericClass()->isObjC()
+                                 ? LayoutConstraintKind::Class
+                                 : LayoutConstraintKind::NativeClass,
+                             getASTContext()),
+                         layoutReqSource);
     return false;
   }
 
@@ -3459,7 +3474,9 @@ void GenericSignatureBuilder::checkLayoutConstraints(
       return constraint.value == equivClass->layout;
     },
     [&](LayoutConstraint layout) {
-      if (layout == equivClass->layout)
+      // If the layout constraints are mergable, i.e. compatible,
+      // it is a redundancy.
+      if (layout.merge(equivClass->layout)->isKnownLayout())
         return ConstraintRelation::Redundant;
 
       return ConstraintRelation::Conflicting;