Demangle inverse requirements when building AST types

Extend TypeDecoder with support for inverse requirements, passing them
along to the type builder. Then implement support for inverse
requirements within the AST demangler, which addresses the round-trip
demangling failures we've been seeing.

The runtime and remote inspection facilities still need metadata to
deal with inverse requirements.

Fixes rdar://124564447.

Author: DougGregor

include/swift/AST/ASTDemangler.h

@@ -83,6 +83,7 @@ class ASTBuilder {
   using BuiltProtocolDecl = swift::ProtocolDecl *;
   using BuiltGenericSignature = swift::GenericSignature;
   using BuiltRequirement = swift::Requirement;
+  using BuiltInverseRequirement = swift::InverseRequirement;
   using BuiltSubstitutionMap = swift::SubstitutionMap;
 
   static constexpr bool needsToPrecomputeParentGenericContextShapes = false;
@@ -161,8 +162,10 @@ class ASTBuilder {
 
   Type createProtocolTypeFromDecl(ProtocolDecl *protocol);
 
-  Type createConstrainedExistentialType(Type base,
-                                        ArrayRef<BuiltRequirement> constraints);
+  Type createConstrainedExistentialType(
+      Type base,
+      ArrayRef<BuiltRequirement> constraints,
+      ArrayRef<BuiltInverseRequirement> inverseRequirements);
 
   Type createSymbolicExtendedExistentialType(NodePointer shapeNode,
                                              ArrayRef<Type> genArgs);
@@ -193,9 +196,11 @@ class ASTBuilder {
   using BuiltSILBoxField = llvm::PointerIntPair<Type, 1>;
   using BuiltSubstitution = std::pair<Type, Type>;
   using BuiltLayoutConstraint = swift::LayoutConstraint;
-  Type createSILBoxTypeWithLayout(ArrayRef<BuiltSILBoxField> Fields,
-                                  ArrayRef<BuiltSubstitution> Substitutions,
-                                  ArrayRef<BuiltRequirement> Requirements);
+  Type createSILBoxTypeWithLayout(
+      ArrayRef<BuiltSILBoxField> Fields,
+      ArrayRef<BuiltSubstitution> Substitutions,
+      ArrayRef<BuiltRequirement> Requirements,
+      ArrayRef<BuiltInverseRequirement> inverseRequirements);
 
   bool isExistential(Type type) {
     return type->isExistentialType();
@@ -238,6 +243,9 @@ class ASTBuilder {
                                                     unsigned size,
                                                     unsigned alignment);
 
+  InverseRequirement createInverseRequirement(
+      Type subject, InvertibleProtocolKind kind);
+
 private:
   bool validateParentType(TypeDecl *decl, Type parent);
   CanGenericSignature demangleGenericSignature(

include/swift/AST/InvertibleProtocolKind.h

@@ -0,0 +1,33 @@
+//===--- InvertibleProtocolKind.h - -----------------------------*- 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 header declares the InvertibleProtocolKind enum and some
+// related operations.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_INVERTIBLEPROTOCOLKIND_H
+#define SWIFT_AST_INVERTIBLEPROTOCOLKIND_H
+
+#include <stdint.h>
+
+namespace swift {
+
+enum class InvertibleProtocolKind : uint8_t {
+#define INVERTIBLE_PROTOCOL_WITH_NAME(Id, Name) Id,
+#include "swift/AST/KnownProtocols.def"
+};
+
+
+} // end namespace swift
+
+#endif // SWIFT_AST_INVERTIBLEPROTOCOLKIND_H

include/swift/AST/KnownProtocols.h

@@ -15,6 +15,7 @@
 
 #include "swift/Basic/InlineBitfield.h"
 #include "swift/Basic/FixedBitSet.h"
+#include "swift/AST/InvertibleProtocolKind.h"
 #include "swift/Config.h"
 
 namespace llvm {
@@ -57,11 +58,6 @@ enum : uint8_t {
 #include "swift/AST/KnownProtocols.def"
 };
 
-enum class InvertibleProtocolKind : uint8_t {
-#define INVERTIBLE_PROTOCOL_WITH_NAME(Id, Name) Id,
-#include "swift/AST/KnownProtocols.def"
-};
-
 using InvertibleProtocolSet = FixedBitSet<NumInvertibleProtocols,
                                           InvertibleProtocolKind>;
 

include/swift/Demangling/TypeDecoder.h

@@ -22,6 +22,7 @@
 #include "swift/Basic/LLVM.h"
 
 #include "swift/ABI/MetadataValues.h"
+#include "swift/AST/InvertibleProtocolKind.h"
 #include "swift/AST/LayoutConstraintKind.h"
 #include "swift/AST/RequirementKind.h"
 #include "swift/Basic/OptionSet.h"
@@ -422,10 +423,13 @@ getObjCClassOrProtocolName(NodePointer node) {
 #endif
 
 template <typename BuiltType, typename BuiltRequirement,
+          typename BuiltInverseRequirement,
           typename BuiltLayoutConstraint, typename BuilderType>
-void decodeRequirement(NodePointer node,
-                       llvm::SmallVectorImpl<BuiltRequirement> &requirements,
-                       BuilderType &Builder) {
+void decodeRequirement(
+    NodePointer node,
+    llvm::SmallVectorImpl<BuiltRequirement> &requirements,
+    llvm::SmallVectorImpl<BuiltInverseRequirement> &inverseRequirements,
+    BuilderType &Builder) {
   for (auto &child : *node) {
     if (child->getKind() == Demangle::Node::Kind::DependentGenericParamCount ||
         child->getKind() == Demangle::Node::Kind::DependentGenericParamPackMarker)
@@ -451,9 +455,40 @@ void decodeRequirement(NodePointer node,
         return;
     } else if (child->getKind() ==
           Demangle::Node::Kind::DependentGenericInverseConformanceRequirement) {
-      // FIXME(kavon): this is unimplemented! We should build a PCT here with
-      //               the inverse in it.
-      return;
+      // Type child
+      auto constraintNode = child->getChild(1);
+      if (constraintNode->getKind() != Demangle::Node::Kind::Type ||
+          constraintNode->getNumChildren() != 1)
+        return;
+
+      // Protocol child
+      auto protocolNode = constraintNode->getChild(0);
+      if (protocolNode->getKind() != Demangle::Node::Kind::Protocol ||
+          protocolNode->getNumChildren() != 2)
+        return;
+
+      auto moduleNode = protocolNode->getChild(0);
+      if (moduleNode->getKind() != Demangle::Node::Kind::Module ||
+          moduleNode->getText() != "Swift")
+        return;
+
+      auto protocolNameNode = protocolNode->getChild(1);
+      if (protocolNameNode->getKind() != Demangle::Node::Kind::Identifier)
+        return;
+
+      auto protocolName = protocolNameNode->getText();
+      using OptInvertibleKind = std::optional<InvertibleProtocolKind>;
+      auto protocolKind = llvm::StringSwitch<OptInvertibleKind>(protocolName)
+#define INVERTIBLE_PROTOCOL_WITH_NAME(Id, Name) \
+          .Case(Name, InvertibleProtocolKind::Id)
+#include "swift/AST/KnownProtocols.def"
+          .Default(std::nullopt);
+      if (!protocolKind)
+        return;
+
+      inverseRequirements.push_back(
+          Builder.createInverseRequirement(subjectType, *protocolKind));
+      continue;
     }
 
 
@@ -538,6 +573,7 @@ class TypeDecoder {
   using Field = typename BuilderType::BuiltSILBoxField;
   using BuiltSubstitution = typename BuilderType::BuiltSubstitution;
   using BuiltRequirement = typename BuilderType::BuiltRequirement;
+  using BuiltInverseRequirement = typename BuilderType::BuiltInverseRequirement;
   using BuiltLayoutConstraint = typename BuilderType::BuiltLayoutConstraint;
   using BuiltGenericSignature = typename BuilderType::BuiltGenericSignature;
   using BuiltSubstitutionMap = typename BuilderType::BuiltSubstitutionMap;
@@ -800,16 +836,19 @@ class TypeDecoder {
         return protocolType;
 
       llvm::SmallVector<BuiltRequirement, 8> requirements;
+      llvm::SmallVector<BuiltInverseRequirement, 8> inverseRequirements;
 
       auto *reqts = Node->getChild(1);
       if (reqts->getKind() != NodeKind::ConstrainedExistentialRequirementList)
         return MAKE_NODE_TYPE_ERROR0(reqts, "is not requirement list");
 
-      decodeRequirement<BuiltType, BuiltRequirement, BuiltLayoutConstraint,
-                        BuilderType>(reqts, requirements, Builder);
+      decodeRequirement<BuiltType, BuiltRequirement, BuiltInverseRequirement,
+                        BuiltLayoutConstraint, BuilderType>(
+          reqts, requirements, inverseRequirements, Builder);
 
       return Builder.createConstrainedExistentialType(protocolType.getType(),
-                                                      requirements);
+                                                      requirements,
+                                                      inverseRequirements);
     }
     case NodeKind::ConstrainedExistentialSelf:
       return Builder.createGenericTypeParameterType(/*depth*/ 0, /*index*/ 0);
@@ -1280,6 +1319,7 @@ class TypeDecoder {
       llvm::SmallVector<Field, 4> fields;
       llvm::SmallVector<BuiltSubstitution, 4> substitutions;
       llvm::SmallVector<BuiltRequirement, 4> requirements;
+      llvm::SmallVector<BuiltInverseRequirement, 8> inverseRequirements;
       llvm::SmallVector<BuiltType, 4> genericParams;
 
       if (Node->getNumChildren() < 1)
@@ -1332,10 +1372,10 @@ class TypeDecoder {
         }
 
         // Decode requirements.
-        decodeRequirement<BuiltType, BuiltRequirement, BuiltLayoutConstraint,
-                          BuilderType>(dependentGenericSignatureNode,
-                                       requirements,
-                                       Builder);
+        decodeRequirement<BuiltType, BuiltRequirement, BuiltInverseRequirement,
+                          BuiltLayoutConstraint, BuilderType>(
+            dependentGenericSignatureNode, requirements, inverseRequirements,
+            Builder);
 
         // Decode substitutions.
         for (unsigned i = 0, e = substNode->getNumChildren(); i < e; ++i) {
@@ -1373,7 +1413,8 @@ class TypeDecoder {
       }
 
       return Builder.createSILBoxTypeWithLayout(fields, substitutions,
-                                                requirements);
+                                                requirements,
+                                                inverseRequirements);
     }
     case NodeKind::SugaredOptional: {
       if (Node->getNumChildren() < 1)

include/swift/RemoteInspection/TypeRef.h

@@ -192,6 +192,25 @@ class TypeRefRequirement {
   }
 };
 
+class TypeRefInverseRequirement {
+  llvm::PointerIntPair<const TypeRef *, 3, InvertibleProtocolKind> Storage;
+
+public:
+  TypeRefInverseRequirement(const TypeRef *first, InvertibleProtocolKind proto)
+      : Storage(first, proto) {
+    assert(first);
+  }
+
+  /// Retrieve the first type.
+  const TypeRef *getFirstType() const {
+    return Storage.getPointer();
+  }
+
+  /// Determine the kind of requirement.
+  InvertibleProtocolKind getKind() const { return Storage.getInt(); }
+};
+
+
 // On 32-bit systems this needs more than just pointer alignment to fit the
 // extra bits needed by TypeRefRequirement.
 class alignas(8) TypeRef {

include/swift/RemoteInspection/TypeRefBuilder.h

@@ -389,6 +389,7 @@ class TypeRefBuilder {
       std::optional<std::pair<std::string, bool /*isObjC*/>>;
   using BuiltSubstitution = std::pair<const TypeRef *, const TypeRef *>;
   using BuiltRequirement = TypeRefRequirement;
+  using BuiltInverseRequirement = TypeRefInverseRequirement;
   using BuiltLayoutConstraint = TypeRefLayoutConstraint;
   using BuiltGenericTypeParam = const GenericTypeParameterTypeRef *;
   using BuiltGenericSignature = const GenericSignatureRef *;
@@ -1221,7 +1222,9 @@ class TypeRefBuilder {
   }
 
   const ConstrainedExistentialTypeRef *createConstrainedExistentialType(
-      const TypeRef *base, llvm::ArrayRef<BuiltRequirement> constraints) {
+      const TypeRef *base, llvm::ArrayRef<BuiltRequirement> constraints,
+      llvm::ArrayRef<BuiltInverseRequirement> InverseRequirements) {
+    // FIXME: Handle inverse requirements.
     auto *baseProto = llvm::dyn_cast<ProtocolCompositionTypeRef>(base);
     if (!baseProto)
       return nullptr;
@@ -1295,10 +1298,17 @@ class TypeRefBuilder {
     return {};
   }
 
+  BuiltInverseRequirement createInverseRequirement(
+      const TypeRef *subject, InvertibleProtocolKind proto) {
+    return TypeRefInverseRequirement(subject, proto);
+  }
+
   const SILBoxTypeWithLayoutTypeRef *createSILBoxTypeWithLayout(
       const llvm::SmallVectorImpl<BuiltSILBoxField> &Fields,
       const llvm::SmallVectorImpl<BuiltSubstitution> &Substitutions,
-      const llvm::SmallVectorImpl<BuiltRequirement> &Requirements) {
+      const llvm::SmallVectorImpl<BuiltRequirement> &Requirements,
+      llvm::ArrayRef<BuiltInverseRequirement> InverseRequirements) {
+    // FIXME: Handle inverse requirements.
     return SILBoxTypeWithLayoutTypeRef::create(*this, Fields, Substitutions,
                                                Requirements);
   }