Define Mangling for ParameterizedProtocol

CodaFi · CodaFi · commit 3b3ff6a5dbbf · 2022-03-08T22:01:19.000-08:00
diff --git a/docs/ABI/Mangling.rst b/docs/ABI/Mangling.rst
@@ -635,6 +635,7 @@ Types
   type ::= protocol-list 'p'                 // existential type
   type ::= protocol-list superclass 'Xc'     // existential type with superclass
   type ::= protocol-list 'Xl'                // existential type with AnyObject
+  type ::= protocol-list 'y' (type* '_')* type* retroactive-conformance* 'Xp'   // parameterized protocol type
   type ::= type-list 't'                     // tuple
   type ::= type generic-signature 'u'        // generic type
   type ::= 'x'                               // generic param, depth=0, idx=0
diff --git a/include/swift/AST/ASTDemangler.h b/include/swift/AST/ASTDemangler.h
@@ -112,6 +112,8 @@ class ASTBuilder {
                                      bool isClassBound,
                                      bool forRequirement = true);
 
+  Type createParameterizedProtocolType(Type base, ArrayRef<Type> args);
+
   Type createExistentialMetatypeType(Type instance,
                      Optional<Demangle::ImplMetatypeRepresentation> repr=None);
 
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
@@ -6417,9 +6417,10 @@ inline bool TypeBase::isAnyExistentialType() {
 }
 
 inline bool CanType::isExistentialTypeImpl(CanType type) {
-  return (isa<ProtocolType>(type) ||
-          isa<ProtocolCompositionType>(type) ||
-          isa<ExistentialType>(type));
+  return isa<ProtocolType>(type) ||
+         isa<ProtocolCompositionType>(type) ||
+         isa<ExistentialType>(type) ||
+         isa<ParameterizedProtocolType>(type);
 }
 
 inline bool CanType::isAnyExistentialTypeImpl(CanType type) {
@@ -6515,6 +6516,8 @@ inline NominalTypeDecl *CanType::getNominalOrBoundGenericNominal() const {
     return Ty->getDecl();
   if (auto Ty = dyn_cast<ExistentialType>(*this))
     return Ty->getConstraintType()->getNominalOrBoundGenericNominal();
+  if (auto Ty = dyn_cast<ParameterizedProtocolType>(*this))
+    return Ty->getBaseType()->getNominalOrBoundGenericNominal();
   return nullptr;
 }
 
diff --git a/include/swift/Demangling/DemangleNodes.def b/include/swift/Demangling/DemangleNodes.def
@@ -170,6 +170,7 @@ NODE(EscapingObjCBlock)
 CONTEXT_NODE(OtherNominalType)
 CONTEXT_NODE(OwningAddressor)
 CONTEXT_NODE(OwningMutableAddressor)
+NODE(ParameterizedProtocol)
 NODE(PartialApplyForwarder)
 NODE(PartialApplyObjCForwarder)
 NODE(PostfixOperator)
diff --git a/include/swift/Demangling/TypeDecoder.h b/include/swift/Demangling/TypeDecoder.h
@@ -710,6 +710,34 @@ class TypeDecoder {
                                                    forRequirement);
     }
 
