Skip to content

Commit b7ea88a

Browse files
adrian-prantladrian-prantl
committed
Merge commit 'ad53c6a089b6' from swift/release/6.1 into stable/20240723
 Conflicts: lldb/source/Plugins/TypeSystem/Swift/TypeSystemSwiftTypeRef.cpp lldb/source/Plugins/TypeSystem/Swift/TypeSystemSwiftTypeRef.h
2 parents 42362ee + ad53c6a commit b7ea88a

File tree

2 files changed

+113
-65
lines changed

2 files changed

+113
-65
lines changed

‎lldb/source/Plugins/TypeSystem/Swift/TypeSystemSwiftTypeRef.cpp

Lines changed: 97 additions & 65 deletions
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,6 @@
1111
//===----------------------------------------------------------------------===//
1212

1313
#include "Plugins/TypeSystem/Swift/TypeSystemSwiftTypeRef.h"
14-
#include "Plugins/LanguageRuntime/Swift/SwiftLanguageRuntimeImpl.h"
1514
#include "Plugins/TypeSystem/Swift/SwiftASTContext.h"
1615
#include "Plugins/TypeSystem/Swift/SwiftDWARFImporterForClangTypes.h"
1716
#include "Plugins/TypeSystem/Swift/SwiftDemangle.h"
@@ -1075,8 +1074,8 @@ TypeSystemSwiftTypeRef::GetTupleElement(lldb::opaque_compiler_type_t type,
10751074
using namespace swift::Demangle;
10761075
Demangler dem;
10771076
auto flavor = SwiftLanguageRuntime::GetManglingFlavor(AsMangledName(type));
1078-
1079-
NodePointer node = TypeSystemSwiftTypeRef::DemangleCanonicalType(dem, type);
1077+
NodePointer node =
1078+
TypeSystemSwiftTypeRef::DemangleCanonicalOutermostType(dem, type);
10801079
if (!node || node->getKind() != Node::Kind::Tuple)
10811080
return {};
10821081
if (node->getNumChildren() < idx)
@@ -1182,6 +1181,59 @@ Desugar(swift::Demangle::Demangler &dem, swift::Demangle::NodePointer node,
11821181
return desugared;
11831182
}
11841183

1184+
swift::Demangle::NodePointer
1185+
TypeSystemSwiftTypeRef::Canonicalize(swift::Demangle::Demangler &dem,
1186+
swift::Demangle::NodePointer node,
1187+
swift::Mangle::ManglingFlavor flavor) {
1188+
assert(node);
1189+
auto kind = node->getKind();
1190+
switch (kind) {
1191+
case Node::Kind::SugaredOptional:
1192+
// FIXME: Factor these three cases out.
1193+
assert(node->getNumChildren() == 1);
1194+
if (node->getNumChildren() != 1)
1195+
return node;
1196+
return Desugar(dem, node, Node::Kind::BoundGenericEnum, Node::Kind::Enum,
1197+
"Optional");
1198+
case Node::Kind::SugaredArray: {
1199+
assert(node->getNumChildren() == 1);
1200+
if (node->getNumChildren() != 1)
1201+
return node;
1202+
return Desugar(dem, node, Node::Kind::BoundGenericStructure,
1203+
Node::Kind::Structure, "Array");
1204+
}
1205+
case Node::Kind::SugaredDictionary:
1206+
// FIXME: This isnt covered by any test.
1207+
assert(node->getNumChildren() == 2);
1208+
if (node->getNumChildren() != 2)
1209+
return node;
1210+
return Desugar(dem, node, Node::Kind::BoundGenericStructure,
1211+
Node::Kind::Structure, "Dictionary");
1212+
case Node::Kind::SugaredParen:
1213+
assert(node->getNumChildren() == 1);
1214+
if (node->getNumChildren() != 1)
1215+
return node;
1216+
return node->getFirstChild();
1217+
1218+
case Node::Kind::BoundGenericTypeAlias:
1219+
case Node::Kind::TypeAlias: {
1220+
auto node_clangtype = ResolveTypeAlias(dem, node, flavor);
1221+
if (CompilerType clang_type = node_clangtype.second) {
1222+
if (auto result = GetClangTypeNode(clang_type, dem))
1223+
return result;
1224+
else
1225+
return node;
1226+
}
1227+
if (node_clangtype.first)
1228+
return node_clangtype.first;
1229+
return node;
1230+
}
1231+
default:
1232+
break;
1233+
}
1234+
return node;
1235+
}
1236+
11851237
/// Iteratively resolve all type aliases in \p node by looking up their
11861238
/// desugared types in the debug info of module \p M.
11871239
swift::Demangle::NodePointer
@@ -1190,52 +1242,7 @@ TypeSystemSwiftTypeRef::GetCanonicalNode(swift::Demangle::Demangler &dem,
11901242
swift::Mangle::ManglingFlavor flavor) {
11911243
using namespace swift::Demangle;
11921244
return TypeSystemSwiftTypeRef::Transform(dem, node, [&](NodePointer node) {
1193-
auto kind = node->getKind();
1194-
switch (kind) {
1195-
case Node::Kind::SugaredOptional:
1196-
// FIXME: Factor these three cases out.
1197-
assert(node->getNumChildren() == 1);
1198-
if (node->getNumChildren() != 1)
1199-
return node;
1200-
return Desugar(dem, node, Node::Kind::BoundGenericEnum, Node::Kind::Enum,
1201-
"Optional");
1202-
case Node::Kind::SugaredArray: {
1203-
assert(node->getNumChildren() == 1);
1204-
if (node->getNumChildren() != 1)
1205-
return node;
1206-
return Desugar(dem, node, Node::Kind::BoundGenericStructure,
1207-
Node::Kind::Structure, "Array");
1208-
}
1209-
case Node::Kind::SugaredDictionary:
1210-
// FIXME: This isnt covered by any test.
1211-
assert(node->getNumChildren() == 2);
1212-
if (node->getNumChildren() != 2)
1213-
return node;
1214-
return Desugar(dem, node, Node::Kind::BoundGenericStructure,
1215-
Node::Kind::Structure, "Dictionary");
1216-
case Node::Kind::SugaredParen:
1217-
assert(node->getNumChildren() == 1);
1218-
if (node->getNumChildren() != 1)
1219-
return node;
1220-
return node->getFirstChild();
1221-
1222-
case Node::Kind::BoundGenericTypeAlias:
1223-
case Node::Kind::TypeAlias: {
1224-
auto node_clangtype = ResolveTypeAlias(dem, node, flavor);
1225-
if (CompilerType clang_type = node_clangtype.second) {
1226-
if (auto result = GetClangTypeNode(clang_type, dem))
1227-
return result;
1228-
else
1229-
return node;
1230-
}
1231-
if (node_clangtype.first)
1232-
return node_clangtype.first;
1233-
return node;
1234-
}
1235-
default:
1236-
break;
1237-
}
1238-
return node;
1245+
return Canonicalize(dem, node, flavor);
12391246
});
12401247
}
12411248

@@ -2444,6 +2451,7 @@ template <> bool Equivalent<CompilerType>(CompilerType l, CompilerType r) {
24442451
ast_ctx->ReconstructType(l.GetMangledTypeName()))
24452452
.value_or(nullptr)) == r.GetOpaqueQualType())
24462453
return true;
2454+
24472455
ConstString lhs = l.GetMangledTypeName();
24482456
ConstString rhs = r.GetMangledTypeName();
24492457
if (lhs == ConstString("$sSiD") && rhs == ConstString("$sSuD"))
@@ -2719,12 +2727,34 @@ TypeSystemSwiftTypeRef::RemangleAsType(swift::Demangle::Demangler &dem,
27192727
}
27202728

