Merge pull request #9407 from slavapestov/use-objc-msgsend-for-overrides-of-imported-methods
Use objc_msgSend() for overrides of imported methods [4.0]
diff --git a/include/swift/AST/Witness.h b/include/swift/AST/Witness.h
index 738e2f1..e81c5ea 100644
--- a/include/swift/AST/Witness.h
+++ b/include/swift/AST/Witness.h
@@ -108,6 +108,16 @@
/// not generic (excepting \c Self) and the conforming type is non-generic.
Witness(ValueDecl *witness) : storage(witness) { assert(witness != nullptr); }
+ /// Create an opaque witness for the given requirement.
+ ///
+ /// This indicates that a witness exists, but is not visible to the current
+ /// module.
+ static Witness forOpaque(ValueDecl *requirement) {
+ // TODO: It's probably a good idea to have a separate 'opaque' bit.
+ // Making req == witness is kind of a hack.
+ return Witness(requirement);
+ }
+
/// Create a witness that requires substitutions.
///
/// \param decl The declaration for the witness.
diff --git a/include/swift/Basic/Version.h b/include/swift/Basic/Version.h
index 9c36999..9d157dc 100644
--- a/include/swift/Basic/Version.h
+++ b/include/swift/Basic/Version.h
@@ -144,6 +144,9 @@
bool operator>=(const Version &lhs, const Version &rhs);
bool operator==(const Version &lhs, const Version &rhs);
+inline bool operator!=(const Version &lhs, const Version &rhs) {
+ return !(lhs == rhs);
+}
raw_ostream &operator<<(raw_ostream &os, const Version &version);
diff --git a/include/swift/ClangImporter/ClangImporter.h b/include/swift/ClangImporter/ClangImporter.h
index 263941a..6401709 100644
--- a/include/swift/ClangImporter/ClangImporter.h
+++ b/include/swift/ClangImporter/ClangImporter.h
@@ -308,10 +308,12 @@
Optional<std::string>
getOrCreatePCH(const ClangImporterOptions &ImporterOptions,
- const std::string &SwiftPCHHash);
+ StringRef SwiftPCHHash);
Optional<std::string>
+ /// \param isExplicit true if the PCH filename was passed directly
+ /// with -import-objc-header option.
getPCHFilename(const ClangImporterOptions &ImporterOptions,
- const std::string &SwiftPCHHash);
+ StringRef SwiftPCHHash, bool &isExplicit);
};
ImportDecl *createImportDecl(ASTContext &Ctx, DeclContext *DC, ClangNode ClangN,
diff --git a/include/swift/Demangling/Demangle.h b/include/swift/Demangling/Demangle.h
index d7106e6..0904510 100644
--- a/include/swift/Demangling/Demangle.h
+++ b/include/swift/Demangling/Demangle.h
@@ -409,6 +409,12 @@
/// This should always round-trip perfectly with demangleSymbolAsNode.
std::string mangleNode(const NodePointer &root);
+/// Remangle in the old mangling scheme.
+///
+/// This is only used for objc-runtime names and should be removed as soon as
+/// we switch to the new mangling for those names as well.
+std::string mangleNodeOld(const NodePointer &root);
+
/// \brief Transform the node structure to a string.
///
/// Typical usage:
diff --git a/include/swift/IDE/Utils.h b/include/swift/IDE/Utils.h
index d53c555..a3293e7 100644
--- a/include/swift/IDE/Utils.h
+++ b/include/swift/IDE/Utils.h
@@ -13,6 +13,7 @@
#ifndef SWIFT_IDE_UTILS_H
#define SWIFT_IDE_UTILS_H
+#include "llvm/ADT/PointerIntPair.h"
#include "swift/Basic/LLVM.h"
#include "swift/AST/ASTNode.h"
#include "swift/AST/Module.h"
@@ -243,9 +244,12 @@
Break,
Continue,
};
+
+typedef llvm::PointerIntPair<TypeBase*, 1, bool> ReturnTyAndWhetherExit;
+
struct ResolvedRangeInfo {
RangeKind Kind;
- Type Ty;
+ ReturnTyAndWhetherExit ExitInfo;
StringRef Content;
bool HasSingleEntry;
bool ThrowingUnhandledError;
@@ -256,23 +260,26 @@
ArrayRef<DeclaredDecl> DeclaredDecls;
ArrayRef<ReferencedDecl> ReferencedDecls;
DeclContext* RangeContext;
- ResolvedRangeInfo(RangeKind Kind, Type Ty, StringRef Content,
+ ResolvedRangeInfo(RangeKind Kind, ReturnTyAndWhetherExit ExitInfo, StringRef Content,
DeclContext* RangeContext,
bool HasSingleEntry, bool ThrowingUnhandledError,
OrphanKind Orphan, ArrayRef<ASTNode> ContainedNodes,
ArrayRef<DeclaredDecl> DeclaredDecls,
ArrayRef<ReferencedDecl> ReferencedDecls): Kind(Kind),
- Ty(Ty), Content(Content), HasSingleEntry(HasSingleEntry),
+ ExitInfo(ExitInfo), Content(Content),
+ HasSingleEntry(HasSingleEntry),
ThrowingUnhandledError(ThrowingUnhandledError),
Orphan(Orphan), ContainedNodes(ContainedNodes),
DeclaredDecls(DeclaredDecls),
ReferencedDecls(ReferencedDecls),
RangeContext(RangeContext) {}
ResolvedRangeInfo(StringRef Content) :
- ResolvedRangeInfo(RangeKind::Invalid, Type(), Content, nullptr,
+ ResolvedRangeInfo(RangeKind::Invalid, {nullptr, false}, Content, nullptr,
/*Single entry*/true, /*unhandled error*/false,
OrphanKind::None, {}, {}, {}) {}
void print(llvm::raw_ostream &OS);
+ bool exit() const { return ExitInfo.getInt(); }
+ Type getType() const { return ExitInfo.getPointer(); }
};
class RangeResolver : public SourceEntityWalker {
diff --git a/include/swift/Serialization/ModuleFile.h b/include/swift/Serialization/ModuleFile.h
index 429aec1..6c4c320 100644
--- a/include/swift/Serialization/ModuleFile.h
+++ b/include/swift/Serialization/ModuleFile.h
@@ -73,7 +73,7 @@
StringRef TargetTriple;
/// The Swift compatibility version in use when this module was built.
- StringRef CompatibilityVersion;
+ version::Version CompatibilityVersion;
/// The data blob containing all of the module's identifiers.
StringRef IdentifierData;
diff --git a/include/swift/Serialization/Validation.h b/include/swift/Serialization/Validation.h
index 76b279b..dbd86e1 100644
--- a/include/swift/Serialization/Validation.h
+++ b/include/swift/Serialization/Validation.h
@@ -71,7 +71,7 @@
StringRef name = {};
StringRef targetTriple = {};
StringRef shortVersion = {};
- StringRef compatibilityVersion = {};
+ version::Version compatibilityVersion = {};
size_t bytes = 0;
Status status = Status::Malformed;
};
diff --git a/lib/AST/ASTMangler.cpp b/lib/AST/ASTMangler.cpp
index 93d5a07..fa9a543 100644
--- a/lib/AST/ASTMangler.cpp
+++ b/lib/AST/ASTMangler.cpp
@@ -24,6 +24,7 @@
#include "swift/AST/ParameterList.h"
#include "swift/AST/ProtocolConformance.h"
#include "swift/Demangling/ManglingUtils.h"
+#include "swift/Demangling/Demangler.h"
#include "swift/Strings.h"
#include "clang/Basic/CharInfo.h"
#include "clang/AST/Attr.h"
@@ -301,12 +302,18 @@
return finalize();
}
+#ifdef USE_NEW_MANGLING_FOR_OBJC_RUNTIME_NAMES
static bool isPrivate(const NominalTypeDecl *Nominal) {
return Nominal->hasAccessibility() &&
Nominal->getFormalAccess() <= Accessibility::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)) {
@@ -338,6 +345,34 @@
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) {
+ // Protocols are actually 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);
+ std::string OldName = mangleNodeOld(NewGlobal);
+ return OldName;
+#endif
}
std::string ASTMangler::mangleTypeAsContextUSR(const NominalTypeDecl *type) {
diff --git a/lib/Basic/Version.cpp b/lib/Basic/Version.cpp
index aebcb27..9ca9f7c 100644
--- a/lib/Basic/Version.cpp
+++ b/lib/Basic/Version.cpp
@@ -226,6 +226,11 @@
return isValidVersion ? Optional<Version>(TheVersion) : None;
}
+Version::Version(StringRef VersionString,
+ SourceLoc Loc,
+ DiagnosticEngine *Diags)
+ : Version(*parseVersionString(VersionString, Loc, Diags))
+{}
Version Version::getCurrentCompilerVersion() {
#ifdef SWIFT_COMPILER_VERSION
diff --git a/lib/ClangImporter/ClangImporter.cpp b/lib/ClangImporter/ClangImporter.cpp
index 5847118..236f4e0 100644
--- a/lib/ClangImporter/ClangImporter.cpp
+++ b/lib/ClangImporter/ClangImporter.cpp
@@ -711,22 +711,73 @@
}
bool ClangImporter::canReadPCH(StringRef PCHFilename) {
- return clang::ASTReader::isAcceptableASTFile(PCHFilename,
- Impl.Instance->getFileManager(),
- Impl.Instance->getPCHContainerReader(),
- Impl.Instance->getLangOpts(),
- Impl.Instance->getTargetOpts(),
- Impl.Instance->getPreprocessorOpts(),
- Impl.Instance->getSpecificModuleCachePath());
+ if (!llvm::sys::fs::exists(PCHFilename))
+ return false;
+
+ // FIXME: The following attempts to do an initial ReadAST invocation to verify
+ // the PCH, without affecting the existing CompilerInstance.
+ // Look into combining creating the ASTReader along with verification + update
+ // if necesary, so that we can create and use one ASTReader in the common case
+ // when there is no need for update.
+
+ CompilerInstance &CI = *Impl.Instance;
+ auto clangDiags = CompilerInstance::createDiagnostics(
+ new clang::DiagnosticOptions());
+ clang::SourceManager clangSrcMgr(*clangDiags, CI.getFileManager());
+ auto FID = clangSrcMgr.createFileID(
+ llvm::make_unique<ZeroFilledMemoryBuffer>(1, "<main>"));
+ clangSrcMgr.setMainFileID(FID);
+ clang::Preprocessor PP(CI.getInvocation().getPreprocessorOptsPtr(),
+ *clangDiags,
+ CI.getLangOpts(),
+ clangSrcMgr,
+ CI.getPCMCache(),
+ CI.getPreprocessor().getHeaderSearchInfo(), CI,
+ /*IILookup=*/nullptr,
+ /*OwnsHeaderSearch=*/false);
+ PP.Initialize(CI.getTarget());
+ clang::ASTContext ctx(CI.getLangOpts(), clangSrcMgr,
+ PP.getIdentifierTable(), PP.getSelectorTable(),
+ PP.getBuiltinInfo());
+
+ std::unique_ptr<clang::ASTReader> Reader(new clang::ASTReader(
+ PP, ctx, CI.getPCHContainerReader(),
+ CI.getFrontendOpts().ModuleFileExtensions,
+ CI.getHeaderSearchOpts().Sysroot,
+ /*DisableValidation*/ false,
+ /*AllowPCHWithCompilerErrors*/ false,
+ /*AllowConfigurationMismatch*/ false,
+ /*ValidateSystemInputs*/ true));
+ ctx.InitBuiltinTypes(CI.getTarget());
+
+ auto result = Reader->ReadAST(PCHFilename,
+ clang::serialization::MK_PCH,
+ clang::SourceLocation(),
+ clang::ASTReader::ARR_None);
+ switch (result) {
+ case clang::ASTReader::Success:
+ return true;
+ case clang::ASTReader::Failure:
+ case clang::ASTReader::Missing:
+ case clang::ASTReader::OutOfDate:
+ case clang::ASTReader::VersionMismatch:
+ return false;
+ case clang::ASTReader::ConfigurationMismatch:
+ case clang::ASTReader::HadErrors:
+ assert(0 && "unexpected ASTReader failure for PCH validation");
+ return false;
+ }
}
Optional<std::string>
ClangImporter::getPCHFilename(const ClangImporterOptions &ImporterOptions,
- const std::string &SwiftPCHHash) {
+ StringRef SwiftPCHHash, bool &isExplicit) {
if (llvm::sys::path::extension(ImporterOptions.BridgingHeader)
.endswith(PCH_EXTENSION)) {
+ isExplicit = true;
return ImporterOptions.BridgingHeader;
}
+ isExplicit = false;
const auto &BridgingHeader = ImporterOptions.BridgingHeader;
const auto &PCHOutputDir = ImporterOptions.PrecompiledHeaderOutputDir;
@@ -749,18 +800,27 @@
Optional<std::string>
ClangImporter::getOrCreatePCH(const ClangImporterOptions &ImporterOptions,
- const std::string &SwiftPCHHash) {
- auto PCHFilename = getPCHFilename(ImporterOptions, SwiftPCHHash);
+ StringRef SwiftPCHHash) {
+ bool isExplicit;
+ auto PCHFilename = getPCHFilename(ImporterOptions, SwiftPCHHash,
+ isExplicit);
if (!PCHFilename.hasValue()) {
return None;
}
- if (!canReadPCH(PCHFilename.getValue())) {
+ if (!isExplicit && !canReadPCH(PCHFilename.getValue())) {
SmallString<256> Message;
llvm::raw_svector_ostream OS(Message);
auto Diags = new clang::TextDiagnosticPrinter {
llvm::errs(),
&Impl.Instance->getDiagnosticOpts()
};
+ StringRef parentDir = llvm::sys::path::parent_path(PCHFilename.getValue());
+ std::error_code EC = llvm::sys::fs::create_directories(parentDir);
+ if (EC) {
+ llvm::errs() << "failed to create directory '" << parentDir << "': "
+ << EC.message();
+ return None;
+ }
auto FailedToEmit = emitBridgingPCH(ImporterOptions.BridgingHeader,
PCHFilename.getValue(),
Diags);
diff --git a/lib/Demangling/CMakeLists.txt b/lib/Demangling/CMakeLists.txt
index d92b3e0..8f83b92 100644
--- a/lib/Demangling/CMakeLists.txt
+++ b/lib/Demangling/CMakeLists.txt
@@ -5,6 +5,7 @@
NodeDumper.cpp
NodePrinter.cpp
OldDemangler.cpp
+ OldRemangler.cpp
Punycode.cpp
Remangler.cpp
)
diff --git a/lib/Demangling/OldRemangler.cpp b/lib/Demangling/OldRemangler.cpp
new file mode 100644
index 0000000..fc4be9c
--- /dev/null
+++ b/lib/Demangling/OldRemangler.cpp
@@ -0,0 +1,1753 @@
+//===--- OldRemangler.cpp - Old Swift Re-mangler --------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the remangler, which turns a demangling parse
+// tree back into a mangled string. This is useful for tools which
+// want to extract subtrees from mangled strings.
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/Demangling/Demangler.h"
+#include "swift/Demangling/Punycode.h"
+#include "swift/Strings.h"
+#include <vector>
+#include <cstdio>
+#include <cstdlib>
+#include <unordered_map>
+
+using namespace swift;
+using namespace Demangle;
+
+[[noreturn]]
+static void unreachable(const char *Message) {
+ fprintf(stderr, "fatal error: %s\n", Message);
+ std::abort();
+}
+
+/// Translate the given operator character into its mangled form.
+///
+/// Current operator characters: @/=-+*%<>!&|^~ and the special operator '..'
+static char mangleOperatorChar(char op) {
+ switch (op) {
+ case '&': return 'a'; // 'and'
+ case '@': return 'c'; // 'commercial at sign'
+ case '/': return 'd'; // 'divide'
+ case '=': return 'e'; // 'equal'
+ case '>': return 'g'; // 'greater'
+ case '<': return 'l'; // 'less'
+ case '*': return 'm'; // 'multiply'
+ case '!': return 'n'; // 'negate'
+ case '|': return 'o'; // 'or'
+ case '+': return 'p'; // 'plus'
+ case '?': return 'q'; // 'question'
+ case '%': return 'r'; // 'remainder'
+ case '-': return 's'; // 'subtract'
+ case '~': return 't'; // 'tilde'
+ case '^': return 'x'; // 'xor'
+ case '.': return 'z'; // 'zperiod' (the z is silent)
+ default:
+ return op;
+ }
+}
+
+static bool isNonAscii(StringRef str) {
+ for (unsigned char c : str) {
+ if (c >= 0x80)
+ return true;
+ }
+ return false;
+}
+
+static char mangleOperatorKind(OperatorKind operatorKind) {
+ switch (operatorKind) {
+ case OperatorKind::NotOperator: unreachable("invalid");
+ case OperatorKind::Infix: return 'i';
+ case OperatorKind::Prefix: return 'p';
+ case OperatorKind::Postfix: return 'P';
+ }
+ unreachable("invalid");
+}
+
+static void mangleIdentifier(StringRef ident, OperatorKind operatorKind,
+ bool usePunycode, DemanglerPrinter &out) {
+ std::string punycodeBuf;
+ if (usePunycode) {
+ // If the identifier contains non-ASCII character, we mangle
+ // with an initial X and Punycode the identifier string.
+ if (isNonAscii(ident)) {
+ out << 'X';
+ Punycode::encodePunycodeUTF8(ident, punycodeBuf);
+ ident = punycodeBuf;
+ }
+ }
+
+ // Mangle normal identifiers as
+ // count identifier-char+
+ // where the count is the number of characters in the identifier,
+ // and where individual identifier characters represent themselves.
+ if (operatorKind == OperatorKind::NotOperator) {
+ out << ident.size() << ident;
+ return;
+ }
+
+ // Mangle operator identifiers as
+ // operator ::= 'o' operator-fixity count operator-char+
+ // operator-fixity ::= 'p' // prefix
+ // operator-fixity ::= 'P' // postfix
+ // operator-fixity ::= 'i' // infix
+ // where the count is the number of characters in the operator,
+ // and where the individual operator characters are translated.
+ out << 'o' << mangleOperatorKind(operatorKind);
+
+ // Mangle ASCII operators directly.
+ out << ident.size();
+ for (char ch : ident) {
+ out << mangleOperatorChar(ch);
+ }
+}
+
+void Demangle::mangleIdentifier(const char *data, size_t length,
+ OperatorKind operatorKind,
+ std::string &out, bool usePunycode) {
+ DemanglerPrinter printer;
+ ::mangleIdentifier(StringRef(data, length), operatorKind,
+ usePunycode, printer);
+ out = std::move(printer).str();
+}
+
+namespace {
+ struct DeepHasher {
+ size_t value = 0;
+
+ void combine(size_t newValue) {
+ value = 33 * value + newValue;
+ }
+
+ void hash(Node *node) {
+ combine((size_t) node->getKind());
+ if (node->hasIndex()) {
+ combine(node->getIndex());
+ } else if (node->hasText()) {
+ StringRef text = node->getText();
+ for (char c : text) {
+ combine((unsigned char) c);
+ }
+ }
+ for (const auto &child : *node) {
+ hash(child);
+ }
+ }
+ };
+} // end anonymous namespace
+
+static size_t deepHash(Node *node) {
+ DeepHasher hasher;
+ hasher.hash(node);
+ return hasher.value;
+}
+
+static bool deepEquals(Node *lhs, Node *rhs) {
+ if (lhs->getKind() != rhs->getKind())
+ return false;
+ if (lhs->hasIndex()) {
+ if (!rhs->hasIndex())
+ return false;
+ if (lhs->getIndex() != rhs->getIndex())
+ return false;
+ } else if (lhs->hasText()) {
+ if (!rhs->hasText())
+ return false;
+ if (lhs->getText() != rhs->getText())
+ return false;
+ } else if (rhs->hasIndex() || rhs->hasText()) {
+ return false;
+ }
+
+ if (lhs->getNumChildren() != rhs->getNumChildren())
+ return false;
+
+ for (auto li = lhs->begin(), ri = lhs->begin(), le = lhs->end();
+ li != le; ++li, ++ri) {
+ if (!deepEquals(*li, *ri))
+ return false;
+ }
+
+ return true;
+}
+
+namespace {
+ struct SubstitutionEntry {
+ Node *TheNode;
+ size_t StoredHash;
+
+ // Note that the constructor leaves this uninitialized.
+
+ struct Hasher {
+ size_t operator()(const SubstitutionEntry &entry) const {
+ return entry.StoredHash;
+ }
+ };
+ friend bool operator==(const SubstitutionEntry &lhs,
+ const SubstitutionEntry &rhs) {
+ return (lhs.StoredHash == rhs.StoredHash &&
+ deepEquals(lhs.TheNode, lhs.TheNode));
+ }
+ };
+
+ class Remangler {
+ DemanglerPrinter &Out;
+
+ // We have to cons up temporary nodes sometimes when remangling
+ // nested generics. This factory owns them.
+ NodeFactory Factory;
+
+ std::unordered_map<SubstitutionEntry, unsigned,
+ SubstitutionEntry::Hasher> Substitutions;
+ public:
+ Remangler(DemanglerPrinter &out) : Out(out) {}
+
+ class EntityContext {
+ bool AsContext = false;
+ public:
+ bool isAsContext() const {
+ return AsContext;
+ }
+
+ class ManglingContextRAII {
+ EntityContext &Ctx;
+ bool SavedValue;
+ public:
+ ManglingContextRAII(EntityContext &ctx)
+ : Ctx(ctx), SavedValue(ctx.AsContext) {
+ ctx.AsContext = true;
+ }
+
+ ~ManglingContextRAII() {
+ Ctx.AsContext = SavedValue;
+ }
+ };
+ };
+
+ void mangle(Node *node) {
+ switch (node->getKind()) {
+#define NODE(ID) case Node::Kind::ID: return mangle##ID(node);
+#include "swift/Demangling/DemangleNodes.def"
+ }
+ unreachable("bad demangling tree node");
+ }
+
+ void mangleGenericArgs(Node *node, EntityContext &ctx);
+ void mangleAnyNominalType(Node *node, EntityContext &ctx);
+
+#define NODE(ID) \
+ void mangle##ID(Node *node);
+#define CONTEXT_NODE(ID) \
+ void mangle##ID(Node *node); \
+ void mangle##ID(Node *node, EntityContext &ctx);
+#include "swift/Demangling/DemangleNodes.def"
+
+ void mangleIndex(Node::IndexType index);
+ void mangleIdentifier(StringRef name, OperatorKind operatorKind);
+
+ void mangleChildNodes(Node *node) { mangleNodes(node->begin(), node->end()); }
+ void mangleNodes(Node::iterator i, Node::iterator e) {
+ for (; i != e; ++i) {
+ mangle(*i);
+ }
+ }
+ void mangleSingleChildNode(Node *node) {
+ assert(node->getNumChildren() == 1);
+ mangle(*node->begin());
+ }
+ void mangleChildNode(Node *node, unsigned index) {
+ assert(index < node->getNumChildren());
+ mangle(node->begin()[index]);
+ }
+
+ void mangleSimpleEntity(Node *node, char basicKind, StringRef entityKind,
+ EntityContext &ctx);
+ void mangleNamedEntity(Node *node, char basicKind, StringRef entityKind,
+ EntityContext &ctx);
+ void mangleTypedEntity(Node *node, char basicKind, StringRef entityKind,
+ EntityContext &ctx);
+ void mangleNamedAndTypedEntity(Node *node, char basicKind,
+ StringRef entityKind,
+ EntityContext &ctx);
+ void mangleNominalType(Node *node, char basicKind, EntityContext &ctx);
+
+ void mangleProtocolWithoutPrefix(Node *node);
+ void mangleProtocolListWithoutPrefix(Node *node,
+ Node *additionalProto = nullptr);
+
+ void mangleEntityContext(Node *node, EntityContext &ctx);
+ void mangleEntityType(Node *node, EntityContext &ctx);
+ void mangleEntityGenericType(Node *node, EntityContext &ctx);
+
+ bool trySubstitution(Node *node, SubstitutionEntry &entry);
+ bool mangleStandardSubstitution(Node *node);
+ void addSubstitution(const SubstitutionEntry &entry);
+ void resetSubstitutions();
+
+ void mangleDependentGenericParamIndex(Node *node);
+ void mangleConstrainedType(Node *node);
+ };
+} // end anonymous namespace
+
+#define NODE(ID)
+#define CONTEXT_NODE(ID) \
+void Remangler::mangle##ID(Node *node) { \
+ EntityContext ctx; \
+ mangle##ID(node, ctx); \
+}
+#include "swift/Demangling/DemangleNodes.def"
+
+/// Reset the currently-active set of substitutions. This is useful
+/// when part of the mangling is done independently, e.g. when an
+/// optimization pass modifies a pass.
+void Remangler::resetSubstitutions() {
+ Substitutions.clear();
+}
+
+bool Remangler::trySubstitution(Node *node, SubstitutionEntry &entry) {
+ if (mangleStandardSubstitution(node))
+ return true;
+
+ // Go ahead and initialize the substitution entry.
+ entry.TheNode = node;
+ entry.StoredHash = deepHash(node);
+
+ auto it = Substitutions.find(entry);
+ if (it == Substitutions.end())
+ return false;
+
+ Out << 'S';
+ mangleIndex(it->second);
+ return true;
+}
+
+static bool isInSwiftModule(Node *node) {
+ Node *context = node->getFirstChild();
+ return (context->getKind() == Node::Kind::Module &&
+ context->getText() == STDLIB_NAME);
+};
+
+bool Remangler::mangleStandardSubstitution(Node *node) {
+ // Look for known substitutions.
+ switch (node->getKind()) {
+#define SUCCESS_IF_IS(VALUE, EXPECTED, SUBSTITUTION) \
+ do { \
+ if ((VALUE) == (EXPECTED)) { \
+ Out << SUBSTITUTION; \
+ return true; \
+ } \
+ } while (0)
+#define SUCCESS_IF_TEXT_IS(EXPECTED, SUBSTITUTION) \
+ SUCCESS_IF_IS(node->getText(), EXPECTED, SUBSTITUTION)
+#define SUCCESS_IF_DECLNAME_IS(EXPECTED, SUBSTITUTION) \
+ SUCCESS_IF_IS(node->getChild(1)->getText(), EXPECTED, SUBSTITUTION)
+
+ case Node::Kind::Module:
+ SUCCESS_IF_TEXT_IS(STDLIB_NAME, "s");
+ SUCCESS_IF_TEXT_IS(MANGLING_MODULE_OBJC, "So");
+ SUCCESS_IF_TEXT_IS(MANGLING_MODULE_CLANG_IMPORTER, "SC");
+ break;
+ case Node::Kind::Structure:
+ if (isInSwiftModule(node)) {
+ SUCCESS_IF_DECLNAME_IS("Array", "Sa");
+ SUCCESS_IF_DECLNAME_IS("Bool", "Sb");
+ SUCCESS_IF_DECLNAME_IS("UnicodeScalar", "Sc");
+ SUCCESS_IF_DECLNAME_IS("Double", "Sd");
+ SUCCESS_IF_DECLNAME_IS("Float", "Sf");
+ SUCCESS_IF_DECLNAME_IS("Int", "Si");
+ SUCCESS_IF_DECLNAME_IS("UnsafeRawPointer", "SV");
+ SUCCESS_IF_DECLNAME_IS("UnsafeMutableRawPointer", "Sv");
+ SUCCESS_IF_DECLNAME_IS("UnsafePointer", "SP");
+ SUCCESS_IF_DECLNAME_IS("UnsafeMutablePointer", "Sp");
+ SUCCESS_IF_DECLNAME_IS("UnsafeBufferPointer", "SR");
+ SUCCESS_IF_DECLNAME_IS("UnsafeMutableBufferPointer", "Sr");
+ SUCCESS_IF_DECLNAME_IS("String", "SS");
+ SUCCESS_IF_DECLNAME_IS("UInt", "Su");
+ }
+ break;
+ case Node::Kind::Enum:
+ if (isInSwiftModule(node)) {
+ SUCCESS_IF_DECLNAME_IS("Optional", "Sq");
+ SUCCESS_IF_DECLNAME_IS("ImplicitlyUnwrappedOptional", "SQ");
+ }
+ break;
+
+ default:
+ break;
+
+#undef SUCCESS_IF_DECLNAME_IS
+#undef SUCCESS_IF_TEXT_IS
+#undef SUCCESS_IF_IS
+ }
+ return false;
+}
+
+void Remangler::addSubstitution(const SubstitutionEntry &entry) {
+ auto result = Substitutions.insert({entry, Substitutions.size()});
+ assert(result.second);
+ (void) result;
+}
+
+void Remangler::mangleIdentifier(Node *node) {
+ mangleIdentifier(node->getText(), OperatorKind::NotOperator);
+}
+void Remangler::manglePrefixOperator(Node *node) {
+ mangleIdentifier(node->getText(), OperatorKind::Prefix);
+}
+void Remangler::manglePostfixOperator(Node *node) {
+ mangleIdentifier(node->getText(), OperatorKind::Postfix);
+}
+void Remangler::mangleInfixOperator(Node *node) {
+ mangleIdentifier(node->getText(), OperatorKind::Infix);
+}
+void Remangler::mangleIdentifier(StringRef ident, OperatorKind operatorKind) {
+ ::mangleIdentifier(ident, operatorKind, /*usePunycode*/ false, Out);
+}
+
+void Remangler::mangleNumber(Node *node) {
+ mangleIndex(node->getIndex());
+}
+void Remangler::mangleIndex(Node::IndexType value) {
+ if (value == 0) {
+ Out << '_';
+ } else {
+ Out << (value - 1) << '_';
+ }
+}
+
+void Remangler::mangleGlobal(Node *node) {
+ Out << "_T";
+ mangleChildNodes(node);
+}
+
+void Remangler::mangleSuffix(Node *node) {
+ // Just add the suffix back on.
+ Out << node->getText();
+}
+
+void Remangler::mangleGenericSpecialization(Node *node) {
+ Out << "TSg";
+ mangleChildNodes(node); // GenericSpecializationParams
+
+ // Specializations are just prepended to already-mangled names.
+ resetSubstitutions();
+
+ // Start another mangled name.
+ Out << "__T";
+}
+void Remangler::mangleGenericSpecializationNotReAbstracted(Node *node) {
+ Out << "TSr";
+ mangleChildNodes(node); // GenericSpecializationParams
+
+ // Specializations are just prepended to already-mangled names.
+ resetSubstitutions();
+
+ // Start another mangled name.
+ Out << "__T";
+}
+
+void Remangler::mangleGenericPartialSpecialization(Node *node) {
+ unreachable("todo");
+}
+
+void Remangler::mangleGenericPartialSpecializationNotReAbstracted(Node *node) {
+ unreachable("todo");
+}
+
+void Remangler::mangleGenericSpecializationParam(Node *node) {
+ // Should be a type followed by a series of protocol conformances.
+ mangleChildNodes(node);
+ Out << '_';
+}
+
+void Remangler::mangleFunctionSignatureSpecialization(Node *node) {
+ Out << "TSf";
+ mangleChildNodes(node); // FunctionSignatureSpecializationParams
+
+ // Specializations are just prepended to already-mangled names.
+ resetSubstitutions();
+
+ // Start another mangled name.
+ Out << "__T";
+}
+
+void Remangler::mangleSpecializationPassID(Node *node) {
+ Out << node->getIndex();
+}
+
+void Remangler::mangleSpecializationIsFragile(Node *node) {
+ Out << "q";
+}
+
+void Remangler::mangleFunctionSignatureSpecializationParam(Node *node) {
+ if (!node->hasChildren()) {
+ Out << "n_";
+ return;
+ }
+
+ // The first child is always a kind that specifies the type of param that we
+ // have.
+ NodePointer firstChild = node->getChild(0);
+ unsigned kindValue = firstChild->getIndex();
+ auto kind = FunctionSigSpecializationParamKind(kindValue);
+
+ switch (kind) {
+ case FunctionSigSpecializationParamKind::ConstantPropFunction:
+ Out << "cpfr";
+ mangleIdentifier(node->getChild(1));
+ Out << '_';
+ return;
+ case FunctionSigSpecializationParamKind::ConstantPropGlobal:
+ Out << "cpg";
+ mangleIdentifier(node->getChild(1));
+ Out << '_';
+ return;
+ case FunctionSigSpecializationParamKind::ConstantPropInteger:
+ Out << "cpi" << node->getChild(1)->getText() << '_';
+ return;
+ case FunctionSigSpecializationParamKind::ConstantPropFloat:
+ Out << "cpfl" << node->getChild(1)->getText() << '_';
+ return;
+ case FunctionSigSpecializationParamKind::ConstantPropString: {
+ Out << "cpse";
+ StringRef encodingStr = node->getChild(1)->getText();
+ if (encodingStr == "u8")
+ Out << '0';
+ else if (encodingStr == "u16")
+ Out << '1';
+ else
+ unreachable("Unknown encoding");
+ Out << 'v';
+ mangleIdentifier(node->getChild(2));
+ Out << '_';
+ return;
+ }
+ case FunctionSigSpecializationParamKind::ClosureProp:
+ Out << "cl";
+ mangleIdentifier(node->getChild(1));
+ for (unsigned i = 2, e = node->getNumChildren(); i != e; ++i) {
+ mangleType(node->getChild(i));
+ }
+ Out << '_';
+ return;
+ case FunctionSigSpecializationParamKind::BoxToValue:
+ Out << "i_";
+ return;
+ case FunctionSigSpecializationParamKind::BoxToStack:
+ Out << "k_";
+ return;
+ default:
+ if (kindValue &
+ unsigned(FunctionSigSpecializationParamKind::Dead))
+ Out << 'd';
+ if (kindValue &
+ unsigned(FunctionSigSpecializationParamKind::OwnedToGuaranteed))
+ Out << 'g';
+ if (kindValue & unsigned(FunctionSigSpecializationParamKind::SROA))
+ Out << 's';
+ Out << '_';
+ return;
+ }
+}
+
+void Remangler::mangleFunctionSignatureSpecializationParamPayload(Node *node) {
+ // This should never be called since mangling parameter payloads require
+ // knowing what the parameter kind is.
+ unreachable("This should never be called");
+}
+
+void Remangler::mangleFunctionSignatureSpecializationParamKind(Node *node) {
+ // This should never be called since mangling parameter kinds have influence
+ // on the payloads.
+ unreachable("This should never be called");
+}
+
+void Remangler::mangleProtocolConformance(Node *node) {
+ // type, protocol name, context
+ assert(node->getNumChildren() == 3);
+ mangleChildNode(node, 0);
+ mangleProtocolWithoutPrefix(node->begin()[1]);
+ mangleChildNode(node, 2);
+}
+
+void Remangler::mangleObjCAttribute(Node *node) {
+ Out << "To";
+}
+
+void Remangler::mangleNonObjCAttribute(Node *node) {
+ Out << "TO";
+}
+
+void Remangler::mangleDirectMethodReferenceAttribute(Node *node) {
+ Out << "Td";
+}
+
+void Remangler::mangleDynamicAttribute(Node *node) {
+ Out << "TD";
+}
+
+void Remangler::mangleVTableAttribute(Node *node) {
+ Out << "TV";
+}
+
+void Remangler::mangleGenericTypeMetadataPattern(Node *node) {
+ Out << "MP";
+ mangleSingleChildNode(node); // type
+}
+
+void Remangler::mangleTypeMetadataAccessFunction(Node *node) {
+ Out << "Ma";
+ mangleSingleChildNode(node); // type
+}
+
+void Remangler::mangleTypeMetadataLazyCache(Node *node) {
+ Out << "ML";
+ mangleSingleChildNode(node); // type
+}
+
+void Remangler::mangleMetaclass(Node *node) {
+ Out << "Mm";
+ mangleSingleChildNode(node); // type
+}
+
+void Remangler::mangleNominalTypeDescriptor(Node *node) {
+ Out << "Mn";
+ mangleSingleChildNode(node); // type
+}
+
+void Remangler::mangleTypeMetadata(Node *node) {
+ Out << "M";
+ mangleSingleChildNode(node); // type
+}
+
+void Remangler::mangleFullTypeMetadata(Node *node) {
+ Out << "Mf";
+ mangleChildNodes(node); // type
+}
+
+void Remangler::mangleProtocolDescriptor(Node *node) {
+ Out << "Mp";
+ mangleProtocolWithoutPrefix(node->begin()[0]);
+}
+
+void Remangler::manglePartialApplyForwarder(Node *node) {
+ Out << "PA__T";
+ mangleSingleChildNode(node); // global
+}
+
+void Remangler::manglePartialApplyObjCForwarder(Node *node) {
+ Out << "PAo__T";
+ mangleSingleChildNode(node); // global
+}
+
+void Remangler::mangleDirectness(Node *node) {
+ auto getChar = [](Directness d) -> char {
+ switch (d) {
+ case Directness::Direct: return 'd';
+ case Directness::Indirect: return 'i';
+ }
+ unreachable("bad directness kind");
+ };
+ Out << getChar(Directness(node->getIndex()));
+}
+
+void Remangler::mangleValueWitness(Node *node) {
+ const char *Code = nullptr;
+ switch (ValueWitnessKind(node->getIndex())) {
+#define VALUE_WITNESS(MANGLING, NAME) \
+ case ValueWitnessKind::NAME: Code = #MANGLING; break;
+#include "swift/Demangling/ValueWitnessMangling.def"
+ }
+ Out << 'w' << Code;
+ mangleSingleChildNode(node); // type
+}
+
+void Remangler::mangleValueWitnessTable(Node *node) {
+ Out << "WV";
+ mangleSingleChildNode(node); // type
+}
+
+void Remangler::mangleThrowsAnnotation(Node *node) {
+ Out << "z";
+}
+
+void Remangler::mangleFieldOffset(Node *node) {
+ Out << "Wv";
+ mangleChildNodes(node); // directness, entity
+}
+
+void Remangler::mangleProtocolWitnessTable(Node *node) {
+ Out << "WP";
+ mangleSingleChildNode(node); // protocol conformance
+}
+
+void Remangler::mangleGenericProtocolWitnessTable(Node *node) {
+ Out << "WG";
+ mangleSingleChildNode(node); // protocol conformance
+}
+
+void Remangler::mangleGenericProtocolWitnessTableInstantiationFunction(
+ Node *node) {
+ Out << "WI";
+ mangleSingleChildNode(node); // protocol conformance
+}
+
+void Remangler::mangleProtocolWitnessTableAccessor(Node *node) {
+ Out << "Wa";
+ mangleSingleChildNode(node); // protocol conformance
+}
+
+void Remangler::mangleLazyProtocolWitnessTableAccessor(Node *node) {
+ Out << "Wl";
+ mangleChildNodes(node); // type, protocol conformance
+}
+
+void Remangler::mangleLazyProtocolWitnessTableCacheVariable(Node *node) {
+ Out << "WL";
+ mangleChildNodes(node); // type, protocol conformance
+}
+
+void Remangler::mangleAssociatedTypeMetadataAccessor(Node *node) {
+ Out << "Wt";
+ mangleChildNodes(node); // protocol conformance, identifier
+}
+
+void Remangler::mangleAssociatedTypeWitnessTableAccessor(Node *node) {
+ Out << "WT";
+ assert(node->getNumChildren() == 3);
+ mangleChildNode(node, 0); // protocol conformance
+ mangleChildNode(node, 1); // identifier
+ mangleProtocolWithoutPrefix(node->begin()[2]); // type
+}
+
+void Remangler::mangleReabstractionThunkHelper(Node *node) {
+ Out << "TR";
+ if (node->getNumChildren() == 3) Out << 'G';
+ mangleChildNodes(node); // generic signature?, type, type
+}
+
+void Remangler::mangleReabstractionThunk(Node *node) {
+ Out << "Tr";
+ if (node->getNumChildren() == 3) Out << 'G';
+ mangleChildNodes(node); // generic signature?, type, type
+}
+
+void Remangler::mangleProtocolWitness(Node *node) {
+ Out << "TW";
+ mangleChildNodes(node); // protocol conformance, entity
+}
+
+void Remangler::mangleFunction(Node *node, EntityContext &ctx) {
+ mangleNamedAndTypedEntity(node, 'F', "", ctx);
+}
+
+void Remangler::mangleVariable(Node *node, EntityContext &ctx) {
+ mangleNamedAndTypedEntity(node, 'v', "", ctx);
+}
+
+void Remangler::mangleSubscript(Node *node, EntityContext &ctx) {
+ mangleNamedAndTypedEntity(node, 'i', "", ctx);
+}
+
+void Remangler::mangleInitializer(Node *node, EntityContext &ctx) {
+ mangleSimpleEntity(node, 'I', "i", ctx);
+}
+
+void Remangler::mangleDefaultArgumentInitializer(Node *node,
+ EntityContext &ctx) {
+ mangleNamedEntity(node, 'I', "A", ctx);
+}
+
+void Remangler::mangleDeallocator(Node *node, EntityContext &ctx) {
+ mangleSimpleEntity(node, 'F', "D", ctx);
+}
+
+void Remangler::mangleDestructor(Node *node, EntityContext &ctx) {
+ mangleSimpleEntity(node, 'F', "d", ctx);
+}
+
+void Remangler::mangleAllocator(Node *node, EntityContext &ctx) {
+ mangleTypedEntity(node, 'F', "C", ctx);
+}
+
+void Remangler::mangleConstructor(Node *node, EntityContext &ctx) {
+ mangleTypedEntity(node, 'F', "c", ctx);
+}
+
+void Remangler::mangleIVarInitializer(Node *node, EntityContext &ctx) {
+ mangleSimpleEntity(node, 'F', "e", ctx);
+}
+
+void Remangler::mangleIVarDestroyer(Node *node, EntityContext &ctx) {
+ mangleSimpleEntity(node, 'F', "E", ctx);
+}
+
+void Remangler::mangleGetter(Node *node, EntityContext &ctx) {
+ mangleNamedAndTypedEntity(node, 'F', "g", ctx);
+}
+
+void Remangler::mangleGlobalGetter(Node *node, EntityContext &ctx) {
+ mangleNamedAndTypedEntity(node, 'F', "G", ctx);
+}
+
+void Remangler::mangleSetter(Node *node, EntityContext &ctx) {
+ mangleNamedAndTypedEntity(node, 'F', "s", ctx);
+}
+
+void Remangler::mangleMaterializeForSet(Node *node, EntityContext &ctx) {
+ mangleNamedAndTypedEntity(node, 'F', "m", ctx);
+}
+
+void Remangler::mangleWillSet(Node *node, EntityContext &ctx) {
+ mangleNamedAndTypedEntity(node, 'F', "w", ctx);
+}
+
+void Remangler::mangleDidSet(Node *node, EntityContext &ctx) {
+ mangleNamedAndTypedEntity(node, 'F', "W", ctx);
+}
+
+void Remangler::mangleOwningMutableAddressor(Node *node, EntityContext &ctx) {
+ mangleNamedAndTypedEntity(node, 'F', "aO", ctx);
+}
+
+void Remangler::mangleNativeOwningMutableAddressor(Node *node,
+ EntityContext &ctx) {
+ mangleNamedAndTypedEntity(node, 'F', "ao", ctx);
+}
+
+void Remangler::mangleNativePinningMutableAddressor(Node *node,
+ EntityContext &ctx) {
+ mangleNamedAndTypedEntity(node, 'F', "ap", ctx);
+}
+
+void Remangler::mangleUnsafeMutableAddressor(Node *node, EntityContext &ctx) {
+ mangleNamedAndTypedEntity(node, 'F', "au", ctx);
+}
+
+void Remangler::mangleOwningAddressor(Node *node, EntityContext &ctx) {
+ mangleNamedAndTypedEntity(node, 'F', "lO", ctx);
+}
+
+void Remangler::mangleNativeOwningAddressor(Node *node, EntityContext &ctx) {
+ mangleNamedAndTypedEntity(node, 'F', "lo", ctx);
+}
+
+void Remangler::mangleNativePinningAddressor(Node *node, EntityContext &ctx) {
+ mangleNamedAndTypedEntity(node, 'F', "lp", ctx);
+}
+
+void Remangler::mangleUnsafeAddressor(Node *node, EntityContext &ctx) {
+ mangleNamedAndTypedEntity(node, 'F', "lu", ctx);
+}
+
+void Remangler::mangleExplicitClosure(Node *node, EntityContext &ctx) {
+ mangleNamedAndTypedEntity(node, 'F', "U", ctx); // name is index
+}
+
+void Remangler::mangleImplicitClosure(Node *node, EntityContext &ctx) {
+ mangleNamedAndTypedEntity(node, 'F', "u", ctx); // name is index
+}
+
+void Remangler::mangleStatic(Node *node, EntityContext &ctx) {
+ Out << 'Z';
+ mangleEntityContext(node->getChild(0), ctx);
+}
+
+void Remangler::mangleSimpleEntity(Node *node, char basicKind,
+ StringRef entityKind,
+ EntityContext &ctx) {
+ assert(node->getNumChildren() == 1);
+ Out << basicKind;
+ mangleEntityContext(node->begin()[0], ctx);
+ Out << entityKind;
+}
+
+void Remangler::mangleNamedEntity(Node *node, char basicKind,
+ StringRef entityKind,
+ EntityContext &ctx) {
+ assert(node->getNumChildren() == 2);
+ if (basicKind != '\0') Out << basicKind;
+ mangleEntityContext(node->begin()[0], ctx);
+ Out << entityKind;
+ mangleChildNode(node, 1); // decl name / index
+}
+
+void Remangler::mangleTypedEntity(Node *node, char basicKind,
+ StringRef entityKind,
+ EntityContext &ctx) {
+ assert(node->getNumChildren() == 2);
+ Out << basicKind;
+ mangleEntityContext(node->begin()[0], ctx);
+ Out << entityKind;
+ mangleEntityType(node->begin()[1], ctx);
+}
+
+void Remangler::mangleNamedAndTypedEntity(Node *node, char basicKind,
+ StringRef entityKind,
+ EntityContext &ctx) {
+ assert(node->getNumChildren() == 3);
+ Out << basicKind;
+ mangleEntityContext(node->begin()[0], ctx);
+ Out << entityKind;
+ mangleChildNode(node, 1); // decl name / index
+ mangleEntityType(node->begin()[2], ctx);
+}
+
+void Remangler::mangleEntityContext(Node *node, EntityContext &ctx) {
+ // Remember that we're mangling a context.
+ EntityContext::ManglingContextRAII raii(ctx);
+
+ switch (node->getKind()) {
+#define NODE(ID) \
+ case Node::Kind::ID:
+#define CONTEXT_NODE(ID)
+#include "swift/Demangling/DemangleNodes.def"
+ unreachable("not a context node");
+
+#define NODE(ID)
+#define CONTEXT_NODE(ID) \
+ case Node::Kind::ID: \
+ return mangle##ID(node, ctx);
+#include "swift/Demangling/DemangleNodes.def"
+ }
+ unreachable("bad node kind");
+}
+
+void Remangler::mangleEntityType(Node *node, EntityContext &ctx) {
+ assert(node->getKind() == Node::Kind::Type);
+ assert(node->getNumChildren() == 1);
+ node = node->begin()[0];
+
+ // Expand certain kinds of type within the entity context.
+ switch (node->getKind()) {
+ case Node::Kind::FunctionType:
+ case Node::Kind::UncurriedFunctionType: {
+ Out << (node->getKind() == Node::Kind::FunctionType ? 'F' : 'f');
+ unsigned inputIndex = node->getNumChildren() - 2;
+ assert(inputIndex <= 1);
+ for (unsigned i = 0; i <= inputIndex; ++i)
+ mangle(node->begin()[i]);
+ auto returnType = node->begin()[inputIndex+1];
+ assert(returnType->getKind() == Node::Kind::ReturnType);
+ assert(returnType->getNumChildren() == 1);
+ mangleEntityType(returnType->begin()[0], ctx);
+ return;
+ }
+ default:
+ mangle(node);
+ return;
+ }
+}
+
+void Remangler::mangleLocalDeclName(Node *node) {
+ Out << 'L';
+ mangleChildNodes(node); // index, identifier
+}
+
+void Remangler::manglePrivateDeclName(Node *node) {
+ Out << 'P';
+ mangleChildNodes(node); // identifier, identifier
+}
+
+void Remangler::mangleTypeMangling(Node *node) {
+ Out << 't';
+ mangleSingleChildNode(node); // type
+}
+
+void Remangler::mangleType(Node *node) {
+ mangleSingleChildNode(node);
+}
+
+template <size_t N>
+static bool stripPrefix(StringRef &string, const char (&data)[N]) {
+ constexpr size_t prefixLength = N - 1;
+ if (!string.startswith(StringRef(data, prefixLength)))
+ return false;
+ string = string.drop_front(prefixLength);
+ return true;
+}
+
+void Remangler::mangleBuiltinTypeName(Node *node) {
+ Out << 'B';
+ StringRef text = node->getText();
+
+ if (text == "Builtin.BridgeObject") {
+ Out << 'b';
+ } else if (text == "Builtin.UnsafeValueBuffer") {
+ Out << 'B';
+ } else if (text == "Builtin.UnknownObject") {
+ Out << 'O';
+ } else if (text == "Builtin.NativeObject") {
+ Out << 'o';
+ } else if (text == "Builtin.RawPointer") {
+ Out << 'p';
+ } else if (text == "Builtin.Word") {
+ Out << 'w';
+ } else if (stripPrefix(text, "Builtin.Int")) {
+ Out << 'i' << text << '_';
+ } else if (stripPrefix(text, "Builtin.Float")) {
+ Out << 'f' << text << '_';
+ } else if (stripPrefix(text, "Builtin.Vec")) {
+ auto split = text.split('x');
+ Out << 'v' << split.first << 'B';
+ if (split.second == "RawPointer") {
+ Out << 'p';
+ } else if (stripPrefix(split.second, "Float")) {
+ Out << 'f' << split.second << '_';
+ } else if (stripPrefix(split.second, "Int")) {
+ Out << 'i' << split.second << '_';
+ } else {
+ unreachable("unexpected builtin vector type");
+ }
+ } else {
+ unreachable("unexpected builtin type");
+ }
+}
+
+void Remangler::mangleTypeAlias(Node *node, EntityContext &ctx) {
+ SubstitutionEntry entry;
+ if (trySubstitution(node, entry)) return;
+ Out << 'a';
+ mangleChildNodes(node); // context, identifier
+ addSubstitution(entry);
+}
+
+void Remangler::mangleFunctionType(Node *node) {
+ Out << 'F';
+ mangleChildNodes(node); // argument tuple, result type
+}
+
+void Remangler::mangleUncurriedFunctionType(Node *node) {
+ Out << 'f';
+ mangleChildNodes(node); // argument tuple, result type
+}
+
+void Remangler::mangleObjCBlock(Node *node) {
+ Out << 'b';
+ mangleChildNodes(node); // argument tuple, result type
+}
+
+void Remangler::mangleCFunctionPointer(Node *node) {
+ Out << 'c';
+ mangleChildNodes(node); // argument tuple, result type
+}
+
+void Remangler::mangleAutoClosureType(Node *node) {
+ Out << 'K';
+ mangleChildNodes(node); // argument tuple, result type
+}
+
+void Remangler::mangleThinFunctionType(Node *node) {
+ Out << "Xf";
+ mangleChildNodes(node); // argument tuple, result type
+}
+
+void Remangler::mangleArgumentTuple(Node *node) {
+ mangleSingleChildNode(node);
+}
+
+void Remangler::mangleReturnType(Node *node) {
+ mangleSingleChildNode(node);
+}
+
+void Remangler::mangleImplFunctionType(Node *node) {
+ Out << "XF";
+ auto i = node->begin(), e = node->end();
+ if (i != e && (*i)->getKind() == Node::Kind::ImplConvention) {
+ StringRef text = (*i)->getText();
+ i++;
+ if (text == "@callee_unowned") {
+ Out << 'd';
+ } else if (text == "@callee_guaranteed") {
+ Out << 'g';
+ } else if (text == "@callee_owned") {
+ Out << 'o';
+ } else {
+ unreachable("bad callee convention");
+ }
+ } else {
+ Out << 't';
+ }
+ for (; i != e &&
+ (*i)->getKind() == Node::Kind::ImplFunctionAttribute; ++i) {
+ mangle(*i); // impl function attribute
+ }
+ if (i != e &&
+ ((*i)->getKind() == Node::Kind::DependentGenericSignature ||
+ (*i)->getKind() == Node::Kind::DependentPseudogenericSignature)) {
+ Out << ((*i)->getKind() == Node::Kind::DependentGenericSignature
+ ? 'G' : 'g');
+ mangleDependentGenericSignature((*i));
+ i++;
+ }
+ Out << '_';
+ for (; i != e && (*i)->getKind() == Node::Kind::ImplParameter; ++i) {
+ mangleImplParameter(*i);
+ }
+ Out << '_';
+ mangleNodes(i, e); // impl results
+ Out << '_';
+}
+
+void Remangler::mangleImplFunctionAttribute(Node *node) {
+ StringRef text = node->getText();
+ if (text == "@convention(block)") {
+ Out << "Cb";
+ } else if (text == "@convention(c)") {
+ Out << "Cc";
+ } else if (text == "@convention(method)") {
+ Out << "Cm";
+ } else if (text == "@convention(objc_method)") {
+ Out << "CO";
+ } else if (text == "@convention(witness_method)") {
+ Out << "Cw";
+ } else {
+ unreachable("bad impl-function-attribute");
+ }
+}
+
+void Remangler::mangleImplParameter(Node *node) {
+ assert(node->getNumChildren() == 2);
+ mangleChildNodes(node); // impl convention, type
+}
+
+void Remangler::mangleImplErrorResult(Node *node) {
+ assert(node->getNumChildren() == 2);
+ Out << 'z';
+ mangleChildNodes(node); // impl convention, type
+}
+
+void Remangler::mangleImplResult(Node *node) {
+ assert(node->getNumChildren() == 2);
+ mangleChildNodes(node); // impl convention, type
+}
+
+void Remangler::mangleImplConvention(Node *node) {
+ assert(node->getKind() == Node::Kind::ImplConvention);
+ StringRef text = node->getText();
+ if (text == "@autoreleased") {
+ Out << 'a';
+ } else if (text == "@unowned") {
+ Out << 'd';
+ } else if (text == "@unowned_inner_pointer") {
+ Out << 'D'; // only in results
+ } else if (text == "@guaranteed") {
+ Out << 'g';
+ } else if (text == "@deallocating") {
+ Out << 'e';
+ } else if (text == "@in") {
+ Out << 'i'; // only in parameters
+ } else if (text == "@out") {
+ Out << 'i'; // only in results
+ } else if (text == "@inout") {
+ Out << 'l';
+ } else if (text == "@owned") {
+ Out << 'o';
+ } else {
+ unreachable("invalid impl convention");
+ }
+}
+
+void Remangler::mangleDynamicSelf(Node *node) {
+ Out << 'D';
+ mangleSingleChildNode(node); // type
+}
+
+void Remangler::mangleErrorType(Node *node) {
+ Out << "ERR";
+}
+
+void Remangler::mangleSILBoxType(Node *node) {
+ Out << 'X' << 'b';
+ mangleSingleChildNode(node);
+}
+
+void Remangler::mangleMetatype(Node *node) {
+ if (node->getNumChildren() == 1) {
+ Out << 'M';
+ mangleSingleChildNode(node); // type
+ } else {
+ assert(node->getNumChildren() == 2);
+ Out << "XM";
+ mangleChildNodes(node); // metatype representation, type
+ }
+}
+
+void Remangler::mangleExistentialMetatype(Node *node) {
+ if (node->getNumChildren() == 1) {
+ Out << "PM";
+ mangleSingleChildNode(node); // type
+ } else {
+ assert(node->getNumChildren() == 2);
+ Out << "XPM";
+ mangleChildNodes(node); // metatype representation, type
+ }
+}
+
+void Remangler::mangleMetatypeRepresentation(Node *node) {
+ StringRef text = node->getText();
+ if (text == "@thin") {
+ Out << 't';
+ } else if (text == "@thick") {
+ Out << 'T';
+ } else if (text == "@objc_metatype") {
+ Out << 'o';
+ } else {
+ unreachable("bad metatype representation");
+ }
+}
+
+void Remangler::mangleProtocolList(Node *node) {
+ // In its usual use as a type, this gets a prefix 'P'.
+ Out << 'P';
+ mangleProtocolListWithoutPrefix(node);
+}
+
+void Remangler::mangleProtocolListWithoutPrefix(Node *node,
+ Node *additionalProto) {
+ assert(node->getKind() == Node::Kind::ProtocolList);
+ assert(node->getNumChildren() == 1);
+ auto typeList = node->begin()[0];
+ assert(typeList->getKind() == Node::Kind::TypeList);
+ for (auto &child : *typeList) {
+ mangleProtocolWithoutPrefix(child);
+ }
+ if (additionalProto) {
+ mangleProtocolWithoutPrefix(additionalProto);
+ }
+ Out << '_';
+}
+
+void Remangler::mangleUnowned(Node *node) {
+ Out << "Xo";
+ mangleSingleChildNode(node); // type
+}
+
+void Remangler::mangleUnmanaged(Node *node) {
+ Out << "Xu";
+ mangleSingleChildNode(node); // type
+}
+
+void Remangler::mangleWeak(Node *node) {
+ Out << "Xw";
+ mangleSingleChildNode(node); // type
+}
+
+void Remangler::mangleInOut(Node *node) {
+ Out << 'R';
+ mangleSingleChildNode(node); // type
+}
+
+void Remangler::mangleTuple(Node *node) {
+ size_t NumElems = node->getNumChildren();
+ if (NumElems > 0 &&
+ node->getChild(NumElems - 1)->getFirstChild()->getKind() ==
+ Node::Kind::VariadicMarker) {
+ Out << 't';
+ } else {
+ Out << 'T';
+ }
+ mangleChildNodes(node); // tuple elements
+ Out << '_';
+}
+
+void Remangler::mangleTupleElement(Node *node) {
+ mangleChildNodes(node); // tuple element name?, type
+}
+
+void Remangler::mangleTupleElementName(Node *node) {
+ mangleIdentifier(node->getText(), OperatorKind::NotOperator);
+}
+
+void Remangler::mangleDependentGenericType(Node *node) {
+ Out << 'u';
+ mangleChildNodes(node); // generic signature, type
+}
+
+void Remangler::mangleDependentPseudogenericSignature(Node *node) {
+ mangleDependentGenericSignature(node);
+}
+
+void Remangler::mangleDependentGenericSignature(Node *node) {
+ auto i = node->begin(), e = node->end();
+
+ // If there's only one generic param, mangle nothing.
+ if (node->getNumChildren() >= 1
+ && node->getChild(0)->getKind() == Node::Kind::DependentGenericParamCount
+ && node->getChild(0)->getIndex() == 1
+ && (node->getNumChildren() == 1
+ || node->getChild(1)->getKind() != Node::Kind::DependentGenericParamCount))
+ {
+ ++i;
+ goto mangle_requirements;
+ }
+
+ // Remangle generic params.
+ for (; i != e &&
+ (*i)->getKind() == Node::Kind::DependentGenericParamCount; ++i) {
+ auto count = *i;
+ if (count->getIndex() > 0)
+ mangleIndex(count->getIndex() - 1);
+ else
+ Out << 'z';
+ }
+
+mangle_requirements:
+ if (i == e) { // no generic requirements
+ Out << 'r';
+ return;
+ }
+
+ Out << 'R';
+ mangleNodes(i, e); // generic requirements
+ Out << 'r';
+}
+
+void Remangler::mangleDependentGenericParamCount(Node *node) {
+ unreachable("handled inline in DependentGenericSignature");
+}
+
+void Remangler::mangleDependentGenericConformanceRequirement(Node *node) {
+ mangleConstrainedType(node->getChild(0));
+ // If the constraint represents a protocol, use the shorter mangling.
+ if (node->getNumChildren() == 2
+ && node->getChild(1)->getKind() == Node::Kind::Type
+ && node->getChild(1)->getNumChildren() == 1
+ && node->getChild(1)->getChild(0)->getKind() == Node::Kind::Protocol) {
+ mangleProtocolWithoutPrefix(node->getChild(1)->getChild(0));
+ return;
+ }
+
+ mangle(node->getChild(1));
+}
+
+void Remangler::mangleDependentGenericSameTypeRequirement(Node *node) {
+ mangleConstrainedType(node->getChild(0));
+ Out << 'z';
+ mangle(node->getChild(1));
+}
+
+void Remangler::mangleDependentGenericLayoutRequirement(Node *node) {
+ mangleConstrainedType(node->getChild(0));
+ Out << 'l';
+ auto id = node->getChild(1)->getText();
+ auto size = -1;
+ if (node->getNumChildren() > 2) {
+ size = node->getChild(2)->getIndex();
+ }
+ int alignment = -1;
+ if (node->getNumChildren() > 3) {
+ alignment = node->getChild(3)->getIndex();
+ }
+ Out << id;
+ if (size >= 0)
+ Out << size;
+ if (alignment >= 0) {
+ Out << "_" << alignment;
+ }
+}
+
+void Remangler::mangleConstrainedType(Node *node) {
+ if (node->getFirstChild()->getKind()
+ == Node::Kind::DependentGenericParamType) {
+ // Can be mangled without an introducer.
+ mangleDependentGenericParamIndex(node->getFirstChild());
+ } else {
+ mangle(node);
+ }
+}
+
+void Remangler::mangleAssociatedType(Node *node) {
+ if (node->hasChildren()) {
+ assert(node->getNumChildren() == 1);
+ mangleProtocolListWithoutPrefix(*node->begin());
+ } else {
+ Out << '_';
+ }
+}
+
+void Remangler::mangleQualifiedArchetype(Node *node) {
+ Out << "Qq";
+ mangleChildNodes(node); // index, declcontext
+}
+
+void Remangler::mangleDeclContext(Node *node) {
+ mangleSingleChildNode(node);
+}
+
+void Remangler::mangleExtension(Node *node, EntityContext &ctx) {
+ assert(node->getNumChildren() == 2 || node->getNumChildren() == 3);
+ if (node->getNumChildren() == 3) {
+ Out << 'e';
+ } else {
+ Out << 'E';
+ }
+ mangleEntityContext(node->begin()[0], ctx); // module
+ if (node->getNumChildren() == 3) {
+ mangleDependentGenericSignature(node->begin()[2]); // generic sig
+ }
+ mangleEntityContext(node->begin()[1], ctx); // context
+}
+
+void Remangler::mangleModule(Node *node, EntityContext &ctx) {
+ SubstitutionEntry entry;
+ if (trySubstitution(node, entry)) return;
+
+ // Module types get an M prefix, but module contexts don't.
+ if (!ctx.isAsContext()) Out << 'M';
+ mangleIdentifier(node->getText(), OperatorKind::NotOperator);
+ addSubstitution(entry);
+}
+
+void Remangler::mangleAssociatedTypeRef(Node *node) {
+ SubstitutionEntry entry;
+ if (trySubstitution(node, entry)) return;
+ Out << "Q";
+ mangleChildNodes(node); // type, identifier
+ addSubstitution(entry);
+}
+
+void Remangler::mangleDependentMemberType(Node *node) {
+ std::vector<Node *> members;
+ Node *base = node;
+ do {
+ members.push_back(base);
+ base = base->getFirstChild()->getFirstChild();
+ } while (base->getKind() == Node::Kind::DependentMemberType);
+
+ assert(base->getKind() == Node::Kind::DependentGenericParamType
+ && "dependent members not based on a generic param are non-canonical"
+ " and shouldn't need remangling");
+ assert(members.size() >= 1);
+ if (members.size() == 1) {
+ Out << 'w';
+ mangleDependentGenericParamIndex(base);
+ mangle(members[0]->getChild(1));
+ } else {
+ Out << 'W';
+ mangleDependentGenericParamIndex(base);
+
+ for (unsigned i = 1, n = members.size(); i <= n; ++i) {
+ Node *member = members[n - i];
+ mangle(member->getChild(1));
+ }
+ Out << '_';
+ }
+}
+
+void Remangler::mangleDependentAssociatedTypeRef(Node *node) {
+ SubstitutionEntry entry;
+ if (trySubstitution(node, entry)) return;
+
+ if (node->getNumChildren() > 0) {
+ Out << 'P';
+ mangleProtocolWithoutPrefix(node->getFirstChild());
+ }
+ mangleIdentifier(node);
+
+ addSubstitution(entry);
+}
+
+void Remangler::mangleDependentGenericParamIndex(Node *node) {
+ auto depth = node->getChild(0)->getIndex();
+ auto index = node->getChild(1)->getIndex();
+
+ if (depth != 0) {
+ Out << 'd';
+ mangleIndex(depth - 1);
+ mangleIndex(index);
+ return;
+ }
+ if (index != 0) {
+ mangleIndex(index - 1);
+ return;
+ }
+
+ // depth == index == 0
+ Out << 'x';
+}
+
+void Remangler::mangleDependentGenericParamType(Node *node) {
+ if (node->getChild(0)->getIndex() == 0
+ && node->getChild(1)->getIndex() == 0) {
+ Out << 'x';
+ return;
+ }
+
+ Out << 'q';
+ mangleDependentGenericParamIndex(node);
+}
+
+void Remangler::mangleIndex(Node *node) {
+ mangleIndex(node->getIndex());
+}
+
+void Remangler::mangleProtocol(Node *node, EntityContext &ctx) {
+ mangleNominalType(node, 'P', ctx);
+}
+
+void Remangler::mangleProtocolWithoutPrefix(Node *node) {
+ if (node->getKind() == Node::Kind::Type) {
+ assert(node->getNumChildren() == 1);
+ node = node->begin()[0];
+ }
+
+ assert(node->getKind() == Node::Kind::Protocol);
+ EntityContext ctx;
+ mangleNominalType(node, '\0', ctx);
+}
+
+void Remangler::mangleGenericArgs(Node *node, EntityContext &ctx) {
+ switch (node->getKind()) {
+ case Node::Kind::Structure:
+ case Node::Kind::Enum:
+ case Node::Kind::Class: {
+ NodePointer parentOrModule = node->getChild(0);
+ mangleGenericArgs(parentOrModule, ctx);
+
+ // No generic arguments at this level
+ Out << '_';
+ break;
+ }
+
+ case Node::Kind::BoundGenericStructure:
+ case Node::Kind::BoundGenericEnum:
+ case Node::Kind::BoundGenericClass: {
+ NodePointer unboundType = node->getChild(0);
+ assert(unboundType->getKind() == Node::Kind::Type);
+ NodePointer nominalType = unboundType->getChild(0);
+ NodePointer parentOrModule = nominalType->getChild(0);
+ mangleGenericArgs(parentOrModule, ctx);
+
+ mangleTypeList(node->getChild(1));
+ break;
+ }
+
+ default:
+ break;
+ }
+}
+
+void Remangler::mangleAnyNominalType(Node *node, EntityContext &ctx) {
+ if (isSpecialized(node)) {
+ Out << 'G';
+
+ NodePointer unboundType = getUnspecialized(node, Factory);
+
+ mangleAnyNominalType(unboundType, ctx);
+ mangleGenericArgs(node, ctx);
+ return;
+ }
+
+ switch (node->getKind()) {
+ case Node::Kind::Structure:
+ mangleNominalType(node, 'V', ctx);
+ break;
+ case Node::Kind::Enum:
+ mangleNominalType(node, 'O', ctx);
+ break;
+ case Node::Kind::Class:
+ mangleNominalType(node, 'C', ctx);
+ break;
+ default:
+ unreachable("bad nominal type kind");
+ }
+}
+
+void Remangler::mangleStructure(Node *node, EntityContext &ctx) {
+ mangleAnyNominalType(node, ctx);
+}
+
+void Remangler::mangleEnum(Node *node, EntityContext &ctx) {
+ mangleAnyNominalType(node, ctx);
+}
+
+void Remangler::mangleClass(Node *node, EntityContext &ctx) {
+ mangleAnyNominalType(node, ctx);
+}
+
+void Remangler::mangleNominalType(Node *node, char kind, EntityContext &ctx) {
+ SubstitutionEntry entry;
+ if (trySubstitution(node, entry)) return;
+ mangleNamedEntity(node, kind, "", ctx);
+ addSubstitution(entry);
+}
+
+void Remangler::mangleBoundGenericClass(Node *node) {
+ EntityContext ctx;
+ mangleAnyNominalType(node, ctx);
+}
+
+void Remangler::mangleBoundGenericStructure(Node *node) {
+ EntityContext ctx;
+ mangleAnyNominalType(node, ctx);
+}
+
+void Remangler::mangleBoundGenericEnum(Node *node) {
+ EntityContext ctx;
+ mangleAnyNominalType(node, ctx);
+}
+
+void Remangler::mangleTypeList(Node *node) {
+ mangleChildNodes(node); // all types
+ Out << '_';
+}
+
+void Remangler::mangleReflectionMetadataBuiltinDescriptor(Node *node) {
+ Out << "MRb";
+}
+
+void Remangler::mangleReflectionMetadataFieldDescriptor(Node *node) {
+ Out << "MRf";
+}
+
+void Remangler::mangleReflectionMetadataAssocTypeDescriptor(Node *node) {
+ Out << "MRa";
+}
+
+void Remangler::mangleReflectionMetadataSuperclassDescriptor(Node *node) {
+ Out << "MRc";
+}
+
+void Remangler::mangleGenericTypeParamDecl(Node *node) {
+ unreachable("todo");
+}
+
+void Remangler::mangleCurryThunk(Node *node, EntityContext &ctx) {
+ Out << "<curry-thunk>";
+}
+
+void Remangler::mangleEmptyList(Node *node) {
+ Out << "<empty>";
+}
+
+void Remangler::mangleFirstElementMarker(Node *node) {
+ Out << "<first>";
+}
+
+void Remangler::mangleVariadicMarker(Node *node) {
+ // Handled in mangleTuple
+}
+
+void Remangler::mangleOutlinedCopy(Node *node) {
+ Out << "Wy";
+ mangleChildNodes(node);
+}
+
+void Remangler::mangleOutlinedConsume(Node *node) {
+ Out << "We";
+ mangleChildNodes(node);
+}
+
+void Remangler::mangleOutlinedRetain(Node *node) {
+ Out << "Wr";
+ mangleSingleChildNode(node);
+}
+
+void Remangler::mangleOutlinedRelease(Node *node) {
+ Out << "Ws";
+ mangleSingleChildNode(node);
+}
+
+void Remangler::mangleKeyPathGetterThunkHelper(Node *node) {
+ Out << "TK";
+ mangleChildNodes(node);
+}
+
+void Remangler::mangleKeyPathSetterThunkHelper(Node *node) {
+ Out << "Tk";
+ mangleChildNodes(node);
+}
+
+void Remangler::mangleProtocolListWithClass(Node *node) {
+ Out << "Xc";
+ mangleChildNode(node, 1);
+ mangleProtocolListWithoutPrefix(node->getChild(0));
+}
+
+void Remangler::mangleProtocolListWithAnyObject(Node *node) {
+ Node *P = Factory.createNode(Node::Kind::Protocol);
+ P->addChild(Factory.createNode(Node::Kind::Module, "Swift"), Factory);
+ P->addChild(Factory.createNode(Node::Kind::Identifier, "AnyObject"), Factory);
+ Out << "P";
+ mangleProtocolListWithoutPrefix(node->getChild(0), /*additionalProto*/ P);
+}
+
+void Remangler::mangleVTableThunk(Node *node) {
+ Out << "TV";
+ mangleChildNodes(node);
+}
+
+void Remangler::mangleSILBoxTypeWithLayout(Node *node) {
+ assert(node->getKind() == Node::Kind::SILBoxTypeWithLayout);
+ assert(node->getNumChildren() == 1 || node->getNumChildren() == 3);
+ Out << "XB";
+ auto layout = node->getChild(0);
+ assert(layout->getKind() == Node::Kind::SILBoxLayout);
+ NodePointer genericArgs = nullptr;
+ if (node->getNumChildren() == 3) {
+ NodePointer signature = node->getChild(1);
+ assert(signature->getKind() == Node::Kind::DependentGenericSignature);
+ genericArgs = node->getChild(2);
+ assert(genericArgs->getKind() == Node::Kind::TypeList);
+
+ Out << 'G';
+ mangleDependentGenericSignature(signature);
+ }
+ mangleSILBoxLayout(layout);
+ if (genericArgs) {
+ for (unsigned i = 0; i < genericArgs->getNumChildren(); ++i) {
+ auto type = genericArgs->getChild(i);
+ assert(genericArgs->getKind() == Node::Kind::Type);
+ mangleType(type);
+ }
+ Out << '_';
+ }
+}
+
+void Remangler::mangleSILBoxLayout(Node *node) {
+ assert(node->getKind() == Node::Kind::SILBoxLayout);
+ for (unsigned i = 0; i < node->getNumChildren(); ++i) {
+ assert(node->getKind() == Node::Kind::SILBoxImmutableField
+ || node->getKind() == Node::Kind::SILBoxMutableField);
+ mangle(node->getChild(i));
+
+ }
+ Out << '_';
+}
+
+void Remangler::mangleSILBoxMutableField(Node *node) {
+ Out << 'm';
+ assert(node->getNumChildren() == 1
+ && node->getChild(0)->getKind() == Node::Kind::Type);
+ mangleType(node->getChild(0));
+}
+
+void Remangler::mangleSILBoxImmutableField(Node *node) {
+ Out << 'i';
+ assert(node->getNumChildren() == 1
+ && node->getChild(0)->getKind() == Node::Kind::Type);
+ mangleType(node->getChild(0));
+}
+
+/// The top-level interface to the remangler.
+std::string Demangle::mangleNodeOld(const NodePointer &node) {
+ if (!node) return "";
+
+ DemanglerPrinter printer;
+ Remangler(printer).mangle(node);
+ return std::move(printer).str();
+}
diff --git a/lib/IDE/SwiftSourceDocInfo.cpp b/lib/IDE/SwiftSourceDocInfo.cpp
index d47d801..d5a2adb 100644
--- a/lib/IDE/SwiftSourceDocInfo.cpp
+++ b/lib/IDE/SwiftSourceDocInfo.cpp
@@ -227,10 +227,15 @@
OS << "</Kind>\n";
OS << "<Content>" << Content << "</Content>\n";
- if (Ty) {
+
+ if (auto Ty = ExitInfo.getPointer()) {
OS << "<Type>";
Ty->print(OS);
- OS << "</Type>\n";
+ OS << "</Type>";
+ if (ExitInfo.getInt()) {
+ OS << "<Exit>true</Exit>";
+ }
+ OS << "\n";
}
if (RangeContext) {
@@ -382,7 +387,10 @@
std::vector<ASTNode> ContainedASTNodes;
/// Collect the type that an ASTNode should be evaluated to.
- Type resolveNodeType(ASTNode N, RangeKind Kind) {
+ ReturnTyAndWhetherExit resolveNodeType(ASTNode N, RangeKind Kind) {
+ auto *VoidTy = Ctx.getVoidDecl()->getDeclaredInterfaceType().getPointer();
+ if (N.isNull())
+ return {VoidTy, false};
switch(Kind) {
case RangeKind::Invalid:
case RangeKind::SingleDecl:
@@ -390,14 +398,18 @@
// For a single expression, its type is apparent.
case RangeKind::SingleExpression:
- return N.get<Expr*>()->getType();
+ return {N.get<Expr*>()->getType().getPointer(), false};
// For statements, we either resolve to the returning type or Void.
case RangeKind::SingleStatement:
case RangeKind::MultiStatement: {
if (N.is<Stmt*>()) {
if (auto RS = dyn_cast<ReturnStmt>(N.get<Stmt*>())) {
- return resolveNodeType(RS->getResult(), RangeKind::SingleExpression);
+ return {
+ resolveNodeType(RS->hasResult() ? RS->getResult() : nullptr,
+ RangeKind::SingleExpression).getPointer(),
+ true
+ };
}
// Unbox the brace statement to find its type.
@@ -407,9 +419,25 @@
RangeKind::SingleStatement);
}
}
+
+ // Unbox the if statement to find its type.
+ if (auto *IS = dyn_cast<IfStmt>(N.get<Stmt*>())) {
+ auto ThenTy = resolveNodeType(IS->getThenStmt(),
+ RangeKind::SingleStatement);
+ auto ElseTy = resolveNodeType(IS->getElseStmt(),
+ RangeKind::SingleStatement);
+
+ // If two branches agree on the return type, return that type.
+ if (ThenTy.getPointer()->isEqual(ElseTy.getPointer()) &&
+ ThenTy.getInt() == ElseTy.getInt())
+ return ThenTy;
+
+ // Otherwise, return the error type.
+ return {Ctx.TheErrorType.getPointer(), false};
+ }
}
// For other statements, the type should be void.
- return Ctx.getVoidDecl()->getDeclaredInterfaceType();
+ return {VoidTy, false};
}
}
}
@@ -440,7 +468,7 @@
llvm::makeArrayRef(ReferencedDecls));
else {
assert(Node.is<Decl*>());
- return ResolvedRangeInfo(RangeKind::SingleDecl, Type(), Content,
+ return ResolvedRangeInfo(RangeKind::SingleDecl, {nullptr, false}, Content,
getImmediateContext(), SingleEntry,
UnhandledError, Kind,
llvm::makeArrayRef(ContainedASTNodes),
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
index 1a8f4e2..0c849fd 100644
--- a/lib/Sema/TypeCheckType.cpp
+++ b/lib/Sema/TypeCheckType.cpp
@@ -3266,6 +3266,12 @@
}
Type TypeChecker::getSuperClassOf(Type type) {
+ if (auto *parenTy = dyn_cast<ParenType>(type.getPointer())) {
+ auto superclassTy = getSuperClassOf(parenTy->getUnderlyingType());
+ if (!superclassTy)
+ return Type();
+ return ParenType::get(Context, superclassTy);
+ }
return type->getSuperclass();
}
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp
index 940b9d1..d2c8caf 100644
--- a/lib/Serialization/Deserialization.cpp
+++ b/lib/Serialization/Deserialization.cpp
@@ -165,13 +165,20 @@
getContext().Diags.diagnose(SourceLoc(), diag::serialization_fatal, Name);
if (!CompatibilityVersion.empty()) {
- SmallString<16> buffer;
- llvm::raw_svector_ostream out(buffer);
- out << getContext().LangOpts.EffectiveLanguageVersion;
- if (out.str() != CompatibilityVersion) {
+ if (getContext().LangOpts.EffectiveLanguageVersion
+ != CompatibilityVersion) {
+ SmallString<16> effectiveVersionBuffer, compatVersionBuffer;
+ {
+ llvm::raw_svector_ostream out(effectiveVersionBuffer);
+ out << getContext().LangOpts.EffectiveLanguageVersion;
+ }
+ {
+ llvm::raw_svector_ostream out(compatVersionBuffer);
+ out << CompatibilityVersion;
+ }
getContext().Diags.diagnose(
SourceLoc(), diag::serialization_compatibility_version_mismatch,
- out.str(), Name, CompatibilityVersion);
+ effectiveVersionBuffer, Name, compatVersionBuffer);
}
}
}
@@ -4464,20 +4471,69 @@
ArrayRef<uint64_t>::iterator rawIDIter = rawIDs.begin();
+ // An imported requirement may have changed type between Swift versions.
+ // In this situation we need to do a post-pass to fill in missing
+ // requirements with opaque witnesses.
+ bool needToFillInOpaqueValueWitnesses = false;
while (valueCount--) {
- auto req = cast<ValueDecl>(getDecl(*rawIDIter++));
- auto witness = cast_or_null<ValueDecl>(getDecl(*rawIDIter++));
- assert(witness ||
+ ValueDecl *req;
+
+ auto trySetWitness = [&](Witness w) {
+ if (req)
+ conformance->setWitness(req, w);
+ };
+
+ auto deserializedReq = getDeclChecked(*rawIDIter++);
+ if (deserializedReq) {
+ req = cast<ValueDecl>(*deserializedReq);
+ } else if (getContext().LangOpts.EnableDeserializationRecovery) {
+ consumeError(deserializedReq.takeError());
+ req = nullptr;
+ needToFillInOpaqueValueWitnesses = true;
+ } else {
+ fatal(deserializedReq.takeError());
+ }
+
+ bool isOpaque = false;
+ ValueDecl *witness;
+ auto deserializedWitness = getDeclChecked(*rawIDIter++);
+ if (deserializedWitness) {
+ witness = cast<ValueDecl>(*deserializedWitness);
+ // Across language compatibility versions, the witnessing decl may have
+ // changed its signature as seen by the current compatibility version.
+ // In that case, we want the conformance to still be available, but
+ // we can't make use of the relationship to the underlying decl.
+ } else if (getContext().LangOpts.EnableDeserializationRecovery) {
+ consumeError(deserializedWitness.takeError());
+ isOpaque = true;
+ witness = nullptr;
+ } else {
+ fatal(deserializedWitness.takeError());
+ }
+
+ assert(!req || isOpaque || witness ||
req->getAttrs().hasAttribute<OptionalAttr>() ||
req->getAttrs().isUnavailable(getContext()));
- if (!witness) {
- conformance->setWitness(req, Witness());
+ if (!witness && !isOpaque) {
+ trySetWitness(Witness());
continue;
}
// Generic signature and environment.
GenericSignature *syntheticSig = nullptr;
GenericEnvironment *syntheticEnv = nullptr;
+
+ auto trySetOpaqueWitness = [&]{
+ if (!req)
+ return;
+
+ // We shouldn't yet need to worry about generic requirements, since
+ // an imported ObjC method should never be generic.
+ assert(syntheticSig == nullptr && syntheticEnv == nullptr &&
+ "opaque witness shouldn't be generic yet. when this is "
+ "possible, it should use forwarding substitutions");
+ conformance->setWitness(req, Witness::forOpaque(req));
+ };
// Requirement -> synthetic map.
SmallVector<Substitution, 4> reqToSyntheticSubs;
@@ -4518,16 +4574,22 @@
}
}
+ // Handle opaque witnesses that couldn't be deserialized.
+ if (isOpaque) {
+ trySetOpaqueWitness();
+ continue;
+ }
+
// Handle simple witnesses.
if (witnessSubstitutions.empty() && !syntheticSig && !syntheticEnv &&
reqToSyntheticSubs.empty()) {
- conformance->setWitness(req, Witness(witness));
+ trySetWitness(Witness(witness));
continue;
}
// Set the witness.
- conformance->setWitness(req, Witness(witness, witnessSubstitutions,
- syntheticEnv, reqToSyntheticSubs));
+ trySetWitness(Witness(witness, witnessSubstitutions,
+ syntheticEnv, reqToSyntheticSubs));
}
assert(rawIDIter <= rawIDs.end() && "read too much");
@@ -4558,6 +4620,20 @@
conformance->setTypeWitness(typeWitness.first, typeWitness.second.first,
typeWitness.second.second);
}
+
+ // Fill in opaque value witnesses if we need to.
+ if (needToFillInOpaqueValueWitnesses) {
+ for (auto member : proto->getMembers()) {
+ // We only care about non-associated-type requirements.
+ auto valueMember = dyn_cast<ValueDecl>(member);
+ if (!valueMember || !valueMember->isProtocolRequirement()
+ || isa<AssociatedTypeDecl>(valueMember))
+ continue;
+
+ if (!conformance->hasWitness(valueMember))
+ conformance->setWitness(valueMember, Witness::forOpaque(valueMember));
+ }
+ }
}
GenericEnvironment *ModuleFile::loadGenericEnvironment(const DeclContext *decl,
diff --git a/lib/Serialization/ModuleFile.cpp b/lib/Serialization/ModuleFile.cpp
index 02bc030..d5cf782 100644
--- a/lib/Serialization/ModuleFile.cpp
+++ b/lib/Serialization/ModuleFile.cpp
@@ -200,7 +200,9 @@
default:
// Add new cases here, in descending order.
case 4:
- result.compatibilityVersion = blobData.substr(scratch[2]+1, scratch[3]);
+ result.compatibilityVersion =
+ version::Version(blobData.substr(scratch[2]+1, scratch[3]),
+ SourceLoc(), nullptr);
LLVM_FALLTHROUGH;
case 3:
result.shortVersion = blobData.slice(0, scratch[2]);
diff --git a/stdlib/private/StdlibCollectionUnittest/CheckCollectionInstance.swift.gyb b/stdlib/private/StdlibCollectionUnittest/CheckCollectionInstance.swift.gyb
index 3bb4871..f4dea7b 100644
--- a/stdlib/private/StdlibCollectionUnittest/CheckCollectionInstance.swift.gyb
+++ b/stdlib/private/StdlibCollectionUnittest/CheckCollectionInstance.swift.gyb
@@ -257,8 +257,7 @@
${TRACE},
resiliencyChecks: CollectionMisuseResiliencyChecks = .all,
sameValue: (${Element}, ${Element}) -> Bool
-) where C.Iterator.Element == ${Element},
- C.SubSequence : Collection {
+) where C.Iterator.Element == ${Element} {
checkForwardCollection(expected, collection, message(),
stackTrace: stackTrace, showFrame: showFrame, file: file, line: line,
@@ -278,7 +277,6 @@
resiliencyChecks: CollectionMisuseResiliencyChecks = .all
) where
C.Iterator.Element == ${Element},
- C.SubSequence : ${TraversalCollection},
${Element} : Equatable {
check${Traversal}Collection(
@@ -298,8 +296,7 @@
resiliencyChecks: CollectionMisuseResiliencyChecks = .all,
sameValue: (${Element}, ${Element}) -> Bool
) where
- C.Iterator.Element == ${Element},
- C.SubSequence : ${TraversalCollection} {
+ C.Iterator.Element == ${Element} {
checkOneLevelOf${Traversal}Collection(expected, collection, ${trace},
resiliencyChecks: resiliencyChecks, sameValue: sameValue)
@@ -504,8 +501,7 @@
resiliencyChecks: CollectionMisuseResiliencyChecks = .all,
sameValue: (${Element}, ${Element}) -> Bool
) where
- S.Iterator.Element == ${Element},
- S.SubSequence : ${TraversalCollection} {
+ S.Iterator.Element == ${Element} {
let expectedArray = Array(expected)
diff --git a/stdlib/private/StdlibCollectionUnittest/CheckCollectionType.swift.gyb b/stdlib/private/StdlibCollectionUnittest/CheckCollectionType.swift.gyb
index 8ce2040..a550216 100644
--- a/stdlib/private/StdlibCollectionUnittest/CheckCollectionType.swift.gyb
+++ b/stdlib/private/StdlibCollectionUnittest/CheckCollectionType.swift.gyb
@@ -471,16 +471,9 @@
%{
from gyb_stdlib_support import collectionForTraversal
def testConstraints(protocol):
- if protocol == 'Collection':
- subseq_as_collection = 'CollectionWithEquatableElement.SubSequence : Collection,'
- else:
- subseq_as_collection=''
return '''
C : %(protocol)s,
CollectionWithEquatableElement : %(protocol)s,
- %(subseq_as_collection)s
- C.SubSequence : %(protocol)s,
- C.Indices : %(protocol)s,
CollectionWithEquatableElement.Iterator.Element : Equatable
''' % locals()
@@ -494,6 +487,7 @@
[CollectionWithEquatableElement.Iterator.Element]
) -> CollectionWithEquatableElement,
+
wrapValueIntoEquatable: @escaping (
MinimalEquatableValue) -> CollectionWithEquatableElement.Iterator.Element,
diff --git a/stdlib/private/StdlibCollectionUnittest/CheckMutableCollectionType.swift.gyb b/stdlib/private/StdlibCollectionUnittest/CheckMutableCollectionType.swift.gyb
index c20f755..fb13a1a 100644
--- a/stdlib/private/StdlibCollectionUnittest/CheckMutableCollectionType.swift.gyb
+++ b/stdlib/private/StdlibCollectionUnittest/CheckMutableCollectionType.swift.gyb
@@ -121,8 +121,6 @@
isFixedLengthCollection: Bool,
collectionIsBidirectional: Bool = false
) where
- C.SubSequence : MutableCollection,
- C.Indices : Collection,
CollectionWithEquatableElement.Iterator.Element : Equatable,
CollectionWithComparableElement.Iterator.Element : Comparable {
@@ -783,8 +781,6 @@
withUnsafeMutableBufferPointerIsSupported: Bool,
isFixedLengthCollection: Bool
) where
- C.SubSequence : BidirectionalCollection & MutableCollection,
- C.Indices : BidirectionalCollection,
CollectionWithEquatableElement.Iterator.Element : Equatable,
CollectionWithComparableElement.Iterator.Element : Comparable {
@@ -929,8 +925,6 @@
withUnsafeMutableBufferPointerIsSupported: Bool,
isFixedLengthCollection: Bool
) where
- C.SubSequence : RandomAccessCollection & MutableCollection,
- C.Indices : RandomAccessCollection,
CollectionWithEquatableElement.Iterator.Element : Equatable,
CollectionWithComparableElement.Iterator.Element : Comparable {
diff --git a/stdlib/private/StdlibCollectionUnittest/CheckRangeReplaceableCollectionType.swift b/stdlib/private/StdlibCollectionUnittest/CheckRangeReplaceableCollectionType.swift
index 14363c6..245f486 100644
--- a/stdlib/private/StdlibCollectionUnittest/CheckRangeReplaceableCollectionType.swift
+++ b/stdlib/private/StdlibCollectionUnittest/CheckRangeReplaceableCollectionType.swift
@@ -462,10 +462,7 @@
outOfBoundsIndexOffset: Int = 1,
collectionIsBidirectional: Bool = false
) where
- C.SubSequence : Collection,
- C.Indices : Collection,
- CollectionWithEquatableElement.Iterator.Element : Equatable,
- CollectionWithEquatableElement.SubSequence : Collection {
+ CollectionWithEquatableElement.Iterator.Element : Equatable {
var testNamePrefix = testNamePrefix
@@ -1180,8 +1177,6 @@
resiliencyChecks: CollectionMisuseResiliencyChecks = .all,
outOfBoundsIndexOffset: Int = 1
) where
- C.SubSequence : BidirectionalCollection & RangeReplaceableCollection,
- C.Indices : BidirectionalCollection,
CollectionWithEquatableElement.Iterator.Element : Equatable {
var testNamePrefix = testNamePrefix
@@ -1302,8 +1297,6 @@
resiliencyChecks: CollectionMisuseResiliencyChecks = .all,
outOfBoundsIndexOffset: Int = 1
) where
- C.SubSequence : RandomAccessCollection & RangeReplaceableCollection,
- C.Indices : RandomAccessCollection,
CollectionWithEquatableElement.Iterator.Element : Equatable {
var testNamePrefix = testNamePrefix
diff --git a/stdlib/private/StdlibCollectionUnittest/CheckRangeReplaceableSliceType.swift b/stdlib/private/StdlibCollectionUnittest/CheckRangeReplaceableSliceType.swift
index fb10e30..28a802e 100644
--- a/stdlib/private/StdlibCollectionUnittest/CheckRangeReplaceableSliceType.swift
+++ b/stdlib/private/StdlibCollectionUnittest/CheckRangeReplaceableSliceType.swift
@@ -33,7 +33,6 @@
collectionIsBidirectional: Bool = false
) where
C.SubSequence == C,
- C.Indices : Collection,
CollectionWithEquatableElement.SubSequence == CollectionWithEquatableElement,
CollectionWithEquatableElement.Iterator.Element : Equatable {
@@ -165,7 +164,6 @@
outOfBoundsIndexOffset: Int = 1
) where
C.SubSequence == C,
- C.Indices : BidirectionalCollection,
CollectionWithEquatableElement.SubSequence == CollectionWithEquatableElement,
CollectionWithEquatableElement.Iterator.Element : Equatable {
@@ -310,7 +308,6 @@
outOfBoundsIndexOffset: Int = 1
) where
C.SubSequence == C,
- C.Indices : RandomAccessCollection,
CollectionWithEquatableElement.SubSequence == CollectionWithEquatableElement,
CollectionWithEquatableElement.Iterator.Element : Equatable {
diff --git a/stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb b/stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb
index 2d61bee..02b1df0 100644
--- a/stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb
+++ b/stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb
@@ -376,14 +376,7 @@
% for Mutable in ['', 'Mutable']:
public func expect${Mutable}CollectionType<X : ${Mutable}Collection>(
_ x: X.Type
-) where
- // FIXME(ABI)#2 (Associated Types with where clauses): there should be no constraints in
- // the 'where' clause, all of these should be required by the protocol.
-% if Mutable == '':
- X.SubSequence : Collection,
-% end
- // X.SubSequence.Indices == X.Indices, // FIXME(ABI)#3 (Recursive Protocol Constraints): can't have this constraint now.
- X.Indices : Collection {}
+) { }
% end
/// A slice is a `Collection` that when sliced returns an instance of
@@ -421,12 +414,7 @@
indexType: X.Index.Type,
indexDistanceType: X.IndexDistance.Type,
indicesType: X.Indices.Type
-) where
- // FIXME(ABI)#6 (Associated Types with where clauses): there should be no constraints in
- // the 'where' clause, all of these should be required by the protocol.
- X.SubSequence : Collection,
- // X.SubSequence.Indices == X.Indices, // FIXME(ABI)#7 (Recursive Protocol Constraints): can't have this constraint now.
- X.Indices : Collection {}
+) { }
/// Check that all associated types of a `BidirectionalCollection` are what we
/// expect them to be.
@@ -437,12 +425,7 @@
indexType: X.Index.Type,
indexDistanceType: X.IndexDistance.Type,
indicesType: X.Indices.Type
-) where
- // FIXME(ABI)#8 (Associated Types with where clauses): there should be no constraints in
- // the 'where' clause, all of these should be required by the protocol.
- X.SubSequence : BidirectionalCollection,
- // X.SubSequence.Indices == X.Indices, // FIXME(ABI)#9 (Recursive Protocol Constraints): can't have this constraint now.
- X.Indices : BidirectionalCollection {}
+) { }
/// Check that all associated types of a `RandomAccessCollection` are what we
/// expect them to be.
@@ -453,12 +436,7 @@
indexType: X.Index.Type,
indexDistanceType: X.IndexDistance.Type,
indicesType: X.Indices.Type
-) where
- // FIXME(ABI)#10 (Associated Types with where clauses): there should be no constraints in
- // the 'where' clause, all of these should be required by the protocol.
- X.SubSequence : RandomAccessCollection,
- // X.SubSequence.Indices == X.Indices, // FIXME(ABI)#11 (Recursive Protocol Constraints): can't have this constraint now.
- X.Indices : RandomAccessCollection {}
+) { }
public struct AssertionResult : CustomStringConvertible {
init(isPass: Bool) {
diff --git a/stdlib/public/core/ArrayBufferProtocol.swift b/stdlib/public/core/ArrayBufferProtocol.swift
index 2748e6d..c5a248c 100644
--- a/stdlib/public/core/ArrayBufferProtocol.swift
+++ b/stdlib/public/core/ArrayBufferProtocol.swift
@@ -16,7 +16,7 @@
internal protocol _ArrayBufferProtocol
: MutableCollection, RandomAccessCollection {
- associatedtype Indices : RandomAccessCollection = CountableRange<Int>
+ associatedtype Indices = CountableRange<Int>
/// The type of elements stored in the buffer.
associatedtype Element
diff --git a/stdlib/public/core/BidirectionalCollection.swift b/stdlib/public/core/BidirectionalCollection.swift
index f7349e2..0668e05 100644
--- a/stdlib/public/core/BidirectionalCollection.swift
+++ b/stdlib/public/core/BidirectionalCollection.swift
@@ -65,8 +65,8 @@
/// `c.index(before: c.index(after: i)) == i`.
/// - If `i > c.startIndex && i <= c.endIndex`
/// `c.index(after: c.index(before: i)) == i`.
-public protocol BidirectionalCollection
- : _BidirectionalIndexable, Collection {
+public protocol BidirectionalCollection : _BidirectionalIndexable, Collection
+where SubSequence: BidirectionalCollection, Indices: BidirectionalCollection {
// TODO: swift-3-indexing-model - replaces functionality in BidirectionalIndex
/// Returns the position immediately before the given index.
@@ -84,17 +84,11 @@
/// A sequence that can represent a contiguous subrange of the collection's
/// elements.
- associatedtype SubSequence : _BidirectionalIndexable, Collection
- = BidirectionalSlice<Self>
- // FIXME(ABI)#93 (Recursive Protocol Constraints):
- // associatedtype SubSequence : BidirectionalCollection
+ associatedtype SubSequence = BidirectionalSlice<Self>
/// A type that represents the indices that are valid for subscripting the
/// collection, in ascending order.
- associatedtype Indices : _BidirectionalIndexable, Collection
- = DefaultBidirectionalIndices<Self>
- // FIXME(ABI)#95 (Recursive Protocol Constraints):
- // associatedtype Indices : BidirectionalCollection
+ associatedtype Indices = DefaultBidirectionalIndices<Self>
/// The indices that are valid for subscripting the collection, in ascending
/// order.
diff --git a/stdlib/public/core/Collection.swift b/stdlib/public/core/Collection.swift
index f7a8175..fb8f0f9 100644
--- a/stdlib/public/core/Collection.swift
+++ b/stdlib/public/core/Collection.swift
@@ -642,7 +642,10 @@
/// forward or bidirectional collection must traverse the entire collection to
/// count the number of contained elements, accessing its `count` property is
/// an O(*n*) operation.
-public protocol Collection : _Indexable, Sequence {
+public protocol Collection : _Indexable, Sequence
+where SubSequence: Collection, Indices: Collection,
+ SubSequence.Index == Index
+{
/// A type that represents the number of steps between a pair of
/// indices.
associatedtype IndexDistance = Int
@@ -668,10 +671,10 @@
/// This associated type appears as a requirement in the `Sequence`
/// protocol, but it is restated here with stricter constraints. In a
/// collection, the subsequence should also conform to `Collection`.
- associatedtype SubSequence : _IndexableBase, Sequence = Slice<Self>
- where Self.SubSequence.Index == Index,
- Self.Iterator.Element == Self.SubSequence.Iterator.Element,
+ associatedtype SubSequence = Slice<Self>
+ where Iterator.Element == SubSequence.Iterator.Element,
SubSequence.SubSequence == SubSequence
+
// FIXME(ABI)#98 (Recursive Protocol Constraints):
// FIXME(ABI)#99 (Associated Types with where clauses):
// associatedtype SubSequence : Collection
@@ -732,10 +735,9 @@
/// A type that represents the indices that are valid for subscripting the
/// collection, in ascending order.
- associatedtype Indices : _Indexable, Sequence = DefaultIndices<Self>
+ associatedtype Indices = DefaultIndices<Self>
where Indices.Iterator.Element == Index,
- Indices.Index == Index,
- Indices.SubSequence == Indices
+ Indices.Index == Index
// FIXME(ABI)#100 (Recursive Protocol Constraints):
// associatedtype Indices : Collection
diff --git a/stdlib/public/core/ExistentialCollection.swift.gyb b/stdlib/public/core/ExistentialCollection.swift.gyb
index 6cdb79d..204ca5c 100644
--- a/stdlib/public/core/ExistentialCollection.swift.gyb
+++ b/stdlib/public/core/ExistentialCollection.swift.gyb
@@ -426,14 +426,11 @@
@_fixed_layout
@_versioned
internal final class _${Kind}Box<S : ${Kind}> : _Any${Kind}Box<S.Iterator.Element>
+% if Kind == 'Sequence':
where
S.SubSequence : ${Kind},
-% if Kind == 'Sequence':
S.SubSequence.Iterator.Element == S.Iterator.Element,
S.SubSequence.SubSequence == S.SubSequence
-% else:
- S.SubSequence.Indices : ${Kind},
- S.Indices : ${Kind}
% end
{
internal typealias Element = S.Iterator.Element
@@ -1040,10 +1037,7 @@
where
// FIXME(ABI)#101 (Associated Types with where clauses): these constraints should be applied to
// associated types of Collection.
- C.SubSequence : ${SubProtocol},
- C.SubSequence.Iterator.Element == Element,
- C.SubSequence.Indices : ${SubProtocol},
- C.Indices : ${SubProtocol}
+ C.SubSequence.Iterator.Element == Element
{
// Traversal: ${Traversal}
// SubTraversal: ${SubTraversal}
diff --git a/stdlib/public/core/Mirror.swift b/stdlib/public/core/Mirror.swift
index c2d319e..37d95d8 100644
--- a/stdlib/public/core/Mirror.swift
+++ b/stdlib/public/core/Mirror.swift
@@ -214,13 +214,7 @@
children: C,
displayStyle: DisplayStyle? = nil,
ancestorRepresentation: AncestorRepresentation = .generated
- ) where
- C.Iterator.Element == Child,
- // FIXME(ABI)#47 (Associated Types with where clauses): these constraints should be applied to
- // associated types of Collection.
- C.SubSequence : Collection,
- C.SubSequence.Indices : Collection,
- C.Indices : Collection {
+ ) where C.Iterator.Element == Child {
self.subjectType = Subject.self
self._makeSuperclassMirror = Mirror._superclassIterator(
@@ -267,11 +261,7 @@
unlabeledChildren: C,
displayStyle: DisplayStyle? = nil,
ancestorRepresentation: AncestorRepresentation = .generated
- ) where
- // FIXME(ABI)#48 (Associated Types with where clauses): these constraints should be applied to
- // associated types of Collection.
- C.SubSequence : Collection,
- C.Indices : Collection {
+ ) {
self.subjectType = Subject.self
self._makeSuperclassMirror = Mirror._superclassIterator(
diff --git a/stdlib/public/core/MutableCollection.swift b/stdlib/public/core/MutableCollection.swift
index 4c424d8..14c47eb 100644
--- a/stdlib/public/core/MutableCollection.swift
+++ b/stdlib/public/core/MutableCollection.swift
@@ -217,14 +217,9 @@
/// // Must be equivalent to:
/// a[i] = x
/// let y = x
-public protocol MutableCollection : _MutableIndexable, Collection {
- // FIXME(ABI)#181: should be constrained to MutableCollection
- // (<rdar://problem/20715009> Implement recursive protocol
- // constraints)
- /// A collection that represents a contiguous subrange of the collection's
- /// elements.
- associatedtype SubSequence : Collection /*: MutableCollection*/
- = MutableSlice<Self>
+public protocol MutableCollection : _MutableIndexable, Collection
+where SubSequence: MutableCollection {
+ associatedtype SubSequence = MutableSlice<Self>
/// Accesses the element at the specified position.
///
diff --git a/stdlib/public/core/RandomAccessCollection.swift b/stdlib/public/core/RandomAccessCollection.swift
index 88f4253..8a4dec0 100644
--- a/stdlib/public/core/RandomAccessCollection.swift
+++ b/stdlib/public/core/RandomAccessCollection.swift
@@ -48,20 +48,15 @@
/// `distance(from:to:)` methods with O(1) efficiency.
public protocol RandomAccessCollection :
_RandomAccessIndexable, BidirectionalCollection
+ where SubSequence: RandomAccessCollection, Indices: RandomAccessCollection
{
/// A collection that represents a contiguous subrange of the collection's
/// elements.
- associatedtype SubSequence : _RandomAccessIndexable, BidirectionalCollection
- = RandomAccessSlice<Self>
- // FIXME(ABI)#102 (Recursive Protocol Constraints):
- // associatedtype SubSequence : RandomAccessCollection
+ associatedtype SubSequence = RandomAccessSlice<Self>
/// A type that represents the indices that are valid for subscripting the
/// collection, in ascending order.
- associatedtype Indices : _RandomAccessIndexable, BidirectionalCollection
- = DefaultRandomAccessIndices<Self>
- // FIXME(ABI)#103 (Recursive Protocol Constraints):
- // associatedtype Indices : RandomAccessCollection
+ associatedtype Indices = DefaultRandomAccessIndices<Self>
/// The indices that are valid for subscripting the collection, in ascending
/// order.
diff --git a/stdlib/public/core/SequenceAlgorithms.swift.gyb b/stdlib/public/core/SequenceAlgorithms.swift.gyb
index a5b99de..5be151b 100644
--- a/stdlib/public/core/SequenceAlgorithms.swift.gyb
+++ b/stdlib/public/core/SequenceAlgorithms.swift.gyb
@@ -729,13 +729,6 @@
}
return result
}
-
- @available(*, deprecated, message: "This call uses implicit promotion to optional. Please use map instead.")
- public func flatMap<T>(
- _ transform: (${GElement}) throws -> T
- ) rethrows -> [T] {
- return try map(transform)
- }
}
extension Sequence {
diff --git a/stdlib/public/core/StringCharacterView.swift b/stdlib/public/core/StringCharacterView.swift
index d06cb92..1201400 100644
--- a/stdlib/public/core/StringCharacterView.swift
+++ b/stdlib/public/core/StringCharacterView.swift
@@ -445,7 +445,14 @@
let relativeOffset = i._base._position - _coreOffset
if _core.isASCII {
let asciiBuffer = _core.asciiBuffer._unsafelyUnwrappedUnchecked
- return Character(UnicodeScalar(asciiBuffer[relativeOffset]))
+ // Bounds checks in an UnsafeBufferPointer (asciiBuffer) are only
+ // performed in Debug mode, so they need to be duplicated here.
+ // Falling back to the non-optimal behavior in the case they don't
+ // pass.
+ if relativeOffset >= asciiBuffer.startIndex &&
+ relativeOffset < asciiBuffer.endIndex {
+ return Character(UnicodeScalar(asciiBuffer[relativeOffset]))
+ }
} else if _core._baseAddress != nil {
let cu = _core._nthContiguous(relativeOffset)
// Only constructible if sub-surrogate
diff --git a/stdlib/public/runtime/CMakeLists.txt b/stdlib/public/runtime/CMakeLists.txt
index a471e5f..5263c15 100644
--- a/stdlib/public/runtime/CMakeLists.txt
+++ b/stdlib/public/runtime/CMakeLists.txt
@@ -49,6 +49,7 @@
SwiftObject.mm
SwiftValue.mm
Reflection.mm
+ "${SWIFT_SOURCE_DIR}/lib/Demangling/OldRemangler.cpp"
"${SWIFT_SOURCE_DIR}/lib/Demangling/Remangler.cpp")
set(swift_runtime_sources
diff --git a/stdlib/public/runtime/Metadata.cpp b/stdlib/public/runtime/Metadata.cpp
index 583178f..b7ee950 100644
--- a/stdlib/public/runtime/Metadata.cpp
+++ b/stdlib/public/runtime/Metadata.cpp
@@ -1532,7 +1532,7 @@
auto globalNode = Dem.createNode(Demangle::Node::Kind::Global);
globalNode->addChild(typeNode, Dem);
- auto string = Demangle::mangleNode(globalNode);
+ auto string = Demangle::mangleNodeOld(globalNode);
auto fullNameBuf = (char*)swift_slowAlloc(string.size() + 1, 0);
memcpy(fullNameBuf, string.c_str(), string.size() + 1);
diff --git a/test/Compatibility/MixAndMatch/Inputs/SomeObjCModule.apinotes b/test/Compatibility/MixAndMatch/Inputs/SomeObjCModule.apinotes
new file mode 100644
index 0000000..adad67b
--- /dev/null
+++ b/test/Compatibility/MixAndMatch/Inputs/SomeObjCModule.apinotes
@@ -0,0 +1,9 @@
+Name: SomeObjCModule
+Classes:
+- Name: NSRuncibleSpoon
+ SwiftBridge: RuncibleSpoon
+SwiftVersions:
+- Version: 3
+ Classes:
+ - Name: NSRuncibleSpoon
+ SwiftBridge: ""
diff --git a/test/Compatibility/MixAndMatch/Inputs/SomeObjCModule.h b/test/Compatibility/MixAndMatch/Inputs/SomeObjCModule.h
new file mode 100644
index 0000000..a12b1af
--- /dev/null
+++ b/test/Compatibility/MixAndMatch/Inputs/SomeObjCModule.h
@@ -0,0 +1,24 @@
+// Swift 3 sees the ObjC class NSRuncibleSpoon as the class, and uses methods
+// with type signatures involving NSRuncibleSpoon to conform to protocols
+// across the language boundary. Swift 4 sees the type as bridged to
+// a RuncibleSpoon value type, but still needs to be able to use conformances
+// declared by Swift 3.
+
+@import Foundation;
+
+@interface NSRuncibleSpoon: NSObject
+@end
+
+@interface SomeObjCClass: NSObject
+- (instancetype _Nonnull)initWithSomeSwiftInitRequirement:(NSRuncibleSpoon* _Nonnull)s;
+- (void)someSwiftMethodRequirement:(NSRuncibleSpoon* _Nonnull)s;
+@property NSRuncibleSpoon * _Nonnull someSwiftPropertyRequirement;
+@end
+
+@protocol SomeObjCProtocol
+- (instancetype _Nonnull)initWithSomeObjCInitRequirement:(NSRuncibleSpoon * _Nonnull)string;
+- (void)someObjCMethodRequirement:(NSRuncibleSpoon * _Nonnull)string;
+@property NSRuncibleSpoon * _Nonnull someObjCPropertyRequirement;
+@end
+
+
diff --git a/test/Compatibility/MixAndMatch/Inputs/SomeObjCModuleX.swift b/test/Compatibility/MixAndMatch/Inputs/SomeObjCModuleX.swift
new file mode 100644
index 0000000..2abcabe
--- /dev/null
+++ b/test/Compatibility/MixAndMatch/Inputs/SomeObjCModuleX.swift
@@ -0,0 +1,22 @@
+// NB: This file is not named SomeObjCModule.swift to avoid getting picked up
+// by -enable-source-import
+
+@_exported import SomeObjCModule
+
+public struct RuncibleSpoon: _ObjectiveCBridgeable {
+ public init() {}
+
+ public func _bridgeToObjectiveC() -> NSRuncibleSpoon {
+ fatalError()
+ }
+ public static func _forceBridgeFromObjectiveC(_: NSRuncibleSpoon, result: inout RuncibleSpoon?) {
+ fatalError()
+ }
+ public static func _conditionallyBridgeFromObjectiveC(_: NSRuncibleSpoon, result: inout RuncibleSpoon?) -> Bool {
+ fatalError()
+ }
+ public static func _unconditionallyBridgeFromObjectiveC(_: NSRuncibleSpoon?) -> RuncibleSpoon {
+ fatalError()
+ }
+}
+
diff --git a/test/Compatibility/MixAndMatch/Inputs/module.modulemap b/test/Compatibility/MixAndMatch/Inputs/module.modulemap
new file mode 100644
index 0000000..154dc37
--- /dev/null
+++ b/test/Compatibility/MixAndMatch/Inputs/module.modulemap
@@ -0,0 +1,4 @@
+module SomeObjCModule {
+ header "SomeObjCModule.h"
+ export *
+}
diff --git a/test/Compatibility/MixAndMatch/Inputs/witness_change_swift3_leaf.swift b/test/Compatibility/MixAndMatch/Inputs/witness_change_swift3_leaf.swift
new file mode 100644
index 0000000..89a5a70
--- /dev/null
+++ b/test/Compatibility/MixAndMatch/Inputs/witness_change_swift3_leaf.swift
@@ -0,0 +1,71 @@
+
+// Swift 3 sees the ObjC class NSRuncibleSpoon as the class, and uses methods
+// with type signatures involving NSRuncibleSpoon to conform to protocols
+// across the language boundary. Swift 4 sees the type as bridged to
+// a RuncibleSpoon value type, but still needs to be able to use conformances
+// declared by Swift 3.
+
+// Swift 3, importing Swift 3 and Swift 4 code
+
+import SomeObjCModule
+import SomeSwift3Module
+import SomeSwift4Module
+
+func testMatchAndMix(bridged: RuncibleSpoon, unbridged: NSRuncibleSpoon) {
+ let objcInstanceViaClass
+ = SomeObjCClass(someSwiftInitRequirement: unbridged)
+
+ let objcClassAsS3Protocol: SomeSwift3Protocol.Type = SomeObjCClass.self
+ let objcInstanceViaS3Protocol
+ = objcClassAsS3Protocol.init(someSwiftInitRequirement: unbridged)
+
+ let objcClassAsS4Protocol: SomeSwift4Protocol.Type = SomeObjCClass.self
+ let objcInstanceViaS4Protocol
+ = objcClassAsS4Protocol.init(someSwiftInitRequirement: bridged)
+
+ var bridgedSink: RuncibleSpoon
+ var unbridgedSink: NSRuncibleSpoon
+
+ let swiftPropertyViaClass = objcInstanceViaClass.someSwiftPropertyRequirement
+ unbridgedSink = swiftPropertyViaClass
+ let swiftPropertyViaS3Protocol = objcInstanceViaS3Protocol.someSwiftPropertyRequirement
+ unbridgedSink = swiftPropertyViaS3Protocol
+ let swiftPropertyViaS4Protocol = objcInstanceViaS4Protocol.someSwiftPropertyRequirement
+ bridgedSink = swiftPropertyViaS4Protocol
+
+ objcInstanceViaClass.someSwiftMethodRequirement(unbridged)
+ objcInstanceViaS3Protocol.someSwiftMethodRequirement(unbridged)
+ objcInstanceViaS4Protocol.someSwiftMethodRequirement(bridged)
+
+ let swift3InstanceViaClass
+ = SomeSwift3Class(someObjCInitRequirement: unbridged)
+ let swift3ClassAsProtocol: SomeObjCProtocol.Type = SomeSwift3Class.self
+ let swift3InstanceViaProtocol
+ = swift3ClassAsProtocol.init(someObjCInitRequirement: unbridged)
+
+ let objcPropertyViaClassS3 = swift3InstanceViaClass.someObjCPropertyRequirement
+ unbridgedSink = objcPropertyViaClassS3
+ let objcPropertyViaProtocolS3 = swift3InstanceViaProtocol.someObjCPropertyRequirement
+ unbridgedSink = objcPropertyViaProtocolS3
+
+ swift3InstanceViaClass.someObjCMethodRequirement(unbridged)
+ swift3InstanceViaProtocol.someObjCMethodRequirement(unbridged)
+
+ let swift4InstanceViaClass
+ = SomeSwift4Class(someObjCInitRequirement: bridged)
+ let swift4ClassAsProtocol: SomeObjCProtocol.Type = SomeSwift4Class.self
+ let swift4InstanceViaProtocol
+ = swift4ClassAsProtocol.init(someObjCInitRequirement: unbridged)
+
+ let objcPropertyViaClassS4 = swift4InstanceViaClass.someObjCPropertyRequirement
+ bridgedSink = objcPropertyViaClassS4
+ let objcPropertyViaProtocolS4 = swift4InstanceViaProtocol.someObjCPropertyRequirement
+ unbridgedSink = objcPropertyViaProtocolS4
+
+ swift4InstanceViaClass.someObjCMethodRequirement(bridged)
+ swift4InstanceViaProtocol.someObjCMethodRequirement(unbridged)
+
+ _ = bridgedSink
+ _ = unbridgedSink
+}
+
diff --git a/test/Compatibility/MixAndMatch/Inputs/witness_change_swift4.swift b/test/Compatibility/MixAndMatch/Inputs/witness_change_swift4.swift
new file mode 100644
index 0000000..0ebad72
--- /dev/null
+++ b/test/Compatibility/MixAndMatch/Inputs/witness_change_swift4.swift
@@ -0,0 +1,65 @@
+
+// Swift 3 sees the ObjC class NSRuncibleSpoon as the class, and uses methods
+// with type signatures involving NSRuncibleSpoon to conform to protocols
+// across the language boundary. Swift 4 sees the type as bridged to
+// a RuncibleSpoon value type, but still needs to be able to use conformances
+// declared by Swift 3.
+
+// Swift 4
+
+import SomeObjCModule
+import SomeSwift3Module
+
+public func testMixAndMatch(bridged: RuncibleSpoon, unbridged: NSRuncibleSpoon) {
+ let objcInstanceViaClass
+ = SomeObjCClass(someSwiftInitRequirement: bridged)
+ let objcClassAsProtocol: SomeSwift3Protocol.Type = SomeObjCClass.self
+ let objcInstanceViaProtocol
+ = objcClassAsProtocol.init(someSwiftInitRequirement: unbridged)
+
+ var bridgedSink: RuncibleSpoon
+ var unbridgedSink: NSRuncibleSpoon
+
+ let swiftPropertyViaClass = objcInstanceViaClass.someSwiftPropertyRequirement
+ bridgedSink = swiftPropertyViaClass
+ let swiftPropertyViaProtocol = objcInstanceViaProtocol.someSwiftPropertyRequirement
+ unbridgedSink = swiftPropertyViaProtocol
+
+ objcInstanceViaClass.someSwiftMethodRequirement(bridged)
+ objcInstanceViaProtocol.someSwiftMethodRequirement(unbridged)
+
+ let swiftInstanceViaClass
+ = SomeSwift3Class(someObjCInitRequirement: unbridged)
+ let swiftClassAsProtocol: SomeObjCProtocol.Type = SomeSwift3Class.self
+ let swiftInstanceViaProtocol
+ = swiftClassAsProtocol.init(someObjCInitRequirement: bridged)
+
+ let objcPropertyViaClass = swiftInstanceViaClass.someObjCPropertyRequirement
+ unbridgedSink = objcPropertyViaClass
+ let objcPropertyViaProtocol = swiftInstanceViaProtocol.someObjCPropertyRequirement
+ bridgedSink = objcPropertyViaProtocol
+
+ swiftInstanceViaClass.someObjCMethodRequirement(unbridged)
+ swiftInstanceViaProtocol.someObjCMethodRequirement(bridged)
+
+ _ = bridgedSink
+ _ = unbridgedSink
+}
+
+public protocol SomeSwift4Protocol {
+ init(someSwiftInitRequirement: RuncibleSpoon)
+ func someSwiftMethodRequirement(_: RuncibleSpoon)
+ var someSwiftPropertyRequirement: RuncibleSpoon { get }
+}
+
+extension SomeObjCClass: SomeSwift4Protocol {}
+
+public class SomeSwift4Class: NSObject {
+ public required init(someObjCInitRequirement x: RuncibleSpoon) {
+ someObjCPropertyRequirement = x
+ }
+ public func someObjCMethodRequirement(_: RuncibleSpoon) {}
+ public var someObjCPropertyRequirement: RuncibleSpoon
+}
+
+extension SomeSwift4Class: SomeObjCProtocol {}
diff --git a/test/Compatibility/MixAndMatch/witness_change.swift b/test/Compatibility/MixAndMatch/witness_change.swift
new file mode 100644
index 0000000..f384cd8
--- /dev/null
+++ b/test/Compatibility/MixAndMatch/witness_change.swift
@@ -0,0 +1,37 @@
+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -enable-experimental-deserialization-recovery -emit-module -o %t/SomeObjCModule.swiftmodule -module-name SomeObjCModule -I %t -I %S/Inputs -swift-version 3 %S/Inputs/SomeObjCModuleX.swift
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -enable-experimental-deserialization-recovery -emit-module -o %t/SomeSwift3Module.swiftmodule -module-name SomeSwift3Module -I %t -I %S/Inputs -swift-version 3 %s
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -enable-experimental-deserialization-recovery -emit-module -o %t/SomeSwift4Module.swiftmodule -module-name SomeSwift4Module -I %t -I %S/Inputs -swift-version 4 %S/Inputs/witness_change_swift4.swift
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -enable-experimental-deserialization-recovery -c -I %t -I %S/Inputs -swift-version 3 %S/Inputs/witness_change_swift3_leaf.swift
+
+// REQUIRES: objc_interop
+
+// Swift 3 sees the ObjC class NSRuncibleSpoon as the class, and uses methods
+// with type signatures involving NSRuncibleSpoon to conform to protocols
+// across the language boundary. Swift 4 sees the type as bridged to
+// a RuncibleSpoon value type, but still needs to be able to use conformances
+// declared by Swift 3.
+
+// Swift 3
+
+import SomeObjCModule
+
+_ = RuncibleSpoon()
+
+public class SomeSwift3Class: NSObject {
+ public required init(someObjCInitRequirement x: NSRuncibleSpoon) {
+ someObjCPropertyRequirement = x
+ }
+ public func someObjCMethodRequirement(_: NSRuncibleSpoon) {}
+ public var someObjCPropertyRequirement: NSRuncibleSpoon
+}
+extension SomeSwift3Class: SomeObjCProtocol {}
+
+public protocol SomeSwift3Protocol {
+ init(someSwiftInitRequirement: NSRuncibleSpoon)
+ func someSwiftMethodRequirement(_: NSRuncibleSpoon)
+ var someSwiftPropertyRequirement: NSRuncibleSpoon { get }
+}
+extension SomeObjCClass: SomeSwift3Protocol {}
+
diff --git a/test/Constraints/closures.swift b/test/Constraints/closures.swift
index a78ab61..8bd3650 100644
--- a/test/Constraints/closures.swift
+++ b/test/Constraints/closures.swift
@@ -512,8 +512,7 @@
returnsArray().flatMap { $0 }.flatMap { }
// expected-warning@-1 {{expression of type 'Int' is unused}}
-// expected-warning@-2 {{Please use map instead.}}
-// expected-warning@-3 {{result of call to 'flatMap' is unused}}
+// expected-warning@-2 {{result of call to 'flatMap' is unused}}
// rdar://problem/30271695
_ = ["hi"].flatMap { $0.isEmpty ? nil : $0 }
diff --git a/test/Constraints/function_conversion.swift b/test/Constraints/function_conversion.swift
new file mode 100644
index 0000000..58375e5
--- /dev/null
+++ b/test/Constraints/function_conversion.swift
@@ -0,0 +1,23 @@
+// RUN: %target-typecheck-verify-swift -swift-version 3
+// RUN: %target-typecheck-verify-swift -swift-version 4
+
+// rdar://problem/31969605
+
+class Base {}
+class Derived : Base {}
+
+protocol Refined {}
+protocol Proto : Refined {}
+extension Base : Refined {}
+
+func baseFn(_: Base) {}
+
+func superclassConversion(fn: @escaping (Base) -> ()) {
+ let _: (Derived) -> () = fn
+}
+
+func existentialConversion(fn: @escaping (Refined) -> ()) {
+ let _: (Proto) -> () = fn
+ let _: (Base) -> () = fn
+ let _: (Derived) -> () = fn
+}
diff --git a/test/IDE/complete_with_header_import.swift b/test/IDE/complete_with_header_import.swift
index 2da9189..3ba7ab9 100644
--- a/test/IDE/complete_with_header_import.swift
+++ b/test/IDE/complete_with_header_import.swift
@@ -4,6 +4,11 @@
// RUN: %target-swift-ide-test -code-completion -pch-output-dir %t -source-filename %s -code-completion-token=TOP -import-objc-header %S/Inputs/header.h | %FileCheck %s -check-prefix=CHECK-TOP
// RUN: %target-swift-ide-test -code-completion -pch-output-dir %t -source-filename %s -code-completion-token=TYPE -import-objc-header %S/Inputs/header.h | %FileCheck %s -check-prefix=CHECK-TYPE
// RUN: stat %t/*.pch
+// RUN: cp %S/Inputs/header.h %t
+// RUN: %target-swift-ide-test -code-completion -pch-output-dir %t/pch -source-filename %s -code-completion-token=TOP -import-objc-header %t/header.h | %FileCheck %s -check-prefix=CHECK-TOP
+// RUN: stat %t/pch/*.pch
+// RUN: echo '// new stuff' >> %t/header.h
+// RUN: %target-swift-ide-test -code-completion -pch-output-dir %t/pch -source-filename %s -code-completion-token=TOP -import-objc-header %t/header.h | %FileCheck %s -check-prefix=CHECK-TOP
// REQUIRES: objc_interop
diff --git a/test/IDE/range_info_branches.swift b/test/IDE/range_info_branches.swift
new file mode 100644
index 0000000..049eea8
--- /dev/null
+++ b/test/IDE/range_info_branches.swift
@@ -0,0 +1,40 @@
+func foo(_ a: Bool) -> Int{
+ if a {
+ return 1
+ } else {
+ }
+ if a {
+ return 0
+ } else {
+ return 1
+ }
+}
+
+func foo1(_ a: Bool) {
+ if a {}
+ if a {}
+ else {}
+ if a {
+ return
+ } else {
+ return
+ }
+}
+
+// RUN: %target-swift-ide-test -range -pos=2:1 -end-pos 5:4 -source-filename %s | %FileCheck %s -check-prefix=CHECK-ERR
+// RUN: %target-swift-ide-test -range -pos=6:1 -end-pos 10:4 -source-filename %s | %FileCheck %s -check-prefix=CHECK-INT
+// RUN: %target-swift-ide-test -range -pos=14:1 -end-pos 14:10 -source-filename %s | %FileCheck %s -check-prefix=CHECK-VOID-NO-RETURN
+// RUN: %target-swift-ide-test -range -pos=15:1 -end-pos 16:10 -source-filename %s | %FileCheck %s -check-prefix=CHECK-VOID-NO-RETURN
+// RUN: %target-swift-ide-test -range -pos=17:1 -end-pos 21:4 -source-filename %s | %FileCheck %s -check-prefix=CHECK-VOID-RETURN
+
+// CHECK-ERR: <Type><<error type>></Type>
+// CHECK-ERR-NOT: <Exit>true</Exit>
+
+// CHECK-INT: <Type>Int</Type>
+// CHECK-INT: <Exit>true</Exit>
+
+// CHECK-VOID-NO-RETURN: <Type>Void</Type>
+// CHECK-VOID-NO-RETURN-NOT: <Exit>true</Exit>
+
+// CHECK-VOID-RETURN: <Type>Void</Type>
+// CHECK-VOID-RETURN: <Exit>true</Exit>
diff --git a/test/Interpreter/SDK/Inputs/test.arc b/test/Interpreter/SDK/Inputs/test.arc
new file mode 100644
index 0000000..780fd62
--- /dev/null
+++ b/test/Interpreter/SDK/Inputs/test.arc
Binary files differ
diff --git a/test/Interpreter/SDK/archive_compatibility.swift b/test/Interpreter/SDK/archive_compatibility.swift
new file mode 100644
index 0000000..19875d2
--- /dev/null
+++ b/test/Interpreter/SDK/archive_compatibility.swift
@@ -0,0 +1,131 @@
+// RUN: rm -rf %t && mkdir -p %t
+// RUN: %target-build-swift %s -module-name=test -o %t/a.out
+// RUN: %target-run %t/a.out %S/Inputs/test.arc | %FileCheck %s
+
+// REQUIRES: executable_test
+// REQUIRES: objc_interop
+// UNSUPPORTED: OS=tvos
+// UNSUPPORTED: OS=watchos
+
+// This test checks if an archive, produced with the swift 3.1 compiler, can
+// still be read with the current compiler.
+
+import Foundation
+
+struct ABC {
+ class NestedClass : NSObject, NSCoding {
+ var i : Int
+
+ init(_ ii: Int) {
+ i = ii
+ }
+
+ required init(coder aDecoder: NSCoder) {
+ i = aDecoder.decodeInteger(forKey: "i")
+ }
+
+ func encode(with aCoder: NSCoder) {
+ aCoder.encode(i, forKey: "i")
+ }
+ }
+}
+
+private class PrivateClass : NSObject, NSCoding {
+ var pi : Int
+
+ init(_ ii: Int) {
+ pi = ii
+ }
+
+ required init(coder aDecoder: NSCoder) {
+ pi = aDecoder.decodeInteger(forKey: "pi")
+ }
+
+ func encode(with aCoder: NSCoder) {
+ aCoder.encode(pi, forKey: "pi")
+ }
+}
+
+class GenericClass<T> : NSObject, NSCoding {
+ var gi : Int
+
+ init(_ ii: Int) {
+ gi = ii
+ }
+
+ required init(coder aDecoder: NSCoder) {
+ gi = aDecoder.decodeInteger(forKey: "gi")
+ }
+
+ func encode(with aCoder: NSCoder) {
+ aCoder.encode(gi, forKey: "gi")
+ }
+}
+
+class TopLevel : NSObject, NSCoding {
+ var tli : Int
+
+ var nested: ABC.NestedClass?
+ fileprivate var priv: PrivateClass?
+ var generic : GenericClass<Int>?
+
+ init(_ ii: Int) {
+ tli = ii
+ }
+
+ required init(coder aDecoder: NSCoder) {
+ tli = aDecoder.decodeInteger(forKey: "tli")
+ nested = aDecoder.decodeObject(forKey: "nested") as? ABC.NestedClass
+ priv = aDecoder.decodeObject(forKey: "priv") as? PrivateClass
+ generic = aDecoder.decodeObject(forKey: "generic") as? GenericClass<Int>
+ }
+
+ func encode(with aCoder: NSCoder) {
+ aCoder.encode(tli, forKey: "tli")
+ aCoder.encode(nested, forKey: "nested")
+ aCoder.encode(priv, forKey: "priv")
+ aCoder.encode(generic, forKey: "generic")
+ }
+}
+
+func main() {
+
+ let args = CommandLine.arguments
+
+ let g = GenericClass<Int>(42)
+#if ENCODE
+ // This is how the archive was created with the swift 3.1 compiler.
+ let c = TopLevel(27)
+ c.nested = ABC.NestedClass(28)
+ c.priv = PrivateClass(29)
+ c.generic = g
+
+ NSKeyedArchiver.archiveRootObject(c, toFile: args[1])
+#else
+ if let u = NSKeyedUnarchiver.unarchiveObject(withFile: args[1]) {
+ if let x = u as? TopLevel {
+ // CHECK: top-level: 27
+ print("top-level: \(x.tli)")
+ if let n = x.nested {
+ // CHECK: nested: 28
+ print("nested: \(n.i)")
+ }
+ if let p = x.priv {
+ // CHECK: private: 29
+ print("private: \(p.pi)")
+ }
+ if let g = x.generic {
+ // CHECK: generic: 42
+ print("generic: \(g.gi)")
+ }
+ } else {
+ print(u)
+ }
+ } else {
+ print("nil")
+ }
+#endif
+}
+
+main()
+
diff --git a/test/Interpreter/SDK/archiving_generic_swift_class.swift b/test/Interpreter/SDK/archiving_generic_swift_class.swift
index 52c3bd6..b862e60 100644
--- a/test/Interpreter/SDK/archiving_generic_swift_class.swift
+++ b/test/Interpreter/SDK/archiving_generic_swift_class.swift
@@ -190,10 +190,10 @@
fatalError("unable to unarchive Foo<NSNumber>")
}
- // CHECK-LABEL: <_T04main3FooCySo8NSStringCGD: {{0x[0-9a-f]+}}> #0
+ // CHECK-LABEL: <_TtGC4main3FooCSo8NSString_: {{0x[0-9a-f]+}}> #0
// CHECK: one: one
// CHECK: two: two
- // CHECK-LABEL: <_T04main3FooCySo8NSNumberCGD: {{0x[0-9a-f]+}}> #0
+ // CHECK-LABEL: <_TtGC4main3FooCSo8NSNumber_: {{0x[0-9a-f]+}}> #0
// CHECK: one: 1
// CHECK: two: 2
dump(strings)
diff --git a/test/stdlib/FlatMapDiagnostics.swift.gyb b/test/stdlib/FlatMapDiagnostics.swift.gyb
deleted file mode 100644
index 0183eda..0000000
--- a/test/stdlib/FlatMapDiagnostics.swift.gyb
+++ /dev/null
@@ -1,39 +0,0 @@
-//===--- FlatMapDiagnostics.swift -----------------------------*- swift -*-===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
-//
-//===----------------------------------------------------------------------===//
-// RUN: rm -rf %t && mkdir -p %t
-// RUN: %gyb %s -o %t/FlatMapDiagnostics.swift
-// RUN: %target-swift-frontend -typecheck -verify %t/FlatMapDiagnostics.swift
-
-
-% for Type in [
-% 'Sequence',
-% 'Collection',
-% 'LazySequenceProtocol',
-% 'LazyCollectionProtocol']:
-
-func testGeneric${Type}<T : ${Type}>(xs: T) {
- _ = xs.flatMap { $0 } // expected-warning {{Please use map instead.}}
-}
-
-% end
-
-func testArray(xs: [Int]) {
- _ = xs.flatMap { $0 } // expected-warning {{Please use map instead.}}
- _ = xs.lazy.flatMap { $0 } // expected-warning {{Please use map instead.}}
-}
-
-func testGenericLazyBidirectionalCollection<
- T : LazyCollectionProtocol & BidirectionalCollection
->(xs: T) where T.Elements : BidirectionalCollection {
- _ = xs.flatMap { $0 } // expected-warning {{Please use map instead.}}
-}
-
diff --git a/test/stdlib/RuntimeObjC.swift b/test/stdlib/RuntimeObjC.swift
index 055b937..78c3d1a 100644
--- a/test/stdlib/RuntimeObjC.swift
+++ b/test/stdlib/RuntimeObjC.swift
@@ -334,47 +334,54 @@
protocol ProtocolB {}
Runtime.test("Generic class ObjC runtime names") {
- expectEqual("_T01a12GenericClassCySiGD",
+ expectEqual("_TtGC1a12GenericClassSi_",
NSStringFromClass(GenericClass<Int>.self))
- expectEqual("_T01a12GenericClassCyAA11PlainStructVGD",
+ expectEqual("_TtGC1a12GenericClassVS_11PlainStruct_",
NSStringFromClass(GenericClass<PlainStruct>.self))
- expectEqual("_T01a12GenericClassCyAA9PlainEnumOGD",
+ expectEqual("_TtGC1a12GenericClassOS_9PlainEnum_",
NSStringFromClass(GenericClass<PlainEnum>.self))
- expectEqual("_T01a12GenericClassCyAA11PlainStructV_AA0C4EnumOAEtGD",
+ expectEqual("_TtGC1a12GenericClassTVS_11PlainStructOS_9PlainEnumS1___",
NSStringFromClass(GenericClass<(PlainStruct, PlainEnum, PlainStruct)>.self))
- expectEqual("_T01a12GenericClassCyAA11PlainStructVmGD",
+ expectEqual("_TtGC1a12GenericClassMVS_11PlainStruct_",
NSStringFromClass(GenericClass<PlainStruct.Type>.self))
- expectEqual("_T01a12GenericClassCyAA11PlainStructVAEmcGD",
+ expectEqual("_TtGC1a12GenericClassFMVS_11PlainStructS1__",
NSStringFromClass(GenericClass<(PlainStruct.Type) -> PlainStruct>.self))
- expectEqual("_T01a12GenericClassCyAA11PlainStructVAEmKcGD",
+ expectEqual("_TtGC1a12GenericClassFzMVS_11PlainStructS1__",
NSStringFromClass(GenericClass<(PlainStruct.Type) throws -> PlainStruct>.self))
- expectEqual("_T01a12GenericClassCySiAA11PlainStructV_AA0C4EnumOztcGD",
+ expectEqual("_TtGC1a12GenericClassFTVS_11PlainStructROS_9PlainEnum_Si_",
NSStringFromClass(GenericClass<(PlainStruct, inout PlainEnum) -> Int>.self))
- expectEqual("_T01a12GenericClassCyAA9ProtocolA_pGD",
+ expectEqual("_TtGC1a12GenericClassPS_9ProtocolA__",
NSStringFromClass(GenericClass<ProtocolA>.self))
- expectEqual("_T01a12GenericClassCyAA9ProtocolA_AA0C1BpGD",
+ expectEqual("_TtGC1a12GenericClassPS_9ProtocolAS_9ProtocolB__",
NSStringFromClass(GenericClass<ProtocolA & ProtocolB>.self))
- expectEqual("_T01a12GenericClassCyAA9ProtocolA_AA0C1BpXpGD",
+ expectEqual("_TtGC1a12GenericClassPMPS_9ProtocolAS_9ProtocolB__",
NSStringFromClass(GenericClass<(ProtocolA & ProtocolB).Type>.self))
- expectEqual("_T01a12GenericClassCyAA9ProtocolA_AA0C1BpmGD",
+ expectEqual("_TtGC1a12GenericClassMPS_9ProtocolAS_9ProtocolB__",
NSStringFromClass(GenericClass<(ProtocolB & ProtocolA).Protocol>.self))
- expectEqual("_T01a12GenericClassCySo7CFArrayCGD",
+ expectEqual("_TtGC1a12GenericClassCSo7CFArray_",
NSStringFromClass(GenericClass<CFArray>.self))
- expectEqual("_T01a12GenericClassCySo7DecimalVGD",
+ expectEqual("_TtGC1a12GenericClassVSo7Decimal_",
NSStringFromClass(GenericClass<Decimal>.self))
- expectEqual("_T01a12GenericClassCySo8NSObjectCGD",
+ expectEqual("_TtGC1a12GenericClassCSo8NSObject_",
NSStringFromClass(GenericClass<NSObject>.self))
- expectEqual("_T01a12GenericClassCySo8NSObjectCGD",
+ expectEqual("_TtGC1a12GenericClassCSo8NSObject_",
NSStringFromClass(GenericClass<NSObject>.self))
- expectEqual("_T01a12GenericClassCySo9NSCopying_pGD",
+ expectEqual("_TtGC1a12GenericClassPSo9NSCopying__",
NSStringFromClass(GenericClass<NSCopying>.self))
- expectEqual("_T01a12GenericClassCySo9NSCopying_AA9ProtocolAAA0D1BpGD",
+ expectEqual("_TtGC1a12GenericClassPSo9NSCopyingS_9ProtocolAS_9ProtocolB__",
NSStringFromClass(GenericClass<ProtocolB & NSCopying & ProtocolA>.self))
- expectEqual("_T01a17MultiGenericClassCyAA0B6StructVySiGAA0B4EnumOyAHySiGGGD",
+ expectEqual("_TtGC1a12GenericClassXcCS_9SomeClassS_9ProtocolA__",
+ NSStringFromClass(GenericClass<ProtocolA & SomeClass>.self))
+ expectEqual("_TtGC1a12GenericClassPS_9ProtocolAs9AnyObject__",
+ NSStringFromClass(GenericClass<ProtocolA & AnyObject>.self))
+ expectEqual("_TtGC1a12GenericClassPs9AnyObject__",
+ NSStringFromClass(GenericClass<AnyObject>.self))
+
+ expectEqual("_TtGC1a17MultiGenericClassGVS_13GenericStructSi_GOS_11GenericEnumGS2_Si___",
NSStringFromClass(MultiGenericClass<GenericStruct<Int>,
GenericEnum<GenericEnum<Int>>>.self))
}
diff --git a/tools/SourceKit/lib/SwiftLang/SwiftSourceDocInfo.cpp b/tools/SourceKit/lib/SwiftLang/SwiftSourceDocInfo.cpp
index cea03ff..e4f3c86 100644
--- a/tools/SourceKit/lib/SwiftLang/SwiftSourceDocInfo.cpp
+++ b/tools/SourceKit/lib/SwiftLang/SwiftSourceDocInfo.cpp
@@ -1337,7 +1337,7 @@
case RangeKind::SingleExpression: {
SmallString<64> SS;
llvm::raw_svector_ostream OS(SS);
- Info.Ty.print(OS);
+ Info.ExitInfo.getPointer()->print(OS);
Result.ExprType = OS.str();
Receiver(Result);
return;
diff --git a/utils/build-presets.ini b/utils/build-presets.ini
index d295197..355bda1 100644
--- a/utils/build-presets.ini
+++ b/utils/build-presets.ini
@@ -960,6 +960,8 @@
dash-dash
+skip-test-lldb
+
swift-install-components=compiler;clang-builtin-headers;stdlib;sdk-overlay;license;sourcekit-xpc-service;swift-remote-mirror;swift-remote-mirror-headers
llvm-install-components=libclang;libclang-headers
diff --git a/validation-test/stdlib/CollectionDiagnostics.swift b/validation-test/stdlib/CollectionDiagnostics.swift
index 775fcee..f83e8b4 100644
--- a/validation-test/stdlib/CollectionDiagnostics.swift
+++ b/validation-test/stdlib/CollectionDiagnostics.swift
@@ -23,7 +23,7 @@
fatalError("unreachable")
}
- // expected-note@+3 {{possibly intended match 'CollectionWithBadSubSequence.SubSequence' (aka 'OpaqueValue<Int8>') does not conform to 'Sequence'}}
+ // expected-note@+3 {{possibly intended match}}
// expected-note@+2 {{possibly intended match}}
// expected-note@+1 {{possibly intended match}}
typealias SubSequence = OpaqueValue<Int8>
diff --git a/validation-test/stdlib/String.swift b/validation-test/stdlib/String.swift
index 5ca97e8..a0a8a5b 100644
--- a/validation-test/stdlib/String.swift
+++ b/validation-test/stdlib/String.swift
@@ -192,9 +192,7 @@
expectEqual("a", acceptor[donor.startIndex])
}
-StringTests.test("ForeignIndexes/subscript(Index)/OutOfBoundsTrap")
- .skip(.always("<rdar://problem/31992473>"))
- .code {
+StringTests.test("ForeignIndexes/subscript(Index)/OutOfBoundsTrap") {
let donor = "abcdef"
let acceptor = "uvw"
