OldRemangler.cpp

//===--- OldRemangler.cpp - Old Swift Re-mangler --------------------------===//
//
// 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 implements the remangler, which turns a demangling parse
// tree back into a mangled string. This is useful for tools which
// want to extract subtrees from mangled strings.
//
//===----------------------------------------------------------------------===//

#include"DemanglerAssert.h"
#include"RemanglerBase.h"
#include"swift/AST/Ownership.h"
#include"swift/Demangling/Demangler.h"
#include"swift/Demangling/ManglingUtils.h"
#include"swift/Demangling/Punycode.h"
#include"swift/Strings.h"
#include<cstdio>
#include<cstdlib>

usingnamespaceswift;
usingnamespaceDemangle;

namespace {
classRemangler : publicRemanglerBase {
staticconstunsigned MaxDepth = 1024;

public:
Remangler(NodeFactory &Factory) : RemanglerBase(Factory) { }

classEntityContext {
bool AsContext = false;
 std::string AnonymousContextDiscriminator;
public:
boolisAsContext() const {
return AsContext;
 }

voidsetAnonymousContextDiscriminator(StringRef discriminator) {
 AnonymousContextDiscriminator = discriminator.str();
 }

 std::string takeAnonymousContextDiscriminator() {
auto r = std::move(AnonymousContextDiscriminator);
 AnonymousContextDiscriminator.clear();
return r;
 }

classManglingContextRAII {
 EntityContext &Ctx;
bool SavedValue;
public:
ManglingContextRAII(EntityContext &ctx)
 : Ctx(ctx), SavedValue(ctx.AsContext) {
 ctx.AsContext = true;
 }

~ManglingContextRAII() {
 Ctx.AsContext = SavedValue;
 }
 };
 };

 ManglingError mangle(Node *node, unsigned depth) {
if (depth > Remangler::MaxDepth) {
returnMANGLING_ERROR(ManglingError::TooComplex, node);
 }

switch (node->getKind()) {
#defineNODE(ID) \
case Node::Kind::ID: \
return mangle##ID(node, depth);
#include"swift/Demangling/DemangleNodes.def"
 }
returnMANGLING_ERROR(ManglingError::BadNodeKind, node);
 }

 ManglingError mangleGenericArgs(Node *node, EntityContext &ctx,
unsigned depth);
 ManglingError mangleAnyNominalType(Node *node, EntityContext &ctx,
unsigned depth);

#defineNODE(ID) ManglingError mangle##ID(Node *node, unsigned depth);
#defineCONTEXT_NODE(ID) \
 ManglingError mangle##ID(Node *node, unsigned depth); \
 ManglingError mangle##ID(Node *node, EntityContext &ctx, unsigned depth);
#include"swift/Demangling/DemangleNodes.def"

voidmangleIndex(Node::IndexType index);
 ManglingError mangleIdentifier(StringRef name, OperatorKind operatorKind);
 ManglingError mangleAccessor(Node *storageNode, StringRef accessorCode,
 EntityContext &ctx, unsigned depth);

 ManglingError mangleChildNodes(Node *node, unsigned depth) {
returnmangleNodes(node->begin(), node->end(), depth);
 }
 ManglingError mangleNodes(Node::iterator i, Node::iterator e,
unsigned depth) {
for (; i != e; ++i) {
RETURN_IF_ERROR(mangle(*i, depth));
 }
return ManglingError::Success;
 }
 ManglingError mangleSingleChildNode(Node *node, unsigned depth) {
if (node->getNumChildren() != 1)
returnMANGLING_ERROR(ManglingError::MultipleChildNodes, node);

returnmangle(*node->begin(), depth);
 }
 ManglingError mangleChildNode(Node *node, unsigned index, unsigned depth) {
DEMANGLER_ASSERT(index < node->getNumChildren(), node);
returnmangle(node->begin()[index], depth);
 }

 ManglingError mangleSimpleEntity(Node *node, char basicKind,
 StringRef entityKind, EntityContext &ctx,
unsigned depth);
 ManglingError
mangleNamedEntity(Node *node, char basicKind, StringRef entityKind,
 EntityContext &ctx, unsigned depth,
 StringRef ArtificialPrivateDiscriminator = {});
 ManglingError mangleTypedEntity(Node *node, char basicKind,
 StringRef entityKind, EntityContext &ctx,
unsigned depth);
 ManglingError mangleNamedAndTypedEntity(Node *node, char basicKind,
 StringRef entityKind,
 EntityContext &ctx, unsigned depth);
 ManglingError
mangleNominalType(Node *node, char basicKind, EntityContext &ctx,
unsigned depth,
 StringRef ArtificialPrivateDiscriminator = {});

 ManglingError mangleProtocolWithoutPrefix(Node *node, unsigned depth);
 ManglingError
mangleProtocolListWithoutPrefix(Node *node, unsigned depth,
 Node *additionalProto = nullptr);

 ManglingError mangleEntityContext(Node *node, EntityContext &ctx,
unsigned depth);
 ManglingError mangleEntityType(Node *node, EntityContext &ctx,
unsigned depth);
 ManglingError mangleEntityGenericType(Node *node, EntityContext &ctx);

booltrySubstitution(Node *node, SubstitutionEntry &entry);
boolmangleStandardSubstitution(Node *node);

 ManglingError mangleDependentGenericParamIndex(Node *node, unsigned depth);
 ManglingError mangleConstrainedType(Node *node, unsigned depth);
 };
} // end anonymous namespace

