Skip to content

Commit 721182d

Browse files
nkcsgexinkcsgexi
committed
swift-module-digester: refactor all node creation functions into SwiftDeclCollector. NFC
1 parent a28c9d6 commit 721182d

File tree

2 files changed

+98
-97
lines changed

2 files changed

+98
-97
lines changed

‎tools/swift-api-digester/ModuleAnalyzerNodes.cpp

Lines changed: 84 additions & 97 deletions
Original file line numberDiff line numberDiff line change
@@ -15,14 +15,6 @@ enum class KeyKind {
1515
#include "swift/IDE/DigesterEnums.def"
1616
};
1717

18-
/// The additional information we need to create a type node.
19-
struct TypeInitInfo {
20-
bool IsImplicitlyUnwrappedOptional = false;
21-
/// When this type node represents a function parameter, this boolean value
22-
/// indicates whether the parameter has default argument.
23-
bool hasDefaultArgument = false;
24-
};
25-
2618
static StringRef getAttrName(DeclAttrKind Kind) {
2719
switch (Kind) {
2820
#define DECL_ATTR(NAME, CLASS, ...) \
@@ -57,13 +49,14 @@ struct swift::ide::api::SDKNodeInitInfo {
5749
std::vector<StringRef> ConformingProtocols;
5850
StringRef SuperclassUsr;
5951
StringRef EnumRawTypeName;
60-
TypeInitInfo TypeInfo;
52+
bool hasDefaultArgument = false;
6153
StringRef GenericSig;
6254
bool HasSetter = false;
6355

6456
SDKNodeInitInfo(SDKContext &Ctx) : Ctx(Ctx) {}
6557
SDKNodeInitInfo(SDKContext &Ctx, ValueDecl *VD);
66-
SDKNodeInitInfo(SDKContext &Ctx, Type Ty, TypeInitInfo Info = TypeInitInfo());
58+
SDKNodeInitInfo(SDKContext &Ctx, Type Ty, bool IsImplicitlyUnwrappedOptional,
59+
bool hasDefaultArgument);
6760
SDKNode* createSDKNode(SDKNodeKind Kind);
6861
};
6962

@@ -94,7 +87,7 @@ SDKNodeDecl::SDKNodeDecl(SDKNodeInitInfo Info, SDKNodeKind Kind)
9487

9588
SDKNodeType::SDKNodeType(SDKNodeInitInfo Info, SDKNodeKind Kind):
9689
SDKNode(Info, Kind), TypeAttributes(Info.TypeAttrs),
97-
HasDefaultArg(Info.TypeInfo.hasDefaultArgument) {}
90+
HasDefaultArg(Info.hasDefaultArgument) {}
9891

9992
SDKNodeTypeNominal::SDKNodeTypeNominal(SDKNodeInitInfo Info):
10093
SDKNodeType(Info, SDKNodeKind::TypeNominal), USR(Info.USR) {}
@@ -585,7 +578,7 @@ SDKNode* SDKNode::constructSDKNode(SDKContext &Ctx,
585578
Info.IsMutating = true;
586579
break;
587580
case KeyKind::KK_hasDefaultArg:
588-
Info.TypeInfo.hasDefaultArgument = true;
581+
Info.hasDefaultArgument = true;
589582
break;
590583
case KeyKind::KK_static:
591584
Info.IsStatic = true;
@@ -1036,10 +1029,11 @@ static Optional<unsigned> getFixedBinaryOrder(ValueDecl *VD) {
10361029
}
10371030

10381031
SDKNodeInitInfo::SDKNodeInitInfo(SDKContext &Ctx, Type Ty,
1039-
TypeInitInfo TypeInfo) :
1040-
Ctx(Ctx), Name(getTypeName(Ctx, Ty, TypeInfo.IsImplicitlyUnwrappedOptional)),
1041-
PrintedName(getPrintedName(Ctx, Ty, TypeInfo.IsImplicitlyUnwrappedOptional)),
1042-
TypeInfo(TypeInfo) {
1032+
bool IsImplicitlyUnwrappedOptional = false,
1033+
bool hasDefaultArgument = false) :
1034+
Ctx(Ctx), Name(getTypeName(Ctx, Ty, IsImplicitlyUnwrappedOptional)),
1035+
PrintedName(getPrintedName(Ctx, Ty, IsImplicitlyUnwrappedOptional)),
1036+
hasDefaultArgument(hasDefaultArgument) {
10431037
if (isFunctionTypeNoEscape(Ty))
10441038
TypeAttrs.push_back(TypeAttrKind::TAK_noescape);
10451039
// If this is a nominal type, get its Usr.
@@ -1109,64 +1103,62 @@ case SDKNodeKind::X: \
11091103

11101104
// Recursively construct a node that represents a type, for instance,
11111105
// representing the return value type of a function decl.
1112-
static SDKNode *constructTypeNode(SDKContext &Ctx, Type T,
1113-
TypeInitInfo InitInfo = TypeInitInfo()) {
1106+
SDKNode *swift::ide::api::
1107+
SwiftDeclCollector::constructTypeNode(Type T,
1108+
bool IsImplicitlyUnwrappedOptional,
1109+
bool hasDefaultArgument) {
11141110
if (Ctx.checkingABI()) {
11151111
T = T->getCanonicalType();
11161112
}
1117-
SDKNode* Root = SDKNodeInitInfo(Ctx, T, InitInfo)
1118-
.createSDKNode(SDKNodeKind::TypeNominal);
1113+
SDKNode* Root = SDKNodeInitInfo(Ctx, T, IsImplicitlyUnwrappedOptional,
1114+
hasDefaultArgument).createSDKNode(SDKNodeKind::TypeNominal);
11191115

11201116
if (auto NAT = dyn_cast<NameAliasType>(T.getPointer())) {
11211117
SDKNode* Root = SDKNodeInitInfo(Ctx, T).createSDKNode(SDKNodeKind::TypeAlias);
1122-
Root->addChild(constructTypeNode(Ctx, NAT->getCanonicalType()));
1118+
Root->addChild(constructTypeNode(NAT->getCanonicalType()));
11231119
return Root;
11241120
}
11251121

11261122
if (auto Fun = T->getAs<AnyFunctionType>()) {
11271123
SDKNode* Root = SDKNodeInitInfo(Ctx, T).createSDKNode(SDKNodeKind::TypeFunc);
11281124

11291125
// Still, return type first
1130-
Root->addChild(constructTypeNode(Ctx, Fun->getResult()));
1131-
Root->addChild(constructTypeNode(Ctx, Fun->getInput()));
1126+
Root->addChild(constructTypeNode(Fun->getResult()));
1127+
Root->addChild(constructTypeNode(Fun->getInput()));
11321128
return Root;
11331129
}
11341130

11351131
// Keep paren type as a stand-alone level.
11361132
if (auto *PT = dyn_cast<ParenType>(T.getPointer())) {
1137-
Root->addChild(constructTypeNode(Ctx, PT->getSinglyDesugaredType()));
1133+
Root->addChild(constructTypeNode(PT->getSinglyDesugaredType()));
11381134
return Root;
11391135
}
11401136

11411137
// Handle the case where Type has sub-types.
11421138
if (auto BGT = T->getAs<BoundGenericType>()) {
11431139
for (auto Arg : BGT->getGenericArgs()) {
1144-
Root->addChild(constructTypeNode(Ctx, Arg));
1140+
Root->addChild(constructTypeNode(Arg));
11451141
}
11461142
} else if (auto Tup = T->getAs<TupleType>()) {
11471143
for (auto Elt : Tup->getElementTypes())
1148-
Root->addChild(constructTypeNode(Ctx, Elt));
1144+
Root->addChild(constructTypeNode(Elt));
11491145
} else if (auto MTT = T->getAs<AnyMetatypeType>()) {
1150-
Root->addChild(constructTypeNode(Ctx, MTT->getInstanceType()));
1146+
Root->addChild(constructTypeNode(MTT->getInstanceType()));
11511147
} else if (auto ATT = T->getAs<ArchetypeType>()) {
11521148
for (auto Pro : ATT->getConformsTo()) {
1153-
Root->addChild(constructTypeNode(Ctx, Pro->getDeclaredType()));
1149+
Root->addChild(constructTypeNode(Pro->getDeclaredType()));
11541150
}
11551151
}
11561152
return Root;
11571153
}
11581154

1159-
static std::vector<SDKNode*>
1160-
createParameterNodes(SDKContext &Ctx, ParameterList *PL) {
1155+
std::vector<SDKNode*> swift::ide::api::
1156+
SwiftDeclCollector::createParameterNodes(ParameterList *PL) {
11611157
std::vector<SDKNode*> Result;
11621158
for (auto param: *PL) {
1163-
TypeInitInfo TypeInfo;
1164-
TypeInfo.IsImplicitlyUnwrappedOptional = param->getAttrs().
1165-
hasAttribute<ImplicitlyUnwrappedOptionalAttr>();
1166-
TypeInfo.hasDefaultArgument = param->getDefaultArgumentKind() !=
1167-
DefaultArgumentKind::None;
1168-
Result.push_back(constructTypeNode(Ctx, param->getInterfaceType(),
1169-
TypeInfo));
1159+
Result.push_back(constructTypeNode(param->getInterfaceType(),
1160+
param->getAttrs().hasAttribute<ImplicitlyUnwrappedOptionalAttr>(),
1161+
param->getDefaultArgumentKind() != DefaultArgumentKind::None));
11701162
}
11711163
return Result;
11721164
}
@@ -1175,27 +1167,28 @@ createParameterNodes(SDKContext &Ctx, ParameterList *PL) {
11751167
// is guaranteed to be the return value type of this function.
11761168
// We sometimes skip the first parameter because it can be metatype of dynamic
11771169
// this if the function is a member function.
1178-
static SDKNode *constructFunctionNode(SDKContext &Ctx, FuncDecl* FD,
1179-
SDKNodeKind Kind) {
1170+
SDKNode *swift::ide::api::
1171+
SwiftDeclCollector::constructFunctionNode(FuncDecl* FD,
1172+
SDKNodeKind Kind) {
11801173
auto Func = SDKNodeInitInfo(Ctx, FD).createSDKNode(Kind);
1181-
TypeInitInfo TypeInfo;
1182-
TypeInfo.IsImplicitlyUnwrappedOptional = FD->getAttrs().
1183-
hasAttribute<ImplicitlyUnwrappedOptionalAttr>();
1184-
Func->addChild(constructTypeNode(Ctx, FD->getResultInterfaceType(), TypeInfo));
1185-
for (auto *Node : createParameterNodes(Ctx, FD->getParameters()))
1174+
Func->addChild(constructTypeNode(FD->getResultInterfaceType(),
1175+
FD->getAttrs().hasAttribute<ImplicitlyUnwrappedOptionalAttr>()));
1176+
for (auto *Node : createParameterNodes(FD->getParameters()))
11861177
Func->addChild(Node);
11871178
return Func;
11881179
}
11891180

1190-
static SDKNode* constructInitNode(SDKContext &Ctx, ConstructorDecl *CD) {
1181+
SDKNode* swift::ide::api::
1182+
SwiftDeclCollector::constructInitNode(ConstructorDecl *CD) {
11911183
auto Func = SDKNodeInitInfo(Ctx, CD).createSDKNode(SDKNodeKind::DeclConstructor);
1192-
Func->addChild(constructTypeNode(Ctx, CD->getResultInterfaceType()));
1193-
for (auto *Node : createParameterNodes(Ctx, CD->getParameters()))
1184+
Func->addChild(constructTypeNode(CD->getResultInterfaceType()));
1185+
for (auto *Node : createParameterNodes(CD->getParameters()))
11941186
Func->addChild(Node);
11951187
return Func;
11961188
}
11971189

1198-
static bool shouldIgnore(Decl *D, const Decl* Parent, SDKContext &Ctx) {
1190+
bool swift::ide::api::
1191+
SwiftDeclCollector::shouldIgnore(Decl *D, const Decl* Parent) {
11991192
if (D->isPrivateStdlibDecl(false))
12001193
return true;
12011194
if (AvailableAttr::isUnavailable(D))
@@ -1242,17 +1235,13 @@ static bool shouldIgnore(Decl *D, const Decl* Parent, SDKContext &Ctx) {
12421235
return false;
12431236
}
12441237

1245-
static void addMembersToRoot(SDKContext &Ctx, SDKNode *Root,
1246-
IterableDeclContext *Context,
1247-
std::set<ExtensionDecl*> &HandledExts);
1248-
1249-
static SDKNode *constructTypeDeclNode(SDKContext &Ctx, NominalTypeDecl *NTD,
1250-
std::set<ExtensionDecl*> &HandledExts) {
1238+
SDKNode *swift::ide::api::
1239+
SwiftDeclCollector::constructTypeDeclNode(NominalTypeDecl *NTD) {
12511240
auto TypeNode = SDKNodeInitInfo(Ctx, NTD).createSDKNode(SDKNodeKind::DeclType);
1252-
addMembersToRoot(Ctx, TypeNode, NTD, HandledExts);
1241+
addMembersToRoot(TypeNode, NTD);
12531242
for (auto Ext : NTD->getExtensions()) {
1254-
HandledExts.insert(Ext);
1255-
addMembersToRoot(Ctx, TypeNode, Ext, HandledExts);
1243+
HandledExtensions.insert(Ext);
1244+
addMembersToRoot(TypeNode, Ext);
12561245
}
12571246
return TypeNode;
12581247
}
@@ -1262,83 +1251,82 @@ static SDKNode *constructTypeDeclNode(SDKContext &Ctx, NominalTypeDecl *NTD,
12621251
/// extended types. If the extended types are from a different module, we have to
12631252
/// synthesize this type node to include those extension members, since these
12641253
/// extension members are legit members of the module.
1265-
static SDKNode *constructExternalExtensionNode(SDKContext &Ctx, SDKNode *Root,
1266-
NominalTypeDecl *NTD,
1267-
ArrayRef<ExtensionDecl*> AllExts,
1268-
std::set<ExtensionDecl*> &HandledExts) {
1254+
SDKNode *swift::ide::api::
1255+
SwiftDeclCollector::constructExternalExtensionNode(NominalTypeDecl *NTD,
1256+
ArrayRef<ExtensionDecl*> AllExts) {
12691257
auto *TypeNode = SDKNodeInitInfo(Ctx, NTD).createSDKNode(SDKNodeKind::DeclType);
12701258

12711259
// The members of the extensions are the only members of this synthesized type.
12721260
for (auto *Ext: AllExts) {
1273-
HandledExts.insert(Ext);
1274-
addMembersToRoot(Ctx, TypeNode, Ext, HandledExts);
1261+
HandledExtensions.insert(Ext);
1262+
addMembersToRoot(TypeNode, Ext);
12751263
}
12761264
return TypeNode;
12771265
}
12781266

1279-
static SDKNode *constructVarNode(SDKContext &Ctx, ValueDecl *VD) {
1267+
SDKNode *swift::ide::api::
1268+
SwiftDeclCollector::constructVarNode(ValueDecl *VD) {
12801269
auto Var = SDKNodeInitInfo(Ctx, VD).createSDKNode(SDKNodeKind::DeclVar);
1281-
TypeInitInfo TypeInfo;
1282-
TypeInfo.IsImplicitlyUnwrappedOptional = VD->getAttrs().
1283-
hasAttribute<ImplicitlyUnwrappedOptionalAttr>();
1284-
Var->addChild(constructTypeNode(Ctx, VD->getInterfaceType(), TypeInfo));
1270+
Var->addChild(constructTypeNode(VD->getInterfaceType(),
1271+
VD->getAttrs().hasAttribute<ImplicitlyUnwrappedOptionalAttr>()));
12851272
if (auto VAD = dyn_cast<AbstractStorageDecl>(VD)) {
12861273
if (auto Getter = VAD->getGetter())
1287-
Var->addChild(constructFunctionNode(Ctx, Getter, SDKNodeKind::DeclGetter));
1274+
Var->addChild(constructFunctionNode(Getter, SDKNodeKind::DeclGetter));
12881275
if (auto Setter = VAD->getSetter()) {
12891276
if (Setter->getFormalAccess() > AccessLevel::Internal)
1290-
Var->addChild(constructFunctionNode(Ctx, Setter, SDKNodeKind::DeclSetter));
1277+
Var->addChild(constructFunctionNode(Setter, SDKNodeKind::DeclSetter));
12911278
}
12921279
}
12931280
return Var;
12941281
}
12951282

1296-
static SDKNode *constructTypeAliasNode(SDKContext &Ctx,TypeAliasDecl *TAD) {
1283+
SDKNode *swift::ide::api::
1284+
SwiftDeclCollector::constructTypeAliasNode(TypeAliasDecl *TAD) {
12971285
auto Alias = SDKNodeInitInfo(Ctx, TAD).createSDKNode(SDKNodeKind::DeclTypeAlias);
1298-
Alias->addChild(constructTypeNode(Ctx, TAD->getUnderlyingTypeLoc().getType()));
1286+
Alias->addChild(constructTypeNode(TAD->getUnderlyingTypeLoc().getType()));
12991287
return Alias;
13001288
}
13011289

1302-
static SDKNode *constructAssociatedTypeNode(SDKContext &Ctx,
1303-
AssociatedTypeDecl *ATD) {
1290+
SDKNode *swift::ide::api::
1291+
SwiftDeclCollector::constructAssociatedTypeNode(AssociatedTypeDecl *ATD) {
13041292
auto Asso = SDKNodeInitInfo(Ctx, ATD).
13051293
createSDKNode(SDKNodeKind::DeclAssociatedType);
13061294
if (auto DT = ATD->getDefaultDefinitionType()) {
1307-
Asso->addChild(constructTypeNode(Ctx, DT));
1295+
Asso->addChild(constructTypeNode(DT));
13081296
}
13091297
return Asso;
13101298
}
13111299

1312-
static SDKNode *constructSubscriptDeclNode(SDKContext &Ctx, SubscriptDecl *SD) {
1300+
SDKNode *swift::ide::api::
1301+
SwiftDeclCollector::constructSubscriptDeclNode(SubscriptDecl *SD) {
13131302
auto Subs = SDKNodeInitInfo(Ctx, SD).createSDKNode(SDKNodeKind::DeclSubscript);
1314-
Subs->addChild(constructTypeNode(Ctx, SD->getElementInterfaceType()));
1315-
for (auto *Node: createParameterNodes(Ctx, SD->getIndices()))
1303+
Subs->addChild(constructTypeNode(SD->getElementInterfaceType()));
1304+
for (auto *Node: createParameterNodes(SD->getIndices()))
13161305
Subs->addChild(Node);
13171306
return Subs;
13181307
}
13191308

1320-
static void addMembersToRoot(SDKContext &Ctx, SDKNode *Root,
1321-
IterableDeclContext *Context,
1322-
std::set<ExtensionDecl*> &HandledExts) {
1309+
void swift::ide::api::
1310+
SwiftDeclCollector::addMembersToRoot(SDKNode *Root, IterableDeclContext *Context) {
13231311
for (auto *Member : Context->getMembers()) {
1324-
if (shouldIgnore(Member, Context->getDecl(), Ctx))
1312+
if (shouldIgnore(Member, Context->getDecl()))
13251313
continue;
13261314
if (auto Func = dyn_cast<FuncDecl>(Member)) {
1327-
Root->addChild(constructFunctionNode(Ctx, Func, SDKNodeKind::DeclFunction));
1315+
Root->addChild(constructFunctionNode(Func, SDKNodeKind::DeclFunction));
13281316
} else if (auto CD = dyn_cast<ConstructorDecl>(Member)) {
1329-
Root->addChild(constructInitNode(Ctx, CD));
1317+
Root->addChild(constructInitNode(CD));
13301318
} else if (auto VD = dyn_cast<VarDecl>(Member)) {
1331-
Root->addChild(constructVarNode(Ctx, VD));
1319+
Root->addChild(constructVarNode(VD));
13321320
} else if (auto TAD = dyn_cast<TypeAliasDecl>(Member)) {
1333-
Root->addChild(constructTypeAliasNode(Ctx, TAD));
1321+
Root->addChild(constructTypeAliasNode(TAD));
13341322
} else if (auto EED = dyn_cast<EnumElementDecl>(Member)) {
1335-
Root->addChild(constructVarNode(Ctx, EED));
1323+
Root->addChild(constructVarNode(EED));
13361324
} else if (auto NTD = dyn_cast<NominalTypeDecl>(Member)) {
1337-
Root->addChild(constructTypeDeclNode(Ctx, NTD, HandledExts));
1325+
Root->addChild(constructTypeDeclNode(NTD));
13381326
} else if (auto ATD = dyn_cast<AssociatedTypeDecl>(Member)) {
1339-
Root->addChild(constructAssociatedTypeNode(Ctx, ATD));
1327+
Root->addChild(constructAssociatedTypeNode(ATD));
13401328
} else if (auto SD = dyn_cast<SubscriptDecl>(Member)) {
1341-
Root->addChild(constructSubscriptDeclNode(Ctx, SD));
1329+
Root->addChild(constructSubscriptDeclNode(SD));
13421330
} else if (isa<PatternBindingDecl>(Member)) {
13431331
// All containing variables should have been handled.
13441332
} else if (isa<DestructorDecl>(Member)) {
@@ -1360,7 +1348,7 @@ void SwiftDeclCollector::lookupVisibleDecls(ArrayRef<ModuleDecl *> Modules) {
13601348
llvm::SmallVector<Decl*, 512> Decls;
13611349
M->getDisplayDecls(Decls);
13621350
for (auto D : Decls) {
1363-
if (shouldIgnore(D, nullptr, Ctx))
1351+
if (shouldIgnore(D, nullptr))
13641352
continue;
13651353
if (KnownDecls.count(D))
13661354
continue;
@@ -1393,22 +1381,21 @@ void SwiftDeclCollector::lookupVisibleDecls(ArrayRef<ModuleDecl *> Modules) {
13931381
}
13941382
}
13951383
for (auto Pair: ExtensionMap) {
1396-
RootNode->addChild(constructExternalExtensionNode(Ctx, RootNode,
1397-
Pair.first, Pair.second, HandledExtensions));
1384+
RootNode->addChild(constructExternalExtensionNode(Pair.first, Pair.second));
13981385
}
13991386
}
14001387

14011388
void SwiftDeclCollector::processDecl(ValueDecl *VD) {
14021389
if (auto FD = dyn_cast<FuncDecl>(VD)) {
1403-
RootNode->addChild(constructFunctionNode(Ctx, FD, SDKNodeKind::DeclFunction));
1390+
RootNode->addChild(constructFunctionNode(FD, SDKNodeKind::DeclFunction));
14041391
} else if (auto NTD = dyn_cast<NominalTypeDecl>(VD)) {
1405-
RootNode->addChild(constructTypeDeclNode(Ctx, NTD, HandledExtensions));
1392+
RootNode->addChild(constructTypeDeclNode(NTD));
14061393
}
14071394
if (auto VAD = dyn_cast<VarDecl>(VD)) {
1408-
RootNode->addChild(constructVarNode(Ctx, VAD));
1395+
RootNode->addChild(constructVarNode(VAD));
14091396
}
14101397
if (auto TAD = dyn_cast<TypeAliasDecl>(VD)) {
1411-
RootNode->addChild(constructTypeAliasNode(Ctx, TAD));
1398+
RootNode->addChild(constructTypeAliasNode(TAD));
14121399
}
14131400
}
14141401

‎tools/swift-api-digester/ModuleAnalyzerNodes.h

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -542,6 +542,20 @@ class SwiftDeclCollector: public VisibleDeclConsumer {
542542

543543
void printTopLevelNames();
544544

545+
bool shouldIgnore(Decl *D, const Decl* Parent);
546+
void addMembersToRoot(SDKNode *Root, IterableDeclContext *Context);
547+
SDKNode *constructSubscriptDeclNode(SubscriptDecl *SD);
548+
SDKNode *constructAssociatedTypeNode(AssociatedTypeDecl *ATD);
549+
SDKNode *constructTypeAliasNode(TypeAliasDecl *TAD);
550+
SDKNode *constructVarNode(ValueDecl *VD);
551+
SDKNode *constructExternalExtensionNode(NominalTypeDecl *NTD,
552+
ArrayRef<ExtensionDecl*> AllExts);
553+
SDKNode *constructTypeDeclNode(NominalTypeDecl *NTD);
554+
SDKNode *constructInitNode(ConstructorDecl *CD);
555+
SDKNode *constructFunctionNode(FuncDecl* FD, SDKNodeKind Kind);
556+
std::vector<SDKNode*> createParameterNodes(ParameterList *PL);
557+
SDKNode *constructTypeNode(Type T, bool IsImplicitlyUnwrappedOptional = false,
558+
bool hasDefaultArgument = false);
545559
public:
546560
void lookupVisibleDecls(ArrayRef<ModuleDecl *> Modules);
547561
void processDecl(ValueDecl *VD);

0 commit comments

Comments
 (0)