Support SILBoxWithLayout in TypeDecoder and factor out decodeRequirement() from

ASTBuilder.

Author: adrian-prantl

include/swift/AST/ASTDemangler.h

@@ -66,6 +66,7 @@ class ASTBuilder {
 
   Demangle::NodeFactory &getNodeFactory() { return Factory; }
 
+  Type decodeMangledType(NodePointer node);
   Type createBuiltinType(StringRef builtinName, StringRef mangledName);
 
   TypeDecl *createTypeDecl(NodePointer node);
@@ -126,6 +127,18 @@ class ASTBuilder {
 #include "swift/AST/ReferenceStorage.def"
 
   Type createSILBoxType(Type base);
+  using BuiltSILBoxField = llvm::PointerIntPair<Type, 1>;
+  using BuiltSubstitution = std::pair<Type, Type>;
+  using BuiltRequirement = swift::Requirement;
+  using BuiltLayoutConstraint = swift::LayoutConstraint;
+  Type createSILBoxTypeWithLayout(ArrayRef<BuiltSILBoxField> Fields,
+                                  ArrayRef<BuiltSubstitution> Substitutions,
+                                  ArrayRef<BuiltRequirement> Requirements);
+
+  bool isExistential(Type type) {
+    return type->isExistentialType();
+  }
+
 
   Type createObjCClassType(StringRef name);
 
@@ -149,6 +162,11 @@ class ASTBuilder {
 
   Type createParenType(Type base);
 
+  LayoutConstraint getLayoutConstraint(LayoutConstraintKind kind);
+  LayoutConstraint getLayoutConstraintWithSizeAlign(LayoutConstraintKind kind,
+                                                    unsigned size,
+                                                    unsigned alignment);
+
 private:
   bool validateParentType(TypeDecl *decl, Type parent);
   CanGenericSignature demangleGenericSignature(

include/swift/AST/LayoutConstraint.h

@@ -17,44 +17,22 @@
 #ifndef SWIFT_LAYOUT_CONSTRAINT_H
 #define SWIFT_LAYOUT_CONSTRAINT_H
 
+#include "swift/AST/LayoutConstraintKind.h"
+#include "swift/AST/PrintOptions.h"
 #include "swift/AST/TypeAlignments.h"
 #include "swift/Basic/Debug.h"
 #include "swift/Basic/SourceLoc.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/StringRef.h"
-#include "swift/AST/PrintOptions.h"
 
 namespace swift {
 
 enum class AllocationArena;
 class ASTContext;
 class ASTPrinter;
 
-/// Describes a layout constraint information.
-enum class LayoutConstraintKind : uint8_t {
-  // It is not a known layout constraint.
-  UnknownLayout,
-  // It is a layout constraint representing a trivial type of a known size.
-  TrivialOfExactSize,
-  // It is a layout constraint representing a trivial type of a size known to
-  // be no larger than a given size.
-  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.
 class LayoutConstraintInfo : public llvm::FoldingSetNode {
   friend class LayoutConstraint;

include/swift/AST/LayoutConstraintKind.h

@@ -0,0 +1,43 @@
+//===-- LayoutConstraintKind.h - Layout constraints kinds -------*- 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 types and APIs for layout constraints.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_LAYOUT_CONSTRAINTKIND_H
+#define SWIFT_LAYOUT_CONSTRAINTKIND_H
+
+/// Describes a layout constraint information.
+enum class LayoutConstraintKind : uint8_t {
+  // It is not a known layout constraint.
+  UnknownLayout,
+  // It is a layout constraint representing a trivial type of a known size.
+  TrivialOfExactSize,
+  // It is a layout constraint representing a trivial type of a size known to
+  // be no larger than a given size.
+  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,
+};
+
+#endif

include/swift/AST/Requirement.h

@@ -17,6 +17,8 @@
 #ifndef SWIFT_AST_REQUIREMENT_H
 #define SWIFT_AST_REQUIREMENT_H
 
+#include "swift/AST/LayoutConstraint.h"
+#include "swift/AST/RequirementBase.h"
 #include "swift/AST/Type.h"
 #include "swift/Basic/Debug.h"
 #include "llvm/ADT/Hashing.h"
@@ -25,76 +27,33 @@
 
 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,
-
-  // Note: there is code that packs this enum in a 2-bit bitfield.  Audit users
-  // when adding enumerators.
-};
-
 /// A single requirement placed on the type parameters (or associated
 /// types thereof) of a
-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;
-  };
-
+class Requirement
+    : public RequirementBase<Type,
+                             llvm::PointerIntPair<Type, 3, RequirementKind>,
+                             LayoutConstraint> {
 public:
   /// Create a conformance or same-type requirement.
   Requirement(RequirementKind kind, Type first, Type second)
-    : FirstTypeAndKind(first, kind), SecondType(second) {
-    assert(first);
-    assert(second);
-  }
+      : RequirementBase(kind, first, second) {}
 
   /// Create a layout constraint requirement.
   Requirement(RequirementKind kind, Type first, LayoutConstraint second)
-    : FirstTypeAndKind(first, kind), SecondLayout(second) {
-    assert(first);
-    assert(second);
-  }
-
-  /// Determine the kind of requirement.
-  RequirementKind getKind() const { return FirstTypeAndKind.getInt(); }
+    : RequirementBase(kind, first, second) {}
 
-  /// Retrieve the first type.
-  Type getFirstType() const {
-    return FirstTypeAndKind.getPointer();
-  }
+  /// Whether this requirement is in its canonical form.
+  bool isCanonical() const;
 
-  /// Retrieve the second type.
-  Type getSecondType() const {
-    assert(getKind() != RequirementKind::Layout);
-    return SecondType;
-  }
+  /// Get the canonical form of this requirement.
+  Requirement getCanonical() const;
 
   /// Subst the types involved in this requirement.
   ///
   /// The \c args arguments are passed through to Type::subst. This doesn't
   /// touch the superclasses, protocols or layout constraints.
-  template <typename... Args>
-  Optional<Requirement> subst(Args &&... args) const {
+  template <typename ...Args>
+  llvm::Optional<Requirement> subst(Args &&...args) const {
     auto newFirst = getFirstType().subst(std::forward<Args>(args)...);
     if (newFirst->hasError())
       return None;
@@ -115,61 +74,10 @@ class Requirement {
     llvm_unreachable("Unhandled RequirementKind in switch.");
   }
 
-  /// Retrieve the layout constraint.
-  LayoutConstraint getLayoutConstraint() const {
-    assert(getKind() == RequirementKind::Layout);
-    return SecondLayout;
-  }
-
-  /// Whether this requirement is in its canonical form.
-  bool isCanonical() const;
-
-  /// Get the canonical form of this requirement.
-  Requirement getCanonical() const;
-
   SWIFT_DEBUG_DUMP;
   void dump(raw_ostream &out) const;
   void print(raw_ostream &os, const PrintOptions &opts) const;
   void print(ASTPrinter &printer, const PrintOptions &opts) const;
-
-  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::Conformance:
-    case RequirementKind::Superclass:
-    case RequirementKind::SameType:
-      second = hash_value(requirement.getSecondType().getPointer());
-      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::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");
-  }
 };
 
 inline void simple_display(llvm::raw_ostream &out, const Requirement &req) {