AST: Fold RequirementBase into it's three subclasses

It's a very simple algebraic data type, and factoring it out into
a template doesn't carry its weight.

Author: slavapestov

include/swift/AST/Requirement.h

@@ -18,7 +18,7 @@
 #define SWIFT_AST_REQUIREMENT_H
 
 #include "swift/AST/LayoutConstraint.h"
-#include "swift/AST/RequirementBase.h"
+#include "swift/AST/RequirementKind.h"
 #include "swift/AST/Type.h"
 #include "swift/Basic/Debug.h"
 #include "llvm/ADT/Hashing.h"
@@ -29,18 +29,97 @@ namespace swift {
 
 /// A single requirement placed on the type parameters (or associated
 /// types thereof) of a
-class Requirement
-    : public RequirementBase<Type,
-                             llvm::PointerIntPair<Type, 3, RequirementKind>,
-                             LayoutConstraint> {
+class Requirement {
+  llvm::PointerIntPair<Type, 3, RequirementKind> FirstTypeAndKind;
+  /// The second element of the requirement. Its content is dependent
+  /// on the requirement kind.
+  /// The payload of the following enum should always match the kind!
+  /// Any access to the fields of this enum should first check if the
+  /// requested access matches the kind of the requirement.
+  union {
+    Type SecondType;
+    LayoutConstraint SecondLayout;
+  };
+
 public:
   /// Create a conformance or same-type requirement.
   Requirement(RequirementKind kind, Type first, Type second)
-      : RequirementBase(kind, first, second) {}
+      : FirstTypeAndKind(first, kind), SecondType(second) {
+    assert(first);
+    assert(second);
+    assert(kind != RequirementKind::Layout);
+  }
 
   /// Create a layout constraint requirement.
   Requirement(RequirementKind kind, Type first, LayoutConstraint second)
-    : RequirementBase(kind, first, second) {}
+      : FirstTypeAndKind(first, kind), SecondLayout(second) {
+    assert(first);
+    assert(second);
+    assert(kind == RequirementKind::Layout);
+  }
+
+
+  /// Determine the kind of requirement.
+  RequirementKind getKind() const { return FirstTypeAndKind.getInt(); }
+
+  /// Retrieve the first type.
+  Type getFirstType() const {
+    return FirstTypeAndKind.getPointer();
+  }
+
+  /// Retrieve the second type.
+  Type getSecondType() const {
+    assert(getKind() != RequirementKind::Layout);
+    return SecondType;
+  }
+
+  /// Retrieve the layout constraint.
+  LayoutConstraint getLayoutConstraint() const {
+    assert(getKind() == RequirementKind::Layout);
+    return SecondLayout;
+  }
+
+  friend llvm::hash_code hash_value(const Requirement &requirement) {
+    using llvm::hash_value;
+
+    llvm::hash_code first =
+        hash_value(requirement.FirstTypeAndKind.getOpaqueValue());
+    llvm::hash_code second;
+    switch (requirement.getKind()) {
+    case RequirementKind::SameShape:
+    case RequirementKind::Conformance:
+    case RequirementKind::Superclass:
+    case RequirementKind::SameType:
+      second = hash_value(requirement.getSecondType());
+      break;
+
+    case RequirementKind::Layout:
+      second = hash_value(requirement.getLayoutConstraint());
+      break;
+    }
+
+    return llvm::hash_combine(first, second);
+  }
+
+  friend bool operator==(const Requirement &lhs,
+                         const Requirement &rhs) {
+    if (lhs.FirstTypeAndKind.getOpaqueValue()
+          != rhs.FirstTypeAndKind.getOpaqueValue())
+      return false;
+
+    switch (lhs.getKind()) {
+    case RequirementKind::SameShape:
+    case RequirementKind::Conformance:
+    case RequirementKind::Superclass:
+    case RequirementKind::SameType:
+      return lhs.getSecondType().getPointer() ==
+          rhs.getSecondType().getPointer();
+
+    case RequirementKind::Layout:
+      return lhs.getLayoutConstraint() == rhs.getLayoutConstraint();
+    }
+    llvm_unreachable("Unhandled RequirementKind in switch");
+  }
 
   /// Whether this requirement's types contain ErrorTypes.
   bool hasError() const;

include/swift/AST/RequirementBase.h

@@ -0,0 +1,46 @@
+//===--- RequirementKind.h - Swift RequirementKind AST ---------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the RequirementKind enum.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_REQUIREMENTKIND_H
+#define SWIFT_AST_REQUIREMENTKIND_H
+
+namespace swift {
+/// Describes the kind of a requirement that occurs within a requirements
+/// clause.
+enum class RequirementKind : unsigned {
+  /// A conformance requirement T : P, where T is a type that depends
+  /// on a generic parameter and P is a protocol to which T must conform.
+  Conformance,
+  /// A superclass requirement T : C, where T is a type that depends
+  /// on a generic parameter and C is a concrete class type which T must
+  /// equal or be a subclass of.
+  Superclass,
+  /// A same-type requirement T == U, where T and U are types that shall be
+  /// equivalent.
+  SameType,
+  /// A layout bound T : L, where T is a type that depends on a generic
+  /// parameter and L is some layout specification that should bound T.
+  Layout,
+  /// A same-shape requirement shape(T) == shape(U), where T and U are pack
+  /// parameters.
+  SameShape
+
+  // Note: there is code that packs this enum in a 3-bit bitfield.  Audit users
+  // when adding enumerators.
+};
+
+} // namespace swift
+#endif

include/swift/AST/RequirementKind.h

@@ -22,7 +22,7 @@
 #include "swift/Basic/LLVM.h"
 #include "swift/ABI/MetadataValues.h"
 #include "swift/AST/LayoutConstraintKind.h"
-#include "swift/AST/RequirementBase.h"
+#include "swift/AST/RequirementKind.h"
 #include "swift/Basic/Unreachable.h"
 #include "swift/Demangling/Demangler.h"
 #include "swift/Demangling/NamespaceMacros.h"

include/swift/Demangling/TypeDecoder.h

@@ -141,18 +141,55 @@ struct TypeRefLayoutConstraint {
   }
 };
 
-class TypeRefRequirement
-    : public RequirementBase<
-          const TypeRef *,
-          llvm::PointerIntPair<const TypeRef *, 3, RequirementKind>,
-          TypeRefLayoutConstraint> {
+class TypeRefRequirement {
+  llvm::PointerIntPair<const TypeRef *, 3, RequirementKind> FirstTypeAndKind;
+
+  /// The second element of the requirement. Its content is dependent
+  /// on the requirement kind.
+  /// The payload of the following enum should always match the kind!
+  /// Any access to the fields of this enum should first check if the
+  /// requested access matches the kind of the requirement.
+  union {
+    const TypeRef * SecondType;
+    TypeRefLayoutConstraint SecondLayout;
+  };
+
 public:
   TypeRefRequirement(RequirementKind kind, const TypeRef *first,
                      const TypeRef *second)
-      : RequirementBase(kind, first, second) {}
+      : FirstTypeAndKind(first, kind), SecondType(second) {
+    assert(first);
+    assert(second);
+    assert(kind != RequirementKind::Layout);
+  }
+
   TypeRefRequirement(RequirementKind kind, const TypeRef *first,
                      TypeRefLayoutConstraint second)
-      : RequirementBase(kind, first, second) {}
+      : FirstTypeAndKind(first, kind), SecondLayout(second) {
+    assert(first);
+    assert(second);
+    assert(kind == RequirementKind::Layout);
+  }
+
+  /// Determine the kind of requirement.
+  RequirementKind getKind() const { return FirstTypeAndKind.getInt(); }
+
+  /// Retrieve the first type.
+  const TypeRef *getFirstType() const {
+    return FirstTypeAndKind.getPointer();
+  }
+
+  /// Retrieve the second type.
+  const TypeRef *getSecondType() const {
+    assert(getKind() != RequirementKind::Layout);
+    return SecondType;
+  }
+
+  /// Retrieve the layout constraint.
+  TypeRefLayoutConstraint getLayoutConstraint() const {
+    assert(getKind() == RequirementKind::Layout);
+    return SecondLayout;
+  }
 };
 
 // On 32-bit systems this needs more than just pointer alignment to fit the
@@ -991,8 +1028,16 @@ class SILBoxTypeWithLayoutTypeRef final : public TypeRef {
       ID.addPointer(s.first);
       ID.addPointer(s.second);
     }
-    for (auto &r : Requirements)
-      ID.addInteger((uint64_t)(size_t)hash_value(hash_value(r)));
+    for (auto &r : Requirements) {
+      ID.addInteger(uint32_t(r.getKind()));
+      ID.addPointer(r.getFirstType());
+      if (r.getKind() != RequirementKind::Layout)
+        ID.addPointer(r.getSecondType());
+      else {
+        // FIXME: Implement TypeRefLayoutConstraint
+        ID.addInteger(uint32_t(0));
+      }
+    }
     return ID;
   }