#defineNODE(ID)
#defineCONTEXT_NODE(ID) \
 ManglingError Remangler::mangle##ID(Node *node, unsigned depth) { \
 EntityContext ctx; \
return mangle##ID(node, ctx, depth); \
 }
#include"swift/Demangling/DemangleNodes.def"

/// Re-apply labels from the function to its parameter type
/// to preserve old mangling style.
///
/// \param LabelList The list of labels to apply.
/// \param OrigType The function parameter type to apply labels to.
/// \param Factory The node factory to use to allocate new nodes.
static NodePointer applyParamLabels(NodePointer LabelList, NodePointer OrigType,
 NodeFactory &Factory) {
if (LabelList->getNumChildren() == 0)
return OrigType;

auto applyParamLabels = [&](NodePointer ArgTuple) -> NodePointer {
assert(ArgTuple->getKind() == Node::Kind::ArgumentTuple);

auto ParamsType = Factory.createNode(Node::Kind::ArgumentTuple);
auto Tuple = Factory.createNode(Node::Kind::Tuple);

auto processParameter = [&](NodePointer Label, NodePointer Param) {
if (Label->getKind() == Node::Kind::FirstElementMarker) {
 Tuple->addChild(Param, Factory);
return;
 }

auto NewParam = Factory.createNode(Node::Kind::TupleElement);
 NewParam->addChild(Factory.createNodeWithAllocatedText(
 Node::Kind::TupleElementName, Label->getText()),
 Factory);

for (auto &Child : *Param)
 NewParam->addChild(Child, Factory);

 Tuple->addChild(NewParam, Factory);
 };

auto OrigTuple = ArgTuple->getFirstChild()->getFirstChild();

if (OrigTuple->getKind() != Node::Kind::Tuple) {
processParameter(LabelList->getChild(0), OrigTuple);
 } else {
for (unsigned i = 0, n = OrigTuple->getNumChildren(); i != n; ++i) {
processParameter(LabelList->getChild(i), OrigTuple->getChild(i));
 }
 }

auto Type = Factory.createNode(Node::Kind::Type);
 Type->addChild(Tuple, Factory);
 ParamsType->addChild(Type, Factory);
return ParamsType;
 };

auto visitTypeChild = [&](NodePointer Child) -> NodePointer {
if (Child->getKind() != Node::Kind::FunctionType &&
 Child->getKind() != Node::Kind::NoEscapeFunctionType)
return Child;

auto FuncType = Factory.createNode(Node::Kind::FunctionType);
for (unsigned i = 0, n = Child->getNumChildren(); i != n; ++i) {
 NodePointer FuncChild = Child->getChild(i);
if (FuncChild->getKind() == Node::Kind::ArgumentTuple)
 FuncChild = applyParamLabels(FuncChild);
 FuncType->addChild(FuncChild, Factory);
 }
return FuncType;
 };

auto Type = Factory.createNode(OrigType->getKind());
for (auto &Child : *OrigType)
 Type->addChild(visitTypeChild(Child), Factory);

return Type;
}

