Merge pull request #64222 from slavapestov/demangle-variadic-generic-types

Demangling variadic generic types to metadata

Author: hborla

include/swift/ABI/Metadata.h

@@ -4917,6 +4917,8 @@ class TargetPackPointer {
   using PointerType = typename Runtime::template Pointer<const Pointee<Runtime>>;
 
 public:
+  explicit TargetPackPointer() : Ptr(0) {}
+
   explicit TargetPackPointer(typename Runtime::StoredSize rawPtr) : Ptr(rawPtr) {}
 
   explicit TargetPackPointer(const void *rawPtr)
@@ -4926,6 +4928,10 @@ class TargetPackPointer {
     : Ptr(reinterpret_cast<typename Runtime::StoredSize>(ptr) |
           (lifetime == PackLifetime::OnHeap ? 1 : 0)) {}
 
+  explicit operator bool() const {
+    return Ptr != 0;
+  }
+
   // Strips off the LSB.
   const PointerType *getElements() const {
     return reinterpret_cast<const PointerType *>(Ptr & ~1);
@@ -4944,6 +4950,14 @@ class TargetPackPointer {
   PackLifetime getLifetime() const {
     return (bool)(Ptr & 1) ? PackLifetime::OnHeap : PackLifetime::OnStack;
   }
+
+  // Get the number of elements in the pack, only valid for on-heap packs.
+  size_t getNumElements() const {
+    if (getLifetime() == PackLifetime::OnHeap)
+      return *(reinterpret_cast<const size_t *>(Ptr & ~1) - 1);
+
+    fatalError(0, "Cannot get length of on-stack pack");
+  }
 };
 
 /// A pointer to a metadata pack.

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"