Skip to content

Commit 32057c5

Browse files
rintarorintaro
authored
Merge pull request #63111 from rintaro/sourcektid-mangling-langsupport
[SourceKit] Move demangle/mangle logic to SwfitLangSupport
2 parents 30891cc + 8d8ec09 commit 32057c5

File tree

5 files changed

+144
-88
lines changed

5 files changed

+144
-88
lines changed

‎tools/SourceKit/include/SourceKit/Core/LangSupport.h

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -845,6 +845,16 @@ class LangSupport {
845845

846846
virtual void dependencyUpdated() {}
847847

848+
virtual void demangleNames(
849+
ArrayRef<const char *> MangledNames, bool Simplified,
850+
std::function<void(const RequestResult<ArrayRef<std::string>> &)>
851+
Receiver) = 0;
852+
853+
virtual void mangleSimpleClassNames(
854+
ArrayRef<std::pair<StringRef, StringRef>> ModuleClassPairs,
855+
std::function<void(const RequestResult<ArrayRef<std::string>> &)>
856+
Receiver) = 0;
857+
848858
virtual void indexSource(StringRef Filename,
849859
IndexingConsumer &Consumer,
850860
ArrayRef<const char *> Args) = 0;

‎tools/SourceKit/lib/SwiftLang/CMakeLists.txt

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,7 @@ add_sourcekit_library(SourceKitSwiftLang
99
SwiftEditorInterfaceGen.cpp
1010
SwiftIndexing.cpp
1111
SwiftLangSupport.cpp
12+
SwiftMangling.cpp
1213
SwiftSourceDocInfo.cpp
1314
SwiftTypeContextInfo.cpp
1415
LLVM_LINK_COMPONENTS ${LLVM_TARGETS_TO_BUILD}

‎tools/SourceKit/lib/SwiftLang/SwiftLangSupport.h

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -537,6 +537,16 @@ class SwiftLangSupport : public LangSupport {
537537

538538
void dependencyUpdated() override;
539539

540+
void demangleNames(
541+
ArrayRef<const char *> MangledNames, bool Simplified,
542+
std::function<void(const RequestResult<ArrayRef<std::string>> &)>
543+
Receiver) override;
544+
545+
void mangleSimpleClassNames(
546+
ArrayRef<std::pair<StringRef, StringRef>> ModuleClassPairs,
547+
std::function<void(const RequestResult<ArrayRef<std::string>> &)>
548+
Receiver) override;
549+
540550
void indexSource(StringRef Filename, IndexingConsumer &Consumer,
541551
ArrayRef<const char *> Args) override;
542552

‎tools/SourceKit/lib/SwiftLang/SwiftMangling.cpp

Lines changed: 92 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,92 @@
1+
//===--- SwiftMangling.cpp ------------------------------------------------===//
2+
//
3+
// This source file is part of the Swift.org open source project
4+
//
5+
// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
6+
// Licensed under Apache License v2.0 with Runtime Library Exception
7+
//
8+
// See https://swift.org/LICENSE.txt for license information
9+
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
10+
//
11+
//===----------------------------------------------------------------------===//
12+
13+
#include "SwiftLangSupport.h"
14+
15+
#include "swift/Demangling/Demangle.h"
16+
#include "swift/Demangling/Demangler.h"
17+
18+
using namespace SourceKit;
19+
using namespace swift;
20+
using namespace ide;
21+
22+
void SwiftLangSupport::demangleNames(
23+
ArrayRef<const char *> MangledNames, bool Simplified,
24+
std::function<void(const RequestResult<ArrayRef<std::string>> &)>
25+
Receiver) {
26+
27+
swift::Demangle::DemangleOptions DemangleOptions;
28+
if (Simplified) {
29+
DemangleOptions =
30+
swift::Demangle::DemangleOptions::SimplifiedUIDemangleOptions();
31+
}
32+
33+
auto getDemangledName = [&](StringRef MangledName) -> std::string {
34+
if (!swift::Demangle::isSwiftSymbol(MangledName))
35+
return std::string(); // Not a mangled name
36+
37+
std::string Result =
38+
swift::Demangle::demangleSymbolAsString(MangledName, DemangleOptions);
39+
40+
if (Result == MangledName)
41+
return std::string(); // Not a mangled name
42+
43+
return Result;
44+
};
45+
46+
SmallVector<std::string, 4> results;
47+
for (auto &MangledName : MangledNames) {
48+
results.push_back(getDemangledName(MangledName));
49+
}
50+
51+
Receiver(RequestResult<ArrayRef<std::string>>::fromResult(results));
52+
}
53+
54+
static ManglingErrorOr<std::string> mangleSimpleClass(StringRef moduleName,
55+
StringRef className) {
56+
using namespace swift::Demangle;
57+
Demangler Dem;
58+
auto moduleNode = Dem.createNode(Node::Kind::Module, moduleName);
59+
auto IdNode = Dem.createNode(Node::Kind::Identifier, className);
60+
auto classNode = Dem.createNode(Node::Kind::Class);
61+
auto typeNode = Dem.createNode(Node::Kind::Type);
62+
auto typeManglingNode = Dem.createNode(Node::Kind::TypeMangling);
63+
auto globalNode = Dem.createNode(Node::Kind::Global);
64+
65+
classNode->addChild(moduleNode, Dem);
66+
classNode->addChild(IdNode, Dem);
67+
typeNode->addChild(classNode, Dem);
68+
typeManglingNode->addChild(typeNode, Dem);
69+
globalNode->addChild(typeManglingNode, Dem);
70+
return mangleNode(globalNode);
71+
}
72+
73+
void SwiftLangSupport::mangleSimpleClassNames(
74+
ArrayRef<std::pair<StringRef, StringRef>> ModuleClassPairs,
75+
std::function<void(const RequestResult<ArrayRef<std::string>> &)>
76+
Receiver) {
77+
78+
SmallVector<std::string, 4> results;
79+
for (auto &pair : ModuleClassPairs) {
80+
auto mangling = mangleSimpleClass(pair.first, pair.second);
81+
if (!mangling.isSuccess()) {
82+
std::string message = "name mangling failed for ";
83+
message += pair.first;
84+
message += ".";
85+
message += pair.second;
86+
Receiver(RequestResult<ArrayRef<std::string>>::fromError(message));
87+
return;
88+
}
89+
results.push_back(mangling.result());
90+
}
91+
Receiver(RequestResult<ArrayRef<std::string>>::fromResult(results));
92+
}

‎tools/SourceKit/tools/sourcekitd/lib/Service/Requests.cpp

Lines changed: 31 additions & 88 deletions
Original file line numberDiff line numberDiff line change
@@ -30,23 +30,17 @@
3030
#include "SourceKit/Support/UIdent.h"
3131
#include "SourceKit/SwiftLang/Factory.h"
3232

33-
#include "swift/Basic/ExponentialGrowthAppendingBinaryByteStream.h"
34-
#include "swift/Basic/LLVMInitialize.h"
3533
#include "swift/Basic/InitializeSwiftModules.h"
36-
#include "swift/Basic/Mangler.h"
34+
#include "swift/Basic/LLVMInitialize.h"
3735
#include "swift/Basic/Statistic.h"
3836
#include "swift/Basic/Version.h"
39-
#include "swift/Demangling/Demangler.h"
40-
#include "swift/Demangling/ManglingMacros.h"
4137

4238
#include "llvm/ADT/ArrayRef.h"
4339
#include "llvm/ADT/IntrusiveRefCntPtr.h"
40+
#include "llvm/ADT/STLExtras.h"
4441
#include "llvm/ADT/SmallString.h"
4542
#include "llvm/ADT/StringRef.h"
46-
#include "llvm/ADT/STLExtras.h"
47-
#include "llvm/Support/BinaryByteStream.h"
4843
#include "llvm/Support/MemoryBuffer.h"
49-
#include "llvm/Support/NativeFormatting.h"
5044
#include "llvm/Support/Path.h"
5145
#include "llvm/Support/PrettyStackTrace.h"
5246
#include "llvm/Support/VirtualFileSystem.h"
@@ -187,12 +181,6 @@ static SourceKit::Context &getGlobalContext() {
187181
return *GlobalCtx;
188182
}
189183
190-
static sourcekitd_response_t demangleNames(ArrayRef<const char *> MangledNames,
191-
bool Simplified);
192-
193-
static sourcekitd_response_t
194-
mangleSimpleClassNames(ArrayRef<std::pair<StringRef, StringRef>> ModuleClassPairs);
195-
196184
static sourcekitd_response_t indexSource(StringRef Filename,
197185
ArrayRef<const char *> Args);
198186
@@ -620,7 +608,21 @@ static void handleRequestDemangle(const RequestDict &Req,
620608
}
621609
int64_t Simplified = false;
622610
Req.getInt64(KeySimplified, Simplified, /*isOptional=*/true);
623-
return Rec(demangleNames(MangledNames, Simplified));
611+
612+
LangSupport &Lang = getGlobalContext().getSwiftLangSupport();
613+
Lang.demangleNames(MangledNames, Simplified, [Rec](auto result) {
614+
if (result.isError())
615+
return Rec(createErrorRequestFailed(result.getError()));
616+
if (result.isCancelled())
617+
return Rec(createErrorRequestFailed(result.getError()));
618+
ResponseBuilder RespBuilder;
619+
auto Arr = RespBuilder.getDictionary().setArray(KeyResults);
620+
for (auto demangldedName : result.value()) {
621+
auto Entry = Arr.appendDictionary();
622+
Entry.set(KeyName, demangldedName.c_str());
623+
}
624+
Rec(RespBuilder.createResponse());
625+
});
624626
}
625627
}
626628
@@ -652,7 +654,20 @@ handleRequestMangleSimpleClass(const RequestDict &Req,
652654
return Rec(err);
653655
}
654656
655-
return Rec(mangleSimpleClassNames(ModuleClassPairs));
657+
LangSupport &Lang = getGlobalContext().getSwiftLangSupport();
658+
Lang.mangleSimpleClassNames(ModuleClassPairs, [Rec](auto result) {
659+
if (result.isError())
660+
return Rec(createErrorRequestFailed(result.getError()));
661+
if (result.isCancelled())
662+
return Rec(createErrorRequestFailed(result.getError()));
663+
ResponseBuilder RespBuilder;
664+
auto Arr = RespBuilder.getDictionary().setArray(KeyResults);
665+
for (auto &mangledName : result.value()) {
666+
auto Entry = Arr.appendDictionary();
667+
Entry.set(KeyName, mangledName.c_str());
668+
}
669+
Rec(RespBuilder.createResponse());
670+
});
656671
}
657672
}
658673
@@ -2054,78 +2069,6 @@ class SKDocConsumer : public DocInfoConsumer {
20542069
};
20552070
} // end anonymous namespace
20562071