boolRemangler::trySubstitution(Node *node, SubstitutionEntry &entry) {
if (mangleStandardSubstitution(node))
returntrue;

// Go ahead and initialize the substitution entry.
 entry = entryForNode(node);

int Idx = findSubstitution(entry);
if (Idx < 0)
returnfalse;

 Buffer << 'S';
mangleIndex(Idx);
returntrue;
}

staticboolisInSwiftModule(Node *node) {
 Node *context = node->getFirstChild();
return (context->getKind() == Node::Kind::Module &&
 context->getText() == STDLIB_NAME &&
// Check for private declarations in Swift
 node->getChild(1)->getKind() == Node::Kind::Identifier);
}

boolRemangler::mangleStandardSubstitution(Node *node) {
// Look for known substitutions.
switch (node->getKind()) {
#defineSUCCESS_IF_IS(VALUE, EXPECTED, SUBSTITUTION) \
do { \
if ((VALUE) == (EXPECTED)) { \
 Buffer << SUBSTITUTION; \
returntrue; \
 } \
 } while (0)
#defineSUCCESS_IF_TEXT_IS(EXPECTED, SUBSTITUTION) \
SUCCESS_IF_IS(node->getText(), EXPECTED, SUBSTITUTION)
#defineSUCCESS_IF_DECLNAME_IS(EXPECTED, SUBSTITUTION) \
SUCCESS_IF_IS(node->getChild(1)->getText(), EXPECTED, SUBSTITUTION)

case Node::Kind::Module:
SUCCESS_IF_TEXT_IS(STDLIB_NAME, "s");
SUCCESS_IF_TEXT_IS(MANGLING_MODULE_OBJC, "So");
SUCCESS_IF_TEXT_IS(MANGLING_MODULE_CLANG_IMPORTER, "SC");
break;
case Node::Kind::Structure:
if (isInSwiftModule(node)) {
SUCCESS_IF_DECLNAME_IS("Array", "Sa");
SUCCESS_IF_DECLNAME_IS("Bool", "Sb");
SUCCESS_IF_DECLNAME_IS("UnicodeScalar", "Sc");
SUCCESS_IF_DECLNAME_IS("Double", "Sd");
SUCCESS_IF_DECLNAME_IS("Float", "Sf");
SUCCESS_IF_DECLNAME_IS("Int", "Si");
SUCCESS_IF_DECLNAME_IS("UnsafeRawPointer", "SV");
SUCCESS_IF_DECLNAME_IS("UnsafeMutableRawPointer", "Sv");
SUCCESS_IF_DECLNAME_IS("UnsafePointer", "SP");
SUCCESS_IF_DECLNAME_IS("UnsafeMutablePointer", "Sp");
SUCCESS_IF_DECLNAME_IS("UnsafeBufferPointer", "SR");
SUCCESS_IF_DECLNAME_IS("UnsafeMutableBufferPointer", "Sr");
SUCCESS_IF_DECLNAME_IS("String", "SS");
SUCCESS_IF_DECLNAME_IS("UInt", "Su");
 }
break;
case Node::Kind::Enum:
if (isInSwiftModule(node)) {
SUCCESS_IF_DECLNAME_IS("Optional", "Sq");
SUCCESS_IF_DECLNAME_IS("ImplicitlyUnwrappedOptional", "SQ");
 }
break;

default:
break;

#undef SUCCESS_IF_DECLNAME_IS
#undef SUCCESS_IF_TEXT_IS
#undef SUCCESS_IF_IS
 }
returnfalse;
}

