Skip to content

Commit d0c7b15

Browse files
slavapestovslavapestov
committed
ASTMangler: Mangle sugared types for the debugger
Fixes <rdar://problem/48004306>.
1 parent 1dd6765 commit d0c7b15

20 files changed

+334
-55
lines changed

‎include/swift/AST/ASTDemangler.h

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -126,6 +126,14 @@ class ASTBuilder {
126126

127127
Type getOpaqueType();
128128

129+
Type createOptionalType(Type base);
130+
131+
Type createArrayType(Type base);
132+
133+
Type createDictionaryType(Type key, Type value);
134+
135+
Type createParenType(Type base);
136+
129137
private:
130138
bool validateParentType(TypeDecl *decl, Type parent);
131139
CanGenericSignature demangleGenericSignature(

‎include/swift/AST/ASTMangler.h

Lines changed: 0 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -210,14 +210,6 @@ class ASTMangler : public Mangler {
210210

211211
void bindGenericParameters(CanGenericSignature sig);
212212

213-
/// Mangles a sugared type iff we are mangling for the debugger.
214-
template <class T> void appendSugaredType(Type type) {
215-
assert(DWARFMangling &&
216-
"sugared types are only legal when mangling for the debugger");
217-
auto *BlandTy = cast<T>(type.getPointer())->getSinglyDesugaredType();
218-
appendType(BlandTy);
219-
}
220-
221213
void appendBoundGenericArgs(Type type, bool &isFirstArgList);
222214

223215
/// Append the bound generics arguments for the given declaration context

‎include/swift/Demangling/DemangleNodes.def

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -252,5 +252,9 @@ NODE(ModuleDescriptor)
252252
NODE(ExtensionDescriptor)
253253
NODE(AnonymousDescriptor)
254254
NODE(AssociatedTypeGenericParamRef)
255+
NODE(SugaredOptional)
256+
NODE(SugaredArray)
257+
NODE(SugaredDictionary)
258+
NODE(SugaredParen)
255259
#undef CONTEXT_NODE
256260
#undef NODE

‎include/swift/Demangling/TypeDecoder.h

Lines changed: 44 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -733,6 +733,50 @@ class TypeDecoder {
733733
// NativeObject type ref.
734734
return Builder.createBuiltinType("Builtin.NativeObject", "Bo");
735735
}
736+
case NodeKind::SugaredOptional: {
737+
if (Node->getNumChildren() < 1)
738+
return BuiltType();
739+
740+
auto base = decodeMangledType(Node->getChild(0));
741+
if (!base)
742+
return BuiltType();
743+
744+
return Builder.createOptionalType(base);
745+
}
746+
case NodeKind::SugaredArray: {
747+
if (Node->getNumChildren() < 1)
748+
return BuiltType();
749+
750+
auto base = decodeMangledType(Node->getChild(0));
751+
if (!base)
752+
return BuiltType();
753+
754+
return Builder.createArrayType(base);
755+
}
756+
case NodeKind::SugaredDictionary: {
757+
if (Node->getNumChildren() < 2)
758+
return BuiltType();
759+
760+
auto key = decodeMangledType(Node->getChild(0));
761+
if (!key)
762+
return BuiltType();
763+
764+
auto value = decodeMangledType(Node->getChild(1));
765+
if (!key)
766+
return BuiltType();
767+
768+
return Builder.createDictionaryType(key, value);
769+
}
770+
case NodeKind::SugaredParen: {
771+
if (Node->getNumChildren() < 1)
772+
return BuiltType();
773+
774+
auto base = decodeMangledType(Node->getChild(0));
775+
if (!base)
776+
return BuiltType();
777+
778+
return Builder.createParenType(base);
779+
}
736780
default:
737781
return BuiltType();
738782
}

‎include/swift/Reflection/TypeRefBuilder.h

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -248,6 +248,26 @@ class TypeRefBuilder {
248248
return nullptr;
249249
}
250250

251+
const TypeRef *createOptionalType(const TypeRef *base) {
252+
// TypeRefs don't contain sugared types
253+
return nullptr;
254+
}
255+
256+
const TypeRef *createArrayType(const TypeRef *base) {
257+
// TypeRefs don't contain sugared types
258+
return nullptr;
259+
}
260+
261+
const TypeRef *createDictionaryType(const TypeRef *key, const TypeRef *value) {
262+
// TypeRefs don't contain sugared types
263+
return nullptr;
264+
}
265+
266+
const TypeRef *createParenType(const TypeRef *base) {
267+
// TypeRefs don't contain sugared types
268+
return nullptr;
269+
}
270+
251271
const BoundGenericTypeRef *
252272
createBoundGenericType(const Optional<std::string> &mangledName,
253273
const std::vector<const TypeRef *> &args) {

‎lib/AST/ASTDemangler.cpp

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -577,6 +577,22 @@ Type ASTBuilder::getOpaqueType() {
577577
return Type();
578578
}
579579

580+
Type ASTBuilder::createOptionalType(Type base) {
581+
return OptionalType::get(base);
582+
}
583+
584+
Type ASTBuilder::createArrayType(Type base) {
585+
return ArraySliceType::get(base);
586+
}
587+
588+
Type ASTBuilder::createDictionaryType(Type key, Type value) {
589+
return DictionaryType::get(key, value);
590+
}
591+
592+
Type ASTBuilder::createParenType(Type base) {
593+
return ParenType::get(Ctx, base);
594+
}
595+
580596
bool ASTBuilder::validateParentType(TypeDecl *decl, Type parent) {
581597
auto parentDecl = decl->getDeclContext()->getSelfNominalTypeDecl();
582598

‎lib/AST/ASTMangler.cpp

Lines changed: 33 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -779,11 +779,29 @@ void ASTMangler::appendType(Type type) {
779779
}
780780

781781
case TypeKind::Paren:
782-
return appendSugaredType<ParenType>(type);
783-
case TypeKind::ArraySlice: /* fallthrough */
782+
assert(DWARFMangling && "sugared types are only legal for the debugger");
783+
appendType(cast<ParenType>(tybase)->getUnderlyingType());
784+
appendOperator("XSp");
785+
return;
786+
787+
case TypeKind::ArraySlice:
788+
assert(DWARFMangling && "sugared types are only legal for the debugger");
789+
appendType(cast<ArraySliceType>(tybase)->getBaseType());
790+
appendOperator("XSa");
791+
return;
792+
784793
case TypeKind::Optional:
794+
assert(DWARFMangling && "sugared types are only legal for the debugger");
795+
appendType(cast<OptionalType>(tybase)->getBaseType());
796+
appendOperator("XSq");
797+
return;
798+
785799
case TypeKind::Dictionary:
786-
return appendSugaredType<SyntaxSugarType>(type);
800+
assert(DWARFMangling && "sugared types are only legal for the debugger");
801+
appendType(cast<DictionaryType>(tybase)->getKeyType());
802+
appendType(cast<DictionaryType>(tybase)->getValueType());
803+
appendOperator("XSD");
804+
return;
787805

788806
case TypeKind::ExistentialMetatype: {
789807
ExistentialMetatypeType *EMT = cast<ExistentialMetatypeType>(tybase);
@@ -1647,28 +1665,24 @@ void ASTMangler::appendAnyGenericType(const GenericTypeDecl *decl) {
16471665
if (tryAppendStandardSubstitution(decl))
16481666
return;
16491667

1668+
auto *nominal = dyn_cast<NominalTypeDecl>(decl);
1669+
16501670
// For generic types, this uses the unbound type.
1651-
Type key;
1652-
if (auto *alias = dyn_cast<TypeAliasDecl>(decl)) {
1653-
if (alias->isGeneric())
1654-
key = alias->getUnboundGenericType();
1655-
else
1656-
key = alias->getDeclaredInterfaceType();
1671+
if (nominal) {
1672+
if (tryMangleTypeSubstitution(nominal->getDeclaredType()))
1673+
return;
16571674
} else {
1658-
key = cast<NominalTypeDecl>(decl)->getDeclaredType();
1675+
if (tryMangleSubstitution(cast<TypeAliasDecl>(decl)))
1676+
return;
16591677
}
16601678

1661-
// Try to mangle the entire name as a substitution.
1662-
if (tryMangleTypeSubstitution(key))
1663-
return;
16641679

16651680
// Try to mangle a symbolic reference for a nominal type.
16661681
if (AllowSymbolicReferences) {
1667-
auto nominal = key->getAnyNominal();
16681682
if (nominal && (!CanSymbolicReference || CanSymbolicReference(nominal))) {
16691683
appendSymbolicReference(nominal);
16701684
// Substitutions can refer back to the symbolic reference.
1671-
addTypeSubstitution(key);
1685+
addTypeSubstitution(nominal->getDeclaredType());
16721686
return;
16731687
}
16741688
}
@@ -1731,7 +1745,10 @@ void ASTMangler::appendAnyGenericType(const GenericTypeDecl *decl) {
17311745
}
17321746
}
17331747

1734-
addTypeSubstitution(key);
1748+
if (nominal)
1749+
addTypeSubstitution(nominal->getDeclaredType());
1750+
else
1751+
addSubstitution(cast<TypeAliasDecl>(decl));
17351752
}
17361753

17371754
void ASTMangler::appendFunction(AnyFunctionType *fn, bool isFunctionMangling) {

‎lib/Demangling/Demangler.cpp

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2655,6 +2655,27 @@ NodePointer Demangler::demangleSpecialType() {
26552655
}
26562656
case 'e':
26572657
return createType(createNode(Node::Kind::ErrorType));
2658+
case 'S':
2659+
// Sugared type for debugger.
2660+
switch (nextChar()) {
2661+
case 'q':
2662+
return createType(createWithChild(Node::Kind::SugaredOptional,
2663+
popNode(Node::Kind::Type)));
2664+
case 'a':
2665+
return createType(createWithChild(Node::Kind::SugaredArray,
2666+
popNode(Node::Kind::Type)));
2667+
case 'D': {
2668+
NodePointer value = popNode(Node::Kind::Type);
2669+
NodePointer key = popNode(Node::Kind::Type);
2670+
return createType(createWithChildren(Node::Kind::SugaredDictionary,
2671+
key, value));
2672+
}
2673+
case 'p':
2674+
return createType(createWithChild(Node::Kind::SugaredParen,
2675+
popNode(Node::Kind::Type)));
2676+
default:
2677+
return nullptr;
2678+
}
26582679
default:
26592680
return nullptr;
26602681
}

‎lib/Demangling/NodePrinter.cpp

Lines changed: 36 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -303,6 +303,10 @@ class NodePrinter {
303303
case Node::Kind::TypeList:
304304
case Node::Kind::LabelList:
305305
case Node::Kind::TypeSymbolicReference:
306+
case Node::Kind::SugaredOptional:
307+
case Node::Kind::SugaredArray:
308+
case Node::Kind::SugaredDictionary:
309+
case Node::Kind::SugaredParen:
306310
return true;
307311

308312
case Node::Kind::ProtocolList:
@@ -508,6 +512,15 @@ class NodePrinter {
508512
printer_unreachable("bad node kind");
509513
}
510514

515+
void printWithParens(NodePointer type) {
516+
bool needs_parens = !isSimpleType(type);
517+
if (needs_parens)
518+
Printer << "(";
519+
print(type);
520+
if (needs_parens)
521+
Printer << ")";
522+
}
523+
511524
SugarType findSugar(NodePointer Node) {
512525
if (Node->getNumChildren() == 1 &&
513526
Node->getKind() == Node::Kind::Type)
@@ -595,12 +608,7 @@ class NodePrinter {
595608
case SugarType::Optional:
596609
case SugarType::ImplicitlyUnwrappedOptional: {
597610
NodePointer type = Node->getChild(1)->getChild(0);
598-
bool needs_parens = !isSimpleType(type);
599-
if (needs_parens)
600-
Printer << "(";
601-
print(type);
602-
if (needs_parens)
603-
Printer << ")";
611+
printWithParens(type);
604612
Printer << (sugarType == SugarType::Optional ? "?" : "!");
605613
break;
606614
}
@@ -1731,12 +1739,7 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
17311739
Idx++;
17321740
}
17331741
NodePointer type = Node->getChild(Idx)->getChild(0);
1734-
bool needs_parens = !isSimpleType(type);
1735-
if (needs_parens)
1736-
Printer << "(";
1737-
print(type);
1738-
if (needs_parens)
1739-
Printer << ")";
1742+
printWithParens(type);
17401743
if (isExistentialType(type)) {
17411744
Printer << ".Protocol";
17421745
} else {
@@ -2189,6 +2192,27 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
21892192
Printer << "protocol conformance ref (retroactive) ";
21902193
printChildren(Node);
21912194
return nullptr;
2195+
case Node::Kind::SugaredOptional:
2196+
printWithParens(Node->getChild(0));
2197+
Printer << "?";
2198+
return nullptr;
2199+
case Node::Kind::SugaredArray:
2200+
Printer << "[";
2201+
print(Node->getChild(0));
2202+
Printer << "]";
2203+
return nullptr;
2204+
case Node::Kind::SugaredDictionary:
2205+
Printer << "[";
2206+
print(Node->getChild(0));
2207+
Printer << " : ";
2208+
print(Node->getChild(1));
2209+
Printer << "]";
2210+
return nullptr;
2211+
case Node::Kind::SugaredParen:
2212+
Printer << "(";
2213+
print(Node->getChild(0));
2214+
Printer << ")";
2215+
return nullptr;
21922216
}
21932217
printer_unreachable("bad node kind!");
21942218
}

‎lib/Demangling/OldRemangler.cpp

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2260,6 +2260,22 @@ void Remangler::mangleProtocolSymbolicReference(Node *node, EntityContext&) {
22602260
unreachable("unsupported");
22612261
}
22622262

2263+
void Remangler::mangleSugaredOptional(Node *node) {
2264+
unreachable("unsupported");
2265+
}
2266+
2267+
void Remangler::mangleSugaredArray(Node *node) {
2268+
unreachable("unsupported");
2269+
}
2270+
2271+
void Remangler::mangleSugaredDictionary(Node *node) {
2272+
unreachable("unsupported");
2273+
}
2274+
2275+
void Remangler::mangleSugaredParen(Node *node) {
2276+
unreachable("unsupported");
2277+
}
2278+
22632279
/// The top-level interface to the remangler.
22642280
std::string Demangle::mangleNodeOld(const NodePointer &node) {
22652281
if (!node) return "";

‎lib/Demangling/Remangler.cpp

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2307,6 +2307,27 @@ void Remangler::mangleProtocolSymbolicReference(Node *node) {
23072307
(const void *)node->getIndex()));
23082308
}
23092309

2310+
void Remangler::mangleSugaredOptional(Node *node) {
2311+
mangleType(node->getChild(0));
2312+
Buffer << "XSq";
2313+
}
2314+
2315+
void Remangler::mangleSugaredArray(Node *node) {
2316+
mangleType(node->getChild(0));
2317+
Buffer << "XSa";
2318+
}
2319+
2320+
void Remangler::mangleSugaredDictionary(Node *node) {
2321+
mangleType(node->getChild(0));
2322+
mangleType(node->getChild(1));
2323+
Buffer << "XSD";
2324+
}
2325+
2326+
void Remangler::mangleSugaredParen(Node *node) {
2327+
mangleType(node->getChild(0));
2328+
Buffer << "XSp";
2329+
}
2330+
23102331
} // anonymous namespace
23112332

23122333
/// The top-level interface to the remangler.

0 commit comments

Comments
 (0)