2057-
static sourcekitd_response_t demangleNames(ArrayRef<const char *> MangledNames,
2058-
bool Simplified) {
2059-
swift::Demangle::DemangleOptions DemangleOptions;
2060-
if (Simplified) {
2061-
DemangleOptions =
2062-
swift::Demangle::DemangleOptions::SimplifiedUIDemangleOptions();
2063-
}
2064-
2065-
auto getDemangledName = [&](StringRef MangledName) -> std::string {
2066-
if (!swift::Demangle::isSwiftSymbol(MangledName))
2067-
return std::string(); // Not a mangled name
2068-
2069-
std::string Result = swift::Demangle::demangleSymbolAsString(
2070-
MangledName, DemangleOptions);
2071-
2072-
if (Result == MangledName)
2073-
return std::string(); // Not a mangled name
2074-
2075-
return Result;
2076-
};
2077-
2078-
ResponseBuilder RespBuilder;
2079-
auto Arr = RespBuilder.getDictionary().setArray(KeyResults);
2080-
for (auto MangledName : MangledNames) {
2081-
std::string Result = getDemangledName(MangledName);
2082-
auto Entry = Arr.appendDictionary();
2083-
Entry.set(KeyName, Result.c_str());
2084-
}
2085-
2086-
return RespBuilder.createResponse();
2087-
}
2088-
2089-
static ManglingErrorOr<std::string> mangleSimpleClass(StringRef moduleName,
2090-
StringRef className) {
2091-
using namespace swift::Demangle;
2092-
Demangler Dem;
2093-
auto moduleNode = Dem.createNode(Node::Kind::Module, moduleName);
2094-
auto IdNode = Dem.createNode(Node::Kind::Identifier, className);
2095-
auto classNode = Dem.createNode(Node::Kind::Class);
2096-
auto typeNode = Dem.createNode(Node::Kind::Type);
2097-
auto typeManglingNode = Dem.createNode(Node::Kind::TypeMangling);
2098-
auto globalNode = Dem.createNode(Node::Kind::Global);
2099-
2100-
classNode->addChild(moduleNode, Dem);
2101-
classNode->addChild(IdNode, Dem);
2102-
typeNode->addChild(classNode, Dem);
2103-
typeManglingNode->addChild(typeNode, Dem);
2104-
globalNode->addChild(typeManglingNode, Dem);
2105-
return mangleNode(globalNode);
2106-
}
2107-
2108-
static sourcekitd_response_t
2109-
mangleSimpleClassNames(ArrayRef<std::pair<StringRef, StringRef>> ModuleClassPairs) {
2110-
ResponseBuilder RespBuilder;
2111-
auto Arr = RespBuilder.getDictionary().setArray(KeyResults);
2112-
for (auto &pair : ModuleClassPairs) {
2113-
auto Mangling = mangleSimpleClass(pair.first, pair.second);
2114-
if (!Mangling.isSuccess()) {
2115-
std::string message = "name mangling failed for ";
2116-
message += pair.first.str();
2117-
message += ".";
2118-
message += pair.second.str();
2119-
return createErrorRequestFailed(message);
2120-
}
2121-
std::string Result = Mangling.result();
2122-
auto Entry = Arr.appendDictionary();
2123-
Entry.set(KeyName, Result.c_str());
2124-
}
2125-
2126-
return RespBuilder.createResponse();
2127-
}
2128-
21292072
static sourcekitd_response_t reportDocInfo(llvm::MemoryBuffer *InputBuf,
21302073
StringRef ModuleName,
21312074
ArrayRef<const char *> Args) {

0 commit comments

Comments
 (0)