Revert "Demangle inverse requirements when building AST types"

This reverts commit a2ae214.

Author: kavon

include/swift/AST/ASTDemangler.h

@@ -83,7 +83,6 @@ 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;
@@ -162,10 +161,8 @@ class ASTBuilder {
 
   Type createProtocolTypeFromDecl(ProtocolDecl *protocol);
 
-  Type createConstrainedExistentialType(
-      Type base,
-      ArrayRef<BuiltRequirement> constraints,
-      ArrayRef<BuiltInverseRequirement> inverseRequirements);
+  Type createConstrainedExistentialType(Type base,
+                                        ArrayRef<BuiltRequirement> constraints);
 
   Type createSymbolicExtendedExistentialType(NodePointer shapeNode,
                                              ArrayRef<Type> genArgs);
@@ -196,11 +193,9 @@ 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,
-      ArrayRef<BuiltInverseRequirement> inverseRequirements);
+  Type createSILBoxTypeWithLayout(ArrayRef<BuiltSILBoxField> Fields,
+                                  ArrayRef<BuiltSubstitution> Substitutions,
+                                  ArrayRef<BuiltRequirement> Requirements);
 
   bool isExistential(Type type) {
     return type->isExistentialType();
@@ -243,9 +238,6 @@ 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

@@ -15,7 +15,6 @@
 
 #include "swift/Basic/InlineBitfield.h"
 #include "swift/Basic/FixedBitSet.h"
-#include "swift/AST/InvertibleProtocolKind.h"
 #include "swift/Config.h"
 
 namespace llvm {
@@ -58,6 +57,11 @@ 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/AST/KnownProtocols.h

@@ -22,7 +22,6 @@
 #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"
@@ -423,13 +422,10 @@ getObjCClassOrProtocolName(NodePointer node) {
 #endif
 
 template <typename BuiltType, typename BuiltRequirement,
-          typename BuiltInverseRequirement,
           typename BuiltLayoutConstraint, typename BuilderType>
-void decodeRequirement(
-    NodePointer node,
-    llvm::SmallVectorImpl<BuiltRequirement> &requirements,
-    llvm::SmallVectorImpl<BuiltInverseRequirement> &inverseRequirements,
-    BuilderType &Builder) {
+void decodeRequirement(NodePointer node,
+                       llvm::SmallVectorImpl<BuiltRequirement> &requirements,
+                       BuilderType &Builder) {
   for (auto &child : *node) {
     if (child->getKind() == Demangle::Node::Kind::DependentGenericParamCount ||
         child->getKind() == Demangle::Node::Kind::DependentGenericParamPackMarker)
@@ -455,40 +451,9 @@ void decodeRequirement(
         return;
     } else if (child->getKind() ==
           Demangle::Node::Kind::DependentGenericInverseConformanceRequirement) {
-      // 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;
+      // FIXME(kavon): this is unimplemented! We should build a PCT here with
+      //               the inverse in it.
+      return;
     }
 
 
@@ -573,7 +538,6 @@ 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;
@@ -836,19 +800,16 @@ 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, BuiltInverseRequirement,
-                        BuiltLayoutConstraint, BuilderType>(
-          reqts, requirements, inverseRequirements, Builder);
+      decodeRequirement<BuiltType, BuiltRequirement, BuiltLayoutConstraint,
+                        BuilderType>(reqts, requirements, Builder);
 
       return Builder.createConstrainedExistentialType(protocolType.getType(),
-                                                      requirements,
-                                                      inverseRequirements);
+                                                      requirements);
     }
     case NodeKind::ConstrainedExistentialSelf:
       return Builder.createGenericTypeParameterType(/*depth*/ 0, /*index*/ 0);
@@ -1319,7 +1280,6 @@ 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)
@@ -1372,10 +1332,10 @@ class TypeDecoder {
         }
 
         // Decode requirements.
-        decodeRequirement<BuiltType, BuiltRequirement, BuiltInverseRequirement,
-                          BuiltLayoutConstraint, BuilderType>(
-            dependentGenericSignatureNode, requirements, inverseRequirements,
-            Builder);
+        decodeRequirement<BuiltType, BuiltRequirement, BuiltLayoutConstraint,
+                          BuilderType>(dependentGenericSignatureNode,
+                                       requirements,
+                                       Builder);
 
         // Decode substitutions.
         for (unsigned i = 0, e = substNode->getNumChildren(); i < e; ++i) {
@@ -1413,8 +1373,7 @@ class TypeDecoder {
       }
 
       return Builder.createSILBoxTypeWithLayout(fields, substitutions,
-                                                requirements,
-                                                inverseRequirements);
+                                                requirements);
     }
     case NodeKind::SugaredOptional: {
       if (Node->getNumChildren() < 1)

include/swift/Demangling/TypeDecoder.h

@@ -192,25 +192,6 @@ 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/TypeRef.h

@@ -389,7 +389,6 @@ 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 *;
@@ -1222,9 +1221,7 @@ class TypeRefBuilder {
   }
 
   const ConstrainedExistentialTypeRef *createConstrainedExistentialType(
-      const TypeRef *base, llvm::ArrayRef<BuiltRequirement> constraints,
-      llvm::ArrayRef<BuiltInverseRequirement> InverseRequirements) {
-    // FIXME: Handle inverse requirements.
+      const TypeRef *base, llvm::ArrayRef<BuiltRequirement> constraints) {
     auto *baseProto = llvm::dyn_cast<ProtocolCompositionTypeRef>(base);
     if (!baseProto)
       return nullptr;
@@ -1298,17 +1295,10 @@ 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,
-      llvm::ArrayRef<BuiltInverseRequirement> InverseRequirements) {
-    // FIXME: Handle inverse requirements.
+      const llvm::SmallVectorImpl<BuiltRequirement> &Requirements) {
     return SILBoxTypeWithLayoutTypeRef::create(*this, Fields, Substitutions,
                                                Requirements);
   }