+    case NodeKind::ParameterizedProtocol: {
+      if (Node->getNumChildren() < 2)
+        return MAKE_NODE_TYPE_ERROR(Node,
+                                    "fewer children (%zu) than required (2)",
+                                    Node->getNumChildren());
+
+      auto protocolType = decodeMangledType(Node->getChild(0), depth + 1);
+      if (protocolType.isError())
+        return protocolType;
+
+      llvm::SmallVector<BuiltType, 8> args;
+
+      const auto &genericArgs = Node->getChild(1);
+      if (genericArgs->getKind() != NodeKind::TypeList)
+        return MAKE_NODE_TYPE_ERROR0(genericArgs, "is not TypeList");
+
+      for (auto genericArg : *genericArgs) {
+        auto paramType = decodeMangledType(genericArg, depth + 1,
+                                           /*forRequirement=*/false);
+        if (paramType.isError())
+          return paramType;
+        args.push_back(paramType.getType());
+      }
+
+      return Builder.createParameterizedProtocolType(protocolType.getType(),
+                                                     args);
+    }
+
     case NodeKind::Protocol:
     case NodeKind::ProtocolSymbolicReference: {
       if (auto Proto = decodeMangledProtocolType(Node, depth + 1)) {
diff --git a/include/swift/Reflection/TypeRef.h b/include/swift/Reflection/TypeRef.h
@@ -563,6 +563,42 @@ class ProtocolCompositionTypeRef final : public TypeRef {
   }
 };
 
+class ParameterizedProtocolTypeRef final : public TypeRef {
+  const ProtocolCompositionTypeRef *Base;
+  std::vector<const TypeRef *> Args;
+
+  static TypeRefID Profile(const ProtocolCompositionTypeRef *Protocol,
+                           std::vector<const TypeRef *> Args) {
+    TypeRefID ID;
+    ID.addPointer(Protocol);
+    for (auto Arg : Args) {
+      ID.addPointer(Arg);
+    }
+    return ID;
+  }
+
+public:
+  ParameterizedProtocolTypeRef(const ProtocolCompositionTypeRef *Protocol,
+                               std::vector<const TypeRef *> Args)
+      : TypeRef(TypeRefKind::ParameterizedProtocol), Base(Protocol),
+        Args(Args) {}
+
+  template <typename Allocator>
+  static const ParameterizedProtocolTypeRef *
+  create(Allocator &A, const ProtocolCompositionTypeRef *Protocol,
+         std::vector<const TypeRef *> Args) {
+    FIND_OR_CREATE_TYPEREF(A, ParameterizedProtocolTypeRef, Protocol, Args);
+  }
+
+  const ProtocolCompositionTypeRef *getBase() const { return Base; }
+
+  const std::vector<const TypeRef *> &getArgs() const { return Args; }
+
+  static bool classof(const TypeRef *TR) {
+    return TR->getKind() == TypeRefKind::ParameterizedProtocol;
+  }
+};
+
 class MetatypeTypeRef final : public TypeRef {
   const TypeRef *InstanceType;
   bool WasAbstract;
diff --git a/include/swift/Reflection/TypeRefBuilder.h b/include/swift/Reflection/TypeRefBuilder.h
@@ -614,6 +614,15 @@ class TypeRefBuilder {
                                               isClassBound);
   }
 
+  const ParameterizedProtocolTypeRef *
+  createParameterizedProtocolType(const TypeRef *base,
+                                  llvm::ArrayRef<const TypeRef *> args) {
+    auto *baseProto = llvm::dyn_cast<ProtocolCompositionTypeRef>(base);
+    if (!baseProto)
+      return nullptr;
+    return ParameterizedProtocolTypeRef::create(*this, baseProto, args);
+  }
+
   const ExistentialMetatypeTypeRef *createExistentialMetatypeType(
       const TypeRef *instance,
       llvm::Optional<Demangle::ImplMetatypeRepresentation> repr = None) {
diff --git a/include/swift/Reflection/TypeRefs.def b/include/swift/Reflection/TypeRefs.def
@@ -22,6 +22,7 @@ TYPEREF(BoundGeneric, TypeRef)
 TYPEREF(Tuple, TypeRef)
 TYPEREF(Function, TypeRef)
 TYPEREF(ProtocolComposition, TypeRef)
+TYPEREF(ParameterizedProtocol, TypeRef)
 TYPEREF(Metatype, TypeRef)
 TYPEREF(ExistentialMetatype, TypeRef)
 TYPEREF(GenericTypeParameter, TypeRef)
diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
@@ -4444,7 +4444,8 @@ CanTypeWrapper<OpenedArchetypeType>
 OpenedArchetypeType::get(CanType existential, GenericSignature parentSig,
                          Optional<UUID> knownID) {
   assert(existential->isExistentialType());
-  auto interfaceType = OpenedArchetypeType::getSelfInterfaceTypeFromContext(parentSig, existential->getASTContext());
+  auto interfaceType = OpenedArchetypeType::getSelfInterfaceTypeFromContext(
+      parentSig, existential->getASTContext());
   return get(existential, interfaceType, parentSig, knownID);
 }
 
@@ -4510,7 +4511,8 @@ CanType OpenedArchetypeType::getAny(CanType existential, Type interfaceType,
 
 CanType OpenedArchetypeType::getAny(CanType existential,
                                     GenericSignature parentSig) {
-  auto interfaceTy = OpenedArchetypeType::getSelfInterfaceTypeFromContext(parentSig, existential->getASTContext());
+  auto interfaceTy = OpenedArchetypeType::getSelfInterfaceTypeFromContext(
+      parentSig, existential->getASTContext());
   return getAny(existential, interfaceTy, parentSig);
 }
 
diff --git a/lib/AST/ASTDemangler.cpp b/lib/AST/ASTDemangler.cpp
@@ -621,6 +621,14 @@ Type ASTBuilder::createExistentialMetatypeType(Type instance,
                                       getMetatypeRepresentation(*repr));
 }
 
+Type ASTBuilder::createParameterizedProtocolType(Type base,
+                                                 ArrayRef<Type> args) {
+  if (!base->getAs<ProtocolType>())
+    return Type();
+  return ParameterizedProtocolType::get(base->getASTContext(),
+                                        base->castTo<ProtocolType>(), args);
+}
+
 Type ASTBuilder::createMetatypeType(Type instance,
                          Optional<Demangle::ImplMetatypeRepresentation> repr) {
   if (!repr)
diff --git a/lib/AST/ASTMangler.cpp b/lib/AST/ASTMangler.cpp
@@ -1269,8 +1269,11 @@ void ASTMangler::appendType(Type type, GenericSignature sig,
     }
 
     case TypeKind::ParameterizedProtocol: {
-      llvm::errs() << "Not implemented\n";
-      abort();
+      auto layout = type->getExistentialLayout();
+      appendExistentialLayout(layout, sig, forDecl);
+      bool isFirstArgList = true;
+      appendBoundGenericArgs(type, sig, isFirstArgList, forDecl);
+      return appendOperator("XP");
     }
 
     case TypeKind::Existential: {
@@ -1574,6 +1577,9 @@ void ASTMangler::appendBoundGenericArgs(Type type, GenericSignature sig,
     if (Type parent = nominalType->getParent())
       appendBoundGenericArgs(parent->getDesugaredType(), sig, isFirstArgList,
                              forDecl);
+  } else if (auto *ppt = dyn_cast<ParameterizedProtocolType>(typePtr)) {
+    assert(!ppt->getBaseType()->getParent());
+    genericArgs = ppt->getArgs();
   } else {
     auto boundType = cast<BoundGenericType>(typePtr);
     genericArgs = boundType->getGenericArgs();
diff --git a/lib/Demangling/Demangler.cpp b/lib/Demangling/Demangler.cpp
@@ -1815,6 +1815,12 @@ NodePointer Demangler::demangleBoundGenericArgs(NodePointer Nominal,
   case Node::Kind::Constructor:
     // Well, not really a nominal type.
     return createWithChildren(Node::Kind::BoundGenericFunction, Nominal, args);
+  case Node::Kind::Type:
+    if (!Nominal->hasChildren())
+      return nullptr;
+    if (Nominal->getFirstChild()->getKind() != Node::Kind::ProtocolList)
+      return nullptr;
+    return createWithChildren(Node::Kind::ParameterizedProtocol, Nominal, args);
   default:
     return nullptr;
   }
@@ -3253,6 +3259,22 @@ NodePointer Demangler::demangleSpecialType() {
       return createType(createWithChildren(Node::Kind::ExistentialMetatype,
                                            MTR, Type));
     }
+    case 'P': {
+      NodePointer RetroactiveConformances;
+      Vector<NodePointer> TypeListList(*this, 4);
+
+      if (!demangleBoundGenerics(TypeListList, RetroactiveConformances))
+        return nullptr;
+
+      NodePointer Type = popNode(Node::Kind::Type);
+      if (!Type)
+        return nullptr;
+
+      NodePointer BoundNode = demangleBoundGenericArgs(Type, TypeListList, 0);
+      NodePointer NTy = createType(BoundNode);
+      addSubstitution(NTy);
+      return NTy;
+    }
     case 'p':
       return createType(createWithChild(Node::Kind::ExistentialMetatype,
                                         popNode(Node::Kind::Type)));
diff --git a/lib/Demangling/NodePrinter.cpp b/lib/Demangling/NodePrinter.cpp
@@ -306,6 +306,7 @@ class NodePrinter {
     case Node::Kind::MetatypeRepresentation:
     case Node::Kind::Module:
     case Node::Kind::Tuple:
+    case Node::Kind::ParameterizedProtocol:
     case Node::Kind::Protocol:
     case Node::Kind::ProtocolSymbolicReference:
     case Node::Kind::ReturnType:
@@ -2270,6 +2271,10 @@ NodePointer NodePrinter::print(NodePointer Node, unsigned depth,
     }
     return nullptr;
   }
+  case Node::Kind::ParameterizedProtocol: {
+    Printer << "parameterized protocol";
+    return nullptr;
+  }
   case Node::Kind::ExistentialMetatype: {
     unsigned Idx = 0;
     if (Node->getNumChildren() == 2) {
diff --git a/lib/Demangling/OldRemangler.cpp b/lib/Demangling/OldRemangler.cpp
@@ -2714,7 +2714,10 @@ ManglingError Remangler::mangleObjCAsyncCompletionHandlerImpl(Node *node,
                                                               unsigned depth) {
   return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
 }
-
+ManglingError Remangler::mangleParameterizedProtocol(Node *node,
+                                                     unsigned int depth) {
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
+}
 ManglingError
 Remangler::mangleCanonicalSpecializedGenericMetaclass(Node *node,
                                                       unsigned depth) {
diff --git a/lib/Demangling/Remangler.cpp b/lib/Demangling/Remangler.cpp
@@ -601,6 +601,13 @@ ManglingError Remangler::mangleGenericArgs(Node *node, char &Separator,
       break;
     }
 
+    case Node::Kind::ParameterizedProtocol: {
+      Buffer << Separator;
+      Separator = '_';
+      RETURN_IF_ERROR(mangleChildNodes(node->getChild(1), depth + 1));
+      break;
+    }
+
     case Node::Kind::BoundGenericFunction: {
       fullSubstitutionMap = true;
 
@@ -1218,6 +1225,15 @@ ManglingError Remangler::mangleErrorType(Node *node, unsigned depth) {
   return ManglingError::Success;
 }
 
+ManglingError Remangler::mangleParameterizedProtocol(Node *node,
+                                                     unsigned int depth) {
+  RETURN_IF_ERROR(mangleType(node->getChild(0), depth + 1));
+  char separator = 'y';
+  RETURN_IF_ERROR(mangleGenericArgs(node, separator, depth + 1));
+  Buffer << "XP";
+  return ManglingError::Success;
+}
+
 ManglingError Remangler::mangleExistentialMetatype(Node *node, unsigned depth) {
   if (node->getFirstChild()->getKind() == Node::Kind::MetatypeRepresentation) {
     RETURN_IF_ERROR(mangleChildNode(node, 1, depth + 1));
@@ -3475,6 +3491,7 @@ bool Demangle::isSpecialized(Node *node) {
     case Node::Kind::BoundGenericTypeAlias:
     case Node::Kind::BoundGenericProtocol:
     case Node::Kind::BoundGenericFunction:
+    case Node::Kind::ParameterizedProtocol:
       return true;
 
     case Node::Kind::Structure:
@@ -3577,6 +3594,12 @@ ManglingErrorOr<NodePointer> Demangle::getUnspecialized(Node *node,
       return nominalType;
     }
 
+    case Node::Kind::ParameterizedProtocol: {
+      NodePointer unboundType = node->getChild(0);
+      DEMANGLER_ASSERT(unboundType->getKind() == Node::Kind::Type, unboundType);
+      return unboundType;
+    }
+
     case Node::Kind::BoundGenericFunction: {
       NodePointer unboundFunction = node->getChild(0);
       DEMANGLER_ASSERT(unboundFunction->getKind() == Node::Kind::Function ||
diff --git a/stdlib/public/Reflection/TypeLowering.cpp b/stdlib/public/Reflection/TypeLowering.cpp
@@ -1698,6 +1698,11 @@ class HasFixedSize
     return true;
   }
 
+  bool
+  visitParameterizedProtocolTypeRef(const ParameterizedProtocolTypeRef *PPT) {
+    return true;
+  }
+
   bool
   visitSILBoxTypeRef(const SILBoxTypeRef *SB) {
     return true;
@@ -1814,6 +1819,11 @@ class HasSingletonMetatype
     return MetatypeRepresentation::Thin;
   }
 
+  MetatypeRepresentation
+  visitParameterizedProtocolTypeRef(const ParameterizedProtocolTypeRef *PPT) {
+    return MetatypeRepresentation::Thin;
+  }
+
   MetatypeRepresentation visitMetatypeTypeRef(const MetatypeTypeRef *M) {
     if (M->wasAbstract())
       return MetatypeRepresentation::Thick;
@@ -2260,6 +2270,11 @@ class LowerType
     return builder.build(ExternalTypeInfo);
   }
 
+  const TypeInfo *
+  visitParameterizedProtocolTypeRef(const ParameterizedProtocolTypeRef *PPT) {
+    return visitProtocolCompositionTypeRef(PPT->getBase());
+  }
+
   const TypeInfo *visitMetatypeTypeRef(const MetatypeTypeRef *M) {
     switch (HasSingletonMetatype().visit(M)) {
     case MetatypeRepresentation::Unknown:
diff --git a/stdlib/public/Reflection/TypeRef.cpp b/stdlib/public/Reflection/TypeRef.cpp
diff --git a/stdlib/public/runtime/MetadataLookup.cpp b/stdlib/public/runtime/MetadataLookup.cpp
diff --git a/test/Demangle/Inputs/manglings.txt b/test/Demangle/Inputs/manglings.txt

Original file line number	Diff line number	Diff line change
`@@ -6417,9 +6417,10 @@ inline bool TypeBase::isAnyExistentialType() {`
`6417`	`6417`	`}`
`6418`	`6418`
`6419`	`6419`	`inline bool CanType::isExistentialTypeImpl(CanType type) {`
`6420`		`- return (isa<ProtocolType>(type) \|\|`
`6421`		`- isa<ProtocolCompositionType>(type) \|\|`
`6422`		`- isa<ExistentialType>(type));`
	`6420`	`+ return isa<ProtocolType>(type) \|\|`
	`6421`	`+ isa<ProtocolCompositionType>(type) \|\|`
	`6422`	`+ isa<ExistentialType>(type) \|\|`
	`6423`	`+ isa<ParameterizedProtocolType>(type);`
`6423`	`6424`	`}`
`6424`	`6425`
`6425`	`6426`	`inline bool CanType::isAnyExistentialTypeImpl(CanType type) {`
`@@ -6515,6 +6516,8 @@ inline NominalTypeDecl *CanType::getNominalOrBoundGenericNominal() const {`
`6515`	`6516`	`return Ty->getDecl();`
`6516`	`6517`	`if (auto Ty = dyn_cast<ExistentialType>(*this))`
`6517`	`6518`	`return Ty->getConstraintType()->getNominalOrBoundGenericNominal();`
	`6519`	`+ if (auto Ty = dyn_cast<ParameterizedProtocolType>(*this))`
	`6520`	`+ return Ty->getBaseType()->getNominalOrBoundGenericNominal();`
`6518`	`6521`	`return nullptr;`
`6519`	`6522`	`}`
`6520`	`6523`