RequirementMachine: Preliminary support for layout requirements

Author: slavapestov

include/swift/AST/LayoutConstraint.h

@@ -284,6 +284,10 @@ class LayoutConstraint {
   bool operator!=(LayoutConstraint rhs) const {
     return !(*this == rhs);
   }
+
+  /// Defines a somewhat arbitrary linear order on layout constraints.
+  /// -1 if this < rhs, 0 if this == rhs, 1 if this > rhs.
+  int compare(LayoutConstraint rhs) const;
 };
 
 // Permit direct uses of isa/cast/dyn_cast on LayoutConstraint.

include/swift/AST/RewriteSystem.h

@@ -15,6 +15,7 @@
 
 #include "swift/AST/Decl.h"
 #include "swift/AST/Identifier.h"
+#include "swift/AST/LayoutConstraint.h"
 #include "swift/AST/Types.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/SmallVector.h"
@@ -31,7 +32,9 @@ using ProtocolOrder = std::function<int (const ProtocolDecl *,
                                          const ProtocolDecl *)>;
 
 class Atom final {
-  using Storage = llvm::PointerUnion<Identifier, GenericTypeParamType *>;
+  using Storage = llvm::PointerUnion<Identifier,
+                                     GenericTypeParamType *,
+                                     LayoutConstraint>;
 
   const ProtocolDecl *Proto;
   Storage Value;
@@ -62,11 +65,17 @@ class Atom final {
     return Atom(nullptr, param);
   }
 
+  static Atom forLayout(LayoutConstraint layout) {
+    assert(layout->isKnownLayout());
+    return Atom(nullptr, layout);
+  }
+
   enum class Kind : uint8_t {
     AssociatedType,
     GenericParam,
     Name,
     Protocol,
+    Layout
   };
 
   Kind getKind() const {
@@ -86,6 +95,11 @@ class Atom final {
       return Kind::GenericParam;
     }
 
+    if (Value.is<LayoutConstraint>()) {
+      assert(Proto == nullptr);
+      return Kind::Layout;
+    }
+
     llvm_unreachable("Bad term rewriting atom");
   }
 
@@ -106,6 +120,11 @@ class Atom final {
     return Value.get<GenericTypeParamType *>();
   }
 
+  LayoutConstraint getLayoutConstraint() const {
+    assert(getKind() == Kind::Layout);
+    return Value.get<LayoutConstraint>();
+  }
+
   int compare(Atom other, ProtocolOrder compare) const;
 
   void dump(llvm::raw_ostream &out) const;

lib/AST/LayoutConstraint.cpp

@@ -358,4 +358,18 @@ LayoutConstraintInfo LayoutConstraintInfo::NativeClassConstraintInfo(
 LayoutConstraintInfo LayoutConstraintInfo::TrivialConstraintInfo(
     LayoutConstraintKind::Trivial);
 
+int LayoutConstraint::compare(LayoutConstraint rhs) const {
+  if (Ptr->getKind() != rhs->getKind())
+    return int(rhs->getKind()) - int(Ptr->getKind());
+
+  if (Ptr->SizeInBits != rhs->SizeInBits)
+    return int(rhs->SizeInBits) - int(Ptr->SizeInBits);
+
+  if (Ptr->Alignment != rhs->Alignment)
+    return int(rhs->Alignment) - int(Ptr->Alignment);
+
+  assert(*this == rhs);
+  return 0;
+}
+
 } // end namespace swift

lib/AST/RequirementMachine.cpp

@@ -284,8 +284,13 @@ void RewriteSystemBuilder::addRequirement(const Requirement &req,
   }
   case RequirementKind::Superclass:
     break;
-  case RequirementKind::Layout:
+  case RequirementKind::Layout: {
+    auto constraintTerm = subjectTerm;
+    constraintTerm.add(Atom::forLayout(req.getLayoutConstraint()));
+
+    Rules.emplace_back(subjectTerm, constraintTerm);
     break;
+  }
   case RequirementKind::SameType: {
     auto otherType = CanType(req.getSecondType());
 

lib/AST/RewriteSystem.cpp

@@ -53,6 +53,10 @@ int Atom::compare(Atom other, ProtocolOrder protocolOrder) const {
 
     return 0;
   }
+
+  case Kind::Layout: {
+    return getLayoutConstraint().compare(other.getLayoutConstraint());
+  }
   }
 
   llvm_unreachable("Bad atom kind");
@@ -77,6 +81,11 @@ void Atom::dump(llvm::raw_ostream &out) const {
   case Kind::GenericParam:
     out << Type(getGenericParam());
     return;
+
+  case Kind::Layout:
+    out << "[layout: ";
+    getLayoutConstraint()->print(out);
+    out << "]";
   }
 
   llvm_unreachable("Bad atom kind");