ManglingError Remangler::mangleIdentifier(Node *node, unsigned depth) {
returnmangleIdentifier(node->getText(), OperatorKind::NotOperator);
}
ManglingError Remangler::manglePrefixOperator(Node *node, unsigned depth) {
returnmangleIdentifier(node->getText(), OperatorKind::Prefix);
}
ManglingError Remangler::manglePostfixOperator(Node *node, unsigned depth) {
returnmangleIdentifier(node->getText(), OperatorKind::Postfix);
}
ManglingError Remangler::mangleInfixOperator(Node *node, unsigned depth) {
returnmangleIdentifier(node->getText(), OperatorKind::Infix);
}
ManglingError Remangler::mangleIdentifier(StringRef ident,
 OperatorKind operatorKind) {
// Mangle normal identifiers as
// count identifier-char+
// where the count is the number of characters in the identifier,
// and where individual identifier characters represent themselves.

// Mangle operator identifiers as
// operator ::= 'o' operator-fixity count operator-char+
// operator-fixity ::= 'p' // prefix
// operator-fixity ::= 'P' // postfix
// operator-fixity ::= 'i' // infix
// where the count is the number of characters in the operator,
// and where the individual operator characters are translated.
switch (operatorKind) {
case OperatorKind::NotOperator:
 Buffer << ident.size() << ident;
return ManglingError::Success;
case OperatorKind::Infix:
 Buffer << "oi";
break;
case OperatorKind::Prefix:
 Buffer << "op";
break;
case OperatorKind::Postfix:
 Buffer << "oP";
break;
 }

// Mangle ASCII operators directly.
 Buffer << ident.size();
for (char ch : ident) {
 Buffer << Mangle::translateOperatorChar(ch);
 }
return ManglingError::Success;
}

ManglingError Remangler::mangleNumber(Node *node, unsigned depth) {
mangleIndex(node->getIndex());
return ManglingError::Success;
}

voidRemangler::mangleIndex(Node::IndexType value) {
if (value == 0) {
 Buffer << '_';
 } else {
 Buffer << (value - 1) << '_';
 }
}

ManglingError Remangler::mangleGlobal(Node *node, unsigned depth) {
 Buffer << "_T";
returnmangleChildNodes(node, depth + 1);
}

ManglingError Remangler::mangleSuffix(Node *node, unsigned depth) {
// Just add the suffix back on.
 Buffer << node->getText();
return ManglingError::Success;
}

