Skip to content

Commit 6688873

Browse files
AnthonyLatsisAnthonyLatsis
committed
[NFC] AST: Rename CompoundIdentTypeRepr → MemberTypeRepr 
1 parent a4635ce commit 6688873

18 files changed

+104
-101
lines changed

‎include/swift/AST/TypeRepr.h

Lines changed: 19 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -87,7 +87,7 @@ class alignas(1 << TypeReprAlignInBits) TypeRepr
8787
NumGenericArgs : 32
8888
);
8989

90-
SWIFT_INLINE_BITFIELD_FULL(CompoundIdentTypeRepr, IdentTypeRepr, 32,
90+
SWIFT_INLINE_BITFIELD_FULL(MemberTypeRepr, IdentTypeRepr, 32,
9191
: NumPadBits,
9292
NumMemberComponents : 32
9393
);
@@ -266,9 +266,9 @@ class IdentTypeRepr : public TypeRepr {
266266
DeclNameRef getNameRef() const;
267267

268268
static bool classof(const TypeRepr *T) {
269-
return T->getKind() == TypeReprKind::SimpleIdent ||
269+
return T->getKind() == TypeReprKind::SimpleIdent ||
270270
T->getKind() == TypeReprKind::GenericIdent ||
271-
T->getKind() == TypeReprKind::CompoundIdent;
271+
T->getKind() == TypeReprKind::Member;
272272
}
273273
static bool classof(const IdentTypeRepr *T) { return true; }
274274
};
@@ -403,51 +403,53 @@ class GenericIdentTypeRepr final : public ComponentIdentTypeRepr,
403403
friend class TypeRepr;
404404
};
405405

