Skip to content

Commit 746c7af

Browse files
AnthonyLatsisAnthonyLatsis
committed
[NFC] AST: Rename CompoundIdentTypeRepr → MemberTypeRepr 
1 parent 0c3a72d commit 746c7af

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
@@ -3112,39 +3112,35 @@ class PrintTypeRepr : public TypeReprVisitor<PrintTypeRepr> {
31123112
printRec(T->getTypeRepr());
31133113
}
31143114

3115-
void visitIdentTypeRepr(IdentTypeRepr *T) {
3115+
void visitComponentIdentTypeRepr(ComponentIdentTypeRepr *T) {
31163116
printCommon("type_ident");
3117-
Indent += 2;
3118-
3119-
SmallVector<ComponentIdentTypeRepr *, 2> components;
3120-
if (auto *comp = dyn_cast<ComponentIdentTypeRepr>(T)) {
3121-
components.push_back(comp);
3122-
} else {
3123-
auto memberComps = cast<CompoundIdentTypeRepr>(T)->getMemberComponents();
31243117

3125-
components.push_back(cast<ComponentIdentTypeRepr>(T->getBaseComponent()));
3126-
components.append(memberComps.begin(), memberComps.end());
3118+
PrintWithColorRAII(OS, IdentifierColor)
3119+
<< " id='" << T->getNameRef() << '\'';
3120+
OS << " bind=";
3121+
if (T->isBound())
3122+
T->getBoundDecl()->dumpRef(OS);
3123+
else
3124+
OS << "none";
3125+
PrintWithColorRAII(OS, ParenthesisColor) << ')';
3126+
if (auto *GenIdT = dyn_cast<GenericIdentTypeRepr>(T)) {
3127+
for (auto genArg : GenIdT->getGenericArgs()) {
3128+
OS << '\n';
3129+
printRec(genArg);
3130+
}
31273131
}
3132+
}
31283133

3129-
for (auto comp : components) {
3134+
void visitMemberTypeRepr(MemberTypeRepr *T) {
3135+
printCommon("type_member");
3136+
3137+
OS << '\n';
3138+
printRec(T->getBaseComponent());
3139+
for (auto *comp : T->getMemberComponents()) {
31303140
OS << '\n';
3131-
printCommon("component");
3132-
PrintWithColorRAII(OS, IdentifierColor)
3133-
<< " id='" << comp->getNameRef() << '\'';
3134-
OS << " bind=";
3135-
if (comp->isBound())
3136-
comp->getBoundDecl()->dumpRef(OS);
3137-
else OS << "none";
3138-
PrintWithColorRAII(OS, ParenthesisColor) << ')';
3139-
if (auto GenIdT = dyn_cast<GenericIdentTypeRepr>(comp)) {
3140-
for (auto genArg : GenIdT->getGenericArgs()) {
3141-
OS << '\n';
3142-
printRec(genArg);
3143-
}
3144-
}
3141+
printRec(comp);
31453142
}
31463143
PrintWithColorRAII(OS, ParenthesisColor) << ')';
3147-
Indent -= 2;
31483144
}
31493145

31503146
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
@@ -2220,7 +2220,7 @@ TypeExpr *TypeExpr::createForMemberDecl(DeclNameLoc ParentNameLoc,
22202220
new (C) SimpleIdentTypeRepr(NameLoc, Decl->createNameRef());
22212221
MemberComp->setValue(Decl, nullptr);
22222222

2223-
auto *TR = CompoundIdentTypeRepr::create(C, ParentComp, {MemberComp});
2223+
auto *TR = MemberTypeRepr::create(C, ParentComp, {MemberComp});
22242224
return new (C) TypeExpr(TR);
22252225
}
22262226

@@ -2231,8 +2231,8 @@ TypeExpr *TypeExpr::createForMemberDecl(IdentTypeRepr *ParentTR,
22312231

22322232
// Create a new list of components.
22332233
SmallVector<ComponentIdentTypeRepr *, 2> Components;
2234-
if (auto *Compound = dyn_cast<CompoundIdentTypeRepr>(ParentTR)) {
2235-
auto MemberComps = Compound->getMemberComponents();
2234+
if (auto *MemberTR = dyn_cast<MemberTypeRepr>(ParentTR)) {
2235+
auto MemberComps = MemberTR->getMemberComponents();
22362236
Components.append(MemberComps.begin(), MemberComps.end());
22372237
}
22382238

@@ -2241,8 +2241,8 @@ TypeExpr *TypeExpr::createForMemberDecl(IdentTypeRepr *ParentTR,
22412241
NewComp->setValue(Decl, nullptr);
22422242
Components.push_back(NewComp);
22432243

2244-
auto *TR = CompoundIdentTypeRepr::create(C, ParentTR->getBaseComponent(),
2245-
Components);
2244+
auto *TR =
2245+
MemberTypeRepr::create(C, ParentTR->getBaseComponent(), Components);
22462246
return new (C) TypeExpr(TR);
22472247
}
22482248

@@ -2256,7 +2256,7 @@ TypeExpr *TypeExpr::createForSpecializedDecl(IdentTypeRepr *ParentTR,
22562256
return nullptr;
22572257

22582258
if (isa<TypeAliasDecl>(lastComp->getBoundDecl())) {
2259-
if (auto *compound = dyn_cast<CompoundIdentTypeRepr>(ParentTR)) {
2259+
if (auto *memberTR = dyn_cast<MemberTypeRepr>(ParentTR)) {
22602260
// If any of our parent types are unbound, bail out and let
22612261
// the constraint solver can infer generic parameters for them.
22622262
//
@@ -2279,13 +2279,13 @@ TypeExpr *TypeExpr::createForSpecializedDecl(IdentTypeRepr *ParentTR,
22792279
return false;
22802280
};
22812281

2282-
for (auto *comp : compound->getMemberComponents().drop_back()) {
2282+
for (auto *comp : memberTR->getMemberComponents().drop_back()) {
22832283
if (isUnboundGenericComponent(comp))
22842284
return nullptr;
22852285
}
22862286

22872287
if (auto *identBase =
2288-
dyn_cast<ComponentIdentTypeRepr>(compound->getBaseComponent())) {
2288+
dyn_cast<ComponentIdentTypeRepr>(memberTR->getBaseComponent())) {
22892289
if (isUnboundGenericComponent(identBase))
22902290
return nullptr;
22912291
}
@@ -2297,17 +2297,17 @@ TypeExpr *TypeExpr::createForSpecializedDecl(IdentTypeRepr *ParentTR,
22972297
genericComp->setValue(lastComp->getBoundDecl(), lastComp->getDeclContext());
22982298

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

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

2309-
TR = CompoundIdentTypeRepr::create(C, compound->getBaseComponent(),
2310-
newMemberComps);
2309+
TR =
2310+
MemberTypeRepr::create(C, memberTR->getBaseComponent(), newMemberComps);
23112311
} else {
23122312
TR = genericComp;
23132313
}

‎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)