ManglingError Remangler::mangleGenericSpecialization(Node *node,
unsigned depth) {
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError
Remangler::mangleGenericSpecializationPrespecialized(Node *node,
unsigned depth) {
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}
ManglingError
Remangler::mangleGenericSpecializationNotReAbstracted(Node *node,
unsigned depth) {
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}
ManglingError
Remangler::mangleGenericSpecializationInResilienceDomain(Node *node,
unsigned depth) {
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError Remangler::mangleInlinedGenericFunction(Node *node,
unsigned depth) {
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError Remangler::mangleGenericPartialSpecialization(Node *node,
unsigned depth) {
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError
Remangler::mangleGenericPartialSpecializationNotReAbstracted(Node *node,
unsigned depth) {
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError Remangler::mangleGenericSpecializationParam(Node *node,
unsigned depth) {
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError Remangler::mangleFunctionSignatureSpecialization(Node *node,
unsigned depth) {
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError Remangler::mangleSpecializationPassID(Node *node,
unsigned depth) {
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError Remangler::mangleIsSerialized(Node *node, unsigned depth) {
 Buffer << "q";
return ManglingError::Success;
}

ManglingError Remangler::mangleAsyncRemoved(Node *node, unsigned depth) {
 Buffer << "a";
return ManglingError::Success;
}

ManglingError Remangler::mangleDroppedArgument(Node *node, unsigned depth) {
 Buffer << "t" << node->getIndex();
return ManglingError::Success;
}

ManglingError
Remangler::mangleFunctionSignatureSpecializationReturn(Node *node,
unsigned depth) {
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError
Remangler::mangleFunctionSignatureSpecializationParam(Node *node,
unsigned depth) {
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError
Remangler::mangleFunctionSignatureSpecializationParamPayload(Node *node,
unsigned depth) {
// This should never be called since mangling parameter payloads require
// knowing what the parameter kind is.
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError
Remangler::mangleFunctionSignatureSpecializationParamKind(Node *node,
unsigned depth) {
// This should never be called since mangling parameter kinds have influence
// on the payloads.
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError Remangler::mangleRetroactiveConformance(Node *node,
unsigned depth) {
// Retroactive conformances aren't in the old mangling
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError
Remangler::mangleProtocolConformanceRefInTypeModule(Node *node,
unsigned depth) {
// Protocol conformance references aren't in the old mangling
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError
Remangler::mangleProtocolConformanceRefInProtocolModule(Node *node,
unsigned depth) {
// Protocol conformance references aren't in the old mangling
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError
Remangler::mangleProtocolConformanceRefInOtherModule(Node *node,
unsigned depth) {
// Protocol conformance references aren't in the old mangling
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError Remangler::mangleConcreteProtocolConformance(Node *node,
unsigned depth) {
// Concrete conformances aren't in the old mangling
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError Remangler::manglePackProtocolConformance(Node *node,
unsigned depth) {
// Pack conformances aren't in the old mangling
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError Remangler::mangleAnyProtocolConformanceList(Node *node,
unsigned depth) {
// Conformance lists aren't in the old mangling
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError Remangler::mangleDependentAssociatedConformance(Node *node,
unsigned depth) {
// Dependent associated conformances aren't in the old mangling
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError
Remangler::mangleDependentProtocolConformanceRoot(Node *node, unsigned depth) {
// Dependent conformances aren't in the old mangling
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError
Remangler::mangleDependentProtocolConformanceInherited(Node *node,
unsigned depth) {
// Dependent conformances aren't in the old mangling
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError
Remangler::mangleDependentProtocolConformanceAssociated(Node *node,
unsigned depth) {
// Dependent conformances aren't in the old mangling
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError
Remangler::mangleDependentProtocolConformanceOpaque(Node *node,
unsigned depth) {
// Dependent conformances aren't in the old mangling
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError Remangler::mangleProtocolConformance(Node *node, unsigned depth) {
// type, protocol name, context
DEMANGLER_ASSERT(node->getNumChildren() == 3, node);
RETURN_IF_ERROR(mangleChildNode(node, 0, depth + 1));
RETURN_IF_ERROR(mangleProtocolWithoutPrefix(node->begin()[1], depth + 1));
returnmangleChildNode(node, 2, depth + 1);
}

ManglingError Remangler::mangleObjCAttribute(Node *node, unsigned depth) {
 Buffer << "To";
return ManglingError::Success;
}

ManglingError Remangler::mangleNonObjCAttribute(Node *node, unsigned depth) {
 Buffer << "TO";
return ManglingError::Success;
}

ManglingError Remangler::mangleDirectMethodReferenceAttribute(Node *node,
unsigned depth) {
 Buffer << "Td";
return ManglingError::Success;
}

ManglingError Remangler::mangleDynamicAttribute(Node *node, unsigned depth) {
 Buffer << "TD";
return ManglingError::Success;
}

ManglingError Remangler::mangleVTableAttribute(Node *node, unsigned depth) {
 Buffer << "TV";
return ManglingError::Success;
}

ManglingError Remangler::mangleGenericTypeMetadataPattern(Node *node,
unsigned depth) {
 Buffer << "MP";
returnmangleSingleChildNode(node, depth + 1); // type
}

ManglingError Remangler::mangleTypeMetadataAccessFunction(Node *node,
unsigned depth) {
 Buffer << "Ma";
returnmangleSingleChildNode(node, depth + 1); // type
}

ManglingError Remangler::mangleTypeMetadataInstantiationCache(Node *node,
unsigned depth) {
 Buffer << "MI";
returnmangleSingleChildNode(node, depth + 1); // type
}

ManglingError
Remangler::mangleTypeMetadataInstantiationFunction(Node *node, unsigned depth) {
 Buffer << "Mi";
returnmangleSingleChildNode(node, depth + 1); // type
}

ManglingError
Remangler::mangleTypeMetadataSingletonInitializationCache(Node *node,
unsigned depth) {
 Buffer << "Ml";
returnmangleSingleChildNode(node, depth + 1); // type
}

ManglingError Remangler::mangleTypeMetadataCompletionFunction(Node *node,
unsigned depth) {
 Buffer << "Mr";
returnmangleSingleChildNode(node, depth + 1); // type
}

ManglingError Remangler::mangleTypeMetadataDemanglingCache(Node *node,
unsigned depth) {
// not supported
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError Remangler::mangleTypeMetadataLazyCache(Node *node,
unsigned depth) {
 Buffer << "ML";
returnmangleSingleChildNode(node, depth + 1); // type
}

ManglingError Remangler::mangleMetaclass(Node *node, unsigned depth) {
 Buffer << "Mm";
returnmangleSingleChildNode(node, depth + 1); // type
}

ManglingError Remangler::mangleClassMetadataBaseOffset(Node *node,
unsigned depth) {
 Buffer << "Mo";
returnmangleSingleChildNode(node, depth + 1); // type
}

ManglingError Remangler::mangleNominalTypeDescriptor(Node *node,
unsigned depth) {
 Buffer << "Mn";
returnmangleSingleChildNode(node, depth + 1); // type
}

ManglingError Remangler::mangleNominalTypeDescriptorRecord(Node *node,
unsigned depth) {
 Buffer << "Hn";
returnmangleSingleChildNode(node, depth + 1); // type
}

ManglingError Remangler::manglePropertyDescriptor(Node *node, unsigned depth) {
// not supported
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError Remangler::mangleTypeMetadata(Node *node, unsigned depth) {
 Buffer << "M";
returnmangleSingleChildNode(node, depth + 1); // type
}

ManglingError Remangler::mangleFullTypeMetadata(Node *node, unsigned depth) {
 Buffer << "Mf";
returnmangleChildNodes(node, depth + 1); // type
}

ManglingError Remangler::mangleProtocolDescriptor(Node *node, unsigned depth) {
 Buffer << "Mp";
returnmangleProtocolWithoutPrefix(node->begin()[0], depth + 1);
}

ManglingError Remangler::mangleProtocolDescriptorRecord(Node *node,
unsigned depth) {
 Buffer << "Hr";
returnmangleProtocolWithoutPrefix(node->begin()[0], depth + 1);
}

ManglingError
Remangler::mangleProtocolRequirementsBaseDescriptor(Node *node,
unsigned depth) {
// ###TODO: Is this an error?
 Buffer << "<protocol-requirements-base-descriptor>";
return ManglingError::Success;
}

ManglingError Remangler::mangleProtocolWitnessTablePattern(Node *node,
unsigned depth) {
// todo
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError Remangler::mangleProtocolConformanceDescriptor(Node *node,
unsigned depth) {
 Buffer << "Mc";
returnmangleProtocolConformance(node->begin()[0], depth + 1);
}

ManglingError
Remangler::mangleProtocolConformanceDescriptorRecord(Node *node,
unsigned depth) {
 Buffer << "Hc";
returnmangleProtocolConformance(node->begin()[0], depth + 1);
}

ManglingError
Remangler::mangleProtocolSelfConformanceDescriptor(Node *node, unsigned depth) {
 Buffer << "MS";
returnmangleProtocol(node->begin()[0], depth + 1);
}

ManglingError Remangler::manglePartialApplyForwarder(Node *node,
unsigned depth) {
 Buffer << "PA";
if (node->getNumChildren() == 1) {
 Buffer << "__T";
RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1)); // global
 }
return ManglingError::Success;
}

ManglingError Remangler::manglePartialApplyObjCForwarder(Node *node,
unsigned depth) {
 Buffer << "PAo";
if (node->getNumChildren() == 1) {
 Buffer << "__T";
RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1)); // global
 }
return ManglingError::Success;
}

ManglingError Remangler::mangleMergedFunction(Node *node, unsigned depth) {
 Buffer << "Tm";
return ManglingError::Success;
}

ManglingError
Remangler::mangleDistributedThunk(Node *node, unsigned depth) {
 Buffer << "TE";
return ManglingError::Success;
}

ManglingError
Remangler::mangleDistributedAccessor(Node *node, unsigned depth) {
 Buffer << "TF";
return ManglingError::Success;
}

ManglingError
Remangler::mangleDynamicallyReplaceableFunctionImpl(Node *node,
unsigned depth) {
 Buffer << "TI";
return ManglingError::Success;
}

ManglingError
Remangler::mangleDynamicallyReplaceableFunctionKey(Node *node, unsigned depth) {
 Buffer << "Tx";
return ManglingError::Success;
}

ManglingError
Remangler::mangleDynamicallyReplaceableFunctionVar(Node *node, unsigned depth) {
 Buffer << "TX";
return ManglingError::Success;
}

ManglingError Remangler::mangleAsyncAwaitResumePartialFunction(Node *node,
unsigned depth) {
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}
ManglingError
Remangler::mangleAsyncSuspendResumePartialFunction(Node *node, unsigned depth) {
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError Remangler::mangleDirectness(Node *node, unsigned depth) {
switch (node->getIndex()) {
caseuint64_t(Directness::Direct):
 Buffer << 'd';
break;
caseuint64_t(Directness::Indirect):
 Buffer << 'i';
break;
default:
returnMANGLING_ERROR(ManglingError::BadDirectness, node);
 }
return ManglingError::Success;
}

ManglingError Remangler::mangleValueWitness(Node *node, unsigned depth) {
constchar *Code = nullptr;
switch (node->getFirstChild()->getIndex()) {
#defineVALUE_WITNESS(MANGLING, NAME) \
caseuint64_t(ValueWitnessKind::NAME): \
 Code = #MANGLING; \
break;
#include"swift/Demangling/ValueWitnessMangling.def"
default:
returnMANGLING_ERROR(ManglingError::BadValueWitnessKind, node);
 }
 Buffer << 'w' << Code;
returnmangleChildNode(node, 1, depth + 1); // type
}

ManglingError Remangler::mangleValueWitnessTable(Node *node, unsigned depth) {
 Buffer << "WV";
returnmangleSingleChildNode(node, depth + 1); // type
}

ManglingError Remangler::mangleConcurrentFunctionType(Node *node,
unsigned depth) {
 Buffer << "y";
return ManglingError::Success;
}

ManglingError Remangler::mangleAsyncAnnotation(Node *node, unsigned depth) {
 Buffer << "Z";
return ManglingError::Success;
}

ManglingError Remangler::mangleThrowsAnnotation(Node *node, unsigned depth) {
 Buffer << "z";
return ManglingError::Success;
}

ManglingError Remangler::mangleTypedThrowsAnnotation(Node *node, unsigned depth) {
 Buffer << "z";
return ManglingError::Success;
}

ManglingError Remangler::mangleDifferentiableFunctionType(Node *node,
unsigned depth) {
 Buffer << "D";
returnmangleChildNodes(node, depth + 1);
}

ManglingError Remangler::mangleGlobalActorFunctionType(Node *node,
unsigned depth) {
 Buffer << "Y" << (char)node->getIndex(); // differentiability kind
return ManglingError::Success;
}

ManglingError Remangler::mangleIsolatedAnyFunctionType(Node *node,
unsigned depth) {
 Buffer << "YA";
return ManglingError::Success;
}

ManglingError Remangler::mangleNonIsolatedCallerFunctionType(Node *node,
unsigned depth) {
 Buffer << "YC";
return ManglingError::Success;
}

ManglingError Remangler::mangleSendingResultFunctionType(Node *node,
unsigned depth) {
 Buffer << "YT";
return ManglingError::Success;
}

ManglingError Remangler::mangleFieldOffset(Node *node, unsigned depth) {
 Buffer << "Wv";
returnmangleChildNodes(node, depth + 1); // directness, entity
}

ManglingError Remangler::mangleEnumCase(Node *node, unsigned depth) {
 Buffer << "WC";
returnmangleSingleChildNode(node, depth + 1); // enum case
}

ManglingError
Remangler::mangleProtocolSelfConformanceWitnessTable(Node *node,
unsigned depth) {
 Buffer << "WS";
returnmangleSingleChildNode(node, depth + 1); // protocol
}

ManglingError Remangler::mangleProtocolWitnessTable(Node *node,
unsigned depth) {
 Buffer << "WP";
returnmangleSingleChildNode(node, depth + 1); // protocol conformance
}

ManglingError Remangler::mangleGenericProtocolWitnessTable(Node *node,
unsigned depth) {
 Buffer << "WG";
returnmangleSingleChildNode(node, depth + 1); // protocol conformance
}

ManglingError Remangler::mangleResilientProtocolWitnessTable(Node *node,
unsigned depth) {
// todo
returnMANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
}

ManglingError Remangler::mangleGenericProtocolWitnessTableInstantiationFunction(
 Node *node, unsigned depth) {
 Buffer << "WI";
returnmangleSingleChildNode(node, depth + 1); // protocol conformance
}

ManglingError Remangler::mangleProtocolWitnessTableAccessor(Node *node,
unsigned depth) {
 Buffer << "Wa";
returnmangleSingleChildNode(node, depth + 1); // protocol conformance
}

ManglingError
Remangler::mangleLazyProtocolWitnessTableAccessor(Node *node, unsigned depth) {
 Buffer << "Wl";
returnmangleChildNodes(node, depth + 1); // type, protocol conformance
}

ManglingError
Remangler::mangleLazyProtocolWitnessTableCacheVariable(Node *node,
unsigned depth) {
 Buffer << "WL";
returnmangleChildNodes(node, depth + 1); // type, protocol conformance
}

ManglingError Remangler::mangleAssociatedTypeDescriptor(Node *node,
unsigned depth) {
// ###TODO: Check this (and similar ones below). Should this be a failure?
 Buffer << "<associated-type-descriptor>";
return ManglingError::Success;
}

ManglingError Remangler::mangleAssociatedConformanceDescriptor(Node *node,
unsigned depth) {
 Buffer << "<associated-conformance-descriptor>";
return ManglingError::Success;
}

ManglingError
Remangler::mangleDefaultAssociatedConformanceAccessor(Node *node,
unsigned depth) {
 Buffer << "<default-associated-conformance-descriptor>";
return ManglingError::Success;
}

ManglingError Remangler::mangleBaseConformanceDescriptor(Node *node,
unsigned depth) {
 Buffer << "<base-conformance-descriptor>";
return ManglingError::Success;
}

ManglingError Remangler::mangleAssociatedTypeMetadataAccessor(Node *node,
unsigned depth) {
 Buffer << "Wt";
returnmangleChildNodes(node, depth + 1); // protocol conformance, identifier
}

ManglingError
Remangler::mangleDefaultAssociatedTypeMetadataAccessor(Node *node,
unsigned depth) {
 Buffer << "<default-associated-type-metadata-accessor>";
return ManglingError::Success;
}

ManglingError
Remangler::mangleAssociatedTypeWitnessTableAccessor(Node *node,
unsigned depth) {
 Buffer << "WT";
DEMANGLER_ASSERT(node->getNumChildren() == 3, node);
RETURN_IF_ERROR(mangleChildNode(node, 0, depth + 1)); // protocol conformance
RETURN_IF_ERROR(mangleChildNode(node, 1, depth + 1)); // type
returnmangleProtocolWithoutPrefix(node->begin()[2], depth + 1); // type
}

ManglingError Remangler::mangleBaseWitnessTableAccessor(Node *node,
unsigned depth) {
 Buffer << "<base-witness-table-accessor>";
return ManglingError::Success;
}

ManglingError Remangler::mangleReabstractionThunkHelper(Node *node,
unsigned depth) {
 Buffer << "<reabstraction-thunk-helper>";
return ManglingError::Success;
}