27212729
swift::Demangle::NodePointer TypeSystemSwiftTypeRef::DemangleCanonicalType(
2722-
swift::Demangle::Demangler &dem, opaque_compiler_type_t opaque_type) {
2730+
swift::Demangle::Demangler &dem, lldb::opaque_compiler_type_t opaque_type) {
27232731
using namespace swift::Demangle;
27242732
CompilerType type = GetCanonicalType(opaque_type);
27252733
return GetDemangledType(dem, type.GetMangledTypeName().GetStringRef());
27262734
}
27272735

2736+
swift::Demangle::NodePointer
2737+
TypeSystemSwiftTypeRef::DemangleCanonicalOutermostType(
2738+
swift::Demangle::Demangler &dem, lldb::opaque_compiler_type_t type) {
2739+
using namespace swift::Demangle;
2740+
const auto *mangled_name = AsMangledName(type);
2741+
auto flavor = SwiftLanguageRuntime::GetManglingFlavor(mangled_name);
2742+
NodePointer node = GetDemangledType(dem, mangled_name);
2743+
2744+
if (!node)
2745+
return nullptr;
2746+
NodePointer canonical = Canonicalize(dem, node, flavor);
2747+
if (canonical &&
2748+
canonical->getKind() == swift::Demangle::Node::Kind::TypeAlias) {
2749+
// If this is a typealias defined in the expression evaluator,
2750+
// then we don't have debug info to resolve it from.
2751+
CompilerType ast_type =
2752+
ReconstructType({weak_from_this(), type}, nullptr).GetCanonicalType();
2753+
return GetDemangledType(dem, ast_type.GetMangledTypeName());
2754+
}
2755+
return canonical;
2756+
}
2757+
27282758
CompilerType TypeSystemSwiftTypeRef::CreateGenericTypeParamType(
27292759
unsigned int depth, unsigned int index,
27302760
swift::Mangle::ManglingFlavor flavor) {
@@ -2754,7 +2784,7 @@ bool TypeSystemSwiftTypeRef::IsArrayType(opaque_compiler_type_t type,
27542784
auto flavor = SwiftLanguageRuntime::GetManglingFlavor(mangled_name);
27552785

27562786
Demangler dem;
2757-
NodePointer node = DemangleCanonicalType(dem, type);
2787+
NodePointer node = DemangleCanonicalOutermostType(dem, type);
27582788
if (!node || node->getNumChildren() != 2 ||
27592789
node->getKind() != Node::Kind::BoundGenericStructure)
27602790
return false;
@@ -2780,7 +2810,9 @@ bool TypeSystemSwiftTypeRef::IsArrayType(opaque_compiler_type_t type,
27802810
return false;
27812811
elem_node = elem_node->getFirstChild();
27822812
if (element_type)
2783-
*element_type = RemangleAsType(dem, elem_node, flavor);
2813+
// FIXME: This expensive canonicalization is only there for
2814+
// SwiftASTContext compatibility.
2815+
*element_type = RemangleAsType(dem, elem_node, flavor).GetCanonicalType();
27842816

27852817
if (is_incomplete)
27862818
*is_incomplete = true;
@@ -2797,7 +2829,7 @@ bool TypeSystemSwiftTypeRef::IsAggregateType(opaque_compiler_type_t type) {
27972829
auto impl = [&]() -> bool {
27982830
using namespace swift::Demangle;
27992831
Demangler dem;
2800-
NodePointer node = DemangleCanonicalType(dem, type);
2832+
NodePointer node = DemangleCanonicalOutermostType(dem, type);
28012833

28022834
if (!node)
28032835
return false;
@@ -2835,7 +2867,7 @@ bool TypeSystemSwiftTypeRef::IsFunctionType(opaque_compiler_type_t type) {
28352867
auto impl = [&]() -> bool {
28362868
using namespace swift::Demangle;
28372869
Demangler dem;
2838-
NodePointer node = DemangleCanonicalType(dem, type);
2870+
NodePointer node = DemangleCanonicalOutermostType(dem, type);
28392871
// Note: There are a number of other candidates, and this list may need
28402872
// updating. Ex: `NoEscapeFunctionType`, `ThinFunctionType`, etc.
28412873
return node && (node->getKind() == Node::Kind::FunctionType ||
@@ -2850,7 +2882,7 @@ size_t TypeSystemSwiftTypeRef::GetNumberOfFunctionArguments(
28502882
auto impl = [&]() -> size_t {
28512883
using namespace swift::Demangle;
28522884
Demangler dem;
2853-
NodePointer node = DemangleCanonicalType(dem, type);
2885+
NodePointer node = DemangleCanonicalOutermostType(dem, type);
28542886
if (!node || (node->getKind() != Node::Kind::FunctionType &&
28552887
node->getKind() != Node::Kind::NoEscapeFunctionType &&
28562888
node->getKind() != Node::Kind::ImplFunctionType))
@@ -2884,7 +2916,7 @@ TypeSystemSwiftTypeRef::GetFunctionArgumentAtIndex(opaque_compiler_type_t type,
28842916
auto flavor = SwiftLanguageRuntime::GetManglingFlavor(mangled_name);
28852917

28862918
Demangler dem;
2887-
NodePointer node = DemangleCanonicalType(dem, type);
2919+
NodePointer node = DemangleCanonicalOutermostType(dem, type);
28882920
if (!node || (node->getKind() != Node::Kind::FunctionType &&
28892921
node->getKind() != Node::Kind::NoEscapeFunctionType &&
28902922
node->getKind() != Node::Kind::ImplFunctionType))
@@ -3013,7 +3045,7 @@ bool TypeSystemSwiftTypeRef::IsPointerType(opaque_compiler_type_t type,
30133045
auto impl = [&]() {
30143046
using namespace swift::Demangle;
30153047
Demangler dem;
3016-
NodePointer node = DemangleCanonicalType(dem, type);
3048+
NodePointer node = DemangleCanonicalOutermostType(dem, type);
30173049
if (!node || node->getKind() != Node::Kind::BuiltinTypeName ||
30183050
!node->hasText())
30193051
return false;
@@ -3029,7 +3061,7 @@ bool TypeSystemSwiftTypeRef::IsVoidType(opaque_compiler_type_t type) {
30293061
auto impl = [&]() {
30303062
using namespace swift::Demangle;
30313063
Demangler dem;
3032-
NodePointer node = DemangleCanonicalType(dem, type);
3064+
NodePointer node = DemangleCanonicalOutermostType(dem, type);
30333065
return node && node->getNumChildren() == 0 &&
30343066
node->getKind() == Node::Kind::Tuple;
30353067
};
@@ -3218,7 +3250,7 @@ TypeSystemSwiftTypeRef::GetFunctionReturnType(opaque_compiler_type_t type) {
32183250
auto flavor = SwiftLanguageRuntime::GetManglingFlavor(mangled_name);
32193251

32203252
Demangler dem;
3221-
NodePointer node = DemangleCanonicalType(dem, type);
3253+
NodePointer node = DemangleCanonicalOutermostType(dem, type);
32223254
if (!node || (node->getKind() != Node::Kind::FunctionType &&
32233255
node->getKind() != Node::Kind::NoEscapeFunctionType &&
32243256
node->getKind() != Node::Kind::ImplFunctionType))
@@ -3451,7 +3483,7 @@ lldb::Encoding TypeSystemSwiftTypeRef::GetEncoding(opaque_compiler_type_t type,
34513483

34523484
using namespace swift::Demangle;
34533485
Demangler dem;
3454-
auto *node = DemangleCanonicalType(dem, type);
3486+
auto *node = DemangleCanonicalOutermostType(dem, type);
34553487
if (!node)
34563488
return lldb::eEncodingInvalid;
34573489
auto kind = node->getKind();
@@ -4031,7 +4063,7 @@ TypeSystemSwiftTypeRef::GetNumTemplateArguments(opaque_compiler_type_t type,
40314063
auto impl = [&]() -> size_t {
40324064
using namespace swift::Demangle;
40334065
Demangler dem;
4034-
NodePointer node = DemangleCanonicalType(dem, type);
4066+
NodePointer node = DemangleCanonicalOutermostType(dem, type);
40354067

40364068
if (!node)
40374069
return 0;
@@ -4171,7 +4203,7 @@ bool TypeSystemSwiftTypeRef::IsExistentialType(
41714203
lldb::opaque_compiler_type_t type) {
41724204
using namespace swift::Demangle;
41734205
Demangler dem;
4174-
NodePointer node = DemangleCanonicalType(dem, type);
4206+
NodePointer node = DemangleCanonicalOutermostType(dem, type);
41754207
if (!node || node->getNumChildren() != 1)
41764208
return false;
41774209
switch (node->getKind()) {
@@ -4198,7 +4230,7 @@ bool TypeSystemSwiftTypeRef::IsErrorType(opaque_compiler_type_t type) {
41984230
auto impl = [&]() -> bool {
41994231
using namespace swift::Demangle;
42004232
Demangler dem;
4201-
NodePointer protocol_list = DemangleCanonicalType(dem, type);
4233+
NodePointer protocol_list = DemangleCanonicalOutermostType(dem, type);
42024234
if (protocol_list && protocol_list->getKind() == Node::Kind::ProtocolList)
42034235
for (auto type_list : *protocol_list)
42044236
if (type_list && type_list->getKind() == Node::Kind::TypeList)
@@ -4999,7 +5031,7 @@ bool TypeSystemSwiftTypeRef::IsReferenceType(opaque_compiler_type_t type,
49995031
auto flavor = SwiftLanguageRuntime::GetManglingFlavor(mangled_name);
50005032

50015033
Demangler dem;
5002-
NodePointer node = DemangleCanonicalType(dem, type);
5034+
NodePointer node = DemangleCanonicalOutermostType(dem, type);
50035035
if (!node || node->getNumChildren() != 1 ||
50045036
node->getKind() != Node::Kind::InOut)
50055037
return false;
@@ -5029,7 +5061,7 @@ TypeSystemSwiftTypeRef::GetGenericArgumentType(opaque_compiler_type_t type,
50295061
auto flavor = SwiftLanguageRuntime::GetManglingFlavor(mangled_name);
50305062

50315063
Demangler dem;
5032-
NodePointer node = DemangleCanonicalType(dem, type);
5064+
NodePointer node = DemangleCanonicalOutermostType(dem, type);
50335065
if (!node || node->getNumChildren() != 2)
50345066
return {};
50355067

‎lldb/source/Plugins/TypeSystem/Swift/TypeSystemSwiftTypeRef.h

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -448,6 +448,13 @@ class TypeSystemSwiftTypeRef : public TypeSystemSwift {
448448
/// Cast \p opaque_type as a mangled name.
449449
static const char *AsMangledName(lldb::opaque_compiler_type_t type);
450450

451+
/// Helper function that canonicalizes node, but doesn't look at its
452+
/// children.
453+
swift::Demangle::NodePointer
454+
Canonicalize(swift::Demangle::Demangler &dem,
455+
swift::Demangle::NodePointer node,
456+
swift::Mangle::ManglingFlavor flavor);
457+
451458
/// Demangle the mangled name of the canonical type of \p type and
452459
/// drill into the Global(TypeMangling(Type())).
453460
///
@@ -456,6 +463,15 @@ class TypeSystemSwiftTypeRef : public TypeSystemSwift {
456463
DemangleCanonicalType(swift::Demangle::Demangler &dem,
457464
lldb::opaque_compiler_type_t type);
458465

466+
/// Demangle the mangled name of \p type after canonicalizing its
467+
/// outermost type node and drill into the
468+
/// Global(TypeMangling(Type())).
469+
///
470+
/// \return the child of Type or a nullptr.
471+
swift::Demangle::NodePointer
472+
DemangleCanonicalOutermostType(swift::Demangle::Demangler &dem,
473+
lldb::opaque_compiler_type_t type);
474+
459475
/// If \p node is a Struct/Class/Typedef in the __C module, return a
460476
/// Swiftified node by looking up the name in the corresponding APINotes and
461477
/// optionally putting it into the correctly named module.

0 commit comments

Comments
 (0)