406-
/// A type with identifier components.
406+
/// A member type consisting of an arbitrary base component and one or more
407+
/// identifier type member components.
407408
/// \code
408-
/// Foo.Bar<Gen>
409+
/// Foo.Bar<Gen>.Baz
410+
/// [Int].Bar
409411
/// \endcode
410-
class CompoundIdentTypeRepr final : public IdentTypeRepr,
411-
private llvm::TrailingObjects<CompoundIdentTypeRepr,
412+
class MemberTypeRepr final : public IdentTypeRepr,
413+
private llvm::TrailingObjects<MemberTypeRepr,
412414
ComponentIdentTypeRepr *> {
413415
friend TrailingObjects;
414416

415417
/// The base component, which is not necessarily an identifier type.
416418
TypeRepr *Base;
417419

418-
CompoundIdentTypeRepr(TypeRepr *Base,
419-
ArrayRef<ComponentIdentTypeRepr *> MemberComponents)
420-
: IdentTypeRepr(TypeReprKind::CompoundIdent), Base(Base) {
421-
Bits.CompoundIdentTypeRepr.NumMemberComponents = MemberComponents.size();
420+
MemberTypeRepr(TypeRepr *Base,
421+
ArrayRef<ComponentIdentTypeRepr *> MemberComponents)
422+
: IdentTypeRepr(TypeReprKind::Member), Base(Base) {
423+
Bits.MemberTypeRepr.NumMemberComponents = MemberComponents.size();
422424
assert(MemberComponents.size() > 0 &&
423425
"should have just used the single ComponentIdentTypeRepr directly");
424426
std::uninitialized_copy(MemberComponents.begin(), MemberComponents.end(),
425427
getTrailingObjects<ComponentIdentTypeRepr *>());
426428
}
427429

428430
public:
429-
static CompoundIdentTypeRepr *
431+
static MemberTypeRepr *
430432
create(const ASTContext &Ctx, TypeRepr *Base,
431433
ArrayRef<ComponentIdentTypeRepr *> MemberComponents);
432434

433-
static CompoundIdentTypeRepr *
435+
static MemberTypeRepr *
434436
create(const ASTContext &Ctx, ArrayRef<ComponentIdentTypeRepr *> Components);
435437

436438
TypeRepr *getBaseComponent() const { return Base; }
437439

438440
ArrayRef<ComponentIdentTypeRepr *> getMemberComponents() const {
439441
return {getTrailingObjects<ComponentIdentTypeRepr *>(),
440-
Bits.CompoundIdentTypeRepr.NumMemberComponents};
442+
Bits.MemberTypeRepr.NumMemberComponents};
441443
}
442444

443445
ComponentIdentTypeRepr *getLastComponent() const {
444446
return getMemberComponents().back();
445447
}
446448

447449
static bool classof(const TypeRepr *T) {
448-
return T->getKind() == TypeReprKind::CompoundIdent;
450+
return T->getKind() == TypeReprKind::Member;
449451
}
450-
static bool classof(const CompoundIdentTypeRepr *T) { return true; }
452+
static bool classof(const MemberTypeRepr *T) { return true; }
451453

452454
private:
453455
SourceLoc getStartLocImpl() const {
@@ -1354,7 +1356,7 @@ inline bool TypeRepr::isSimple() const {
13541356
return false;
13551357
case TypeReprKind::SimpleIdent:
13561358
case TypeReprKind::GenericIdent:
1357-
case TypeReprKind::CompoundIdent:
1359+
case TypeReprKind::Member:
13581360
case TypeReprKind::Metatype:
13591361
case TypeReprKind::Protocol:
13601362
case TypeReprKind::Dictionary:

‎include/swift/AST/TypeReprNodes.def

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -49,7 +49,7 @@ ABSTRACT_TYPEREPR(Ident, TypeRepr)
4949
ABSTRACT_TYPEREPR(ComponentIdent, IdentTypeRepr)
5050
TYPEREPR(SimpleIdent, ComponentIdentTypeRepr)
5151
TYPEREPR(GenericIdent, ComponentIdentTypeRepr)
52-
TYPEREPR(CompoundIdent, IdentTypeRepr)
52+
TYPEREPR(Member, IdentTypeRepr)
5353

5454
TYPEREPR(Function, TypeRepr)
5555
TYPEREPR(Array, TypeRepr)

‎lib/AST/ASTDumper.cpp

Lines changed: 22 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -3106,39 +3106,35 @@ class PrintTypeRepr : public TypeReprVisitor<PrintTypeRepr> {
31063106
printRec(T->getTypeRepr());
31073107
}
31083108

3109-
void visitIdentTypeRepr(IdentTypeRepr *T) {
3109+
void visitComponentIdentTypeRepr(ComponentIdentTypeRepr *T) {
31103110
printCommon("type_ident");
3111-
Indent += 2;
3112-
3113-
SmallVector<ComponentIdentTypeRepr *, 2> components;
3114-
if (auto *comp = dyn_cast<ComponentIdentTypeRepr>(T)) {
3115-
components.push_back(comp);
3116-
} else {
3117-
auto memberComps = cast<CompoundIdentTypeRepr>(T)->getMemberComponents();
31183111

3119-
components.push_back(cast<ComponentIdentTypeRepr>(T->getBaseComponent()));
3120-
components.append(memberComps.begin(), memberComps.end());
3112+
PrintWithColorRAII(OS, IdentifierColor)
3113+
<< " id='" << T->getNameRef() << '\'';
3114+
OS << " bind=";
3115+
if (T->isBound())
3116+
T->getBoundDecl()->dumpRef(OS);
3117+
else
3118+
OS << "none";
3119+
PrintWithColorRAII(OS, ParenthesisColor) << ')';
3120+
if (auto *GenIdT = dyn_cast<GenericIdentTypeRepr>(T)) {
3121+
for (auto genArg : GenIdT->getGenericArgs()) {
3122+
OS << '\n';
3123+
printRec(genArg);
3124+
}
31213125
}
3126+
}
31223127

3123-
for (auto comp : components) {
3128+
void visitMemberTypeRepr(MemberTypeRepr *T) {
3129+
printCommon("type_member");
3130+
3131+
OS << '\n';
3132+
printRec(T->getBaseComponent());
3133+
for (auto *comp : T->getMemberComponents()) {
31243134
OS << '\n';
3125-
printCommon("component");
3126-
PrintWithColorRAII(OS, IdentifierColor)
3127-
<< " id='" << comp->getNameRef() << '\'';
3128-
OS << " bind=";
3129-
if (comp->isBound())
3130-
comp->getBoundDecl()->dumpRef(OS);
3131-
else OS << "none";
3132-
PrintWithColorRAII(OS, ParenthesisColor) << ')';
3133-
if (auto GenIdT = dyn_cast<GenericIdentTypeRepr>(comp)) {
3134-
for (auto genArg : GenIdT->getGenericArgs()) {
3135-
OS << '\n';
3136-
printRec(genArg);
3137-
}
3138-
}
3135+
printRec(comp);
31393136
}
31403137
PrintWithColorRAII(OS, ParenthesisColor) << ')';
3141-
Indent -= 2;
31423138
}
31433139

31443140
void visitFunctionTypeRepr(FunctionTypeRepr *T) {

‎lib/AST/ASTWalker.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1972,7 +1972,7 @@ bool Traversal::visitGenericIdentTypeRepr(GenericIdentTypeRepr *T) {
19721972
return false;
19731973
}
19741974

1975-
bool Traversal::visitCompoundIdentTypeRepr(CompoundIdentTypeRepr *T) {
1975+
bool Traversal::visitMemberTypeRepr(MemberTypeRepr *T) {
19761976
if (doIt(T->getBaseComponent()))
19771977
return true;
19781978

‎lib/AST/CASTBridging.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -504,7 +504,7 @@ void *IdentTypeRepr_create(void *ctx, BridgedArrayRef bridgedComponents) {
504504
return components.front();
505505
}
506506

507-
return CompoundIdentTypeRepr::create(Context, components);
507+
return MemberTypeRepr::create(Context, components);
508508
}
509509

510510
void *CompositionTypeRepr_create(void *ctx, BridgedArrayRef types,

‎lib/AST/Expr.cpp

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -2217,7 +2217,7 @@ TypeExpr *TypeExpr::createForMemberDecl(DeclNameLoc ParentNameLoc,
22172217
new (C) SimpleIdentTypeRepr(NameLoc, Decl->createNameRef());
22182218
MemberComp->setValue(Decl, nullptr);
22192219

2220-
auto *TR = CompoundIdentTypeRepr::create(C, ParentComp, {MemberComp});
2220+
auto *TR = MemberTypeRepr::create(C, ParentComp, {MemberComp});
22212221
return new (C) TypeExpr(TR);
22222222
}
22232223

@@ -2228,8 +2228,8 @@ TypeExpr *TypeExpr::createForMemberDecl(IdentTypeRepr *ParentTR,
22282228

22292229
// Create a new list of components.
22302230
SmallVector<ComponentIdentTypeRepr *, 2> Components;
2231-
if (auto *Compound = dyn_cast<CompoundIdentTypeRepr>(ParentTR)) {
2232-
auto MemberComps = Compound->getMemberComponents();
2231+
if (auto *MemberTR = dyn_cast<MemberTypeRepr>(ParentTR)) {
2232+
auto MemberComps = MemberTR->getMemberComponents();
22332233
Components.append(MemberComps.begin(), MemberComps.end());
22342234
}
22352235

@@ -2238,8 +2238,8 @@ TypeExpr *TypeExpr::createForMemberDecl(IdentTypeRepr *ParentTR,
22382238
NewComp->setValue(Decl, nullptr);
22392239
Components.push_back(NewComp);
22402240

2241-
auto *TR = CompoundIdentTypeRepr::create(C, ParentTR->getBaseComponent(),
2242-
Components);
2241+
auto *TR =
2242+
MemberTypeRepr::create(C, ParentTR->getBaseComponent(), Components);
22432243
return new (C) TypeExpr(TR);
22442244
}
22452245

@@ -2253,7 +2253,7 @@ TypeExpr *TypeExpr::createForSpecializedDecl(IdentTypeRepr *ParentTR,
22532253
return nullptr;
22542254

22552255
if (isa<TypeAliasDecl>(lastComp->getBoundDecl())) {
2256-
if (auto *compound = dyn_cast<CompoundIdentTypeRepr>(ParentTR)) {
2256+
if (auto *memberTR = dyn_cast<MemberTypeRepr>(ParentTR)) {
22572257
// If any of our parent types are unbound, bail out and let
22582258
// the constraint solver can infer generic parameters for them.
22592259
//
@@ -2276,13 +2276,13 @@ TypeExpr *TypeExpr::createForSpecializedDecl(IdentTypeRepr *ParentTR,
22762276
return false;
22772277
};
22782278

2279-
for (auto *comp : compound->getMemberComponents().drop_back()) {
2279+
for (auto *comp : memberTR->getMemberComponents().drop_back()) {
22802280
if (isUnboundGenericComponent(comp))
22812281
return nullptr;
22822282
}
22832283

22842284
if (auto *identBase =
2285-
dyn_cast<ComponentIdentTypeRepr>(compound->getBaseComponent())) {
2285+
dyn_cast<ComponentIdentTypeRepr>(memberTR->getBaseComponent())) {
22862286
if (isUnboundGenericComponent(identBase))
22872287
return nullptr;
22882288
}
@@ -2294,17 +2294,17 @@ TypeExpr *TypeExpr::createForSpecializedDecl(IdentTypeRepr *ParentTR,
22942294
genericComp->setValue(lastComp->getBoundDecl(), lastComp->getDeclContext());
22952295

22962296
TypeRepr *TR = nullptr;
2297-
if (auto *compound = dyn_cast<CompoundIdentTypeRepr>(ParentTR)) {
2298-
auto oldMemberComps = compound->getMemberComponents().drop_back();
2297+
if (auto *memberTR = dyn_cast<MemberTypeRepr>(ParentTR)) {
2298+
auto oldMemberComps = memberTR->getMemberComponents().drop_back();
22992299

23002300
// Create a new list of member components, replacing the last one with the
23012301
// new specialized one.
23022302
SmallVector<ComponentIdentTypeRepr *, 2> newMemberComps;
23032303
newMemberComps.append(oldMemberComps.begin(), oldMemberComps.end());
23042304
newMemberComps.push_back(genericComp);
23052305

2306-
TR = CompoundIdentTypeRepr::create(C, compound->getBaseComponent(),
2307-
newMemberComps);
2306+
TR =
2307+
MemberTypeRepr::create(C, memberTR->getBaseComponent(), newMemberComps);
23082308
} else {
23092309
TR = genericComp;
23102310
}

‎lib/AST/NameLookup.cpp

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -2256,10 +2256,10 @@ resolveTypeDeclsToNominal(Evaluator &evaluator,
22562256
if (typealias->getName().is("AnyObject")) {
22572257
// TypeRepr version: Builtin.AnyObject
22582258
if (auto typeRepr = typealias->getUnderlyingTypeRepr()) {
2259-
if (auto compound = dyn_cast<CompoundIdentTypeRepr>(typeRepr)) {
2259+
if (auto memberTR = dyn_cast<MemberTypeRepr>(typeRepr)) {
22602260
if (auto identBase = dyn_cast<ComponentIdentTypeRepr>(
2261-
compound->getBaseComponent())) {
2262-
auto memberComps = compound->getMemberComponents();
2261+
memberTR->getBaseComponent())) {
2262+
auto memberComps = memberTR->getMemberComponents();
22632263
if (memberComps.size() == 1 &&
22642264
identBase->getNameRef().isSimpleName("Builtin") &&
22652265
memberComps.front()->getNameRef().isSimpleName("AnyObject")) {
@@ -2444,15 +2444,15 @@ directReferencesForIdentTypeRepr(Evaluator &evaluator,
24442444
allowUsableFromInline);
24452445
}
24462446

2447-
auto *compound = dyn_cast<CompoundIdentTypeRepr>(ident);
2448-
if (!compound)
2447+
auto *memberTR = dyn_cast<MemberTypeRepr>(ident);
2448+
if (!memberTR)
24492449
return current;
24502450

24512451
// If we didn't find anything, fail now.
24522452
if (current.empty())
24532453
return current;
24542454

2455-
for (const auto &component : compound->getMemberComponents()) {
2455+
for (const auto &component : memberTR->getMemberComponents()) {
24562456
// If we already set a declaration, use it.
24572457
if (auto typeDecl = component->getBoundDecl()) {
24582458
current = {1, typeDecl};
@@ -2500,7 +2500,7 @@ directReferencesForTypeRepr(Evaluator &evaluator,
25002500
return result;
25012501
}
25022502

2503-
case TypeReprKind::CompoundIdent:
2503+
case TypeReprKind::Member:
25042504
case TypeReprKind::GenericIdent:
25052505
case TypeReprKind::SimpleIdent:
25062506
return directReferencesForIdentTypeRepr(evaluator, ctx,
@@ -3085,7 +3085,7 @@ CustomAttrNominalRequest::evaluate(Evaluator &evaluator,
30853085
identTypeRepr->getNameLoc(), DeclNameRef(moduleName));
30863086

30873087
auto *newTE = new (ctx) TypeExpr(
3088-
CompoundIdentTypeRepr::create(ctx, baseComp, {identTypeRepr}));
3088+
MemberTypeRepr::create(ctx, baseComp, {identTypeRepr}));
30893089
attr->resetTypeInformation(newTE);
30903090
return nominal;
30913091
}

‎lib/AST/TypeRepr.cpp

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -139,14 +139,14 @@ TypeRepr *IdentTypeRepr::getBaseComponent() {
139139
if (auto *Comp = dyn_cast<ComponentIdentTypeRepr>(this))
140140
return Comp;
141141

142-
return cast<CompoundIdentTypeRepr>(this)->getBaseComponent();
142+
return cast<MemberTypeRepr>(this)->getBaseComponent();
143143
}
144144

145145
ComponentIdentTypeRepr *IdentTypeRepr::getLastComponent() {
146146
if (auto *Comp = dyn_cast<ComponentIdentTypeRepr>(this))
147147
return Comp;
148148

149-
return cast<CompoundIdentTypeRepr>(this)->getLastComponent();
149+
return cast<MemberTypeRepr>(this)->getLastComponent();
150150
}
151151

152152
DeclNameRef ComponentIdentTypeRepr::getNameRef() const {
@@ -293,8 +293,8 @@ void ComponentIdentTypeRepr::printImpl(ASTPrinter &Printer,
293293
printGenericArgs(Printer, Opts, GenIdT->getGenericArgs());
294294
}
295295

296-
void CompoundIdentTypeRepr::printImpl(ASTPrinter &Printer,
297-
const PrintOptions &Opts) const {
296+
void MemberTypeRepr::printImpl(ASTPrinter &Printer,
297+
const PrintOptions &Opts) const {
298298
printTypeRepr(getBaseComponent(), Printer, Opts);
299299
for (auto C : getMemberComponents()) {
300300
Printer << ".";
@@ -382,18 +382,18 @@ GenericIdentTypeRepr *GenericIdentTypeRepr::create(const ASTContext &C,
382382
return new (mem) GenericIdentTypeRepr(Loc, Id, GenericArgs, AngleBrackets);
383383
}
384384

385-
CompoundIdentTypeRepr *CompoundIdentTypeRepr::create(
386-
const ASTContext &C, TypeRepr *Base,
387-
ArrayRef<ComponentIdentTypeRepr *> MemberComponents) {
385+
MemberTypeRepr *
386+
MemberTypeRepr::create(const ASTContext &C, TypeRepr *Base,
387+
ArrayRef<ComponentIdentTypeRepr *> MemberComponents) {
388388
auto size =
389389
totalSizeToAlloc<ComponentIdentTypeRepr *>(MemberComponents.size());
390-
auto mem = C.Allocate(size, alignof(CompoundIdentTypeRepr));
391-
return new (mem) CompoundIdentTypeRepr(Base, MemberComponents);
390+
auto mem = C.Allocate(size, alignof(MemberTypeRepr));
391+
return new (mem) MemberTypeRepr(Base, MemberComponents);
392392
}
393393

394-
CompoundIdentTypeRepr *
395-
CompoundIdentTypeRepr::create(const ASTContext &Ctx,
396-
ArrayRef<ComponentIdentTypeRepr *> Components) {
394+
MemberTypeRepr *
395+
MemberTypeRepr::create(const ASTContext &Ctx,
396+
ArrayRef<ComponentIdentTypeRepr *> Components) {
397397
return create(Ctx, Components.front(), Components.drop_front());
398398
}
399399

‎lib/IDE/CodeCompletion.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -216,7 +216,7 @@ class CodeCompletionCallbacksImpl : public IDEInspectionCallbacks {
216216
// It doesn't type check as a type, so see if it's a qualifying module name.
217217
if (auto *ITR = dyn_cast<IdentTypeRepr>(ParsedTypeLoc.getTypeRepr())) {
218218
// If it has more than one component, it can't be a module name.
219-
if (isa<CompoundIdentTypeRepr>(ITR))
219+
if (isa<MemberTypeRepr>(ITR))
220220
return false;
221221

222222
const auto *component = cast<ComponentIdentTypeRepr>(ITR);

‎lib/Migrator/APIDiffMigratorPass.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -205,7 +205,7 @@ class ChildIndexFinder : public TypeReprVisitor<ChildIndexFinder, FoundResult> {
205205
return handleParent(T, T->getGenericArgs());
206206
}
207207

208-
FoundResult visitCompoundIdentTypeRepr(CompoundIdentTypeRepr *T) {
208+
FoundResult visitMemberTypeRepr(MemberTypeRepr *T) {
209209
return visit(T->getLastComponent());
210210
}
211211

‎lib/Parse/ParseType.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -755,7 +755,7 @@ Parser::parseTypeIdentifier(bool isParsingQualifiedDeclBaseType) {
755755
if (ComponentsR.size() == 1) {
756756
ITR = ComponentsR.front();
757757
} else {
758-
ITR = CompoundIdentTypeRepr::create(Context, ComponentsR);
758+
ITR = MemberTypeRepr::create(Context, ComponentsR);
759759
}
760760
}
761761

0 commit comments

Comments
 (0)