averello/swift-mirror
1
0
Fork 0
mirror of https://github.com/apple/swift.git synced 2025-12-14 20:36:38 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
maxd/docc-compiler-docs
swift-mirror/lib/AST/ASTMangler.cpp
Hamish Knight edca7c85ad Adopt ABORT throughout the compiler 
Convert a bunch of places where we're dumping to stderr and calling
`abort` over to using `ABORT` such that the message gets printed to
the pretty stack trace. This ensures it gets picked up by
CrashReporter.
2025-05-19 20:55:01 +01:00

5433 lines
186 KiB
C++
Raw Permalink Blame History

//===--- ASTMangler.cpp - Swift AST symbol mangling -----------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2020 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 declaration name mangling in Swift.
//
//===----------------------------------------------------------------------===//
#include "swift/AST/ASTMangler.h"
#include "swift/AST/ASTContext.h"
#include "swift/AST/ASTVisitor.h"
#include "swift/AST/AutoDiff.h"
#include "swift/AST/Decl.h"
#include "swift/AST/ExistentialLayout.h"
#include "swift/AST/Expr.h"
#include "swift/AST/FileUnit.h"
#include "swift/AST/GenericEnvironment.h"
#include "swift/AST/GenericSignature.h"
#include "swift/AST/Initializer.h"
#include "swift/AST/LazyResolver.h"
#include "swift/AST/LocalArchetypeRequirementCollector.h"
#include "swift/AST/MacroDiscriminatorContext.h"
#include "swift/AST/Module.h"
#include "swift/AST/Ownership.h"
#include "swift/AST/PackConformance.h"
#include "swift/AST/ParameterList.h"
#include "swift/AST/PrettyStackTrace.h"
#include "swift/AST/ProtocolConformance.h"
#include "swift/AST/ProtocolConformanceRef.h"
#include "swift/AST/SILLayout.h"
#include "swift/AST/TypeCheckRequests.h"
#include "swift/Basic/Assertions.h"
#include "swift/Basic/Defer.h"
#include "swift/Basic/SourceManager.h"
#include "swift/ClangImporter/ClangImporter.h"
#include "swift/ClangImporter/ClangModule.h"
#include "swift/Demangling/Demangler.h"
#include "swift/Demangling/ManglingMacros.h"
#include "swift/Demangling/ManglingUtils.h"
#include "swift/Strings.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/Attr.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/Mangle.h"
#include "clang/Basic/CharInfo.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/SaveAndRestore.h"
#include "llvm/Support/raw_ostream.h"
#include <memory>
using namespace swift;
using namespace swift::Mangle;
template<typename DeclType>
static DeclType *getABIDecl(DeclType *D) {
if (!D)
return nullptr;
auto abiRole = ABIRoleInfo(D);
if (!abiRole.providesABI())
return abiRole.getCounterpart();
return nullptr;
}
static std::optional<ASTMangler::SymbolicReferent>
getABIDecl(ASTMangler::SymbolicReferent ref) {
switch (ref.getKind()) {
case ASTMangler::SymbolicReferent::NominalType:
if (auto abiTypeDecl = getABIDecl(ref.getNominalType())) {
return ASTMangler::SymbolicReferent(abiTypeDecl);
}
break;
case ASTMangler::SymbolicReferent::OpaqueType:
if (auto abiTypeDecl = getABIDecl(ref.getOpaqueType())) {
return ASTMangler::SymbolicReferent(abiTypeDecl);
}
break;
case ASTMangler::SymbolicReferent::ExtendedExistentialTypeShape:
// Do nothing; mangling will use the underlying ABI decls in the end.
break;
}
return std::nullopt;
}
void ASTMangler::addSubstitution(const Decl *decl) {
if (auto abiDecl = getABIDecl(decl)) {
return addSubstitution(abiDecl);
}
return Mangler::addSubstitution(decl);
}
bool ASTMangler::tryMangleSubstitution(const Decl *decl) {
if (auto abiDecl = getABIDecl(decl)) {
return tryMangleSubstitution(abiDecl);
}
return Mangler::tryMangleSubstitution(decl);
}
bool ASTMangler::inversesAllowed(const Decl *decl) {
if (!decl)
return true;
if (auto accessor = dyn_cast<AccessorDecl>(decl))
if (auto *storage = accessor->getStorage())
decl = storage;
return !decl->getAttrs().hasAttribute<PreInverseGenericsAttr>();
}
bool ASTMangler::inversesAllowedIn(const DeclContext *ctx) {
assert(ctx);
return inversesAllowed(ctx->getInnermostDeclarationDeclContext());
}
static StringRef getCodeForAccessorKind(AccessorKind kind) {
switch (kind) {
case AccessorKind::Get:
return "g";
case AccessorKind::DistributedGet:
// TODO(distributed): probably does not matter since we mangle distributed
// thunk getters as the name of the Storage?
return "g";
case AccessorKind::Set:
return "s";
case AccessorKind::WillSet:
return "w";
case AccessorKind::DidSet:
return "W";
case AccessorKind::Read:
return "r";
case AccessorKind::Modify:
return "M";
case AccessorKind::Address:
// 'l' is for location. 'A' was taken.
return "lu";
case AccessorKind::MutableAddress:
return "au";
case AccessorKind::Init:
return "i";
case AccessorKind::Modify2:
return "x";
case AccessorKind::Read2:
return "y";
}
llvm_unreachable("bad accessor kind");
}
std::string ASTMangler::mangleClosureEntity(const AbstractClosureExpr *closure,
SymbolKind SKind) {
llvm::SaveAndRestore X(AllowInverses, inversesAllowedIn(closure));
beginMangling();
appendClosureEntity(closure);
appendSymbolKind(SKind);
return finalize();
}
std::string ASTMangler::mangleEntity(const ValueDecl *decl, SymbolKind SKind) {
llvm::SaveAndRestore X(AllowInverses, inversesAllowed(decl));
beginMangling();
appendEntity(decl);
appendSymbolKind(SKind);
return finalize();
}
std::string ASTMangler::mangleDestructorEntity(const DestructorDecl *decl,
DestructorKind kind,
SymbolKind SKind) {
llvm::SaveAndRestore X(AllowInverses, inversesAllowed(decl));
beginMangling();
appendDestructorEntity(decl, kind);
appendSymbolKind(SKind);
return finalize();
}
std::string ASTMangler::mangleConstructorEntity(const ConstructorDecl *ctor,
bool isAllocating,
SymbolKind SKind) {
llvm::SaveAndRestore X(AllowInverses, inversesAllowed(ctor));
beginMangling();
appendConstructorEntity(ctor, isAllocating);
appendSymbolKind(SKind);
return finalize();
}
std::string ASTMangler::mangleIVarInitDestroyEntity(const ClassDecl *decl,
bool isDestroyer,
SymbolKind SKind) {
llvm::SaveAndRestore X(AllowInverses, inversesAllowed(decl));
beginMangling();
BaseEntitySignature base(decl);
appendContext(decl, base, decl->getAlternateModuleName());
appendOperator(isDestroyer ? "fE" : "fe");
appendSymbolKind(SKind);
return finalize();
}
std::string ASTMangler::mangleAccessorEntity(AccessorKind kind,
const AbstractStorageDecl *decl,
bool isStatic,
SymbolKind SKind) {
llvm::SaveAndRestore X(AllowInverses, inversesAllowed(decl));
beginMangling();
appendAccessorEntity(getCodeForAccessorKind(kind), decl, isStatic);
appendSymbolKind(SKind);
return finalize();
}
std::string ASTMangler::mangleDefaultArgumentEntity(const DeclContext *func,
unsigned index,
SymbolKind SKind) {
llvm::SaveAndRestore X(AllowInverses, inversesAllowedIn(func));
beginMangling();
appendDefaultArgumentEntity(func, index);
appendSymbolKind(SKind);
return finalize();
}
std::string ASTMangler::mangleInitializerEntity(const VarDecl *var,
SymbolKind SKind) {
llvm::SaveAndRestore X(AllowInverses, inversesAllowed(var));
beginMangling();
appendInitializerEntity(var);
appendSymbolKind(SKind);
return finalize();
}
std::string ASTMangler::mangleBackingInitializerEntity(const VarDecl *var,
SymbolKind SKind) {
llvm::SaveAndRestore X(AllowInverses, inversesAllowed(var));
beginMangling();
appendBackingInitializerEntity(var);
appendSymbolKind(SKind);
return finalize();
}
std::string ASTMangler::mangleInitFromProjectedValueEntity(const VarDecl *var,
SymbolKind SKind) {
llvm::SaveAndRestore X(AllowInverses, inversesAllowed(var));
beginMangling();
appendInitFromProjectedValueEntity(var);
appendSymbolKind(SKind);
return finalize();
}
std::string ASTMangler::mangleNominalType(const NominalTypeDecl *decl) {
beginMangling();
appendAnyGenericType(decl);
return finalize();
}
std::string ASTMangler::mangleVTableThunk(const FuncDecl *Base,
const FuncDecl *Derived) {
beginMangling();
appendEntity(Derived);
appendEntity(Base);
appendOperator("TV");
return finalize();
}
std::string ASTMangler::mangleConstructorVTableThunk(
const ConstructorDecl *Base,
const ConstructorDecl *Derived,
bool isAllocating) {
beginMangling();
appendConstructorEntity(Derived, isAllocating);
appendConstructorEntity(Base, isAllocating);
appendOperator("TV");
return finalize();
}
std::string ASTMangler::mangleWitnessTable(const ProtocolConformance *C) {
llvm::SaveAndRestore X(AllowInverses,
inversesAllowedIn(C->getDeclContext()));
beginMangling();
if (auto *sc = dyn_cast<SpecializedProtocolConformance>(C)) {
appendProtocolConformance(sc);
appendOperator("WP");
} else if (isa<NormalProtocolConformance>(C) || isa<InheritedProtocolConformance>(C)) {
appendProtocolConformance(C);
appendOperator("WP");
} else if (isa<SelfProtocolConformance>(C)) {
appendProtocolName(cast<SelfProtocolConformance>(C)->getProtocol());
appendOperator("WS");
} else {
llvm_unreachable("mangling unknown conformance kind");
}
return finalize();
}
std::string ASTMangler::mangleWitnessThunk(
const ProtocolConformance *Conformance,
const ValueDecl *Requirement) {
beginMangling();
// Concrete witness thunks get a special mangling.
if (Conformance) {
if (!isa<SelfProtocolConformance>(Conformance)) {
appendProtocolConformance(Conformance);
}
}
if (auto ctor = dyn_cast<ConstructorDecl>(Requirement)) {
appendConstructorEntity(ctor, /*isAllocating=*/true);
} else {
assert(isa<FuncDecl>(Requirement) && "expected function");
appendEntity(cast<FuncDecl>(Requirement));
}
if (Conformance) {
if (isa<SelfProtocolConformance>(Conformance)) {
appendOperator("TS");
} else {
appendOperator("TW");
}
}
return finalize();
}
std::string ASTMangler::mangleClosureWitnessThunk(
const ProtocolConformance *Conformance,
const AbstractClosureExpr *Closure) {
beginMangling();
appendProtocolConformance(Conformance);
appendClosureEntity(Closure);
appendOperator("TW");
return finalize();
}
std::string ASTMangler::mangleGlobalVariableFull(const VarDecl *decl) {
if (auto abiDecl = getABIDecl(decl)) {
return mangleGlobalVariableFull(abiDecl);
}
// Clang globals get mangled using Clang's mangler.
if (auto clangDecl =
dyn_cast_or_null<clang::DeclaratorDecl>(decl->getClangDecl())) {
if (auto asmLabel = clangDecl->getAttr<clang::AsmLabelAttr>()) {
Buffer << '\01' << asmLabel->getLabel();
} else {
if (clangDecl->getDeclContext()->isTranslationUnit()) {
Buffer << clangDecl->getName();
} else {
std::unique_ptr<clang::MangleContext> mangler(
decl->getClangDecl()->getASTContext().createMangleContext());
mangler->mangleName(clangDecl, Buffer);
}
}
return finalize();
}
beginMangling();
appendEntity(decl);
return finalize();
}
std::string ASTMangler::mangleKeyPathGetterThunkHelper(
const AbstractStorageDecl *property, GenericSignature signature,
CanType baseType, SubstitutionMap subs, ResilienceExpansion expansion) {
beginMangling();
appendEntity(property);
if (signature)
appendGenericSignature(signature);
appendType(baseType, signature);
if (isa<SubscriptDecl>(property)) {
// Subscripts can be generic, and different key paths could
// capture the same subscript at different generic arguments.
for (auto sub : subs.getReplacementTypes()) {
sub = sub->mapTypeOutOfContext();
// FIXME: This seems wrong. We used to just mangle opened archetypes as
// their interface type. Let's make that explicit now.
sub = sub.transformRec([](Type t) -> std::optional<Type> {
if (auto *openedExistential = t->getAs<ExistentialArchetypeType>()) {
auto &ctx = openedExistential->getASTContext();
return ctx.TheSelfType;
}
return std::nullopt;
});
appendType(sub->getCanonicalType(), signature);
}
}
appendOperator("TK");
if (expansion == ResilienceExpansion::Minimal)
appendOperator("q");
return finalize();
}
std::string ASTMangler::mangleKeyPathSetterThunkHelper(
const AbstractStorageDecl *property,
GenericSignature signature,
CanType baseType,
SubstitutionMap subs,
ResilienceExpansion expansion) {
beginMangling();
appendEntity(property);
if (signature)
appendGenericSignature(signature);
appendType(baseType, signature);
if (isa<SubscriptDecl>(property)) {
// Subscripts can be generic, and different key paths could capture the same
// subscript at different generic arguments.
for (auto sub : subs.getReplacementTypes()) {
sub = sub->mapTypeOutOfContext();
// FIXME: This seems wrong. We used to just mangle opened archetypes as
// their interface type. Let's make that explicit now.
sub = sub.transformRec([](Type t) -> std::optional<Type> {
if (auto *openedExistential = t->getAs<ExistentialArchetypeType>()) {
auto &ctx = openedExistential->getASTContext();
return ctx.TheSelfType;
}
return std::nullopt;
});
appendType(sub->getCanonicalType(), signature);
}
}
appendOperator("Tk");
if (expansion == ResilienceExpansion::Minimal)
appendOperator("q");
return finalize();
}
std::string ASTMangler::mangleKeyPathAppliedMethodThunkHelper(
const AbstractFunctionDecl *method, GenericSignature signature,
CanType baseType, SubstitutionMap subs, ResilienceExpansion expansion) {
beginMangling();
isa<ConstructorDecl>(method)
? appendConstructorEntity(cast<ConstructorDecl>(method), false)
: appendEntity(method);
if (signature)
appendGenericSignature(signature);
appendType(baseType, signature);
if (isa<FuncDecl>(method) || isa<ConstructorDecl>(method)) {
// Methods can be generic, and different key paths could capture the same
// method at different generic arguments.
for (auto sub : subs.getReplacementTypes()) {
sub = sub->mapTypeOutOfContext();
// FIXME: This seems wrong. We used to just mangle opened archetypes as
// their interface type. Let's make that explicit now.
sub = sub.transformRec([](Type t) -> std::optional<Type> {
if (auto *openedExistential = t->getAs<ExistentialArchetypeType>())
return openedExistential->getInterfaceType();
return std::nullopt;
});
appendType(sub->getCanonicalType(), signature);
}
}
appendOperator("TkMA");
if (expansion == ResilienceExpansion::Minimal)
appendOperator("q");
return finalize();
}
std::string ASTMangler::mangleKeyPathUnappliedMethodThunkHelper(
const AbstractFunctionDecl *method, GenericSignature signature,
CanType baseType, SubstitutionMap subs, ResilienceExpansion expansion) {
beginMangling();
isa<ConstructorDecl>(method)
? appendConstructorEntity(cast<ConstructorDecl>(method), false)
: appendEntity(method);
if (signature)
appendGenericSignature(signature);
appendType(baseType, signature);
if (isa<FuncDecl>(method) || isa<ConstructorDecl>(method)) {
// Methods can be generic, and different key paths could capture the same
// method at different generic arguments.
for (auto sub : subs.getReplacementTypes()) {
sub = sub->mapTypeOutOfContext();
// FIXME: This seems wrong. We used to just mangle opened archetypes as
// their interface type. Let's make that explicit now.
sub = sub.transformRec([](Type t) -> std::optional<Type> {
if (auto *openedExistential = t->getAs<ExistentialArchetypeType>())
return openedExistential->getInterfaceType();
return std::nullopt;
});
appendType(sub->getCanonicalType(), signature);
}
}
appendOperator("Tkmu");
if (expansion == ResilienceExpansion::Minimal)
appendOperator("q");
return finalize();
}
std::string ASTMangler::mangleKeyPathEqualsHelper(ArrayRef<CanType> indices,
GenericSignature signature,
ResilienceExpansion expansion) {
beginMangling();
for (auto &index : indices)
appendType(index, nullptr);
if (signature)
appendGenericSignature(signature);
appendOperator("TH");
if (expansion == ResilienceExpansion::Minimal)
appendOperator("q");
return finalize();
}
std::string ASTMangler::mangleKeyPathHashHelper(ArrayRef<CanType> indices,
GenericSignature signature,
ResilienceExpansion expansion) {
beginMangling();
for (auto &index : indices)
appendType(index, nullptr);
if (signature)
appendGenericSignature(signature);
appendOperator("Th");
if (expansion == ResilienceExpansion::Minimal)
appendOperator("q");
return finalize();
}
std::string ASTMangler::mangleGlobalInit(const PatternBindingDecl *pd,
unsigned pbdEntry,
bool isInitFunc) {
beginMangling();
Pattern *pattern = pd->getPattern(pbdEntry);
bool first = true;
pattern->forEachVariable([&](VarDecl *D) {
if (auto abiD = getABIDecl(D)) {
D = abiD;
}
if (first) {
BaseEntitySignature base(D);
appendContextOf(D, base);
first = false;
}
appendDeclName(D);
appendListSeparator();
});
assert(!first && "no variables in pattern binding?!");
if (isInitFunc) {
appendOperator("WZ");
} else {
appendOperator("Wz");
}
return finalize();
}
std::string ASTMangler::mangleReabstractionThunkHelper(
CanSILFunctionType ThunkType,
Type FromType,
Type ToType,
Type SelfType,
Type GlobalActorBound,
ModuleDecl *Module) {
Mod = Module;
assert(ThunkType->getPatternSubstitutions().empty() && "not implemented");
GenericSignature GenSig = ThunkType->getInvocationGenericSignature();
beginMangling();
appendType(FromType, GenSig);
appendType(ToType, GenSig);
if (SelfType)
appendType(SelfType, GenSig);
if (GenSig)
appendGenericSignature(GenSig);
if (SelfType)
appendOperator("Ty");
else
appendOperator("TR");
if (GlobalActorBound) {
appendType(GlobalActorBound, GenSig);
appendOperator("TU");
}
return finalize();
}
std::string ASTMangler::mangleObjCAsyncCompletionHandlerImpl(
CanSILFunctionType BlockType, CanType ResultType, CanGenericSignature Sig,
std::optional<bool> ErrorOnZero, bool predefined) {
beginMangling();
appendType(BlockType, Sig);
appendType(ResultType, Sig);
if (Sig)
appendGenericSignature(Sig);
if (ErrorOnZero)
appendOperator(predefined ? "TZ" : "Tz", Index(*ErrorOnZero + 1));
else
appendOperator(predefined ? "TZ" : "Tz", Index(0));
return finalize();
}
std::string ASTMangler::mangleAutoDiffDerivativeFunction(
const AbstractFunctionDecl *originalAFD,
AutoDiffDerivativeFunctionKind kind,
const AutoDiffConfig &config,
bool isVTableThunk) {
beginManglingWithAutoDiffOriginalFunction(originalAFD);
appendAutoDiffFunctionParts(
isVTableThunk ? "TJV" : "TJ", getAutoDiffFunctionKind(kind), config);
return finalize();
}
std::string ASTMangler::mangleAutoDiffLinearMap(
const AbstractFunctionDecl *originalAFD, AutoDiffLinearMapKind kind,
const AutoDiffConfig &config) {
beginManglingWithAutoDiffOriginalFunction(originalAFD);
appendAutoDiffFunctionParts("TJ", getAutoDiffFunctionKind(kind), config);
return finalize();
}
void ASTMangler::beginManglingWithAutoDiffOriginalFunction(
const AbstractFunctionDecl *afd) {
if (auto abiAFD = getABIDecl(afd)) {
return beginManglingWithAutoDiffOriginalFunction(abiAFD);
}
if (auto *attr = afd->getAttrs().getAttribute<SILGenNameAttr>()) {
beginManglingWithoutPrefix();
appendOperator(attr->Name);
return;
}
auto beginManglingClangDecl = [&](const clang::NamedDecl *decl) {
beginManglingWithoutPrefix();
appendOperator(decl->getName());
};
// For imported Clang declarations, use the Clang name in order to match how
// DifferentiationMangler handles these.
if (auto clangDecl = getClangDeclForMangling(afd)) {
beginManglingClangDecl(clangDecl);
return;
} else if (auto typedefType = getTypeDefForCXXCFOptionsDefinition(afd)) {
beginManglingClangDecl(typedefType->getDecl());
return;
}
beginMangling();
if (auto *cd = dyn_cast<ConstructorDecl>(afd))
appendConstructorEntity(cd, /*isAllocating*/ !cd->isConvenienceInit());
else
appendEntity(afd);
}
void ASTMangler::appendAutoDiffFunctionParts(StringRef op,
AutoDiffFunctionKind kind,
const AutoDiffConfig &config) {
if (auto sig = config.derivativeGenericSignature)
appendGenericSignature(sig);
auto kindCode = (char)kind;
appendOperator(op, StringRef(&kindCode, 1));
appendIndexSubset(config.parameterIndices);
appendOperator("p");
appendIndexSubset(config.resultIndices);
appendOperator("r");
}
std::string ASTMangler::mangleAutoDiffSelfReorderingReabstractionThunk(
CanType fromType, CanType toType, GenericSignature signature,
AutoDiffLinearMapKind linearMapKind) {
beginMangling();
appendType(fromType, signature);
appendType(toType, signature);
if (signature)
appendGenericSignature(signature);
auto kindCode = (char)getAutoDiffFunctionKind(linearMapKind);
appendOperator("TJO", StringRef(&kindCode, 1));
return finalize();
}
/// Mangle the index subset.
void ASTMangler::appendIndexSubset(IndexSubset *indices) {
Buffer << indices->getString();
}
static NodePointer mangleSILDifferentiabilityWitnessAsNode(
StringRef originalName, DifferentiabilityKind kind,
const AutoDiffConfig &config, Demangler &demangler, ASTMangler *mangler) {
auto *diffWitnessNode = demangler.createNode(
Node::Kind::DifferentiabilityWitness);
auto origNode = demangler.demangleSymbol(originalName);
assert(origNode->getKind() == Node::Kind::Global);
for (auto *child : *origNode)
diffWitnessNode->addChild(child, demangler);
diffWitnessNode->addChild(
demangler.createNode(
Node::Kind::Index,
(Node::IndexType)getMangledDifferentiabilityKind(kind)),
demangler);
diffWitnessNode->addChild(
demangler.createNode(
Node::Kind::IndexSubset, config.parameterIndices->getString()),
demangler);
diffWitnessNode->addChild(
demangler.createNode(
Node::Kind::IndexSubset, config.resultIndices->getString()),
demangler);
if (auto genSig = config.derivativeGenericSignature) {
ASTMangler genSigMangler(mangler->getASTContext());
auto genSigSymbol = genSigMangler.mangleGenericSignature(genSig);
auto demangledGenSig = demangler.demangleSymbol(genSigSymbol);
assert(demangledGenSig);
for (auto *child : *demangledGenSig)
diffWitnessNode->addChild(child, demangler);
}
return diffWitnessNode;
}
std::string ASTMangler::mangleSILDifferentiabilityWitness(StringRef originalName,
DifferentiabilityKind kind,
const AutoDiffConfig &config) {
// If the original name was a mangled name, differentiability witnesses must
// be mangled as node because they contain generic signatures which may repeat
// entities in the original function name. Mangling as node will make sure the
// substitutions are mangled correctly.
if (isMangledName(originalName)) {
Demangler demangler;
auto *node = mangleSILDifferentiabilityWitnessAsNode(
originalName, kind, config, demangler, this);
auto mangling = mangleNode(node, Flavor);
if (!mangling.isSuccess()) {
llvm_unreachable("unexpected mangling failure");
}
return mangling.result();
}
beginManglingWithoutPrefix();
appendOperator(originalName);
if (auto genSig = config.derivativeGenericSignature)
appendGenericSignature(genSig);
auto diffKindCode = (char)getMangledDifferentiabilityKind(kind);
appendOperator("WJ", StringRef(&diffKindCode, 1));
appendIndexSubset(config.parameterIndices);
appendOperator("p");
appendIndexSubset(config.resultIndices);
appendOperator("r");
return finalize();
}
std::string ASTMangler::mangleSILThunkKind(StringRef originalName,
SILThunkKind thunkKind) {
beginManglingWithoutPrefix();
appendOperator(originalName);
// Prefix for thunk inst based thunks
auto code = (char)thunkKind.getMangledKind();
appendOperator("TT", StringRef(&code, 1));
return finalize();
}
std::string ASTMangler::mangleAutoDiffGeneratedDeclaration(
AutoDiffGeneratedDeclarationKind declKind, StringRef origFnName,
unsigned bbId, AutoDiffLinearMapKind linearMapKind,
const AutoDiffConfig &config) {
beginManglingWithoutPrefix();
Buffer << "_AD__" << origFnName << "_bb" + std::to_string(bbId);
switch (declKind) {
case AutoDiffGeneratedDeclarationKind::LinearMapStruct:
switch (linearMapKind) {
case AutoDiffLinearMapKind::Differential:
Buffer << "__DF__";
break;
case AutoDiffLinearMapKind::Pullback:
Buffer << "__PB__";
break;
}
break;
case AutoDiffGeneratedDeclarationKind::BranchingTraceEnum:
switch (linearMapKind) {
case AutoDiffLinearMapKind::Differential:
Buffer << "__Succ__";
break;
case AutoDiffLinearMapKind::Pullback:
Buffer << "__Pred__";
break;
}
break;
}
Buffer << config.mangle();
if (config.derivativeGenericSignature) {
Buffer << '_';
appendGenericSignature(config.derivativeGenericSignature);
}
auto result = Storage.str().str();
Storage.clear();
return result;
}
// In order for the remangler to work correctly, it must agree with
// AST mangler on the substitution scheme. The AST mangler will use a
// substitution if a mangled type is identical to a previous type.
//
// In the DWARF mangling, we don't canonicalize types. Therefore, any
// two types that differ by sugar must have distinct manglings. If this
// invariant is not maintained, then demangling and remangling a type
// will no longer be idempotent.
//
// Since we don't have a distinct mangling for sugared generic
// parameter types, we must desugar them here.
static Type getTypeForDWARFMangling(Type t) {
return t.transformRec(
[](TypeBase *t) -> std::optional<Type> {
if (isa<GenericTypeParamType>(t))
return t->getCanonicalType();
return std::nullopt;
});
}
std::string ASTMangler::mangleTypeForDebugger(Type Ty, GenericSignature sig) {
PrettyStackTraceType prettyStackTrace(Context, "mangling type for debugger",
Ty);
DWARFMangling = true;
RespectOriginallyDefinedIn = true;
OptimizeProtocolNames = false;
beginMangling();
Ty = getTypeForDWARFMangling(Ty);
appendType(Ty, sig);
appendOperator("D");
return finalize();
}
std::string ASTMangler::mangleTypeForTypeName(Type type) {
beginManglingWithoutPrefix();
appendType(type, nullptr);
return finalize();
}
std::string ASTMangler::mangleDeclType(const ValueDecl *decl) {
DWARFMangling = true;
RespectOriginallyDefinedIn = false;
BaseEntitySignature base(decl);
beginMangling();
appendDeclType(decl, base);
appendOperator("D");
return finalize();
}
#ifdef USE_NEW_MANGLING_FOR_OBJC_RUNTIME_NAMES
static bool isPrivate(const NominalTypeDecl *Nominal) {
return Nominal->getFormalAccess() <= AccessLevel::FilePrivate;
}
#endif
std::string ASTMangler::mangleObjCRuntimeName(const NominalTypeDecl *Nominal) {
#ifdef USE_NEW_MANGLING_FOR_OBJC_RUNTIME_NAMES
// Using the new mangling for ObjC runtime names (except for top-level
// classes). This is currently disabled to support old archives.
// TODO: re-enable this as we switch to the new mangling for ObjC names.
DeclContext *Ctx = Nominal->getDeclContext();
if (Ctx->isModuleScopeContext() && !isPrivate(Nominal)) {
// Use the old mangling for non-private top-level classes and protocols.
// This is what the ObjC runtime needs to demangle.
// TODO: Use new mangling scheme as soon as the ObjC runtime
// can demangle it.
//
// Don't use word-substitutions and punycode encoding.
MaxNumWords = 0;
UsePunycode = false;
UseSubstitutions = false;
Buffer << "_Tt";
bool isProto = false;
if (isa<ClassDecl>(Nominal)) {
Buffer << 'C';
} else {
isProto = true;
assert(isa<ProtocolDecl>(Nominal));
Buffer << 'P';
}
appendModule(Ctx->getParentModule(), StringRef());
appendIdentifier(Nominal->getName().str());
if (isProto)
Buffer << '_';
return finalize();
}
// For all other cases, we can use the new mangling.
beginMangling();
appendAnyGenericType(Nominal);
return finalize();
#else
// Use the old mangling for ObjC runtime names.
beginMangling();
appendAnyGenericType(Nominal);
std::string NewName = finalize();
Demangle::Demangler Dem;
Demangle::Node *Root = Dem.demangleSymbol(NewName);
assert(Root->getKind() == Node::Kind::Global);
Node *NomTy = Root->getFirstChild();
if (NomTy->getKind() == Node::Kind::Protocol) {
// Protocol types are mangled as protocol lists.
Node *PTy = Dem.createNode(Node::Kind::Type);
PTy->addChild(NomTy, Dem);
Node *TList = Dem.createNode(Node::Kind::TypeList);
TList->addChild(PTy, Dem);
NomTy = Dem.createNode(Node::Kind::ProtocolList);
NomTy->addChild(TList, Dem);
}
// Add a TypeMangling node at the top
Node *Ty = Dem.createNode(Node::Kind::Type);
Ty->addChild(NomTy, Dem);
Node *TyMangling = Dem.createNode(Node::Kind::TypeMangling);
TyMangling->addChild(Ty, Dem);
Node *NewGlobal = Dem.createNode(Node::Kind::Global);
NewGlobal->addChild(TyMangling, Dem);
auto mangling = mangleNodeOld(NewGlobal);
if (!mangling.isSuccess()) {
llvm_unreachable("unexpected mangling failure");
}
return mangling.result();
#endif
}
std::string ASTMangler::mangleTypeAsContextUSR(const NominalTypeDecl *type) {
beginManglingWithoutPrefix();
llvm::SaveAndRestore<bool> allowUnnamedRAII(AllowNamelessEntities, true);
BaseEntitySignature base(type);
appendContext(type, base, type->getAlternateModuleName());
return finalize();
}
std::string ASTMangler::mangleTypeAsUSR(Type Ty) {
DWARFMangling = true;
RespectOriginallyDefinedIn = false;
beginMangling();
Ty = getTypeForDWARFMangling(Ty);
if (auto *fnType = Ty->getAs<AnyFunctionType>()) {
appendFunction(fnType, nullptr);
} else {
appendType(Ty, nullptr);
}
appendOperator("D");
return finalize();
}
void ASTMangler::appendAnyDecl(const ValueDecl *Decl) {
if (auto Ctor = dyn_cast<ConstructorDecl>(Decl)) {
appendConstructorEntity(Ctor, /*isAllocating=*/false);
} else if (auto Dtor = dyn_cast<DestructorDecl>(Decl)) {
appendDestructorEntity(Dtor, DestructorKind::NonDeallocating);
} else if (auto GTD = dyn_cast<GenericTypeDecl>(Decl)) {
appendAnyGenericType(GTD);
} else if (isa<AssociatedTypeDecl>(Decl)) {
if (auto abiDecl = getABIDecl(Decl)) {
return appendAnyDecl(abiDecl);
}
BaseEntitySignature base(Decl);
appendContextOf(Decl, base);
appendDeclName(Decl);
appendOperator("Qa");
} else {
appendEntity(Decl);
}
}
std::string
ASTMangler::mangleAnyDecl(const ValueDecl *Decl,
bool prefix,
bool respectOriginallyDefinedIn) {
DWARFMangling = true;
RespectOriginallyDefinedIn = respectOriginallyDefinedIn;
if (prefix) {
beginMangling();
} else {
beginManglingWithoutPrefix();
}
llvm::SaveAndRestore<bool> allowUnnamedRAII(AllowNamelessEntities, true);
appendAnyDecl(Decl);
// We have a custom prefix, so finalize() won't verify for us. If we're not
// in invalid code (coming from an IDE caller) verify manually.
if (!Decl->isInvalid())
verify(Storage.str(), Flavor);
return finalize();
}
std::string ASTMangler::mangleDeclAsUSR(const ValueDecl *Decl,
StringRef USRPrefix) {
return (llvm::Twine(USRPrefix) + mangleAnyDecl(Decl, false)).str();
}
std::string ASTMangler::mangleAccessorEntityAsUSR(AccessorKind kind,
const AbstractStorageDecl *decl,
StringRef USRPrefix,
bool isStatic) {
beginManglingWithoutPrefix();
llvm::SaveAndRestore<bool> allowUnnamedRAII(AllowNamelessEntities, true);
Buffer << USRPrefix;
appendAccessorEntity(getCodeForAccessorKind(kind), decl, isStatic);
// We have a custom prefix, so finalize() won't verify for us. If we're not
// in invalid code (coming from an IDE caller) verify manually.
if (!decl->isInvalid())
verify(Storage.str().drop_front(USRPrefix.size()), Flavor);
return finalize();
}
std::string ASTMangler::mangleLocalTypeDecl(const TypeDecl *type) {
if (auto abiType = getABIDecl(type)) {
return mangleLocalTypeDecl(abiType);
}
beginManglingWithoutPrefix();
AllowNamelessEntities = true;
OptimizeProtocolNames = false;
// Local types are not ABI anyway. To avoid problems with the ASTDemangler,
// don't respect @_originallyDefinedIn here, since we don't respect it
// when mangling DWARF types for debug info.
RespectOriginallyDefinedIn = false;
if (auto GTD = dyn_cast<GenericTypeDecl>(type)) {
appendAnyGenericType(GTD);
} else {
assert(isa<AssociatedTypeDecl>(type));
BaseEntitySignature nullBase(nullptr);
appendContextOf(type, nullBase);
appendDeclName(type);
appendOperator("Qa");
}
return finalize();
}
std::string ASTMangler::mangleOpaqueTypeDecl(const OpaqueTypeDecl *decl) {
return mangleOpaqueTypeDecl(decl->getNamingDecl());
}
std::string ASTMangler::mangleOpaqueTypeDecl(const ValueDecl *decl) {
OptimizeProtocolNames = false;
beginMangling();
appendEntity(decl);
return finalize();
}
std::string ASTMangler::mangleGenericSignature(const GenericSignature sig) {
beginMangling();
appendGenericSignature(sig);
return finalize();
}
std::string ASTMangler::mangleHasSymbolQuery(const ValueDecl *Decl) {
beginMangling();
if (auto Ctor = dyn_cast<ConstructorDecl>(Decl)) {
appendConstructorEntity(Ctor, /*isAllocating=*/false);
} else if (auto Dtor = dyn_cast<DestructorDecl>(Decl)) {
appendDestructorEntity(Dtor, DestructorKind::NonDeallocating);
} else if (auto GTD = dyn_cast<GenericTypeDecl>(Decl)) {
appendAnyGenericType(GTD);
} else if (isa<AssociatedTypeDecl>(Decl)) {
if (auto abiDecl = getABIDecl(Decl)) {
Decl = abiDecl;
}
BaseEntitySignature nullBase(nullptr);
appendContextOf(Decl, nullBase);
appendDeclName(Decl);
appendOperator("Qa");
} else {
appendEntity(Decl);
}
appendSymbolKind(ASTMangler::SymbolKind::HasSymbolQuery);
return finalize();
}
void ASTMangler::appendSymbolKind(SymbolKind SKind) {
switch (SKind) {
case SymbolKind::Default: return;
case SymbolKind::DynamicThunk: return appendOperator("TD");
case SymbolKind::SwiftAsObjCThunk: return appendOperator("To");
case SymbolKind::ObjCAsSwiftThunk: return appendOperator("TO");
case SymbolKind::DistributedThunk: return appendOperator("TE");
case SymbolKind::DistributedAccessor: return appendOperator("TF");
case SymbolKind::AccessibleFunctionRecord: return appendOperator("HF");
case SymbolKind::BackDeploymentThunk: return appendOperator("Twb");
case SymbolKind::BackDeploymentFallback: return appendOperator("TwB");
case SymbolKind::HasSymbolQuery: return appendOperator("TwS");
}
}
static bool getUnnamedParamIndex(const ParameterList *ParamList,
const ParamDecl *D,
unsigned &UnnamedIndex) {
for (auto Param : *ParamList) {
if (!Param->hasName()) {
if (Param == D)
return true;
++UnnamedIndex;
}
}
return false;
}
static unsigned getUnnamedParamIndex(const ParamDecl *D) {
ParameterList *ParamList;
auto *DC = D->getDeclContext();
if (isa<AbstractClosureExpr>(DC)) {
ParamList = cast<AbstractClosureExpr>(DC)->getParameters();
} else {
ParamList = cast<ValueDecl>(DC->getAsDecl())->getParameterList();
}
unsigned UnnamedIndex = 0;
if (getUnnamedParamIndex(ParamList, D, UnnamedIndex))
return UnnamedIndex;
llvm_unreachable("param not found");
}
static StringRef getPrivateDiscriminatorIfNecessary(const Decl *decl) {
if (!decl->isOutermostPrivateOrFilePrivateScope())
return StringRef();
// Mangle non-local private declarations with a textual discriminator
// based on their enclosing file.
auto topLevelSubcontext = decl->getDeclContext()->getModuleScopeContext();
auto fileUnit = cast<FileUnit>(topLevelSubcontext);
// Clang modules do not provide a namespace, so no discriminator is needed
// here, even for non-public declarations.
if (isa<ClangModuleUnit>(fileUnit))
return StringRef();
Identifier discriminator =
fileUnit->getDiscriminatorForPrivateDecl(decl);
assert(!discriminator.empty());
assert(!isNonAscii(discriminator.str()) &&
"discriminator contains non-ASCII characters");
(void)&isNonAscii;
assert(!clang::isDigit(discriminator.str().front()) &&
"not a valid identifier");
return discriminator.str();
}
/// If the declaration is an @objc protocol defined in Swift and the
/// Objective-C name has been overridden from the default, return the
/// specified name.
///
/// \param useObjCProtocolNames When false, always returns \c None.
static std::optional<std::string>
getOverriddenSwiftProtocolObjCName(const ValueDecl *decl,
bool useObjCProtocolNames) {
if (!useObjCProtocolNames)
return std::nullopt;
auto proto = dyn_cast<ProtocolDecl>(decl);
if (!proto)
return std::nullopt;
if (!proto->isObjC())
return std::nullopt;
// If there is an 'objc' attribute with a name, use that name.
if (auto objcName = proto->getExplicitObjCName()) {
llvm::SmallString<4> buffer;
return std::string(objcName->getString(buffer));
}
return std::nullopt;
}
void ASTMangler::appendDeclName(const ValueDecl *decl, DeclBaseName name,
bool skipLocalDiscriminator) {
ASSERT(!getABIDecl(decl) && "caller should make sure we get ABI decls");
if (name.empty())
name = decl->getBaseName();
assert(!name.isSpecial() && "Cannot print special names");
auto *synthesizedTypeAttr =
decl->getAttrs().getAttribute<ClangImporterSynthesizedTypeAttr>();
if (synthesizedTypeAttr) {
assert(!isDigit(synthesizedTypeAttr->originalTypeName[0]) &&
"synthesized type's original name must be a valid Swift identifier");
appendIdentifier(synthesizedTypeAttr->originalTypeName);
} else if (name.isOperator()) {
appendIdentifier(translateOperator(name.getIdentifier().str()), /*allowRawIdentifiers=*/ false);
switch (decl->getAttrs().getUnaryOperatorKind()) {
case UnaryOperatorKind::Prefix:
appendOperator("op");
break;
case UnaryOperatorKind::Postfix:
appendOperator("oP");
break;
case UnaryOperatorKind::None:
appendOperator("oi");
break;
}
} else if (auto objCName =
getOverriddenSwiftProtocolObjCName(decl, UseObjCRuntimeNames)) {
// @objc Swift protocols should be mangled as Objective-C protocols,
// so append the Objective-C runtime name.
appendIdentifier(*objCName);
} else if (!name.empty()) {
appendIdentifier(name.getIdentifier().str());
} else {
assert(AllowNamelessEntities && "attempt to mangle unnamed decl");
// Fall back to an unlikely name, so that we still generate a valid
// mangled name.
appendIdentifier("_");
}
if (decl->getDeclContext()->isLocalContext()) {
// If we don't need a local discriminator (attached macros receive a
// separate discriminator), we're done.
if (skipLocalDiscriminator)
return;
if (auto *paramDecl = dyn_cast<ParamDecl>(decl)) {
if (!decl->hasName()) {
// Mangle unnamed params with their ordering.
return appendOperator("L", Index(getUnnamedParamIndex(paramDecl)));
}
}
// Mangle local declarations with a numeric discriminator.
return appendOperator("L", Index(decl->getLocalDiscriminator()));
}
if (synthesizedTypeAttr) {
StringRef relatedEntityKind = synthesizedTypeAttr->getManglingName();
assert(relatedEntityKind.size() == 1 &&
"'L' operator only supports a single letter payload");
assert(((relatedEntityKind[0] >= 'a' && relatedEntityKind[0] <= 'j') ||
(relatedEntityKind[0] >= 'A' && relatedEntityKind[0] <= 'J')) &&
"Only [a-jA-J] are reserved for related entity kinds");
return appendOperatorParam("L", relatedEntityKind);
}
StringRef privateDiscriminator = getPrivateDiscriminatorIfNecessary(decl);
if (!privateDiscriminator.empty()) {
appendIdentifier(privateDiscriminator.str());
return appendOperator("LL");
}
}
static const char *getMetatypeRepresentationOp(MetatypeRepresentation Rep) {
switch (Rep) {
case MetatypeRepresentation::Thin:
return "t";
case MetatypeRepresentation::Thick:
return "T";
case MetatypeRepresentation::ObjC:
return "o";
}
llvm_unreachable("Unhandled MetatypeRepresentation in switch.");
}
static char getParamConvention(ParameterConvention conv) {
// @in and @out are mangled the same because they're put in
// different places.
switch (conv) {
case ParameterConvention::Indirect_In: return 'i';
case ParameterConvention::Indirect_Inout: return 'l';
case ParameterConvention::Indirect_InoutAliasable: return 'b';
case ParameterConvention::Indirect_In_Guaranteed: return 'n';
case ParameterConvention::Indirect_In_CXX: return 'X';
case ParameterConvention::Direct_Owned: return 'x';
case ParameterConvention::Direct_Unowned: return 'y';
case ParameterConvention::Direct_Guaranteed: return 'g';
case ParameterConvention::Pack_Owned: return 'v';
case ParameterConvention::Pack_Inout: return 'm';
case ParameterConvention::Pack_Guaranteed: return 'p';
}
llvm_unreachable("bad parameter convention");
}
/// Whether to mangle the given type as generic.
static bool shouldMangleAsGeneric(Type type) {
if (!type)
return false;
if (auto typeAlias = dyn_cast<TypeAliasType>(type.getPointer()))
return typeAlias->getDecl()->isGenericContext();
return type->isSpecialized();
}
void ASTMangler::appendOpaqueDeclName(const OpaqueTypeDecl *opaqueDecl) {
if (canSymbolicReference(opaqueDecl)) {
appendSymbolicReference(opaqueDecl);
} else if (auto namingDecl = opaqueDecl->getNamingDecl()) {
// Set this to true temporarily, even if we're doing DWARF
// mangling for debug info, where it is false. Otherwise,
// the mangled opaque result type name will not be able to
// be looked up, since we rely on an exact match with the
// ABI name.
llvm::SaveAndRestore<bool> savedRespectOriginallyDefinedIn(
RespectOriginallyDefinedIn, true);
appendEntity(namingDecl);
appendOperator("QO");
} else {
llvm_unreachable("todo: independent opaque type decls");
}
}
void ASTMangler::appendExistentialLayout(
const ExistentialLayout &layout, GenericSignature sig,
const ValueDecl *forDecl) {
bool First = true;
bool DroppedRequiresClass = false;
bool SawRequiresClass = false;
for (auto proto : layout.getProtocols()) {
if (auto abiProto = getABIDecl(proto)) {
proto = abiProto;
}
// Skip requirements to conform to an invertible protocols.
// We only mangle inverse requirements, but as a constrained existential.
if (proto->getInvertibleProtocolKind())
continue;
// If we aren't allowed to emit marker protocols, suppress them here.
if (!AllowMarkerProtocols && proto->isMarkerProtocol()) {
if (proto->requiresClass())
DroppedRequiresClass = true;
continue;
}
if (proto->requiresClass())
SawRequiresClass = true;
appendProtocolName(proto);
appendListSeparator(First);
}
if (First)
appendOperator("y");
if (auto superclass = layout.explicitSuperclass) {
appendType(superclass, sig, forDecl);
return appendOperator("Xc");
} else if (layout.hasExplicitAnyObject ||
(DroppedRequiresClass && !SawRequiresClass)) {
return appendOperator("Xl");
}
return appendOperator("p");
}
/// Mangle a type into the buffer.
///
void ASTMangler::appendType(Type type, GenericSignature sig,
const ValueDecl *forDecl) {
assert((DWARFMangling || type->isCanonical()) &&
"expecting canonical types when not mangling for the debugger");
TypeBase *tybase = type.getPointer();
switch (type->getKind()) {
case TypeKind::TypeVariable:
llvm_unreachable("mangling type variable");
case TypeKind::ErrorUnion:
llvm_unreachable("Error unions should not persist to mangling");
case TypeKind::Module:
llvm_unreachable("Cannot mangle module type yet");
case TypeKind::Error:
case TypeKind::Unresolved:
case TypeKind::Placeholder:
appendOperator("Xe");
return;
// We don't care about these types being a bit verbose because we
// don't expect them to come up that often in API names.
case TypeKind::BuiltinFloat:
switch (cast<BuiltinFloatType>(tybase)->getFPKind()) {
case BuiltinFloatType::IEEE16: appendOperator("Bf16_"); return;
case BuiltinFloatType::IEEE32: appendOperator("Bf32_"); return;
case BuiltinFloatType::IEEE64: appendOperator("Bf64_"); return;
case BuiltinFloatType::IEEE80: appendOperator("Bf80_"); return;
case BuiltinFloatType::IEEE128: appendOperator("Bf128_"); return;
case BuiltinFloatType::PPC128: llvm_unreachable("ppc128 not supported");
}
llvm_unreachable("bad floating-point kind");
case TypeKind::BuiltinInteger: {
auto width = cast<BuiltinIntegerType>(tybase)->getWidth();
if (width.isFixedWidth())
appendOperator("Bi", Index(width.getFixedWidth() + 1));
else if (width.isPointerWidth())
appendOperator("Bw");
else
llvm_unreachable("impossible width value");
return;
}
case TypeKind::BuiltinIntegerLiteral:
return appendOperator("BI");
case TypeKind::BuiltinJob:
return appendOperator("Bj");
case TypeKind::BuiltinExecutor:
return appendOperator("Be");
case TypeKind::BuiltinDefaultActorStorage:
return appendOperator("BD");
case TypeKind::BuiltinNonDefaultDistributedActorStorage:
return appendOperator("Bd");
case TypeKind::BuiltinPackIndex:
return appendOperator("BP");
case TypeKind::BuiltinRawPointer:
return appendOperator("Bp");
case TypeKind::BuiltinRawUnsafeContinuation:
return appendOperator("Bc");
case TypeKind::BuiltinNativeObject:
return appendOperator("Bo");
case TypeKind::BuiltinBridgeObject:
return appendOperator("Bb");
case TypeKind::BuiltinUnsafeValueBuffer:
return appendOperator("BB");
case TypeKind::BuiltinUnboundGeneric:
ABORT("Don't know how to mangle a BuiltinUnboundGenericType");
case TypeKind::Locatable: {
auto loc = cast<LocatableType>(tybase);
return appendType(loc->getSinglyDesugaredType(), sig, forDecl);
}
case TypeKind::BuiltinFixedArray: {
auto bfa = cast<BuiltinFixedArrayType>(tybase);
appendType(bfa->getSize(), sig, forDecl);
appendType(bfa->getElementType(), sig, forDecl);
return appendOperator("BV");
}
case TypeKind::SILToken:
return appendOperator("Bt");
case TypeKind::BuiltinVector:
appendType(cast<BuiltinVectorType>(tybase)->getElementType(), sig,
forDecl);
// The mangling calls for using the actual element count, which we have
// to adjust by 1 in order to mangle it as an index.
return appendOperator("Bv",
Index(cast<BuiltinVectorType>(tybase)->getNumElements() + 1));
case TypeKind::TypeAlias: {
assert(DWARFMangling && "sugared types are only legal for the debugger");
auto aliasTy = cast<TypeAliasType>(tybase);
// It's not possible to mangle the context of the builtin module.
// For the DWARF output we want to mangle the type alias + context,
// unless the type alias references a builtin type.
auto underlyingType = aliasTy->getSinglyDesugaredType();
TypeAliasDecl *decl = aliasTy->getDecl();
if (decl->getModuleContext() == Context.TheBuiltinModule) {
return appendType(underlyingType, sig, forDecl);
}
// If the type alias is in a generic local context, we don't have enough
// information to build a proper substitution map because the outer
// substitutions are not recorded anywhere. In this case, just mangle the
// type alias's underlying type.
auto *dc = decl->getDeclContext();
while (dc->isTypeContext())
dc = dc->getParent();
if (dc->isLocalContext() && dc->isGenericContext()) {
return appendType(underlyingType, sig, forDecl);
}
// If the substitution map is incorrect for some other reason, also skip
// mangling.
//
// FIXME: This shouldn't happen.
if (decl->getDeclaredInterfaceType()
.subst(aliasTy->getSubstitutionMap()).getPointer()
!= aliasTy) {
return appendType(underlyingType, sig, forDecl);
}
if (aliasTy->getDecl()->isGenericContext()) {
// Try to mangle the entire name as a substitution.
if (tryMangleTypeSubstitution(tybase, sig))
return;
appendAnyGenericType(decl);
bool isFirstArgList = true;
appendBoundGenericArgs(type, sig, isFirstArgList, forDecl);
appendRetroactiveConformances(type, sig);
appendOperator("G");
addTypeSubstitution(type, sig);
return;
}
return appendAnyGenericType(decl);
}
case TypeKind::PackExpansion: {
auto expansionTy = cast<PackExpansionType>(tybase);
appendType(expansionTy->getPatternType(), sig, forDecl);
appendType(expansionTy->getCountType(), sig, forDecl);
appendOperator("Qp");
return;
}
case TypeKind::PackElement: {
auto elementType = cast<PackElementType>(tybase);
appendType(elementType->getPackType(), sig, forDecl);
// If this ever changes, just mangle level 0 as a plain type parameter.
assert(elementType->getLevel() > 0);
appendOperator("Qe", Index(elementType->getLevel() - 1));
return;
}
case TypeKind::Pack: {
auto packTy = cast<PackType>(tybase);
if (packTy->getNumElements() == 0)
appendOperator("y");
else {
bool firstField = true;
for (auto element : packTy->getElementTypes()) {
appendType(element, sig, forDecl);
appendListSeparator(firstField);
}
}
appendOperator("QP");
return;
}
case TypeKind::SILPack: {
auto packTy = cast<SILPackType>(tybase);
if (packTy->getNumElements() == 0)
appendOperator("y");
else {
bool firstField = true;
for (auto element : packTy->getElementTypes()) {
appendType(element, sig, forDecl);
appendListSeparator(firstField);
}
}
appendOperator("QS");
Buffer << (packTy->isElementAddress() ? 'i' : 'd');
return;
}
case TypeKind::ArraySlice:
assert(DWARFMangling && "sugared types are only legal for the debugger");
appendType(cast<ArraySliceType>(tybase)->getBaseType(), sig, forDecl);
appendOperator("XSa");
return;
case TypeKind::InlineArray: {
assert(DWARFMangling && "sugared types are only legal for the debugger");
auto *T = cast<InlineArrayType>(tybase);
appendType(T->getCountType(), sig, forDecl);
appendType(T->getElementType(), sig, forDecl);
// Note we don't have a known-type mangling for InlineArray, we can
// use 'A' since it's incredibly unlikely
// AutoreleasingUnsafeMutablePointer will ever receive type sugar.
appendOperator("XSA");
return;
}
case TypeKind::VariadicSequence:
assert(DWARFMangling && "sugared types are only legal for the debugger");
appendType(cast<VariadicSequenceType>(tybase)->getBaseType(), sig, forDecl);
appendOperator("XSa");
return;
case TypeKind::Optional:
assert(DWARFMangling && "sugared types are only legal for the debugger");
appendType(cast<OptionalType>(tybase)->getBaseType(), sig, forDecl);
appendOperator("XSq");
return;
case TypeKind::Dictionary:
assert(DWARFMangling && "sugared types are only legal for the debugger");
appendType(cast<DictionaryType>(tybase)->getKeyType(), sig, forDecl);
appendType(cast<DictionaryType>(tybase)->getValueType(), sig, forDecl);
appendOperator("XSD");
return;
case TypeKind::ExistentialMetatype: {
ExistentialMetatypeType *EMT = cast<ExistentialMetatypeType>(tybase);
// ExtendedExistentialTypeShapes consider existential metatypes to
// be part of the existential, so if we're symbolically referencing
// shapes, we need to handle that at this level.
if (EMT->getExistentialLayout().needsExtendedShape(AllowInverses)) {
auto referent = SymbolicReferent::forExtendedExistentialTypeShape(EMT);
if (canSymbolicReference(referent)) {
appendSymbolicExtendedExistentialType(referent, EMT, sig, forDecl);
return;
}
}
if (EMT->getInstanceType()->isExistentialType() &&
EMT->getExistentialLayout().needsExtendedShape(AllowInverses))
appendConstrainedExistential(EMT->getInstanceType(), sig, forDecl);
else
appendType(EMT->getInstanceType(), sig, forDecl);
if (EMT->hasRepresentation()) {
appendOperator("Xm",
getMetatypeRepresentationOp(EMT->getRepresentation()));
} else {
appendOperator("Xp");
}
return;
}
case TypeKind::Metatype: {
MetatypeType *MT = cast<MetatypeType>(tybase);
appendType(MT->getInstanceType(), sig, forDecl);
if (MT->hasRepresentation()) {
appendOperator("XM",
getMetatypeRepresentationOp(MT->getRepresentation()));
} else {
appendOperator("m");
}
return;
}
case TypeKind::LValue:
llvm_unreachable("@lvalue types should not occur in function interfaces");
case TypeKind::InOut:
appendType(cast<InOutType>(tybase)->getObjectType(), sig, forDecl);
return appendOperator("z");
#define REF_STORAGE(Name, ...) \
case TypeKind::Name##Storage: \
appendType(cast<Name##StorageType>(tybase)->getReferentType(), sig, forDecl); \
return appendOperator(manglingOf(ReferenceOwnership::Name));
#include "swift/AST/ReferenceStorage.def"
case TypeKind::Tuple:
appendTypeList(type, sig, forDecl);
return appendOperator("t");
case TypeKind::Protocol: {
return appendExistentialLayout(
ExistentialLayout(CanProtocolType(cast<ProtocolType>(tybase))),
sig, forDecl);
}
case TypeKind::ProtocolComposition: {
auto *PCT = cast<ProtocolCompositionType>(tybase);
if (!AllowMarkerProtocols) {
auto strippedTy = PCT->withoutMarkerProtocols();
if (!strippedTy->isEqual(PCT))
return appendType(strippedTy, sig, forDecl);
}
if (PCT->getExistentialLayout().needsExtendedShape(AllowInverses))
return appendConstrainedExistential(PCT, sig, forDecl);
// We mangle ProtocolType and ProtocolCompositionType using the
// same production:
auto layout = PCT->getExistentialLayout();
return appendExistentialLayout(layout, sig, forDecl);
}
case TypeKind::ParameterizedProtocol:
return appendConstrainedExistential(tybase, sig, forDecl);
case TypeKind::Existential: {
auto *ET = cast<ExistentialType>(tybase);
if (ET->getExistentialLayout().needsExtendedShape(AllowInverses)) {
auto referent = SymbolicReferent::forExtendedExistentialTypeShape(ET);
if (canSymbolicReference(referent)) {
appendSymbolicExtendedExistentialType(referent, ET, sig, forDecl);
return;
}
return appendConstrainedExistential(ET->getConstraintType(), sig,
forDecl);
}
return appendType(ET->getConstraintType(), sig, forDecl);
}
case TypeKind::UnboundGeneric:
case TypeKind::Class:
case TypeKind::Enum:
case TypeKind::Struct:
case TypeKind::BoundGenericClass:
case TypeKind::BoundGenericEnum:
case TypeKind::BoundGenericStruct:
case TypeKind::BuiltinTuple: {
GenericTypeDecl *Decl;
if (auto typeAlias = dyn_cast<TypeAliasType>(type.getPointer()))
Decl = typeAlias->getDecl();
else
Decl = type->getAnyGeneric();
if (auto abiDecl = getABIDecl(Decl)) {
Decl = abiDecl;
}
if (shouldMangleAsGeneric(type)) {
// Try to mangle the entire name as a substitution.
if (tryMangleTypeSubstitution(tybase, sig))
return;
if (Decl->isStdlibDecl() && Decl->getName().str() == "Optional") {
auto GenArgs = type->castTo<BoundGenericType>()->getGenericArgs();
assert(GenArgs.size() == 1);
appendType(GenArgs[0], sig, forDecl);
appendOperator("Sg");
} else {
appendAnyGenericType(Decl);
bool isFirstArgList = true;
appendBoundGenericArgs(type, sig, isFirstArgList, forDecl);
appendRetroactiveConformances(type, sig);
appendOperator("G");
}
addTypeSubstitution(type, sig);
return;
}
appendAnyGenericType(type->getAnyGeneric());
return;
}
case TypeKind::SILFunction:
return appendImplFunctionType(cast<SILFunctionType>(tybase), sig,
forDecl);
// type ::= archetype
case TypeKind::PrimaryArchetype:
case TypeKind::PackArchetype:
case TypeKind::ElementArchetype:
case TypeKind::ExistentialArchetype:
ABORT([&](auto &out) {
out << "Cannot mangle free-standing archetype: ";
tybase->dump(out);
});
case TypeKind::OpaqueTypeArchetype: {
auto opaqueType = cast<OpaqueTypeArchetypeType>(tybase);
auto opaqueDecl = opaqueType->getDecl();
return appendOpaqueTypeArchetype(
opaqueType, opaqueDecl, opaqueType->getSubstitutions(), sig, forDecl);
}
case TypeKind::DynamicSelf: {
auto dynamicSelf = cast<DynamicSelfType>(tybase);
if (dynamicSelf->getSelfType()->getAnyNominal()) {
appendType(dynamicSelf->getSelfType(), sig, forDecl);
return appendOperator("XD");
}
return appendType(dynamicSelf->getSelfType(), sig, forDecl);
}
case TypeKind::GenericFunction: {
auto genFunc = cast<GenericFunctionType>(tybase);
appendFunctionType(genFunc, genFunc->getGenericSignature(),
/*autoclosure*/ false, forDecl);
appendGenericSignature(genFunc->getGenericSignature());
appendOperator("u");
return;
}
case TypeKind::GenericTypeParam: {
auto paramTy = cast<GenericTypeParamType>(tybase);
// If this assertion fires, it probably means the type being mangled here
// didn't go through getTypeForDWARFMangling().
assert(paramTy->isCanonical() &&
"cannot mangle non-canonical generic parameter");
// A special mangling for the very first generic parameter. This shows up
// frequently because it corresponds to 'Self' in protocol requirement
// generic signatures.
if (paramTy->getDepth() == 0 && paramTy->getIndex() == 0)
return appendOperator("x");
return appendOpWithGenericParamIndex("q", paramTy);
}
case TypeKind::DependentMember: {
auto *DepTy = cast<DependentMemberType>(tybase);
if (tryMangleTypeSubstitution(DepTy, sig))
return;
bool isAssocTypeAtDepth = false;
if (GenericTypeParamType *gpBase = appendAssocType(DepTy, sig,
isAssocTypeAtDepth)) {
if (gpBase->getDepth() == 0 && gpBase->getIndex() == 0) {
appendOperator(isAssocTypeAtDepth ? "QZ" : "Qz");
} else {
appendOpWithGenericParamIndex(isAssocTypeAtDepth ? "QY" : "Qy",
gpBase);
}
} else {
// Dependent members of non-generic-param types are not canonical, but
// we may still want to mangle them for debugging or indexing purposes.
appendType(DepTy->getBase(), sig, forDecl);
appendIdentifier(DepTy->getName().str());
appendOperator("Qa");
}
addTypeSubstitution(DepTy, sig);
return;
}
case TypeKind::Function:
appendFunctionType(cast<FunctionType>(tybase), sig,
/*autoclosure*/ false,
forDecl);
return;
case TypeKind::SILBox: {
auto box = cast<SILBoxType>(tybase);
auto layout = box->getLayout();
bool firstField = true;
for (auto &field : layout->getFields()) {
appendType(field.getLoweredType(), sig, forDecl);
if (field.isMutable()) {
// Use the `inout` mangling to represent a mutable field.
appendOperator("z");
}
appendListSeparator(firstField);
}
if (firstField)
appendOperator("y");
if (auto sig = layout->getGenericSignature()) {
bool firstType = true;
for (Type type : box->getSubstitutions().getReplacementTypes()) {
appendType(type, sig, forDecl);
appendListSeparator(firstType);
}
if (firstType)
appendOperator("y");
appendGenericSignature(sig);
appendOperator("XX");
} else {
appendOperator("Xx");
}
return;
}
case TypeKind::Integer: {
auto integer = cast<IntegerType>(tybase);
appendOperator("$");
auto value = integer->getValue().getSExtValue();
if (integer->isNegative()) {
appendOperator("n", Index(-value));
} else {
appendOperator("", Index(value));
}
return;
}
case TypeKind::SILMoveOnlyWrapped:
// If we hit this, we just mangle the underlying name and move on.
llvm_unreachable("should never be mangled?");
case TypeKind::SILBlockStorage:
llvm_unreachable("should never be mangled");
}
llvm_unreachable("bad type kind");
}
GenericTypeParamType *ASTMangler::appendAssocType(DependentMemberType *DepTy,
GenericSignature sig,
bool &isAssocTypeAtDepth) {
auto base = DepTy->getBase()->getCanonicalType();
// 't_0_0.Member'
if (auto gpBase = dyn_cast<GenericTypeParamType>(base)) {
appendAssociatedTypeName(DepTy, sig);
isAssocTypeAtDepth = false;
return gpBase;
}
// 't_0_0.Member.Member...'
SmallVector<DependentMemberType*, 2> path;
path.push_back(DepTy);
while (auto dmBase = dyn_cast<DependentMemberType>(base)) {
path.push_back(dmBase);
base = dmBase.getBase();
}
if (auto gpRoot = dyn_cast<GenericTypeParamType>(base)) {
bool first = true;
for (auto *member : llvm::reverse(path)) {
appendAssociatedTypeName(member, sig);
appendListSeparator(first);
}
isAssocTypeAtDepth = true;
return gpRoot;
}
return nullptr;
}
void ASTMangler::appendOpWithGenericParamIndex(
StringRef Op, const GenericTypeParamType *paramTy,
bool baseIsProtocolSelf) {
llvm::SmallVector<char, 8> OpBuf(Op.begin(), Op.end());
if (paramTy->getDepth() > 0) {
OpBuf.push_back('d');
return appendOperator(StringRef(OpBuf.data(), OpBuf.size()),
Index(paramTy->getDepth() - 1),
Index(paramTy->getIndex()));
}
if (paramTy->getIndex() == 0) {
if (baseIsProtocolSelf) {
OpBuf.push_back('s');
} else {
OpBuf.push_back('z');
}
return appendOperator(StringRef(OpBuf.data(), OpBuf.size()));
}
appendOperator(Op, Index(paramTy->getIndex() - 1));
}
void ASTMangler::appendFlatGenericArgs(SubstitutionMap subs,
GenericSignature sig,
const ValueDecl *forDecl) {
appendOperator("y");
for (auto replacement : subs.getReplacementTypes()) {
if (replacement->hasArchetype())
replacement = replacement->mapTypeOutOfContext();
appendType(replacement, sig, forDecl);
}
}
unsigned ASTMangler::appendBoundGenericArgs(DeclContext *dc,
GenericSignature sig,
SubstitutionMap subs,
bool &isFirstArgList,
const ValueDecl *forDecl) {
auto decl = dc->getInnermostDeclarationDeclContext();
if (!decl) return 0;
// For a non-protocol extension declaration, use the nominal type declaration
// instead.
//
// This is important when extending a nested type, because the generic
// parameters will line up with the (semantic) nesting of the nominal type.
if (auto ext = dyn_cast<ExtensionDecl>(decl))
decl = ext->getSelfNominalTypeDecl();
// Handle the generic arguments of the parent.
unsigned currentGenericParamIdx =
appendBoundGenericArgs(decl->getDeclContext(), sig, subs, isFirstArgList,
forDecl);
// If this is potentially a generic context, emit a generic argument list.
if (auto genericContext = decl->getAsGenericContext()) {
if (isFirstArgList) {
appendOperator("y");
isFirstArgList = false;
} else {
appendOperator("_");
}
// If we are generic at this level, emit all of the replacements at
// this level.
bool treatAsGeneric;
if (auto opaque = dyn_cast<OpaqueTypeDecl>(decl)) {
// For opaque type declarations, the generic parameters of the opaque
// type declaration are not part of the mangling, so check whether the
// naming declaration has generic parameters.
auto namedGenericContext = opaque->getNamingDecl()->getAsGenericContext();
treatAsGeneric = namedGenericContext && namedGenericContext->isGeneric();
} else {
treatAsGeneric = genericContext->isGeneric();
}
if (treatAsGeneric) {
auto genericParams = subs.getGenericSignature().getGenericParams();
unsigned depth = genericParams[currentGenericParamIdx]->getDepth();
auto replacements = subs.getReplacementTypes();
for (unsigned lastGenericParamIdx = genericParams.size();
(currentGenericParamIdx != lastGenericParamIdx &&
genericParams[currentGenericParamIdx]->getDepth() == depth);
++currentGenericParamIdx) {
Type replacementType = replacements[currentGenericParamIdx];
if (replacementType->hasArchetype())
replacementType = replacementType->mapTypeOutOfContext();
appendType(replacementType, sig, forDecl);
}
}
}
return currentGenericParamIdx;
}
void ASTMangler::appendBoundGenericArgs(Type type, GenericSignature sig,
bool &isFirstArgList,
const ValueDecl *forDecl) {
TypeBase *typePtr = type.getPointer();
ArrayRef<Type> genericArgs;
if (auto *typeAlias = dyn_cast<TypeAliasType>(typePtr)) {
appendBoundGenericArgs(typeAlias->getDecl(), sig,
typeAlias->getSubstitutionMap(),
isFirstArgList, forDecl);
return;
}
if (auto *unboundType = dyn_cast<UnboundGenericType>(typePtr)) {
if (Type parent = unboundType->getParent())
appendBoundGenericArgs(parent->getDesugaredType(), sig, isFirstArgList,
forDecl);
} else if (auto *nominalType = dyn_cast<NominalType>(typePtr)) {
if (Type parent = nominalType->getParent())
appendBoundGenericArgs(parent->getDesugaredType(), sig, isFirstArgList,
forDecl);
} else {
auto boundType = cast<BoundGenericType>(typePtr);
genericArgs = boundType->getGenericArgs();
if (Type parent = boundType->getParent()) {
GenericTypeDecl *decl = boundType->getAnyGeneric();
if (!getSpecialManglingContext(decl, UseObjCRuntimeNames))
appendBoundGenericArgs(parent->getDesugaredType(), sig, isFirstArgList,
forDecl);
}
}
if (isFirstArgList) {
appendOperator("y");
isFirstArgList = false;
} else {
appendOperator("_");
}
for (Type arg : genericArgs) {
appendType(arg, sig, forDecl);
}
}
static bool conformanceHasIdentity(const RootProtocolConformance *root) {
auto conformance = dyn_cast<NormalProtocolConformance>(root);
if (!conformance) {
assert(isa<SelfProtocolConformance>(root) ||
isa<BuiltinProtocolConformance>(root));
return true;
}
// Synthesized conformances can have multiple copies, so they don't
// provide identity.
if (conformance->isSynthesized())
return false;
// Objective-C protocol conformances are checked by the ObjC runtime.
if (conformance->getProtocol()->isObjC())
return false;
return true;
}
/// Determine whether the given protocol conformance is itself retroactive,
/// meaning that there might be multiple conflicting conformances of the
/// same type to the same protocol.
static bool isRetroactiveConformance(const RootProtocolConformance *root) {
auto conformance = dyn_cast<NormalProtocolConformance>(root);
if (!conformance) {
assert(isa<SelfProtocolConformance>(root) ||
isa<BuiltinProtocolConformance>(root));
return false; // self-conformances are never retroactive. nor are builtin.
}
// Don't consider marker protocols at all.
if (conformance->getProtocol()->isMarkerProtocol())
return false;
return conformance->isRetroactive();
}
template<typename Fn>
static bool forEachConditionalConformance(const ProtocolConformance *conformance,
Fn fn) {
auto *rootConformance = conformance->getRootConformance();
auto subMap = conformance->getSubstitutionMap();
auto ext = dyn_cast<ExtensionDecl>(rootConformance->getDeclContext());
if (!ext)
return false;
auto typeSig = ext->getExtendedNominal()->getGenericSignature();
auto extensionSig = rootConformance->getGenericSignature();
for (const auto &req : extensionSig.getRequirements()) {
// We set brokenPackBehavior to true here to maintain compatibility with
// the mangling produced by an old compiler. We could incorrectly return
// false from isRequirementSatisfied() here even if the requirement was
// satisfied, and then it would show up as a conditional requirement
// even though it was already part of the nominal type's generic signature.
if (typeSig->isRequirementSatisfied(req,
/*allowMissing=*/false,
/*brokenPackBehavior=*/true))
continue;
if (req.getKind() != RequirementKind::Conformance)
continue;
ProtocolDecl *proto = req.getProtocolDecl();
auto conformance = subMap.lookupConformance(
req.getFirstType()->getCanonicalType(), proto);
if (fn(req.getFirstType().subst(subMap), conformance))
return true;
}
return false;
}
/// Determine whether the given protocol conformance contains a retroactive
/// protocol conformance anywhere in it.
static bool containsRetroactiveConformance(
ProtocolConformanceRef conformanceRef) {
if (!conformanceRef.isPack() && !conformanceRef.isConcrete())
return false;
if (conformanceRef.isPack()) {
for (auto patternConf : conformanceRef.getPack()->getPatternConformances()) {
if (containsRetroactiveConformance(patternConf))
return true;
}
return false;
}
auto *conformance = conformanceRef.getConcrete();
// If the root conformance is retroactive, it's retroactive.
const RootProtocolConformance *rootConformance =
conformance->getRootConformance();
if (isRetroactiveConformance(rootConformance) &&
conformanceHasIdentity(rootConformance))
return true;
// If the conformance is conditional and any of the substitutions used to
// satisfy the conditions are retroactive, it's retroactive.
return forEachConditionalConformance(conformance,
[&](Type substType, ProtocolConformanceRef substConf) -> bool {
return containsRetroactiveConformance(substConf);
});
}
void ASTMangler::appendRetroactiveConformances(SubstitutionMap subMap,
GenericSignature sig) {
if (subMap.empty()) return;
unsigned numProtocolRequirements = 0;
for (auto conformance : subMap.getConformances()) {
if (conformance.isInvalid())
continue;
if (conformance.getProtocol()->isMarkerProtocol())
continue;
SWIFT_DEFER {
++numProtocolRequirements;
};
// Ignore abstract conformances.
if (!conformance.isConcrete() && !conformance.isPack())
continue;
// Skip non-retroactive conformances.
if (!containsRetroactiveConformance(conformance))
continue;
if (conformance.isConcrete())
appendConcreteProtocolConformance(conformance.getConcrete(), sig);
else
appendPackProtocolConformance(conformance.getPack(), sig);
appendOperator("g", Index(numProtocolRequirements));
}
}
void ASTMangler::appendRetroactiveConformances(Type type, GenericSignature sig) {
// Dig out the substitution map to use.
SubstitutionMap subMap;
if (auto typeAlias = dyn_cast<TypeAliasType>(type.getPointer())) {
subMap = typeAlias->getSubstitutionMap();
} else {
if (type->hasUnboundGenericType())
return;
if (!type->getAnyNominal()) return;
subMap = type->getContextSubstitutionMap();
}
appendRetroactiveConformances(subMap, sig);
}
void ASTMangler::appendSymbolicExtendedExistentialType(
SymbolicReferent shapeReferent,
Type type,
GenericSignature sig,
const ValueDecl *forDecl) {
if (auto abiShapeReferent = getABIDecl(shapeReferent)) {
return appendSymbolicExtendedExistentialType(abiShapeReferent.value(), type,
sig, forDecl);
}
assert(shapeReferent.getKind() ==
SymbolicReferent::ExtendedExistentialTypeShape);
assert(canSymbolicReference(shapeReferent));
assert(type->isAnyExistentialType());
// type ::= symbolic-extended-existential-type-shape
// type* retroactive-conformance* 'Xj'
appendSymbolicReference(shapeReferent);
auto genInfo = ExistentialTypeGeneralization::get(type);
if (genInfo.Generalization) {
for (auto argType : genInfo.Generalization.getReplacementTypes())
appendType(argType, sig, forDecl);
appendRetroactiveConformances(genInfo.Generalization, sig);
}
appendOperator("Xj");
}
static std::optional<char>
getParamDifferentiability(SILParameterInfo::Options options) {
if (options.contains(SILParameterInfo::NotDifferentiable))
return 'w';
return {};
}
static char getResultConvention(ResultConvention conv) {
switch (conv) {
case ResultConvention::Indirect: return 'r';
case ResultConvention::Owned: return 'o';
case ResultConvention::Unowned: return 'd';
case ResultConvention::UnownedInnerPointer: return 'u';
case ResultConvention::Autoreleased: return 'a';
case ResultConvention::Pack: return 'k';
}
llvm_unreachable("bad result convention");
}
static std::optional<char>
getResultDifferentiability(SILResultInfo::Options options) {
if (options.contains(SILResultInfo::NotDifferentiable))
return 'w';
return {};
}
void ASTMangler::appendImplFunctionType(SILFunctionType *fn,
GenericSignature outerGenericSig,
const ValueDecl *forDecl,
bool isInRecursion) {
llvm::SmallVector<char, 32> OpArgs;
if (fn->getPatternSubstitutions()) {
OpArgs.push_back('s');
}
if (fn->getInvocationSubstitutions()) {
OpArgs.push_back('I');
}
if (fn->isPolymorphic() && fn->isPseudogeneric())
OpArgs.push_back('P');
if (!fn->isNoEscape())
OpArgs.push_back('e');
switch (fn->getIsolation().getKind()) {
case SILFunctionTypeIsolation::Unknown:
break;
case SILFunctionTypeIsolation::Erased:
if (AllowIsolatedAny)
OpArgs.push_back('A');
break;
}
// Differentiability kind.
auto diffKind = fn->getExtInfo().getDifferentiabilityKind();
if (diffKind != DifferentiabilityKind::NonDifferentiable) {
OpArgs.push_back((char)getMangledDifferentiabilityKind(diffKind));
}
// <impl-callee-convention>
if (fn->getExtInfo().hasContext()) {
OpArgs.push_back(getParamConvention(fn->getCalleeConvention()));
} else {
OpArgs.push_back('t');
}
bool mangleClangType =
Context.LangOpts.UseClangFunctionTypes && fn->hasNonDerivableClangType();
auto appendClangTypeToVec = [this, fn](auto &Vec) {
llvm::raw_svector_ostream OpArgsOS(Vec);
appendClangType(fn, OpArgsOS);
};
switch (fn->getRepresentation()) {
case SILFunctionTypeRepresentation::Thick:
case SILFunctionTypeRepresentation::Thin:
break;
case SILFunctionTypeRepresentation::Block:
if (!mangleClangType) {
OpArgs.push_back('B');
break;
}
OpArgs.push_back('z');
OpArgs.push_back('B');
appendClangTypeToVec(OpArgs);
break;
case SILFunctionTypeRepresentation::CXXMethod:
case SILFunctionTypeRepresentation::CFunctionPointer:
if (!mangleClangType) {
OpArgs.push_back('C');
break;
}
OpArgs.push_back('z');
OpArgs.push_back('C');
appendClangTypeToVec(OpArgs);
break;
case SILFunctionTypeRepresentation::ObjCMethod:
OpArgs.push_back('O');
break;
case SILFunctionTypeRepresentation::Method:
OpArgs.push_back('M');
break;
case SILFunctionTypeRepresentation::Closure:
OpArgs.push_back('K');
break;
case SILFunctionTypeRepresentation::WitnessMethod:
OpArgs.push_back('W');
break;
case SILFunctionTypeRepresentation::KeyPathAccessorGetter:
case SILFunctionTypeRepresentation::KeyPathAccessorSetter:
case SILFunctionTypeRepresentation::KeyPathAccessorEquals:
case SILFunctionTypeRepresentation::KeyPathAccessorHash:
// KeyPath accessors are mangled separately based on their index types
// by mangleKeyPathGetterThunkHelper, and so on.
llvm_unreachable("key path accessors should not mangle its function type");
}
// Coroutine kind. This is mangled in all pointer auth modes.
switch (fn->getCoroutineKind()) {
case SILCoroutineKind::None:
break;
case SILCoroutineKind::YieldOnce:
OpArgs.push_back('A');
break;
case SILCoroutineKind::YieldOnce2:
OpArgs.push_back('I');
break;
case SILCoroutineKind::YieldMany:
OpArgs.push_back('G');
break;
}
// Concurrent functions.
if (fn->isSendable()) {
OpArgs.push_back('h');
}
// Asynchronous functions.
if (fn->isAsync()) {
OpArgs.push_back('H');
}
// Mangle if we have a sending result and we are in a recursive position.
//
// DISCUSSION: We only want sending results to be in the mangling if it is
// being used in a function value passed to a parameter or generic
// position... but not if it is just added to a return type.
//
// E.x.:
//
// func foo() -> sending X // No mangling
// func bar(_ x: () -> sending X) {} // Add to mangling for x
if (isInRecursion && fn->hasSendingResult())
OpArgs.push_back('T');
GenericSignature sig = fn->getSubstGenericSignature();
// Mangle the parameters.
for (auto param : fn->getParameters()) {
OpArgs.push_back(getParamConvention(param.getConvention()));
if (param.hasOption(SILParameterInfo::Sending))
OpArgs.push_back('T');
if (auto diffKind = getParamDifferentiability(param.getOptions()))
OpArgs.push_back(*diffKind);
appendType(param.getInterfaceType(), sig, forDecl);
}
// Mangle the results.
for (auto result : fn->getResults()) {
OpArgs.push_back(getResultConvention(result.getConvention()));
if (auto diffKind = getResultDifferentiability(result.getOptions()))
OpArgs.push_back(*diffKind);
appendType(result.getInterfaceType(), sig, forDecl);
}
// Mangle the yields.
for (auto yield : fn->getYields()) {
OpArgs.push_back('Y');
OpArgs.push_back(getParamConvention(yield.getConvention()));
appendType(yield.getInterfaceType(), sig, forDecl);
}
// Mangle the error result if present.
if (fn->hasErrorResult()) {
auto error = fn->getErrorResult();
OpArgs.push_back('z');
OpArgs.push_back(getResultConvention(error.getConvention()));
appendType(error.getInterfaceType(), sig, forDecl);
}
if (auto invocationSig = fn->getInvocationGenericSignature()) {
appendGenericSignature(invocationSig);
sig = outerGenericSig;
}
if (auto subs = fn->getInvocationSubstitutions()) {
appendFlatGenericArgs(subs, sig, forDecl);
appendRetroactiveConformances(subs, sig);
}
if (auto subs = fn->getPatternSubstitutions()) {
appendGenericSignature(subs.getGenericSignature());
sig =
fn->getInvocationGenericSignature()
? fn->getInvocationGenericSignature()
: outerGenericSig;
appendFlatGenericArgs(subs, sig, forDecl);
appendRetroactiveConformances(subs, sig);
}
OpArgs.push_back('_');
appendOperator("I", StringRef(OpArgs.data(), OpArgs.size()));
}
void ASTMangler::appendOpaqueTypeArchetype(ArchetypeType *archetype,
OpaqueTypeDecl *opaqueDecl,
SubstitutionMap subs,
GenericSignature sig,
const ValueDecl *forDecl) {
Type interfaceType = archetype->getInterfaceType();
auto genericParam = interfaceType->getAs<GenericTypeParamType>();
// If this is the opaque return type of the declaration currently being
// mangled, use a short mangling to represent it.
if (genericParam && opaqueDecl->getNamingDecl() == forDecl) {
assert(subs.isIdentity());
if (genericParam->getIndex() == 0)
return appendOperator("Qr");
return appendOperator("QR", Index(genericParam->getIndex() - 1));
}
// Otherwise, try to substitute it.
if (tryMangleTypeSubstitution(Type(archetype), sig))
return;
// Mangling at the root, described by a generic parameter.
if (genericParam) {
// Use the fully elaborated explicit mangling.
appendOpaqueDeclName(opaqueDecl);
bool isFirstArgList = true;
appendBoundGenericArgs(opaqueDecl, sig, subs, isFirstArgList, forDecl);
appendRetroactiveConformances(subs, sig);
appendOperator("Qo", Index(genericParam->getIndex()));
} else {
auto *env = archetype->getGenericEnvironment();
appendType(env->mapTypeIntoContext(interfaceType->getRootGenericParam()),
sig, forDecl);
// Mangle associated types of opaque archetypes like dependent member
// types, so that they can be accurately demangled at runtime.
bool isAssocTypeAtDepth = false;
appendAssocType(
interfaceType->castTo<DependentMemberType>(),
sig, isAssocTypeAtDepth);
appendOperator(isAssocTypeAtDepth ? "QX" : "Qx");
}
addTypeSubstitution(Type(archetype), sig);
}
std::optional<ASTMangler::SpecialContext>
ASTMangler::getSpecialManglingContext(const ValueDecl *decl,
bool useObjCProtocolNames) {
// Declarations provided by a C module have a special context mangling.
// known-context ::= 'So'
//
// Also handle top-level imported declarations that don't have corresponding
// Clang decls. Check getKind() directly to avoid a layering dependency.
// known-context ::= 'SC'
if (auto file = dyn_cast<FileUnit>(decl->getDeclContext())) {
if (file->getKind() == FileUnitKind::ClangModule ||
file->getKind() == FileUnitKind::DWARFModule) {
if (decl->getClangDecl())
return ASTMangler::ObjCContext;
return ASTMangler::ClangImporterContext;
}
}
// If @objc Swift protocols should be mangled as Objective-C protocols,
// they are defined in the Objective-C context.
if (getOverriddenSwiftProtocolObjCName(decl, useObjCProtocolNames))
return ASTMangler::ObjCContext;
// Nested types imported from C should also get use the special "So" context.
if (isa<TypeDecl>(decl)) {
if (auto *clangDecl = cast_or_null<clang::NamedDecl>(decl->getClangDecl())){
bool hasNameForLinkage;
if (auto *tagDecl = dyn_cast<clang::TagDecl>(clangDecl))
// Clang does not always populate the fields that determine if a tag
// decl has a linkage name. This is particularly the case for the
// C++ definition of CF_OPTIONS in the sdk. However, we use the
// name of the backing typedef as a linkage name, despite
// the enum itself not having one.
hasNameForLinkage =
tagDecl->hasNameForLinkage() || isCXXCFOptionsDefinition(decl);
else
hasNameForLinkage = !clangDecl->getDeclName().isEmpty();
if (hasNameForLinkage) {
auto *clangDC = clangDecl->getDeclContext();
// In C, "nested" structs, unions, enums, etc. will become siblings:
// struct Foo { struct Bar { }; }; -> struct Foo { }; struct Bar { };
// Whereas in C++, nested records will actually be nested. So if this is
// a C++ record, simply treat it like a namespace and exit early.
if (isa<clang::NamespaceDecl>(clangDC) ||
isa<clang::CXXRecordDecl>(clangDC))
return std::nullopt;
assert(clangDC->getRedeclContext()->isTranslationUnit() &&
"non-top-level Clang types not supported yet");
return ASTMangler::ObjCContext;
}
}
// Types apparently defined in the Builtin module are actually
// synthetic declarations for types defined in the runtime,
// and they should be mangled as C-namespace entities; see e.g.
// IRGenModule::getObjCRuntimeBaseClass.
if (decl->getModuleContext()->isBuiltinModule())
return ASTMangler::ObjCContext;
}
// Importer-synthesized types should always be mangled in the
// ClangImporterContext, even if an __attribute__((swift_name())) nests them
// inside a Swift type syntactically.
if (decl->getAttrs().hasAttribute<ClangImporterSynthesizedTypeAttr>())
return ASTMangler::ClangImporterContext;
return std::nullopt;
}
/// Mangle the context of the given declaration as a <context.
/// This is the top-level entrypoint for mangling <context>.
void ASTMangler::appendContextOf(const ValueDecl *decl,
BaseEntitySignature &base) {
// Check for a special mangling context.
if (auto context = getSpecialManglingContext(decl, UseObjCRuntimeNames)) {
switch (*context) {
case ClangImporterContext:
return appendOperator("SC");
case ObjCContext:
return appendOperator("So");
}
}
// Mangle the decl's DC.
appendContext(decl->getDeclContext(), base, decl->getAlternateModuleName());
}
namespace {
class FindFirstVariable :
public PatternVisitor<FindFirstVariable, VarDecl *> {
public:
VarDecl *visitNamedPattern(NamedPattern *P) {
return P->getDecl();
}
VarDecl *visitTuplePattern(TuplePattern *P) {
for (auto &elt : P->getElements()) {
VarDecl *var = visit(elt.getPattern());
if (var) return var;
}
return nullptr;
}
VarDecl *visitParenPattern(ParenPattern *P) {
return visit(P->getSubPattern());
}
VarDecl *visitBindingPattern(BindingPattern *P) {
return visit(P->getSubPattern());
}
VarDecl *visitTypedPattern(TypedPattern *P) {
return visit(P->getSubPattern());
}
VarDecl *visitAnyPattern(AnyPattern *P) {
return nullptr;
}
// Refutable patterns shouldn't ever come up.
#define REFUTABLE_PATTERN(ID, BASE) \
VarDecl *visit##ID##Pattern(ID##Pattern *P) { \
llvm_unreachable("shouldn't be visiting a refutable pattern here!"); \
}
#define PATTERN(ID, BASE)
#include "swift/AST/PatternNodes.def"
};
} // end anonymous namespace
/// Find the first identifier bound by the given binding. This
/// assumes that field and global-variable bindings always bind at
/// least one name, which is probably a reasonable assumption but may
/// not be adequately enforced.
static std::optional<VarDecl *> findFirstVariable(PatternBindingDecl *binding) {
for (auto idx : range(binding->getNumPatternEntries())) {
auto var = FindFirstVariable().visit(binding->getPattern(idx));
if (var)
return var;
}
// Pattern-binding bound without variables exists in erroneous code, e.g.
// during code completion.
return std::nullopt;
}
void ASTMangler::appendContext(const DeclContext *ctx,
BaseEntitySignature &base,
StringRef useModuleName) {
switch (ctx->getContextKind()) {
case DeclContextKind::Package:
return;
case DeclContextKind::Module:
return appendModule(cast<ModuleDecl>(ctx), useModuleName);
case DeclContextKind::FileUnit:
assert(!isa<BuiltinUnit>(ctx) && "mangling member of builtin module!");
appendContext(ctx->getParent(), base, useModuleName);
return;
case DeclContextKind::GenericTypeDecl: {
auto gtd = cast<GenericTypeDecl>(ctx);
bool innermost = base.reachedInnermostTypeDecl();
appendAnyGenericType(gtd, base);
if (innermost)
appendContextualInverses(gtd, base, ctx->getParentModule(), useModuleName);
return;
}
case DeclContextKind::ExtensionDecl:
appendExtension(cast<ExtensionDecl>(ctx), base, useModuleName);
return;
case DeclContextKind::AbstractClosureExpr:
return appendClosureEntity(cast<AbstractClosureExpr>(ctx));
case DeclContextKind::SerializedAbstractClosure:
return appendClosureEntity(cast<SerializedAbstractClosureExpr>(ctx));
case DeclContextKind::AbstractFunctionDecl: {
auto fn = cast<AbstractFunctionDecl>(ctx);
// Constructors and destructors as contexts are always mangled
// using the non-(de)allocating variants.
if (auto ctor = dyn_cast<ConstructorDecl>(fn)) {
return appendConstructorEntity(ctor, /*allocating*/ false);
}
if (auto dtor = dyn_cast<DestructorDecl>(fn))
return appendDestructorEntity(dtor, DestructorKind::NonDeallocating);
return appendEntity(fn);
}
case DeclContextKind::EnumElementDecl: {
auto eed = cast<EnumElementDecl>(ctx);
return appendEntity(eed);
}
case DeclContextKind::SubscriptDecl: {
auto sd = cast<SubscriptDecl>(ctx);
return appendEntity(sd);
}
case DeclContextKind::Initializer: {
switch (cast<Initializer>(ctx)->getInitializerKind()) {
case InitializerKind::DefaultArgument: {
auto argInit = cast<DefaultArgumentInitializer>(ctx);
return appendDefaultArgumentEntity(ctx->getParent(), argInit->getIndex());
}
case InitializerKind::PatternBinding: {
auto patternInit = cast<PatternBindingInitializer>(ctx);
if (auto var = findFirstVariable(patternInit->getBinding())) {
appendInitializerEntity(var.value());
} else {
BaseEntitySignature nullBase(nullptr);
// This is incorrect in that it does not produce a /unique/ mangling,
// but it will at least produce a /valid/ mangling.
appendContext(ctx->getParent(), nullBase, useModuleName);
}
return;
}
case InitializerKind::PropertyWrapper: {
auto wrapperInit = cast<PropertyWrapperInitializer>(ctx);
switch (wrapperInit->getKind()) {
case PropertyWrapperInitializer::Kind::WrappedValue:
appendBackingInitializerEntity(wrapperInit->getWrappedVar());
break;
case PropertyWrapperInitializer::Kind::ProjectedValue:
appendInitFromProjectedValueEntity(wrapperInit->getWrappedVar());
break;
}
return;
}
case InitializerKind::CustomAttribute: {
BaseEntitySignature nullBase(nullptr);
appendContext(ctx->getParent(), nullBase, useModuleName);
return;
}
}
llvm_unreachable("bad initializer kind");
}
case DeclContextKind::TopLevelCodeDecl:
case DeclContextKind::SerializedTopLevelCodeDecl:
// Mangle the containing module context.
return appendContext(ctx->getParent(), base, useModuleName);
case DeclContextKind::MacroDecl:
return appendContext(ctx->getParent(), base, useModuleName);
}
llvm_unreachable("bad decl context");
}
void ASTMangler::appendModule(const ModuleDecl *module,
StringRef useModuleName) {
assert(!module->getParent() && "cannot mangle nested modules!");
ASSERT(!getABIDecl(module));
// Use the module real name in mangling; this is the physical name
// of the module on-disk, which can be different if -module-alias is
// used.
//
// For example, if a module Foo has 'import Bar', and '-module-alias Bar=Baz'
// was passed, the name 'Baz' will be used for mangling besides loading.
StringRef ModName = module->getRealName().str();
// If RespectOriginallyDefinedIn is not set, ignore the ABI name only for
// _Concurrency.
if ((RespectOriginallyDefinedIn ||
module->getName().str() != SWIFT_CONCURRENCY_NAME) &&
module->getABIName() != module->getName())
ModName = module->getABIName().str();
// Try the special 'swift' substitution.
if (ModName == STDLIB_NAME) {
if (useModuleName.empty() || useModuleName == STDLIB_NAME) {
appendOperator("s");
} else if (!RespectOriginallyDefinedIn) {
appendOperator("s");
} else {
appendIdentifier(useModuleName);
}
return;
}
if (ModName == MANGLING_MODULE_OBJC) {
assert(useModuleName.empty());
return appendOperator("So");
}
if (ModName == MANGLING_MODULE_CLANG_IMPORTER) {
assert(useModuleName.empty());
return appendOperator("SC");
}
// Disabling RespectOriginallyDefinedIn indicate the mangled names are not part
// of the ABI, probably used by the debugger or IDE (USR). These mangled names
// will not be demangled successfully if we use the original module name instead
// of the actual module name.
if (!useModuleName.empty() && RespectOriginallyDefinedIn)
appendIdentifier(useModuleName);
else
appendIdentifier(ModName);
}
/// Mangle the name of a protocol as a substitution candidate.
void ASTMangler::appendProtocolName(const ProtocolDecl *protocol,
bool allowStandardSubstitution) {
assert(AllowMarkerProtocols || !protocol->isMarkerProtocol());
if (auto abiProtocol = getABIDecl(protocol)) {
return appendProtocolName(abiProtocol, allowStandardSubstitution);
}
if (allowStandardSubstitution && tryAppendStandardSubstitution(protocol))
return;
// We can use a symbolic reference if they're allowed in this context.
if (canSymbolicReference(protocol)) {
// Try to use a symbolic reference substitution.
if (tryMangleSubstitution(protocol))
return;
appendSymbolicReference(protocol);
// Substitutions can refer back to the symbolic reference.
addSubstitution(protocol);
return;
}
BaseEntitySignature base(protocol);
appendContextOf(protocol, base);
auto *clangDecl = protocol->getClangDecl();
auto clangProto = cast_or_null<clang::ObjCProtocolDecl>(clangDecl);
if (clangProto && UseObjCRuntimeNames)
appendIdentifier(clangProto->getObjCRuntimeNameAsString());
else if (clangProto)
appendIdentifier(clangProto->getName());
else
appendDeclName(protocol);
}
bool ASTMangler::isCXXCFOptionsDefinition(const ValueDecl *decl) {
return getTypeDefForCXXCFOptionsDefinition(decl);
}
const clang::TypedefType *
ASTMangler::getTypeDefForCXXCFOptionsDefinition(const ValueDecl *decl) {
const clang::Decl *clangDecl = decl->getClangDecl();
if (!clangDecl)
return nullptr;
const auto &clangModuleLoader = decl->getASTContext().getClangModuleLoader();
return clangModuleLoader->getTypeDefForCXXCFOptionsDefinition(clangDecl);
}
const clang::NamedDecl *
ASTMangler::getClangDeclForMangling(const ValueDecl *vd) {
auto namedDecl = dyn_cast_or_null<clang::NamedDecl>(vd->getClangDecl());
if (!namedDecl)
return nullptr;
// Use an anonymous enum's enclosing typedef for the mangled name, if
// present. This matches C++'s rules for linkage names of tag declarations.
if (namedDecl->getDeclName().isEmpty())
if (auto *tagDecl = dyn_cast<clang::TagDecl>(namedDecl))
if (auto *typedefDecl = tagDecl->getTypedefNameForAnonDecl())
namedDecl = typedefDecl;
if (namedDecl->getDeclName().isEmpty())
return nullptr;
return namedDecl;
}
void ASTMangler::appendSymbolicReference(SymbolicReferent referent) {
if (auto abiReferent = getABIDecl(referent)) {
return appendSymbolicReference(abiReferent.value());
}
// Drop in a placeholder. The real reference value has to be filled in during
// lowering to IR.
auto offset = Buffer.str().size();
Buffer << StringRef("\0\0\0\0\0", 5);
SymbolicReferences.emplace_back(referent, offset);
}
// Canonicalizes a list of inverse requirements for the entity in a few ways:
//
// - Filters out inverse requirements that were eliminated by the entity's
// generic signature because that nested signature introduced a conformance
// requirement.
//
// - Filters out inverse requirements that were already mangled into the context
//
// - Sorts the inverse requirements in a canonical way.
static void reconcileInverses(
SmallVector<InverseRequirement, 2> &inverses,
GenericSignature sig,
std::optional<unsigned> inversesAlreadyMangledDepth,
std::optional<unsigned> suppressedInnermostDepth) {
CanGenericSignature baseSig;
if (sig)
baseSig = sig.getCanonicalSignature();
if (baseSig || inversesAlreadyMangledDepth || suppressedInnermostDepth)
llvm::erase_if(inverses, [&](InverseRequirement const& inv) -> bool {
// Drop inverses that aren't applicable in the nested / child signature,
// because of an added requirement.
if (baseSig && baseSig->requiresProtocol(inv.subject, inv.protocol))
return true;
auto gp = inv.subject->castTo<GenericTypeParamType>();
// Remove inverses that were either already mangled for this entity,
// or chosen not to be included in the output.
if (auto limit = inversesAlreadyMangledDepth)
if (gp->getDepth() <= limit)
return true;
if (suppressedInnermostDepth &&
gp->getDepth() == *suppressedInnermostDepth)
return true;
return false;
});
// Sort inverse requirements for stability.
llvm::array_pod_sort(
inverses.begin(), inverses.end(),
[](const InverseRequirement *lhs, const InverseRequirement *rhs) -> int {
return lhs->compare(*rhs);
});
}
// If we're mangling an entity in a `nominal-type` context and it has inverse
// requirements, then after appending the `nominal-type` context, we follow it
// with the mangling of a constrained extension. For example, if we've appended
// a context consisting of just a nominal-type:
//
// context ::= entity
// entity ::= nominal-type
//
// Then this function `appendContextualInverses` will tack-on extension mangling
// with a generic signature containing the inverses for that nominal-type's
// generic parameters:
//
// context ::= entity module generic-signature? 'E'
//
// If there are no inverses, then we do not append extension mangling.
//
// The end goal is that we mangle members of a nominal type, where the nominal
// has inverse requirements in its signature, as though the members are in an
// extension with a generic signature with those inverse requirements:
//
// struct X<Y: ~Copyable> {
// func foo<Z: ~Copyable>() {} // has the same mangling as the `foo` below
// }
//
// extension X where Y: ~Copyable {
// func foo<Z: ~Copyable>() {}
// }
//
// Thus, this function appends the remaining piece to an existing context to
// make it look as if the context is an extension:
//
// context ::= context* nominal-type module generic-signature? 'E'
// ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// this piece will be appended
//
// Only the inverse requirements from the given signature will be included!
void ASTMangler::appendContextualInverses(const GenericTypeDecl *contextDecl,
BaseEntitySignature &base,
const ModuleDecl *module,
StringRef alternateModuleName) {
// If we are nested within a real extension, don't append inverses.
if (base.reachedExtension())
return;
// Only append for contexts non-protocol nominals that support extensions.
if (!isa<ClassDecl, EnumDecl, StructDecl>(contextDecl))
return;
GenericSignature sig = contextDecl->getGenericSignature();
GenericSignatureParts parts;
gatherGenericSignatureParts(contextDecl->getGenericSignature(),
/*contextSig=*/nullptr,
base,
parts);
if (parts.inverses.empty())
return;
// Ignore normal requirements.
parts.requirements.clear();
// Pretend we're an extension, and `sig` is the nominal type decl's signature
// that we're extending.
// There are no generic parameters in this extension itself.
parts.params = std::nullopt;
// The depth of parameters for this extension is +1 of the extended signature.
parts.initialParamDepth = sig.getNextDepth();
appendModule(module, alternateModuleName);
appendGenericSignatureParts(sig, parts);
return appendOperator("E");
}
void ASTMangler::appendExtension(const ExtensionDecl* ext,
BaseEntitySignature &base,
StringRef useModuleName) {
if (auto abiExt = getABIDecl(ext)) {
return appendExtension(abiExt, base, useModuleName);
}
auto decl = ext->getExtendedNominal();
// Recover from erroneous extension.
if (!decl)
return appendContext(ext->getDeclContext(), base, useModuleName);
auto nominalSig = ext->getSelfNominalTypeDecl()
->getGenericSignatureOfContext();
auto sig = ext->getGenericSignature();
base.setReachedExtension();
// Determine what parts of this extension's generic signature actually needs
// to be mangled
GenericSignatureParts sigParts;
gatherGenericSignatureParts(sig, nominalSig, base, sigParts);
// Mangle the extension unless:
// 1. the extension is defined in the same module as the original
// nominal type decl, and
// 2. the extension is unconstrained, and
// 3. the extension is not for a protocol.
// FIXME: In a world where protocol extensions are dynamically dispatched,
// "extension is to a protocol" would no longer be a reason to use the
// extension mangling, because an extension method implementation could be
// resiliently moved into the original protocol itself.
if (ext->isInSameDefiningModule() // case 1
&& !sigParts.hasRequirements() // case 2
&& !ext->getDeclaredInterfaceType()->isExistentialType()) { // case 3
// skip extension mangling
return appendAnyGenericType(decl);
}
// Perform extension mangling
appendAnyGenericType(decl);
appendModule(ext->getParentModule(), useModuleName);
// If the extension is constrained, mangle the generic signature that
// constrains it.
if (!sigParts.isNull()) {
Mod = ext->getModuleContext();
appendGenericSignatureParts(sig, sigParts);
}
return appendOperator("E");
}
void ASTMangler::appendAnyGenericType(const GenericTypeDecl *decl) {
BaseEntitySignature base(decl);
appendAnyGenericType(decl, base);
}
void ASTMangler::appendAnyGenericType(const GenericTypeDecl *decl,
BaseEntitySignature &base) {
if (auto abiDecl = getABIDecl(decl)) {
return appendAnyGenericType(abiDecl);
}
auto *nominal = dyn_cast<NominalTypeDecl>(decl);
if (nominal && isa<BuiltinTupleDecl>(nominal))
return appendOperator("BT");
// Check for certain standard types.
if (tryAppendStandardSubstitution(decl))
return;
// Mangle opaque type names.
if (auto opaque = dyn_cast<OpaqueTypeDecl>(decl)) {
appendOpaqueDeclName(opaque);
return;
}
// For generic types, this uses the unbound type.
if (nominal) {
if (tryMangleTypeSubstitution(nominal->getDeclaredType(), nullptr))
return;
} else {
if (tryMangleSubstitution(cast<TypeAliasDecl>(decl)))
return;
}
// Try to mangle a symbolic reference for a nominal type.
if (nominal && canSymbolicReference(nominal)) {
appendSymbolicReference(nominal);
// Substitutions can refer back to the symbolic reference.
addTypeSubstitution(nominal->getDeclaredType(), nullptr);
return;
}
appendContextOf(decl, base);
// Always use Clang names for imported Clang declarations, unless they don't
// have one.
auto tryAppendClangName = [this, decl]() -> bool {
auto *nominal = dyn_cast<NominalTypeDecl>(decl);
auto namedDecl = getClangDeclForMangling(decl);
if (!namedDecl) {
if (auto typedefType = getTypeDefForCXXCFOptionsDefinition(decl)) {
// To make sure the C++ definition of CF_OPTIONS mangles the
// same way as the Objective-C definition, we mangle using the
// name of the backing typedef, but pretend as if it was an enum.
// See CFAvailability.h to understand how the definitions differ
// in C++ and Objective-C
appendIdentifier(typedefType->getDecl()->getName());
appendOperator("V");
return true;
}
return false;
}
// Mangle ObjC classes using their runtime names.
auto interface = dyn_cast<clang::ObjCInterfaceDecl>(namedDecl);
auto protocol = dyn_cast<clang::ObjCProtocolDecl>(namedDecl);
if (UseObjCRuntimeNames && interface) {
appendIdentifier(interface->getObjCRuntimeNameAsString());
} else if (UseObjCRuntimeNames && protocol) {
appendIdentifier(protocol->getObjCRuntimeNameAsString());
} else if (isa<clang::ClassTemplateSpecializationDecl>(namedDecl)) {
// If this is a `ClassTemplateSpecializationDecl`, it was
// imported as a Swift decl with `__CxxTemplateInst...` name.
// `ClassTemplateSpecializationDecl`'s name does not include information about
// template arguments, and in order to prevent name clashes we use the
// name of the Swift decl which does include template arguments.
appendIdentifier(nominal->getName().str(),
/*allowRawIdentifiers=*/false);
} else {
appendIdentifier(namedDecl->getName());
}
// The important distinctions to maintain here are Objective-C's various
// namespaces: protocols, tags (struct/enum/union), and unqualified names.
// We continue to mangle "class" the standard Swift way because it feels
// weird to call that an alias, but they're really in the same namespace.
if (interface) {
appendOperator("C");
} else if (protocol) {
appendOperator("P");
} else if (isa<clang::TagDecl>(namedDecl)) {
// Note: This includes enums, but that's okay. A Clang enum is not always
// imported as a Swift enum.
appendOperator("V");
} else if (isa<clang::TypedefNameDecl>(namedDecl) ||
isa<clang::ObjCCompatibleAliasDecl>(namedDecl)) {
appendOperator("a");
} else if (isa<clang::NamespaceDecl>(namedDecl)) {
// Note: Namespaces are not really enums, but since namespaces are
// imported as enums, be consistent.
appendOperator("O");
} else if (isa<clang::ClassTemplateDecl>(namedDecl)) {
appendIdentifier(nominal->getName().str(),
/*allowRawIdentifiers=*/false);
} else {
llvm_unreachable("unknown imported Clang type");
}
return true;
};
if (!tryAppendClangName()) {
appendDeclName(decl);
switch (decl->getKind()) {
default:
llvm_unreachable("not a nominal type");
case DeclKind::TypeAlias:
appendOperator("a");
break;
case DeclKind::Protocol:
assert(AllowMarkerProtocols ||
!cast<ProtocolDecl>(decl)->isMarkerProtocol());
appendOperator("P");
break;
case DeclKind::Class:
appendOperator("C");
break;
case DeclKind::Enum:
appendOperator("O");
break;
case DeclKind::Struct:
appendOperator("V");
break;
case DeclKind::BuiltinTuple:
llvm_unreachable("Not implemented");
}
}
if (nominal)
addTypeSubstitution(nominal->getDeclaredType(), nullptr);
else
addSubstitution(cast<TypeAliasDecl>(decl));
}
void ASTMangler::appendFunction(AnyFunctionType *fn, GenericSignature sig,
FunctionManglingKind functionMangling,
const ValueDecl *forDecl, bool isRecursedInto) {
// Append parameter labels right before the signature/type.
auto parameters = fn->getParams();
auto firstLabel = std::find_if(
parameters.begin(), parameters.end(),
[&](AnyFunctionType::Param param) { return param.hasLabel(); });
if (firstLabel != parameters.end()) {
for (auto param : parameters) {
auto label = param.getLabel();
if (!label.empty())
appendIdentifier(label.str());
else
appendOperator("_");
}
} else if (!parameters.empty()) {
appendOperator("y");
}
if (functionMangling != NoFunctionMangling) {
appendFunctionSignature(fn, sig, forDecl, functionMangling, isRecursedInto);
} else {
appendFunctionType(fn, sig, /*autoclosure*/ false, forDecl, isRecursedInto);
}
}
void ASTMangler::appendFunctionType(AnyFunctionType *fn, GenericSignature sig,
bool isAutoClosure,
const ValueDecl *forDecl,
bool isRecursedInto) {
assert((DWARFMangling || fn->isCanonical()) &&
"expecting canonical types when not mangling for the debugger");
appendFunctionSignature(fn, sig, forDecl, NoFunctionMangling, isRecursedInto);
bool mangleClangType =
Context.LangOpts.UseClangFunctionTypes && fn->hasNonDerivableClangType();
// Note that we do not currently use thin representations in the AST
// for the types of function decls. This may need to change at some
// point, in which case the uncurry logic can probably migrate to that
// case.
//
// It would have been cleverer if we'd used 'f' for thin functions
// and something else for uncurried functions, but oh well.
//
// Or maybe we can change the mangling at the same time we make
// changes to better support thin functions.
switch (fn->getRepresentation()) {
case AnyFunctionType::Representation::Block:
if (mangleClangType) {
appendOperator("XzB");
return appendClangType(fn);
}
// We distinguish escaping and non-escaping blocks, but only in the DWARF
// mangling, because the ABI is already set.
if (!fn->isNoEscape() && DWARFMangling)
return appendOperator("XL");
return appendOperator("XB");
case AnyFunctionType::Representation::Thin:
return appendOperator("Xf");
case AnyFunctionType::Representation::Swift:
if (isAutoClosure) {
if (fn->isNoEscape())
return appendOperator("XK");
else
return appendOperator("XA");
} else if (fn->isNoEscape()) {
return appendOperator("XE");
}
return appendOperator("c");
case AnyFunctionType::Representation::CFunctionPointer:
if (mangleClangType) {
appendOperator("XzC");
return appendClangType(fn);
}
return appendOperator("XC");
}
}
template <typename FnType>
void ASTMangler::appendClangType(FnType *fn, llvm::raw_svector_ostream &out) {
auto clangType = fn->getClangTypeInfo().getType();
SmallString<64> scratch;
llvm::raw_svector_ostream scratchOS(scratch);
clang::ASTContext &clangCtx =
Context.getClangModuleLoader()->getClangASTContext();
std::unique_ptr<clang::ItaniumMangleContext> mangler{
clang::ItaniumMangleContext::create(clangCtx, clangCtx.getDiagnostics())};
mangler->mangleCanonicalTypeName(clang::QualType(clangType, 0), scratchOS);
out << scratchOS.str().size() << scratchOS.str();
}
void ASTMangler::appendClangType(AnyFunctionType *fn) {
appendClangType(fn, Buffer);
}
void ASTMangler::appendFunctionSignature(AnyFunctionType *fn,
GenericSignature sig,
const ValueDecl *forDecl,
FunctionManglingKind functionMangling,
bool isRecursedInto) {
appendFunctionResultType(fn->getResult(), sig,
forDecl ? fn->getLifetimeDependenceForResult(forDecl)
: std::nullopt,
forDecl);
appendFunctionInputType(fn, fn->getParams(), sig, forDecl, isRecursedInto);
if (fn->isAsync())
appendOperator("Ya");
if (fn->isSendable())
appendOperator("Yb");
if (auto thrownError = fn->getEffectiveThrownErrorType()) {
if ((*thrownError)->isEqual(Context.getErrorExistentialType())
|| !AllowTypedThrows) {
appendOperator("K");
} else {
appendType(*thrownError, sig);
appendOperator("YK");
}
}
switch (fn->getDifferentiabilityKind()) {
case DifferentiabilityKind::NonDifferentiable:
break;
case DifferentiabilityKind::Forward:
appendOperator("Yjf");
break;
case DifferentiabilityKind::Reverse:
appendOperator("Yjr");
break;
case DifferentiabilityKind::Normal:
appendOperator("Yjd");
break;
case DifferentiabilityKind::Linear:
appendOperator("Yjl");
break;
}
auto isolation = fn->getIsolation();
switch (isolation.getKind()) {
case FunctionTypeIsolation::Kind::NonIsolated:
break;
case FunctionTypeIsolation::Kind::Parameter:
// Parameter isolation is already mangled in the parameters.
break;
case FunctionTypeIsolation::Kind::GlobalActor:
appendType(isolation.getGlobalActorType(), sig);
appendOperator("Yc");
break;
case FunctionTypeIsolation::Kind::Erased:
if (AllowIsolatedAny)
appendOperator("YA");
break;
case FunctionTypeIsolation::Kind::NonIsolatedCaller:
appendOperator("YC");
break;
}
if (isRecursedInto && fn->hasSendingResult()) {
appendOperator("YT");
}
}
ParamSpecifier swift::getDefaultParamSpecifier(const ValueDecl *forDecl) {
// `consuming` is the default ownership for initializers and setters.
// Everything else defaults to borrowing.
if (!forDecl) {
return ParamSpecifier::Borrowing;
}
auto forFuncDecl = dyn_cast<AbstractFunctionDecl>(forDecl);
if (!forFuncDecl) {
return ParamSpecifier::Borrowing;
}
if (isa<ConstructorDecl>(forFuncDecl)) {
return ParamSpecifier::Consuming;
} else if (auto accessor = dyn_cast<AccessorDecl>(forFuncDecl)) {
switch (accessor->getAccessorKind()) {
case AccessorKind::Modify:
case AccessorKind::Set:
return ParamSpecifier::Consuming;
default:
return ParamSpecifier::Borrowing;
}
}
return ParamSpecifier::Borrowing;
}
static ParameterTypeFlags
getParameterFlagsForMangling(ParameterTypeFlags flags,
ParamSpecifier defaultSpecifier,
bool isInRecursion = true) {
bool initiallySending = flags.isSending();
// If we have been recursed into, then remove sending from our flags.
if (!isInRecursion) {
flags = flags.withSending(false);
}
switch (auto specifier = flags.getOwnershipSpecifier()) {
// If no parameter specifier was provided, mangle as-is, because we are by
// definition using the default convention.
case ParamSpecifier::Default:
// If the legacy `__shared` or `__owned` modifier was provided, mangle as-is,
// because we need to maintain compatibility with their existing behavior.
case ParamSpecifier::LegacyOwned:
// `inout` should already be specified in the flags.
case ParamSpecifier::InOut:
return flags;
case ParamSpecifier::ImplicitlyCopyableConsuming:
case ParamSpecifier::Consuming:
case ParamSpecifier::Borrowing:
// Only mangle the ownership if it diverges from the default.
if (specifier == defaultSpecifier) {
flags = flags.withOwnershipSpecifier(ParamSpecifier::Default);
}
return flags;
case ParamSpecifier::LegacyShared:
// If we were originally sending and by default we are borrowing, suppress
// this and set ownership specifier to default so we do not mangle in
// __shared.
//
// This is a work around in the short term since shared borrow is not
// supported.
if (initiallySending && ParamSpecifier::Borrowing == defaultSpecifier)
return flags.withOwnershipSpecifier(ParamSpecifier::Default);
return flags;
}
}
void ASTMangler::appendFunctionInputType(
AnyFunctionType *fnType, ArrayRef<AnyFunctionType::Param> params,
GenericSignature sig, const ValueDecl *forDecl, bool isRecursedInto) {
auto defaultSpecifier = getDefaultParamSpecifier(forDecl);
switch (params.size()) {
case 0:
appendOperator("y");
break;
case 1: {
const auto &param = params.front();
auto type = param.getPlainType();
// If the sole unlabeled parameter has a non-tuple type, encode
// the parameter list as a single type.
if (!param.hasLabel() && !param.isVariadic() &&
!isa<TupleType>(type.getPointer())) {
// Note that we pass `nullptr` as the `forDecl` argument, since the type
// of the input is no longer directly the type of the declaration, so we
// don't want it to pick up contextual behavior, such as default ownership,
// from the top-level declaration type.
appendParameterTypeListElement(
Identifier(), type,
getParameterFlagsForMangling(param.getParameterFlags(),
defaultSpecifier, isRecursedInto),
getLifetimeDependenceFor(fnType->getLifetimeDependencies(), 0), sig,
nullptr);
break;
}
// If this is a tuple type with a single labeled element
// let's handle it as a general case.
LLVM_FALLTHROUGH;
}
default:
bool isFirstParam = true;
unsigned paramIndex = 0;
for (auto &param : params) {
// Note that we pass `nullptr` as the `forDecl` argument, since the type
// of the input is no longer directly the type of the declaration, so we
// don't want it to pick up contextual behavior, such as default ownership,
// from the top-level declaration type.
appendParameterTypeListElement(
Identifier(), param.getPlainType(),
getParameterFlagsForMangling(param.getParameterFlags(),
defaultSpecifier, isRecursedInto),
getLifetimeDependenceFor(fnType->getLifetimeDependencies(),
paramIndex),
sig, nullptr);
appendListSeparator(isFirstParam);
paramIndex++;
}
appendOperator("t");
break;
}
}
void ASTMangler::appendFunctionResultType(
Type resultType, GenericSignature sig,
std::optional<LifetimeDependenceInfo> lifetimeDependence,
const ValueDecl *forDecl) {
if (resultType->isVoid()) {
appendOperator("y");
} else {
appendType(resultType, sig, forDecl);
}
}
void ASTMangler::appendTypeList(Type listTy, GenericSignature sig,
const ValueDecl *forDecl) {
if (TupleType *tuple = listTy->getAs<TupleType>()) {
if (tuple->getNumElements() == 0)
return appendOperator("y");
bool firstField = true;
for (auto &field : tuple->getElements()) {
appendTupleTypeListElement(field.getName(), field.getType(), sig,
forDecl);
appendListSeparator(firstField);
}
} else {
appendType(listTy, sig, forDecl);
appendListSeparator();
}
}
void ASTMangler::appendParameterTypeListElement(
Identifier name, Type elementType, ParameterTypeFlags flags,
std::optional<LifetimeDependenceInfo> lifetimeDependence,
GenericSignature sig, const ValueDecl *forDecl) {
if (auto *fnType = elementType->getAs<FunctionType>())
appendFunctionType(fnType, sig, flags.isAutoClosure(), forDecl);
else
appendType(elementType, sig, forDecl);
if (flags.isNoDerivative()) {
appendOperator("Yk");
}
switch (flags.getValueOwnership()) {
case ValueOwnership::Default:
/* nothing */
break;
case ValueOwnership::InOut:
appendOperator("z");
break;
case ValueOwnership::Shared:
appendOperator("h");
break;
case ValueOwnership::Owned:
appendOperator("n");
break;
}
if (flags.isIsolated())
appendOperator("Yi");
if (flags.isSending())
appendOperator("Yu");
if (flags.isCompileTimeLiteral())
appendOperator("Yt");
if (flags.isConstValue())
appendOperator("Yg");
if (!name.empty())
appendIdentifier(name.str());
if (flags.isVariadic())
appendOperator("d");
}
void ASTMangler::appendTupleTypeListElement(Identifier name, Type elementType,
GenericSignature sig,
const ValueDecl *forDecl) {
if (auto *fnType = elementType->getAs<FunctionType>())
appendFunctionType(fnType, sig, /*isAutoClosure*/ false, forDecl);
else
appendType(elementType, sig, forDecl);
if (!name.empty())
appendIdentifier(name.str());
}
bool ASTMangler::GenericSignatureParts::isNull() const {
return params.empty() && !hasRequirements();
}
bool ASTMangler::GenericSignatureParts::hasRequirements() const {
return !requirements.empty() || !inverses.empty();
}
void ASTMangler::GenericSignatureParts::clear() {
params = std::nullopt;
requirements.clear();
inverses.clear();
initialParamDepth = 0;
}
bool ASTMangler::appendGenericSignature(GenericSignature sig) {
BaseEntitySignature nullBase(nullptr);
return appendGenericSignature(sig, /*contextSig=*/nullptr, nullBase);
}
bool ASTMangler::appendGenericSignature(GenericSignature sig,
GenericSignature contextSig,
BaseEntitySignature &base) {
GenericSignatureParts parts;
gatherGenericSignatureParts(sig, contextSig, base, parts);
if (parts.isNull())
return false;
appendGenericSignatureParts(sig, parts);
return true;
}
template<typename T>
bool same(ArrayRef<T> as, ArrayRef<T> bs) {
if (as.size() != bs.size())
return false;
for (size_t i = 0; i < as.size(); ++i) {
if (as[i] != bs[i])
return false;
}
return true;
}
void ASTMangler::gatherGenericSignatureParts(GenericSignature sig,
GenericSignature contextSig,
BaseEntitySignature &base,
GenericSignatureParts &parts) {
assert(parts.isNull());
// No signature, parts.
if (!sig)
return;
auto canSig = sig.getCanonicalSignature();
// Separate requirements and inverses.
auto &reqs = parts.requirements;
auto &inverseReqs = parts.inverses;
canSig->getRequirementsWithInverses(reqs, inverseReqs);
// Process inverses relative to the base entity's signature.
if (AllowInverses) {
// Simplify and canonicalize inverses.
reconcileInverses(inverseReqs, base.getSignature(), base.getDepth(),
base.getSuppressedInnermostInversesDepth());
} else {
inverseReqs.clear();
}
base.setDepth(canSig->getMaxDepth());
unsigned &initialParamDepth = parts.initialParamDepth;
auto &genericParams = parts.params;
if (!contextSig) {
// Use the complete canonical signature.
initialParamDepth = 0;
genericParams = canSig.getGenericParams();
return;
}
auto canContextSig = contextSig.getCanonicalSignature();
SmallVector<Requirement, 2> contextReqs;
{
SmallVector<InverseRequirement, 2> __ignored;
canContextSig->getRequirementsWithInverses(contextReqs, __ignored);
}
// The signature depth starts above the depth of the context signature.
if (!contextSig.getGenericParams().empty()) {
initialParamDepth = contextSig.getNextDepth();
}
// If both signatures have exactly the same requirements, ignoring
// conformances for invertible protocols, and the same generic parameters,
// and there's no inverses to mangle, then there's nothing to do.
if (inverseReqs.empty()
&& same(canContextSig.getGenericParams(), canSig.getGenericParams())
&& same(llvm::ArrayRef(contextReqs), llvm::ArrayRef(reqs))) {
parts.clear();
return;
}
// Find the parameters at this depth (or greater).
genericParams = canSig.getGenericParams();
unsigned firstParam = genericParams.size();
while (firstParam > 1 &&
genericParams[firstParam-1]->getDepth() >= initialParamDepth)
--firstParam;
genericParams = genericParams.slice(firstParam);
// Special case: if we would be mangling zero generic parameters, but
// the context signature is a single, unconstrained generic parameter,
// it's better to mangle the complete canonical signature because we
// have a special-case mangling for that.
if (genericParams.empty() &&
contextSig.getGenericParams().size() == 1 &&
contextReqs.empty() &&
inverseReqs.empty()) {
initialParamDepth = 0;
genericParams = canSig.getGenericParams();
} else {
llvm::erase_if(reqs, [&](Requirement req) {
// We set brokenPackBehavior to true here to maintain compatibility with
// the mangling produced by an old compiler. We could incorrectly return
// false from isRequirementSatisfied() here even if the requirement was
// satisfied, and then it would show up as a conditional requirement
// even though it was already part of the nominal type's generic signature.
return contextSig->isRequirementSatisfied(req,
/*allowMissing=*/false,
/*brokenPackBehavior=*/true);
});
}
}
ASTMangler::RequirementSubject ASTMangler::appendRequirementSubject(
CanType subjectType, GenericSignature sig) {
// Handle dependent types.
if (auto *depTy = subjectType->getAs<DependentMemberType>()) {
if (tryMangleTypeSubstitution(depTy, sig)) {
return RequirementSubject {RequirementSubject::Substitution};
}
bool isAssocTypeAtDepth = false;
GenericTypeParamType *gpBase = appendAssocType(depTy, sig,
isAssocTypeAtDepth);
addTypeSubstitution(depTy, sig);
return RequirementSubject {
isAssocTypeAtDepth ? RequirementSubject::AssociatedTypeAtDepth
: RequirementSubject::AssociatedType,
gpBase
};
}
GenericTypeParamType *gpBase = subjectType->castTo<GenericTypeParamType>();
return RequirementSubject { RequirementSubject::GenericParameter, gpBase };
}
void ASTMangler::appendRequirement(const Requirement &reqt,
GenericSignature sig,
bool lhsBaseIsProtocolSelf) {
CanType FirstTy = reqt.getFirstType()->getCanonicalType();
switch (reqt.getKind()) {
case RequirementKind::Layout:
break;
case RequirementKind::Conformance: {
// If we don't allow marker protocols but we have one here, skip it.
if (!AllowMarkerProtocols &&
reqt.getProtocolDecl()->isMarkerProtocol())
return;
appendProtocolName(reqt.getProtocolDecl());
} break;
case RequirementKind::Superclass:
case RequirementKind::SameType:
case RequirementKind::SameShape: {
Type SecondTy = reqt.getSecondType();
appendType(SecondTy->getCanonicalType(), sig);
break;
}
}
auto subject = appendRequirementSubject(FirstTy, sig);
switch (subject.kind) {
case RequirementSubject::GenericParameter:
switch (reqt.getKind()) {
case RequirementKind::Conformance:
return appendOpWithGenericParamIndex("R", subject.gpBase);
case RequirementKind::Layout:
appendOpWithGenericParamIndex("Rl", subject.gpBase);
appendOpParamForLayoutConstraint(reqt.getLayoutConstraint());
return;
case RequirementKind::Superclass:
return appendOpWithGenericParamIndex("Rb", subject.gpBase);
case RequirementKind::SameType:
return appendOpWithGenericParamIndex("Rs", subject.gpBase);
case RequirementKind::SameShape:
return appendOpWithGenericParamIndex("Rh", subject.gpBase);
}
break;
case RequirementSubject::Substitution:
switch (reqt.getKind()) {
case RequirementKind::SameShape:
llvm_unreachable("Same-shape requirement with dependent member type?");
case RequirementKind::Conformance:
return appendOperator("RQ");
case RequirementKind::Layout:
appendOperator("RL");
appendOpParamForLayoutConstraint(reqt.getLayoutConstraint());
return;
case RequirementKind::Superclass:
return appendOperator("RB");
case RequirementKind::SameType:
return appendOperator("RS");
}
break;
case RequirementSubject::AssociatedType:
case RequirementSubject::AssociatedTypeAtDepth:
bool isAssocTypeAtDepth =
subject.kind == RequirementSubject::AssociatedTypeAtDepth;
auto gpBase = subject.gpBase;
switch (reqt.getKind()) {
case RequirementKind::SameShape:
llvm_unreachable("Same-shape requirement with a dependent member type?");
case RequirementKind::Conformance:
return appendOpWithGenericParamIndex(isAssocTypeAtDepth ? "RP" : "Rp",
gpBase, lhsBaseIsProtocolSelf);
case RequirementKind::Layout:
appendOpWithGenericParamIndex(isAssocTypeAtDepth ? "RM" : "Rm", gpBase,
lhsBaseIsProtocolSelf);
appendOpParamForLayoutConstraint(reqt.getLayoutConstraint());
return;
case RequirementKind::Superclass:
return appendOpWithGenericParamIndex(isAssocTypeAtDepth ? "RC" : "Rc",
gpBase, lhsBaseIsProtocolSelf);
case RequirementKind::SameType:
return appendOpWithGenericParamIndex(isAssocTypeAtDepth ? "RT" : "Rt",
gpBase, lhsBaseIsProtocolSelf);
}
break;
}
}
void ASTMangler::appendInverseRequirement(const InverseRequirement &req,
GenericSignature sig,
bool lhsBaseIsProtocolSelf) {
unsigned bit = static_cast<uint8_t>(req.getKind());
auto firstType = req.subject->getCanonicalType();
auto subject = appendRequirementSubject(firstType, sig);
switch (subject.kind) {
case RequirementSubject::GenericParameter:
appendOperator("Ri", Index(bit));
return appendOpWithGenericParamIndex("", subject.gpBase,
lhsBaseIsProtocolSelf);
case RequirementSubject::Substitution:
return appendOperator("RI", Index(bit));
case RequirementSubject::AssociatedType:
appendOperator("Rj", Index(bit));
return appendOpWithGenericParamIndex("", subject.gpBase,
lhsBaseIsProtocolSelf);
case RequirementSubject::AssociatedTypeAtDepth:
appendOperator("RJ", Index(bit));
return appendOpWithGenericParamIndex("", subject.gpBase,
lhsBaseIsProtocolSelf);
}
}
void ASTMangler::appendGenericSignatureParts(
GenericSignature sig,
GenericSignatureParts const& parts) {
assert(!parts.isNull());
ArrayRef<CanGenericTypeParamType> params = parts.params;
unsigned initialParamDepth = parts.initialParamDepth;
ArrayRef<Requirement> requirements = parts.requirements;
ArrayRef<InverseRequirement> inverseRequirements = parts.inverses;
// Mangle the kind for each generic parameter.
for (auto param : params) {
// Regular type parameters have no marker.
if (param->isParameterPack())
appendOpWithGenericParamIndex("Rv", param);
if (param->isValue()) {
appendType(param->getValueType(), sig);
appendOpWithGenericParamIndex("RV", param);
}
}
// Mangle the requirements.
for (const Requirement &reqt : requirements) {
appendRequirement(reqt, sig);
}
// Mangle the inverse requirements.
for (auto inverseReq : inverseRequirements) {
appendInverseRequirement(inverseReq, sig);
}
if (params.size() == 1 && params[0]->getDepth() == initialParamDepth)
return appendOperator("l");
llvm::SmallVector<char, 16> OpStorage;
llvm::raw_svector_ostream OpBuffer(OpStorage);
// Mangle the number of parameters.
unsigned depth = 0;
unsigned count = 0;
// Since it's unlikely (but not impossible) to have zero generic parameters
// at a depth, encode indexes starting from 1, and use a special mangling
// for zero.
auto mangleGenericParamCount = [&](unsigned depth, unsigned count) {
if (depth < initialParamDepth)
return;
if (count == 0)
OpBuffer << 'z';
else
OpBuffer << Index(count - 1);
};
// As a special case, mangle nothing if there's a single generic parameter
// at the initial depth.
for (auto param : params) {
if (param->getDepth() != depth) {
assert(param->getDepth() > depth && "generic params not ordered");
while (depth < param->getDepth()) {
mangleGenericParamCount(depth, count);
++depth;
count = 0;
}
}
assert(param->getIndex() == count && "generic params not ordered");
++count;
}
mangleGenericParamCount(depth, count);
OpBuffer << 'l';
appendOperator("r", StringRef(OpStorage.data(), OpStorage.size()));
}
/// Determine whether an associated type reference into the given set of
/// protocols is unambiguous.
static bool associatedTypeRefIsUnambiguous(GenericSignature sig, Type t) {
// FIXME: This should be an assertion.
if (!sig->isValidTypeParameter(t))
return false;
unsigned numProtocols = 0;
for (auto proto : sig->getRequiredProtocols(t)) {
// Skip marker protocols, which cannot have associated types.
if (proto->isMarkerProtocol())
continue;
++numProtocols;
}
return numProtocols <= 1;
}
// If the base type is known to have a single protocol conformance
// in the current generic context, then we don't need to disambiguate the
// associated type name by protocol.
DependentMemberType *
ASTMangler::dropProtocolFromAssociatedType(DependentMemberType *dmt,
GenericSignature sig) {
auto baseTy = dmt->getBase();
bool unambiguous =
(!dmt->getAssocType() ||
associatedTypeRefIsUnambiguous(sig, baseTy));
if (auto *baseDMT = baseTy->getAs<DependentMemberType>())
baseTy = dropProtocolFromAssociatedType(baseDMT, sig);
if (unambiguous)
return DependentMemberType::get(baseTy, dmt->getName());
return DependentMemberType::get(baseTy, dmt->getAssocType());
}
Type
ASTMangler::dropProtocolsFromAssociatedTypes(Type type,
GenericSignature sig) {
if (!OptimizeProtocolNames || !sig)
return type;
if (!type->hasDependentMember())
return type;
return type.transformRec([&](TypeBase *t) -> std::optional<Type> {
if (auto *dmt = dyn_cast<DependentMemberType>(t))
return dropProtocolFromAssociatedType(dmt, sig);
return std::nullopt;
});
}
void ASTMangler::appendAssociatedTypeName(DependentMemberType *dmt,
GenericSignature sig) {
if (auto assocTy = dmt->getAssocType()) {
if (auto abiAssocTy = getABIDecl(assocTy)) {
assocTy = abiAssocTy;
}
appendIdentifier(assocTy->getName().str());
// If the base type is known to have a single protocol conformance
// in the current generic context, then we don't need to disambiguate the
// associated type name by protocol.
if (!OptimizeProtocolNames || !sig ||
!associatedTypeRefIsUnambiguous(
sig, dmt->getBase())) {
BaseEntitySignature base(assocTy);
appendAnyGenericType(assocTy->getProtocol(), base);
}
return;
}
appendIdentifier(dmt->getName().str());
}
void ASTMangler::appendClosureEntity(
const SerializedAbstractClosureExpr *closure) {
auto canType = closure->getType()->getCanonicalType();
assert(!canType->hasLocalArchetype() &&
"Not enough information here to handle this case");
appendClosureComponents(canType,
closure->getDiscriminator(),
closure->isImplicit(), closure->getParent(),
ArrayRef<GenericEnvironment *>());
}
void ASTMangler::appendClosureEntity(const AbstractClosureExpr *closure) {
ArrayRef<GenericEnvironment *> capturedEnvs;
auto type = closure->getType();
// FIXME: We can end up with a null type here in the presence of invalid
// code; the type-checker currently isn't strict about producing typed
// expression nodes when it fails. Once we enforce that, we can remove this.
if (!type)
type = CanType(ErrorType::get(Context));
auto canType = type->getCanonicalType();
if (canType->hasLocalArchetype())
capturedEnvs = closure->getCaptureInfo().getGenericEnvironments();
appendClosureComponents(canType, closure->getDiscriminator(),
isa<AutoClosureExpr>(closure), closure->getParent(),
capturedEnvs);
}
void ASTMangler::appendClosureComponents(CanType Ty, unsigned discriminator,
bool isImplicit,
const DeclContext *parentContext,
ArrayRef<GenericEnvironment *> capturedEnvs) {
assert(discriminator != AbstractClosureExpr::InvalidDiscriminator
&& "closure must be marked correctly with discriminator");
BaseEntitySignature base(parentContext->getInnermostDeclarationDeclContext());
appendContext(parentContext, base, StringRef());
auto Sig = parentContext->getGenericSignatureOfContext();
Ty = mapLocalArchetypesOutOfContext(Ty, Sig, capturedEnvs)
->getCanonicalType();
appendType(Ty, Sig);
appendOperator(isImplicit ? "fu" : "fU", Index(discriminator));
}
void ASTMangler::appendDefaultArgumentEntity(const DeclContext *func,
unsigned index) {
BaseEntitySignature base(func->getInnermostDeclarationDeclContext());
appendContext(func, base, StringRef());
appendOperator("fA", Index(index));
}
void ASTMangler::appendInitializerEntity(const VarDecl *var) {
llvm::SaveAndRestore X(AllowInverses, inversesAllowed(var));
BaseEntitySignature base(var);
appendEntity(var, base, "vp", var->isStatic());
appendOperator("fi");
}
void ASTMangler::appendBackingInitializerEntity(const VarDecl *var) {
llvm::SaveAndRestore X(AllowInverses, inversesAllowed(var));
BaseEntitySignature base(var);
appendEntity(var, base, "vp", var->isStatic());
appendOperator("fP");
}
void ASTMangler::appendInitFromProjectedValueEntity(const VarDecl *var) {
llvm::SaveAndRestore X(AllowInverses, inversesAllowed(var));
BaseEntitySignature base(var);
appendEntity(var, base, "vp", var->isStatic());
appendOperator("fW");
}
/// Is this declaration a method for mangling purposes? If so, we'll leave the
/// Self type out of its mangling.
static bool isMethodDecl(const Decl *decl) {
return isa<AbstractFunctionDecl>(decl)
&& decl->getDeclContext()->isTypeContext();
}
/// Map any local archetypes in a decl's interface type out of context, such
/// that the resulting type is suitable for mangling.
///
/// Note this does not guarantee that different archetypes produce different
/// interface types across decls, but it is guaranteed within a single decl
/// type. This is okay though since local decls are assigned discriminators.
static Type mapLocalArchetypesOutOfContextForDecl(const ValueDecl *decl,
Type ty) {
if (!ty->hasLocalArchetype())
return ty;
ASSERT(decl->getDeclContext()->isLocalContext());
CaptureInfo captureInfo;
auto *innerDC = decl->getInnermostDeclContext();
auto genericSig = innerDC->getGenericSignatureOfContext();
if (auto fn = AnyFunctionRef::fromDeclContext(innerDC))
captureInfo = fn->getCaptureInfo();
// Record any captured generic environments we have.
llvm::SmallSetVector<GenericEnvironment *, 4> capturedEnvs;
for (auto *genericEnv : captureInfo.getGenericEnvironments())
capturedEnvs.insert(genericEnv);
// We may still have archetypes local to the current context, e.g for
// decls in local for loops over pack expansions. In this case, collect
// any remaining generic environments from the type.
ty.visit([&](Type t) {
if (auto *archetypeTy = t->getAs<LocalArchetypeType>()) {
capturedEnvs.insert(archetypeTy->getGenericEnvironment());
}
});
return swift::mapLocalArchetypesOutOfContext(ty, genericSig,
capturedEnvs.getArrayRef());
}
CanType ASTMangler::getDeclTypeForMangling(
const ValueDecl *decl,
GenericSignature &genericSig,
GenericSignature &parentGenericSig) {
if (auto abiDecl = getABIDecl(decl)) {
return getDeclTypeForMangling(abiDecl, genericSig, parentGenericSig);
}
genericSig = GenericSignature();
parentGenericSig = GenericSignature();
auto &C = Context;
auto ty = decl->getInterfaceType()->getReferenceStorageReferent();
if (ty->hasError()) {
if (isa<AbstractFunctionDecl>(decl) || isa<EnumElementDecl>(decl) ||
isa<SubscriptDecl>(decl)) {
// FIXME: Verify ExtInfo state is correct, not working by accident.
CanFunctionType::ExtInfo info;
return CanFunctionType::get({AnyFunctionType::Param(C.TheErrorType)},
C.TheErrorType, info);
}
return C.TheErrorType;
}
// If this declaration predates concurrency, adjust its type to not
// contain type features that were not available pre-concurrency. This
// cannot alter the ABI in any way.
if (decl->preconcurrency()) {
ty = ty->stripConcurrency(/*recurse=*/true, /*dropGlobalActor=*/true);
}
// Map any local archetypes out of context.
ty = mapLocalArchetypesOutOfContextForDecl(decl, ty);
auto canTy = ty->getCanonicalType();
if (auto gft = dyn_cast<GenericFunctionType>(canTy)) {
genericSig = gft.getGenericSignature();
canTy = CanFunctionType::get(gft.getParams(), gft.getResult(),
gft->getExtInfo());
}
if (!canTy->hasError()) {
// Shed the 'self' type and generic requirements from method manglings.
if (isMethodDecl(decl)) {
// Drop the Self argument clause from the type.
canTy = cast<AnyFunctionType>(canTy).getResult();
}
if (isMethodDecl(decl) || isa<SubscriptDecl>(decl))
parentGenericSig = decl->getDeclContext()->getGenericSignatureOfContext();
}
return canTy;
}
void ASTMangler::appendDeclType(const ValueDecl *decl,
BaseEntitySignature &base,
FunctionManglingKind functionMangling) {
Mod = decl->getModuleContext();
GenericSignature genericSig;
GenericSignature parentGenericSig;
auto type = getDeclTypeForMangling(decl, genericSig, parentGenericSig);
auto sig = (genericSig
? genericSig
: decl->getDeclContext()->getGenericSignatureOfContext());
if (AnyFunctionType *FuncTy = type->getAs<AnyFunctionType>()) {
appendFunction(FuncTy, sig, functionMangling, decl,
false /*is recursed into*/);
} else {
appendType(type, sig, decl);
}
// Mangle the generic signature, if any.
if (genericSig
&& appendGenericSignature(genericSig, parentGenericSig, base)) {
// The 'F' function mangling doesn't need a 'u' for its generic signature.
if (functionMangling == NoFunctionMangling)
appendOperator("u");
}
}
bool ASTMangler::tryAppendStandardSubstitution(const GenericTypeDecl *decl) {
// Bail out if our parent isn't the swift standard library.
auto dc = decl->getDeclContext();
if (!dc->isModuleScopeContext() ||
!dc->getParentModule()->hasStandardSubstitutions())
return false;
if (!AllowStandardSubstitutions)
return false;
if (isa<NominalTypeDecl>(decl)) {
if (auto Subst = getStandardTypeSubst(
decl->getName().str(), AllowConcurrencyStandardSubstitutions)) {
if (!SubstMerging.tryMergeSubst(*this, *Subst, /*isStandardSubst*/ true)){
appendOperator("S", *Subst);
}
return true;
}
}
return false;
}
void ASTMangler::appendConstructorEntity(const ConstructorDecl *ctor,
bool isAllocating) {
if (auto abiCtor = getABIDecl(ctor)) {
return appendConstructorEntity(abiCtor, isAllocating);
}
BaseEntitySignature base(ctor);
appendContextOf(ctor, base);
appendDeclType(ctor, base);
StringRef privateDiscriminator = getPrivateDiscriminatorIfNecessary(ctor);
if (!privateDiscriminator.empty()) {
appendIdentifier(privateDiscriminator);
appendOperator("Ll");
}
appendOperator(isAllocating ? "fC" : "fc");
}
void ASTMangler::appendDestructorEntity(const DestructorDecl *dtor,
DestructorKind kind) {
if (auto abiDtor = getABIDecl(dtor)) {
return appendDestructorEntity(abiDtor, kind);
}
BaseEntitySignature base(dtor);
appendContextOf(dtor, base);
switch (kind) {
case DestructorKind::NonDeallocating:
appendOperator("fd");
break;
case DestructorKind::Deallocating:
appendOperator("fD");
break;
case DestructorKind::IsolatedDeallocating:
appendOperator("fZ");
break;
}
}
void ASTMangler::appendAccessorEntity(StringRef accessorKindCode,
const AbstractStorageDecl *decl,
bool isStatic) {
if (auto abiDecl = getABIDecl(decl)) {
return appendAccessorEntity(accessorKindCode, abiDecl, isStatic);
}
BaseEntitySignature base(decl);
appendContextOf(decl, base);
if (isa<VarDecl>(decl)) {
appendDeclName(decl);
appendDeclType(decl, base);
appendOperator("v", accessorKindCode);
} else if (isa<SubscriptDecl>(decl)) {
appendDeclType(decl, base);
StringRef privateDiscriminator = getPrivateDiscriminatorIfNecessary(decl);
if (!privateDiscriminator.empty()) {
appendIdentifier(privateDiscriminator);
appendOperator("Ll");
}
appendOperator("i", accessorKindCode);
} else {
llvm_unreachable("Unknown type of AbstractStorageDecl");
}
if (isStatic)
appendOperator("Z");
}
void ASTMangler::appendEntity(const ValueDecl *decl,
BaseEntitySignature &base,
StringRef EntityOp,
bool isStatic) {
if (auto abiDecl = getABIDecl(decl)) {
return appendEntity(abiDecl, base, EntityOp, isStatic);
}
appendContextOf(decl, base);
appendDeclName(decl);
appendDeclType(decl, base);
appendOperator(EntityOp);
if (isStatic)
appendOperator("Z");
}
void ASTMangler::appendEntity(const ValueDecl *decl) {
assert(!isa<ConstructorDecl>(decl));
assert(!isa<DestructorDecl>(decl));
if (auto abiDecl = getABIDecl(decl)) {
return appendEntity(abiDecl);
}
// Handle accessors specially, they are mangled as modifiers on the accessed
// declaration.
if (auto accessor = dyn_cast<AccessorDecl>(decl)) {
return appendAccessorEntity(
getCodeForAccessorKind(accessor->getAccessorKind()),
accessor->getStorage(), accessor->isStatic());
}
if (auto storageDecl = dyn_cast<AbstractStorageDecl>(decl))
return appendAccessorEntity("p", storageDecl, decl->isStatic());
if (isa<GenericTypeParamDecl>(decl)) {
BaseEntitySignature base(decl);
return appendEntity(decl, base, "fp", decl->isStatic());
}
if (auto macro = dyn_cast<MacroDecl>(decl)) {
BaseEntitySignature base(macro);
return appendEntity(decl, base, "fm", false);
}
if (auto expansion = dyn_cast<MacroExpansionDecl>(decl)) {
appendMacroExpansion(expansion);
return;
}
assert(isa<AbstractFunctionDecl>(decl) || isa<EnumElementDecl>(decl));
BaseEntitySignature base(decl);
appendContextOf(decl, base);
appendDeclName(decl);
appendDeclType(decl, base, FunctionMangling);
appendOperator("F");
if (decl->isStatic())
appendOperator("Z");
}
void
ASTMangler::appendProtocolConformance(const ProtocolConformance *conformance) {
auto topLevelSubcontext =
conformance->getDeclContext()->getModuleScopeContext();
Mod = topLevelSubcontext->getParentModule();
auto conformingType = conformance->getType();
appendType(conformingType->getCanonicalType(), nullptr);
appendProtocolName(conformance->getProtocol());
bool needsModule = true;
if (auto *file = dyn_cast<FileUnit>(topLevelSubcontext)) {
if (file->getKind() == FileUnitKind::ClangModule ||
file->getKind() == FileUnitKind::DWARFModule) {
if (conformance->getProtocol()->hasClangNode())
appendOperator("So");
else
appendOperator("SC");
needsModule = false;
}
}
if (needsModule) {
auto *DC = conformance->getDeclContext();
assert(DC->getAsDecl());
appendModule(Mod, DC->getAsDecl()->getAlternateModuleName());
}
// If this is a non-nominal type, we're done.
if (!conformingType->getAnyNominal())
return;
auto contextSig =
conformingType->getAnyNominal()->getGenericSignatureOfContext();
if (GenericSignature Sig = conformance->getGenericSignature()) {
BaseEntitySignature nullBase(nullptr);
appendGenericSignature(Sig, contextSig, nullBase);
}
}
void ASTMangler::appendProtocolConformanceRef(
const RootProtocolConformance *conformance) {
// FIXME: Symbolic reference to the protocol conformance descriptor.
appendProtocolName(conformance->getProtocol());
// For retroactive conformances, add a reference to the module in which the
// conformance resides. Otherwise, use an operator to indicate which known
// module it's associated with.
if (!conformanceHasIdentity(conformance)) {
// Same as "conformance module matches type", below.
appendOperator("HP");
} else if (isRetroactiveConformance(conformance)) {
auto *DC = conformance->getDeclContext();
assert(DC->getAsDecl());
appendModule(conformance->getDeclContext()->getParentModule(),
DC->getAsDecl()->getAlternateModuleName());
// Builtin conformances are always from the Swift module.
} else if (isa<BuiltinProtocolConformance>(conformance)) {
appendOperator("HP");
} else if (conformance->getDeclContext()->getParentModule() ==
conformance->getType()->getAnyNominal()->getParentModule()) {
appendOperator("HP");
} else {
appendOperator("Hp");
}
}
/// Retrieve the index of the conformance requirement indicated by the
/// conformance path entry within the given set of requirements.
static unsigned conformanceRequirementIndex(
const ConformancePath::Entry &entry,
ArrayRef<Requirement> requirements) {
unsigned result = 0;
for (const auto &req : requirements) {
if (req.getKind() != RequirementKind::Conformance)
continue;
// This is an ABI compatibility hack for noncopyable generics.
// We should have really been skipping marker protocols here all along,
// but it's too late now, so skip Copyable and Escapable specifically.
if (req.getProtocolDecl()->getInvertibleProtocolKind())
continue;
if (req.getFirstType()->isEqual(entry.first) &&
req.getProtocolDecl() == entry.second)
return result;
++result;
}
ABORT("Conformance access path step is missing from requirements");
}
void ASTMangler::appendDependentProtocolConformance(
const ConformancePath &path,
GenericSignature sig) {
ProtocolDecl *currentProtocol = nullptr;
for (const auto &entry : path) {
// After each step, update the current protocol to refer to where we
// are.
SWIFT_DEFER {
currentProtocol = entry.second;
sig = currentProtocol->getGenericSignature();
};
// The first entry is the "root". Find this requirement in the generic
// signature.
if (!currentProtocol) {
appendType(entry.first, sig);
appendProtocolName(entry.second);
auto index =
conformanceRequirementIndex(entry,
sig.getRequirements());
// This is never an unknown index and so must be adjusted by 2 per ABI.
appendOperator("HD", Index(index + 2));
continue;
}
// Conformances are relative to the current protocol's requirement
// signature.
auto reqs = currentProtocol->getRequirementSignature().getRequirements();
auto index = conformanceRequirementIndex(entry, reqs);
// Inherited conformance.
bool isInheritedConformance =
entry.first->isEqual(currentProtocol->getSelfInterfaceType());
if (isInheritedConformance) {
appendProtocolName(entry.second);
// For now, this is never an unknown index and so must be adjusted by 2.
appendOperator("HI", Index(index + 2));
continue;
}
// Associated conformance.
// FIXME: Symbolic reference.
appendType(entry.first, sig);
appendProtocolName(entry.second);
// For resilient protocols, the index is unknown, so we use the special
// value 1; otherwise we adjust by 2.
bool isResilient =
currentProtocol->isResilient(Mod, ResilienceExpansion::Maximal);
appendOperator("HA", Index(isResilient ? 1 : index + 2));
}
}
void ASTMangler::appendAnyProtocolConformance(
GenericSignature genericSig,
CanType conformingType,
ProtocolConformanceRef conformance) {
// If we have a conformance to a marker protocol but we aren't allowed to
// emit marker protocols, skip it.
if (!AllowMarkerProtocols &&
conformance.getProtocol()->isMarkerProtocol())
return;
// While all invertible protocols are marker protocols, do not mangle them
// as a dependent conformance. See `conformanceRequirementIndex` which skips
// these, too. In theory, invertible conformances should never be mangled,
// but we *might* have let that slip by for the other cases below, so the
// early-exits are highly conservative.
const bool forInvertible =
conformance.getProtocol()->getInvertibleProtocolKind().has_value();
if (conformingType->isTypeParameter()) {
assert(genericSig && "Need a generic signature to resolve conformance");
if (forInvertible)
return;
// FIXME: conformingType parameter should no longer be needed, because
// its in conformance.
auto path = genericSig->getConformancePath(conformingType,
conformance.getProtocol());
appendDependentProtocolConformance(path, genericSig);
} else if (auto opaqueType = conformingType->getAs<OpaqueTypeArchetypeType>()) {
if (forInvertible)
return;
GenericSignature opaqueSignature =
opaqueType->getDecl()->getOpaqueInterfaceGenericSignature();
ConformancePath conformancePath =
opaqueSignature->getConformancePath(
opaqueType->getInterfaceType(),
conformance.getProtocol());
// Append the conformance path with the signature of the opaque type.
appendDependentProtocolConformance(conformancePath, opaqueSignature);
appendType(conformingType, genericSig);
appendOperator("HO");
} else if (conformance.isConcrete()) {
appendConcreteProtocolConformance(conformance.getConcrete(), genericSig);
} else if (conformance.isPack()) {
appendPackProtocolConformance(conformance.getPack(), genericSig);
} else {
ABORT([&](auto &out) {
out << "Bad conformance in mangler: ";
conformance.dump(out);
});
}
}
void ASTMangler::appendConcreteProtocolConformance(
const ProtocolConformance *conformance,
GenericSignature sig) {
// Conforming type.
Type conformingType = conformance->getType();
if (conformingType->hasArchetype())
conformingType = conformingType->mapTypeOutOfContext();
appendType(conformingType->getReducedType(sig), sig);
// Protocol conformance reference.
appendProtocolConformanceRef(conformance->getRootConformance());
// Conditional conformance requirements.
bool firstRequirement = true;
forEachConditionalConformance(conformance,
[&](Type substType, ProtocolConformanceRef substConf) -> bool {
if (substType->hasArchetype())
substType = substType->mapTypeOutOfContext();
CanType canType = substType->getReducedType(sig);
appendAnyProtocolConformance(sig, canType, substConf);
appendListSeparator(firstRequirement);
return false;
});
if (firstRequirement)
appendOperator("y");
appendOperator("HC");
}
void ASTMangler::appendPackProtocolConformance(
const PackConformance *conformance,
GenericSignature sig) {
auto conformingType = conformance->getType();
auto patternConformances = conformance->getPatternConformances();
assert(conformingType->getNumElements() == patternConformances.size());
if (conformingType->getNumElements() == 0) {
appendOperator("y");
} else {
bool firstField = true;
for (unsigned i = 0, e = conformingType->getNumElements(); i < e; ++i) {
auto type = conformingType->getElementType(i);
auto conf = patternConformances[i];
if (auto *expansionTy = type->getAs<PackExpansionType>())
type = expansionTy->getPatternType();
appendAnyProtocolConformance(sig, type->getCanonicalType(), conf);
appendListSeparator(firstField);
}
}
appendOperator("HX");
}
void ASTMangler::appendOpParamForLayoutConstraint(LayoutConstraint layout) {
assert(layout);
switch (layout->getKind()) {
case LayoutConstraintKind::UnknownLayout:
appendOperatorParam("U");
break;
case LayoutConstraintKind::RefCountedObject:
appendOperatorParam("R");
break;
case LayoutConstraintKind::NativeRefCountedObject:
appendOperatorParam("N");
break;
case LayoutConstraintKind::Class:
appendOperatorParam("C");
break;
case LayoutConstraintKind::NativeClass:
appendOperatorParam("D");
break;
case LayoutConstraintKind::Trivial:
appendOperatorParam("T");
break;
case LayoutConstraintKind::TrivialOfExactSize:
if (!layout->getAlignmentInBits())
appendOperatorParam("e", Index(layout->getTrivialSizeInBits()));
else
appendOperatorParam("E", Index(layout->getTrivialSizeInBits()),
Index(layout->getAlignmentInBits()));
break;
case LayoutConstraintKind::TrivialOfAtMostSize:
if (!layout->getAlignmentInBits())
appendOperatorParam("m", Index(layout->getTrivialSizeInBits()));
else
appendOperatorParam("M", Index(layout->getTrivialSizeInBits()),
Index(layout->getAlignmentInBits()));
break;
case LayoutConstraintKind::BridgeObject:
appendOperatorParam("B");
break;
case LayoutConstraintKind::TrivialStride:
appendOperatorParam("S", Index(layout->getTrivialSizeInBits()));
break;
}
}
std::string ASTMangler::mangleOpaqueTypeDescriptor(const OpaqueTypeDecl *decl) {
beginMangling();
appendOpaqueDeclName(decl);
appendOperator("MQ");
return finalize();
}
std::string
ASTMangler::mangleOpaqueTypeDescriptorRecord(const OpaqueTypeDecl *decl) {
beginMangling();
appendOpaqueDeclName(decl);
appendOperator("Ho");
return finalize();
}
void ASTMangler::appendDistributedThunk(
const AbstractFunctionDecl *thunk, bool asReference) {
if (auto abiThunk = getABIDecl(thunk)) {
return appendDistributedThunk(abiThunk, asReference);
}
// Marker protocols cannot be checked at runtime, so there is no point
// in recording them for distributed thunks.
llvm::SaveAndRestore<bool> savedAllowMarkerProtocols(AllowMarkerProtocols,
false);
// TODO: add a flag to skip class/struct information from parameter types
BaseEntitySignature base(thunk);
// Since computed property SILDeclRef's refer to the "originator"
// of the thunk, we need to mangle distributed thunks of accessors
// specially.
if (auto *accessor = dyn_cast<AccessorDecl>(thunk)) {
// TODO: This needs to use accessor type instead of
// distributed thunk after all SILDeclRefs are switched
// to use "originator" instead of the thunk itself.
//
// ```
// beginMangling();
// appendContextOf(thunk);
// appendDeclName(accessor->getStorage());
// appendDeclType(accessor, FunctionMangling);
// appendOperator("F");
// appendSymbolKind(SymbolKind::DistributedThunk);
// return finalize();
// ```
auto *storage = accessor->getStorage();
thunk = storage->getDistributedThunk();
assert(thunk);
}
assert(isa<AbstractFunctionDecl>(thunk) &&
"distributed thunk to mangle must be function decl");
assert(thunk->getContextKind() == DeclContextKind::AbstractFunctionDecl);
auto referenceInProtocolContextOrRequirement =
[&thunk, asReference]() -> ProtocolDecl * {
auto *DC = thunk->getDeclContext();
if (!asReference)
return dyn_cast_or_null<ProtocolDecl>(DC);
if (auto extension = dyn_cast<ExtensionDecl>(DC))
return dyn_cast_or_null<ProtocolDecl>(extension->getExtendedNominal());
return nullptr;
};
// Determine if we should mangle with a $Target substitute decl context,
// this matters for @Resolvable calls / protocol calls where the caller
// does not know the type of the recipient distributed actor, and we use the
// $Target type as substitute to then generically invoke it on the type of the
// recipient, whichever 'protocol Type'-conforming type it will be.
NominalTypeDecl *stubActorDecl = nullptr;
if (auto P = referenceInProtocolContextOrRequirement()) {
auto &C = thunk->getASTContext();
auto M = thunk->getModuleContext();
SmallVector<ValueDecl *, 1> stubClassLookupResults;
C.lookupInModule(M, llvm::Twine("$", P->getNameStr()).str(), stubClassLookupResults);
assert(stubClassLookupResults.size() <= 1 && "Found multiple distributed stub types!");
if (stubClassLookupResults.size() > 0) {
stubActorDecl =
dyn_cast_or_null<NominalTypeDecl>(stubClassLookupResults.front());
if (auto abiStub = getABIDecl(stubActorDecl)) {
stubActorDecl = abiStub;
}
}
}
if (stubActorDecl) {
// Effectively mangle the thunk as if it was declared on the $StubTarget
// type, rather than on a `protocol Target`.
appendContext(stubActorDecl, base, thunk->getAlternateModuleName());
} else {
// There's no need to replace the context, this is a normal concrete type
// remote call identifier.
appendContextOf(thunk, base);
}
if (auto accessor = dyn_cast<AccessorDecl>(thunk)) {
assert(accessor->getAccessorKind() == AccessorKind::DistributedGet &&
"Only accessors marked as _distributed_get are expected to be "
"mangled as thunks");
// A distributed getter is mangled as the name of its storage (i.e. "the
// var")
auto storage = accessor->getStorage();
if (auto abiStorage = getABIDecl(storage)) {
storage = abiStorage;
}
appendIdentifier(storage->getBaseIdentifier().str());
} else {
appendIdentifier(thunk->getBaseIdentifier().str());
}
appendDeclType(thunk, base, FunctionMangling);
appendOperator("F");
appendSymbolKind(SymbolKind::DistributedThunk);
}
std::string ASTMangler::mangleDistributedThunkRef(const AbstractFunctionDecl *thunk) {
beginMangling();
appendDistributedThunk(thunk, /*asReference=*/true);
return finalize();
}
std::string ASTMangler::mangleDistributedThunkRecord(const AbstractFunctionDecl *thunk) {
beginMangling();
appendDistributedThunk(thunk, /*asReference=*/true);
appendSymbolKind(SymbolKind::AccessibleFunctionRecord);
return finalize();
}
std::string ASTMangler::mangleDistributedThunk(const AbstractFunctionDecl *thunk) {
beginMangling();
appendDistributedThunk(thunk, /*asReference=*/false);
return finalize();
}
/// Retrieve the outermost local context, or return NULL if there is no such
/// local context.
static const DeclContext *getOutermostLocalContext(const DeclContext *dc) {
// If the parent has an outermost local context, it's ours as well.
if (auto parentDC = dc->getParent()) {
if (auto outermost = getOutermostLocalContext(parentDC))
return outermost;
}
return dc->isLocalContext() ? dc : nullptr;
}
/// Enable a precheck discriminator into the identifier name. These mangled
/// names are not ABI and are not stable.
static Identifier encodeLocalPrecheckedDiscriminator(
ASTContext &ctx, Identifier name, unsigned discriminator) {
llvm::SmallString<16> discriminatedName;
{
llvm::raw_svector_ostream out(discriminatedName);
out << name.str() << "_$l" << discriminator;
}
return ctx.getIdentifier(discriminatedName);
}
void ASTMangler::appendMacroExpansionContext(
SourceLoc loc, DeclContext *origDC,
Identifier macroName,
unsigned macroDiscriminator
) {
origDC = MacroDiscriminatorContext::getInnermostMacroContext(origDC);
BaseEntitySignature nullBase(nullptr);
if (loc.isInvalid()) {
if (auto outermostLocalDC = getOutermostLocalContext(origDC)) {
auto innermostNonlocalDC = outermostLocalDC->getParent();
appendContext(innermostNonlocalDC, nullBase, StringRef());
Identifier name = macroName;
ASTContext &ctx = origDC->getASTContext();
unsigned discriminator = macroDiscriminator;
name = encodeLocalPrecheckedDiscriminator(ctx, name, discriminator);
appendIdentifier(name.str());
} else {
return appendContext(origDC, nullBase, StringRef());
}
}
SourceManager &sourceMgr = Context.SourceMgr;
auto appendMacroExpansionLoc = [&]() {
appendIdentifier(origDC->getParentModule()->getName().str());
auto *SF = origDC->getParentSourceFile();
appendIdentifier(llvm::sys::path::filename(SF->getFilename()), /*allowRawIdentifiers=*/false);
auto lineColumn = sourceMgr.getLineAndColumnInBuffer(loc);
appendOperator("fMX", Index(lineColumn.first), Index(lineColumn.second));
};
auto bufferID = sourceMgr.findBufferContainingLoc(loc);
auto generatedSourceInfo = sourceMgr.getGeneratedSourceInfo(bufferID);
if (!generatedSourceInfo) {
return appendMacroExpansionLoc();
}
SourceLoc outerExpansionLoc;
DeclContext *outerExpansionDC;
DeclBaseName baseName;
unsigned discriminator;
// Determine the macro role.
MacroRole role;
switch (generatedSourceInfo->kind) {
#define MACRO_ROLE(Name, Description) \
case GeneratedSourceInfo::Name##MacroExpansion: \
role = MacroRole::Name; \
break;
#include "swift/Basic/MacroRoles.def"
case GeneratedSourceInfo::PrettyPrinted:
case GeneratedSourceInfo::ReplacedFunctionBody:
case GeneratedSourceInfo::DefaultArgument:
case GeneratedSourceInfo::AttributeFromClang:
return appendMacroExpansionLoc();
}
switch (generatedSourceInfo->kind) {
// Freestanding macros
#define FREESTANDING_MACRO_ROLE(Name, Description) \
case GeneratedSourceInfo::Name##MacroExpansion:
#define ATTACHED_MACRO_ROLE(Name, Description, MangledChar)
#include "swift/Basic/MacroRoles.def"
{
auto parent = ASTNode::getFromOpaqueValue(generatedSourceInfo->astNode);
if (auto expr =
cast_or_null<MacroExpansionExpr>(parent.dyn_cast<Expr *>())) {
outerExpansionLoc = expr->getLoc();
baseName = expr->getMacroName().getBaseName();
discriminator = expr->getDiscriminator();
outerExpansionDC = expr->getDeclContext();
} else {
auto decl = cast<MacroExpansionDecl>(parent.get<Decl *>());
outerExpansionLoc = decl->getLoc();
baseName = decl->getMacroName().getBaseName();
discriminator = decl->getDiscriminator();
outerExpansionDC = decl->getDeclContext();
}
break;
}
// Attached macros
#define FREESTANDING_MACRO_ROLE(Name, Description)
#define ATTACHED_MACRO_ROLE(Name, Description, MangledChar) \
case GeneratedSourceInfo::Name##MacroExpansion:
#include "swift/Basic/MacroRoles.def"
{
auto decl = ASTNode::getFromOpaqueValue(generatedSourceInfo->astNode)
.get<Decl *>();
auto attr = generatedSourceInfo->attachedMacroCustomAttr;
outerExpansionLoc = decl->getLoc();
outerExpansionDC = decl->getDeclContext();
if (auto *macroDecl = decl->getResolvedMacro(attr))
baseName = macroDecl->getBaseName();
else
baseName = Context.getIdentifier("__unknown_macro__");
discriminator = decl->getAttachedMacroDiscriminator(baseName, role, attr);
break;
}
case GeneratedSourceInfo::PrettyPrinted:
case GeneratedSourceInfo::ReplacedFunctionBody:
case GeneratedSourceInfo::DefaultArgument:
case GeneratedSourceInfo::AttributeFromClang:
llvm_unreachable("Exited above");
}
// If we hit the point where the structure is represented as a DeclContext,
// we're done.
if (origDC->isChildContextOf(outerExpansionDC))
return appendMacroExpansionLoc();
// Append our own context and discriminator.
appendMacroExpansionContext(
outerExpansionLoc, origDC,
macroName,
macroDiscriminator);
appendMacroExpansionOperator(
baseName.userFacingName(), role, discriminator);
}
void ASTMangler::appendMacroExpansionOperator(
StringRef macroName, MacroRole role, unsigned discriminator
) {
appendIdentifier(macroName);
switch (role) {
#define FREESTANDING_MACRO_ROLE(Name, Description) case MacroRole::Name:
#define ATTACHED_MACRO_ROLE(Name, Description, MangledChar)
#include "swift/Basic/MacroRoles.def"
appendOperator("fMf", Index(discriminator));
break;
#define FREESTANDING_MACRO_ROLE(Name, Description)
#define ATTACHED_MACRO_ROLE(Name, Description, MangledChar) \
case MacroRole::Name: \
appendOperator("fM" MangledChar, Index(discriminator)); \
break;
#include "swift/Basic/MacroRoles.def"
}
}
static StringRef getPrivateDiscriminatorIfNecessary(
const DeclContext *macroDC) {
auto decl = macroDC->getAsDecl();
if (decl && !decl->isOutermostPrivateOrFilePrivateScope())
return StringRef();
// Mangle non-local private declarations with a textual discriminator
// based on their enclosing file.
auto topLevelSubcontext = macroDC->getModuleScopeContext();
SourceFile *sf = dyn_cast<SourceFile>(topLevelSubcontext);
if (!sf)
return StringRef();
Identifier discriminator =
sf->getPrivateDiscriminator(/*createIfMissing=*/true);
assert(!discriminator.empty());
assert(!isNonAscii(discriminator.str()) &&
"discriminator contains non-ASCII characters");
(void)&isNonAscii;
assert(!clang::isDigit(discriminator.str().front()) &&
"not a valid identifier");
return discriminator.str();
}
static StringRef getPrivateDiscriminatorIfNecessary(
const MacroExpansionExpr *expansion) {
auto dc = MacroDiscriminatorContext::getInnermostMacroContext(
expansion->getDeclContext());
return getPrivateDiscriminatorIfNecessary(dc);
}
static StringRef getPrivateDiscriminatorIfNecessary(
const FreestandingMacroExpansion *expansion) {
switch (expansion->getFreestandingMacroKind()) {
case FreestandingMacroKind::Expr:
return getPrivateDiscriminatorIfNecessary(
cast<MacroExpansionExpr>(expansion));
case FreestandingMacroKind::Decl:
return getPrivateDiscriminatorIfNecessary(
cast<Decl>(cast<MacroExpansionDecl>(expansion)));
}
}
void
ASTMangler::appendMacroExpansion(const FreestandingMacroExpansion *expansion) {
appendMacroExpansionContext(expansion->getPoundLoc(),
expansion->getDeclContext(),
expansion->getMacroName().getBaseIdentifier(),
expansion->getDiscriminator());
auto privateDiscriminator = getPrivateDiscriminatorIfNecessary(expansion);
if (!privateDiscriminator.empty()) {
appendIdentifier(privateDiscriminator);
appendOperator("Ll");
}
appendMacroExpansionOperator(
expansion->getMacroName().getBaseName().userFacingName(),
MacroRole::Declaration,
expansion->getDiscriminator());
}
void ASTMangler::appendMacroExpansion(ClosureExpr *attachedTo,
CustomAttr *attr,
MacroDecl *macro) {
auto &ctx = attachedTo->getASTContext();
auto discriminator =
ctx.getNextMacroDiscriminator(attachedTo,
macro->getBaseName());
appendMacroExpansionContext(
attr->getLocation(),
attachedTo,
macro->getBaseName().getIdentifier(),
discriminator);
auto privateDiscriminator =
getPrivateDiscriminatorIfNecessary(attachedTo);
if (!privateDiscriminator.empty()) {
appendIdentifier(privateDiscriminator);
appendOperator("Ll");
}
appendMacroExpansionOperator(
macro->getBaseName().userFacingName(),
MacroRole::Body,
discriminator);
}
std::string
ASTMangler::mangleAttachedMacroExpansion(ClosureExpr *attachedTo,
CustomAttr *attr,
MacroDecl *macro) {
beginMangling();
appendMacroExpansion(attachedTo, attr, macro);
return finalize();
}
std::string
ASTMangler::mangleMacroExpansion(const FreestandingMacroExpansion *expansion) {
beginMangling();
appendMacroExpansion(expansion);
return finalize();
}
namespace {
/// Stores either a declaration or its enclosing context, for use in mangling
/// of macro expansion contexts.
struct DeclOrEnclosingContext: llvm::PointerUnion<const Decl *, const DeclContext *> {
using PointerUnion::PointerUnion;
const DeclContext *getEnclosingContext() const {
if (auto decl = dyn_cast<const Decl *>()) {
return decl->getDeclContext();
}
return get<const DeclContext *>();
}
};
}
/// Given a declaration, find the declaration or enclosing context that is
/// the innermost context that is not a local context, along with a
/// discriminator that identifies this given specific declaration (along
/// with its `name`) within that enclosing context. This is used to
/// mangle entities within local contexts before they are fully type-checked,
/// as is needed for macro expansions.
static std::pair<DeclOrEnclosingContext, std::optional<unsigned>>
getPrecheckedLocalContextDiscriminator(const Decl *decl, Identifier name) {
auto outermostLocal = getOutermostLocalContext(decl->getDeclContext());
if (!outermostLocal) {
return std::make_pair(
DeclOrEnclosingContext(decl),
std::optional<unsigned>()
);
}
DeclOrEnclosingContext declOrEnclosingContext;
if (decl->getDeclContext() == outermostLocal)
declOrEnclosingContext = decl;
else if (const Decl *fromDecl = outermostLocal->getAsDecl())
declOrEnclosingContext = fromDecl;
else
declOrEnclosingContext = outermostLocal->getParent();
DeclContext *enclosingDC = const_cast<DeclContext *>(
declOrEnclosingContext.getEnclosingContext());
ASTContext &ctx = enclosingDC->getASTContext();
auto discriminator = ctx.getNextMacroDiscriminator(enclosingDC, name);
return std::make_pair(declOrEnclosingContext, discriminator);
}
std::string ASTMangler::mangleAttachedMacroExpansion(
const Decl *decl, CustomAttr *attr, MacroRole role) {
if (auto abiDecl = getABIDecl(decl)) {
return mangleAttachedMacroExpansion(abiDecl, attr, role);
}
// FIXME(kavon): using the decl causes a cycle. Is a null base fine?
BaseEntitySignature nullBase(nullptr);
beginMangling();
auto appendDeclWithName = [&](const Decl *decl, Identifier name) {
// Mangle the context.
auto precheckedMangleContext =
getPrecheckedLocalContextDiscriminator(decl, name);
if (auto mangleDecl = dyn_cast_or_null<ValueDecl>(
precheckedMangleContext.first.dyn_cast<const Decl *>())) {
appendContextOf(mangleDecl, nullBase);
} else {
appendContext(
precheckedMangleContext.first.getEnclosingContext(), nullBase,
StringRef());
}
// If we needed a local discriminator, stuff that into the name itself.
// This is hack, but these names aren't stable anyway.
bool skipLocalDiscriminator = false;
if (auto discriminator = precheckedMangleContext.second) {
skipLocalDiscriminator = true;
name = encodeLocalPrecheckedDiscriminator(
decl->getASTContext(), name, *discriminator);
}
if (auto valueDecl = dyn_cast<ValueDecl>(decl))
appendDeclName(valueDecl, name, skipLocalDiscriminator);
else if (!name.empty())
appendIdentifier(name.str());
else
appendIdentifier("_");
};
// Append the context and name of the declaration.
// We don't mangle the declaration itself because doing so requires semantic
// information (e.g., its interface type), which introduces cyclic
// dependencies.
const Decl *attachedTo = decl;
Identifier attachedToName;
if (auto accessor = dyn_cast<AccessorDecl>(decl)) {
auto storage = accessor->getStorage();
// Introduce an identifier mangling that includes var/subscript, accessor
// kind, and static.
// FIXME: THIS IS A HACK. We need something different.
{
llvm::SmallString<16> name;
{
llvm::raw_svector_ostream out(name);
out << storage->getName().getBaseName().userFacingName()
<< "__";
if (isa<VarDecl>(storage)) {
out << "v";
} else {
assert(isa<SubscriptDecl>(storage));
out << "i";
}
out << getCodeForAccessorKind(accessor->getAccessorKind());
if (storage->isStatic())
out << "Z";
}
attachedToName = decl->getASTContext().getIdentifier(name);
}
appendDeclWithName(storage, attachedToName);
// For member attribute macros, the attribute is attached to the enclosing
// declaration.
if (role == MacroRole::MemberAttribute) {
attachedTo = storage->getDeclContext()->getAsDecl();
}
} else if (auto valueDecl = dyn_cast<ValueDecl>(decl)) {
// Mangle the name, replacing special names with their user-facing names.
auto name = valueDecl->getName().getBaseName();
if (name.isSpecial()) {
attachedToName =
decl->getASTContext().getIdentifier(name.userFacingName());
} else {
attachedToName = name.getIdentifier();
}
appendDeclWithName(valueDecl, attachedToName);
// For member attribute macros, the attribute is attached to the enclosing
// declaration.
if (role == MacroRole::MemberAttribute) {
attachedTo = decl->getDeclContext()->getAsDecl();
}
} else {
appendContext(decl->getDeclContext(), nullBase, "");
appendIdentifier("_");
}
// Determine the name of the macro.
DeclBaseName macroName;
if (auto *macroDecl = attachedTo->getResolvedMacro(attr)) {
macroName = macroDecl->getName().getBaseName();
} else {
macroName = decl->getASTContext().getIdentifier("__unknown_macro__");
}
// FIXME: attached macro discriminators should take attachedToName into
// account.
appendMacroExpansionOperator(
macroName.userFacingName(), role,
decl->getAttachedMacroDiscriminator(macroName, role, attr));
return finalize();
}
static void gatherExistentialRequirements(SmallVectorImpl<Requirement> &reqs,
ParameterizedProtocolType *PPT) {
auto protoTy = PPT->getBaseType();
ASSERT(!getABIDecl(protoTy->getDecl()) && "need to figure out behavior");
PPT->getRequirements(protoTy->getDecl()->getSelfInterfaceType(), reqs);
}
/// Extracts a list of inverse requirements from a PCT serving as the constraint
/// type of an existential.
static void extractExistentialInverseRequirements(
SmallVectorImpl<InverseRequirement> &inverses,
ProtocolCompositionType *PCT) {
if (!PCT->hasInverse())
return;
auto &ctx = PCT->getASTContext();
for (auto ip : PCT->getInverses()) {
auto *proto = ctx.getProtocol(getKnownProtocolKind(ip));
assert(proto);
ASSERT(!getABIDecl(proto) && "can't use @abi on inverse protocols");
inverses.push_back({ctx.TheSelfType, proto, SourceLoc()});
}
}
void ASTMangler::appendConstrainedExistential(Type base, GenericSignature sig,
const ValueDecl *forDecl) {
auto layout = base->getExistentialLayout();
appendExistentialLayout(layout, sig, forDecl);
SmallVector<Requirement, 4> requirements;
SmallVector<InverseRequirement, NumInvertibleProtocols> inverses;
assert(!base->is<ProtocolType>() &&
"plain protocol type constraint has no generalization structure");
if (auto *PCT = base->getAs<ProtocolCompositionType>()) {
for (auto memberTy : PCT->getMembers()) {
if (auto *PPT = memberTy->getAs<ParameterizedProtocolType>())
gatherExistentialRequirements(requirements, PPT);
}
if (AllowInverses)
extractExistentialInverseRequirements(inverses, PCT);
} else {
auto *PPT = base->castTo<ParameterizedProtocolType>();
gatherExistentialRequirements(requirements, PPT);
}
assert(requirements.size() + inverses.size() > 0
&& "Unconstrained existential?");
// Sort the requirements to canonicalize their order.
llvm::array_pod_sort(
requirements.begin(), requirements.end(),
[](const Requirement *lhs, const Requirement *rhs) -> int {
return lhs->compare(*rhs);
});
llvm::array_pod_sort(
inverses.begin(), inverses.end(),
[](const InverseRequirement *lhs, const InverseRequirement *rhs) -> int {
return lhs->compare(*rhs);
});
bool firstRequirement = true;
for (const auto &reqt : requirements) {
switch (reqt.getKind()) {
case RequirementKind::SameShape:
llvm_unreachable("Same-shape requirement not supported here");
case RequirementKind::Layout:
case RequirementKind::Conformance:
case RequirementKind::Superclass:
// The surface language cannot express these requirements yet, so
// we have no mangling for them.
assert(false && "Unexpected requirement in constrained existential!");
continue;
case RequirementKind::SameType: {
break;
}
}
appendRequirement(reqt, sig, /*baseIsProtocolSelf*/ true);
appendListSeparator(firstRequirement);
}
for (const auto invReq : inverses) {
appendInverseRequirement(invReq, sig, /*baseIsProtocolSelf*/ true);
appendListSeparator(firstRequirement);
}
return appendOperator("XP");
}
/// Determine whether this declaration can only occur within the primary
/// type definition.
static bool canOnlyOccurInPrimaryTypeDefinition(const Decl *decl) {
// Enum elements always occur within the primary definition.
if (isa<EnumElementDecl>(decl))
return true;
return false;
}
/// When the immediate enclosing context of this declaration is
/// a generic type (with its own generic parameters), return the depth of
/// the innermost generic parameters.
static std::optional<unsigned> getEnclosingTypeGenericDepth(const Decl *decl) {
auto typeDecl = dyn_cast<GenericTypeDecl>(decl->getDeclContext());
if (!typeDecl)
return std::nullopt;
if (!typeDecl->isGeneric())
return std::nullopt;
return typeDecl->getGenericSignature()->getMaxDepth();
}
ASTMangler::BaseEntitySignature::BaseEntitySignature(const Decl *decl)
: sig(nullptr), innermostTypeDecl(true), extension(false),
mangledDepth(std::nullopt) {
if (decl) {
switch (decl->getKind()) {
case DeclKind::Var:
case DeclKind::Subscript:
case DeclKind::Constructor:
case DeclKind::Destructor:
case DeclKind::Func:
case DeclKind::Accessor:
case DeclKind::Enum:
case DeclKind::Struct:
case DeclKind::Class:
case DeclKind::EnumElement:
sig = decl->getInnermostDeclContext()->getGenericSignatureOfContext();
// Protocol members never mangle inverse constraints on `Self`.
if (isa<ProtocolDecl>(decl->getDeclContext()))
setDepth(0);
// Declarations that can only occur in the primary type definition should
// not mangle inverses for the generic parameters of that type definition.
// This allows types to introduce conditional conformances to invertible
// protocols without breaking ABI.
if (canOnlyOccurInPrimaryTypeDefinition(decl)) {
if (auto depth = getEnclosingTypeGenericDepth(decl))
suppressedInnermostDepth = depth;
}
break;
case DeclKind::TypeAlias: // FIXME: is this right? typealiases have a generic signature!
case DeclKind::PatternBinding:
case DeclKind::Protocol:
case DeclKind::BuiltinTuple:
case DeclKind::OpaqueType:
case DeclKind::GenericTypeParam:
case DeclKind::AssociatedType:
case DeclKind::Module:
case DeclKind::Param:
case DeclKind::Macro:
case DeclKind::Extension:
case DeclKind::TopLevelCode:
case DeclKind::Import:
case DeclKind::PrecedenceGroup:
case DeclKind::Missing:
case DeclKind::MissingMember:
case DeclKind::EnumCase:
case DeclKind::InfixOperator:
case DeclKind::PrefixOperator:
case DeclKind::PostfixOperator:
case DeclKind::MacroExpansion:
break;
};
}
}
Reference in New Issue View Git Blame Copy Permalink