Skip to content

Commit 5d848e7

Browse files
AnthonyLatsisAnthonyLatsis
committed
[NFC] AST: Merge SimpleIdentTypeRepr & GenericIdentTypeRepr into UnqualifiedIdentTypeRepr 
1 parent a315b22 commit 5d848e7

File tree

7 files changed

+109
-144
lines changed

7 files changed

+109
-144
lines changed

‎include/swift/AST/TypeRepr.h

Lines changed: 28 additions & 79 deletions
Original file line numberDiff line numberDiff line change
@@ -196,10 +196,12 @@ class alignas(1 << TypeReprAlignInBits) TypeRepr
196196
/// \c Type::getCanonicalType() or \c Type::getWithoutParens().
197197
TypeRepr *getWithoutParens() const;
198198

199-
/// Whether this is a `SimpleIdentTypeRepr` matching the given identifier.
199+
/// Whether this is a `UnqualifiedIdentTypeRepr` with no generic arguments,
200+
/// matching the given identifier.
200201
bool isSimpleUnqualifiedIdentifier(Identifier identifier) const;
201202

202-
/// Whether this is a `SimpleIdentTypeRepr` matching the given string.
203+
/// Whether this is a `UnqualifiedIdentTypeRepr` with no generic arguments,
204+
/// matching the given string.
203205
bool isSimpleUnqualifiedIdentifier(StringRef str) const;
204206

205207
//*** Allocation Routines ************************************************/
@@ -407,30 +409,40 @@ class DeclRefTypeRepr : public TypeRepr {
407409
SourceRange getAngleBrackets() const;
408410

409411
static bool classof(const TypeRepr *T) {
410-
return T->getKind() == TypeReprKind::SimpleIdent ||
411-
T->getKind() == TypeReprKind::GenericIdent ||
412+
return T->getKind() == TypeReprKind::UnqualifiedIdent ||
412413
T->getKind() == TypeReprKind::Member;
413414
}
414415
static bool classof(const DeclRefTypeRepr *T) { return true; }
415416

416417
protected:
417418
SourceLoc getLocImpl() const;
419+
SourceLoc getEndLocImpl() const;
418420

419421
void printImpl(ASTPrinter &Printer, const PrintOptions &Opts) const;
420422

421423
friend class TypeRepr;
422424
};
423425

424-
/// An identifier type with an optional set of generic arguments.
426+
/// An unqualified identifier type an optional set of generic arguments.
425427
/// \code
426428
/// Foo
427429
/// Bar<Gen>
428430
/// \endcode
429-
class UnqualifiedIdentTypeRepr : public DeclRefTypeRepr {
430-
protected:
431-
UnqualifiedIdentTypeRepr(TypeReprKind K, DeclNameLoc Loc, DeclNameRef Id,
432-
unsigned NumGenericArgs, bool hasGenericArgList)
433-
: DeclRefTypeRepr(K, Id, Loc, NumGenericArgs, hasGenericArgList) {}
431+
class UnqualifiedIdentTypeRepr final
432+
: public DeclRefTypeRepr,
433+
private llvm::TrailingObjects<UnqualifiedIdentTypeRepr, TypeRepr *,
434+
SourceRange> {
435+
friend TrailingObjects;
436+
437+
size_t numTrailingObjects(OverloadToken<TypeRepr *>) const {
438+
return getNumGenericArgs();
439+
}
440+
441+
UnqualifiedIdentTypeRepr(DeclNameRef Name, DeclNameLoc NameLoc);
442+
443+
UnqualifiedIdentTypeRepr(DeclNameRef Name, DeclNameLoc NameLoc,
444+
ArrayRef<TypeRepr *> GenericArgs,
445+
SourceRange AngleBrackets);
434446

435447
public:
436448
static UnqualifiedIdentTypeRepr *
@@ -441,9 +453,12 @@ class UnqualifiedIdentTypeRepr : public DeclRefTypeRepr {
441453
ArrayRef<TypeRepr *> GenericArgs,
442454
SourceRange AngleBrackets);
443455

456+
ArrayRef<TypeRepr *> getGenericArgs() const;
457+
458+
SourceRange getAngleBrackets() const;
459+
444460
static bool classof(const TypeRepr *T) {
445-
return T->getKind() == TypeReprKind::SimpleIdent ||
446-
T->getKind() == TypeReprKind::GenericIdent;
461+
return T->getKind() == TypeReprKind::UnqualifiedIdent;
447462
}
448463
static bool classof(const UnqualifiedIdentTypeRepr *T) { return true; }
449464

@@ -453,70 +468,6 @@ class UnqualifiedIdentTypeRepr : public DeclRefTypeRepr {
453468
friend class TypeRepr;
454469
};
455470

456-
/// A simple identifier type like "Int".
457-
class SimpleIdentTypeRepr : public UnqualifiedIdentTypeRepr {
458-
friend UnqualifiedIdentTypeRepr;
459-
460-
SimpleIdentTypeRepr(DeclNameLoc Loc, DeclNameRef Id)
461-
: UnqualifiedIdentTypeRepr(TypeReprKind::SimpleIdent, Loc, Id,
462-
/*NumGenericArgs=*/0,
463-
/*HasAngleBrackets=*/false) {}
464-
465-
public:
466-
// SmallVector::emplace_back will never need to call this because
467-
// we reserve the right size, but it does try statically.
468-
SimpleIdentTypeRepr(const SimpleIdentTypeRepr &repr)
469-
: SimpleIdentTypeRepr(repr.getNameLoc(), repr.getNameRef()) {
470-
llvm_unreachable("should not be called dynamically");
471-
}
472-
473-
static bool classof(const TypeRepr *T) {
474-
return T->getKind() == TypeReprKind::SimpleIdent;
475-
}
476-
static bool classof(const SimpleIdentTypeRepr *T) { return true; }
477-
478-
private:
479-
SourceLoc getEndLocImpl() const { return getNameLoc().getEndLoc(); }
480-
friend class TypeRepr;
481-
};
482-
483-
/// An identifier type with generic arguments.
484-
/// \code
485-
/// Bar<Gen>
486-
/// \endcode
487-
class GenericIdentTypeRepr final
488-
: public UnqualifiedIdentTypeRepr,
489-
private llvm::TrailingObjects<GenericIdentTypeRepr, TypeRepr *> {
490-
friend UnqualifiedIdentTypeRepr;
491-
friend TrailingObjects;
492-
SourceRange AngleBrackets;
493-
494-
GenericIdentTypeRepr(DeclNameLoc Loc, DeclNameRef Id,
495-
ArrayRef<TypeRepr *> GenericArgs,
496-
SourceRange AngleBrackets);
497-
498-
static GenericIdentTypeRepr *create(const ASTContext &C,
499-
DeclNameLoc Loc,
500-
DeclNameRef Id,
501-
ArrayRef<TypeRepr*> GenericArgs,
502-
SourceRange AngleBrackets);
503-
504-
public:
505-
ArrayRef<TypeRepr*> getGenericArgs() const {
506-
return {getTrailingObjects<TypeRepr *>(), getNumGenericArgs()};
507-
}
508-
SourceRange getAngleBrackets() const { return AngleBrackets; }
509-
510-
static bool classof(const TypeRepr *T) {
511-
return T->getKind() == TypeReprKind::GenericIdent;
512-
}
513-
static bool classof(const GenericIdentTypeRepr *T) { return true; }
514-
515-
private:
516-
SourceLoc getEndLocImpl() const { return AngleBrackets.End; }
517-
friend class TypeRepr;
518-
};
519-
520471
/// A member type consisting of an arbitrary base component and one or more
521472
/// identifier type member components.
522473
/// \code
@@ -567,7 +518,6 @@ class MemberTypeRepr final
567518

568519
private:
569520
SourceLoc getStartLocImpl() const;
570-
SourceLoc getEndLocImpl() const;
571521

572522
friend class TypeRepr;
573523
};
@@ -1652,8 +1602,7 @@ inline bool TypeRepr::isSimple() const {
16521602
case TypeReprKind::Existential:
16531603
case TypeReprKind::PackElement:
16541604
return false;
1655-
case TypeReprKind::SimpleIdent:
1656-
case TypeReprKind::GenericIdent:
1605+
case TypeReprKind::UnqualifiedIdent:
16571606
case TypeReprKind::Member:
16581607
case TypeReprKind::Metatype:
16591608
case TypeReprKind::Protocol:

‎include/swift/AST/TypeReprNodes.def

Lines changed: 1 addition & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -46,11 +46,8 @@ TYPEREPR(Error, TypeRepr)
4646
TYPEREPR(Attributed, TypeRepr)
4747

4848
ABSTRACT_TYPEREPR(DeclRef, TypeRepr)
49-
ABSTRACT_TYPEREPR(UnqualifiedIdent, DeclRefTypeRepr)
50-
TYPEREPR(SimpleIdent, UnqualifiedIdentTypeRepr)
51-
TYPEREPR(GenericIdent, UnqualifiedIdentTypeRepr)
49+
TYPEREPR(UnqualifiedIdent, DeclRefTypeRepr)
5250
TYPEREPR(Member, DeclRefTypeRepr)
53-
5451
TYPEREPR(Function, TypeRepr)
5552
TYPEREPR(Array, TypeRepr)
5653
TYPEREPR(Dictionary, TypeRepr)

‎lib/AST/ASTWalker.cpp

Lines changed: 1 addition & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -2246,11 +2246,7 @@ bool Traversal::visitDeclRefTypeRepr(DeclRefTypeRepr *T) {
22462246
return false;
22472247
}
22482248

2249-
bool Traversal::visitSimpleIdentTypeRepr(SimpleIdentTypeRepr *T) {
2250-
return visitDeclRefTypeRepr(T);
2251-
}
2252-
2253-
bool Traversal::visitGenericIdentTypeRepr(GenericIdentTypeRepr *T) {
2249+
bool Traversal::visitUnqualifiedIdentTypeRepr(UnqualifiedIdentTypeRepr *T) {
22542250
return visitDeclRefTypeRepr(T);
22552251
}
22562252

‎lib/AST/NameLookup.cpp

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2994,8 +2994,7 @@ directReferencesForTypeRepr(Evaluator &evaluator,
29942994
}
29952995

29962996
case TypeReprKind::Member:
2997-
case TypeReprKind::GenericIdent:
2998-
case TypeReprKind::SimpleIdent:
2997+
case TypeReprKind::UnqualifiedIdent:
29992998
return directReferencesForDeclRefTypeRepr(evaluator, ctx,
30002999
cast<DeclRefTypeRepr>(typeRepr),
30013000
dc, allowUsableFromInline);

‎lib/AST/TypeRepr.cpp

Lines changed: 68 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -120,8 +120,9 @@ TypeRepr *TypeRepr::getWithoutParens() const {
120120
}
121121

122122
bool TypeRepr::isSimpleUnqualifiedIdentifier(Identifier identifier) const {
123-
if (auto *identTR = dyn_cast<SimpleIdentTypeRepr>(this)) {
124-
if (identTR->getNameRef().getBaseIdentifier() == identifier) {
123+
if (auto *unqualIdentTR = dyn_cast<UnqualifiedIdentTypeRepr>(this)) {
124+
if (!unqualIdentTR->hasGenericArgList() &&
125+
unqualIdentTR->getNameRef().getBaseIdentifier() == identifier) {
125126
return true;
126127
}
127128
}
@@ -130,8 +131,9 @@ bool TypeRepr::isSimpleUnqualifiedIdentifier(Identifier identifier) const {
130131
}
131132

132133
bool TypeRepr::isSimpleUnqualifiedIdentifier(StringRef str) const {
133-
if (auto *identTR = dyn_cast<SimpleIdentTypeRepr>(this)) {
134-
if (identTR->getNameRef().getBaseIdentifier().is(str)) {
134+
if (auto *unqualIdentTR = dyn_cast<UnqualifiedIdentTypeRepr>(this)) {
135+
if (!unqualIdentTR->hasGenericArgList() &&
136+
unqualIdentTR->getNameRef().getBaseIdentifier().is(str)) {
135137
return true;
136138
}
137139
}
@@ -241,17 +243,16 @@ unsigned DeclRefTypeRepr::getNumGenericArgs() const {
241243
}
242244

243245
bool DeclRefTypeRepr::hasGenericArgList() const {
244-
return Bits.DeclRefTypeRepr.NumGenericArgs ||
245-
Bits.DeclRefTypeRepr.HasAngleBrackets;
246+
return (getNumGenericArgs() != 0) || hasAngleBrackets();
246247
}
247248

248249
ArrayRef<TypeRepr *> DeclRefTypeRepr::getGenericArgs() const {
249250
if (getNumGenericArgs() == 0) {
250251
return {};
251252
}
252253

253-
if (auto *genericITR = dyn_cast<GenericIdentTypeRepr>(this)) {
254-
return genericITR->getGenericArgs();
254+
if (auto *unqualIdentTR = dyn_cast<UnqualifiedIdentTypeRepr>(this)) {
255+
return unqualIdentTR->getGenericArgs();
255256
}
256257

257258
return cast<MemberTypeRepr>(this)->getGenericArgs();
@@ -266,8 +267,8 @@ SourceRange DeclRefTypeRepr::getAngleBrackets() const {
266267
return SourceRange();
267268
}
268269

269-
if (auto *genericITR = dyn_cast<GenericIdentTypeRepr>(this)) {
270-
return genericITR->getAngleBrackets();
270+
if (auto *unqualIdentTR = dyn_cast<UnqualifiedIdentTypeRepr>(this)) {
271+
return unqualIdentTR->getAngleBrackets();
271272
}
272273

273274
return cast<MemberTypeRepr>(this)->getAngleBrackets();
@@ -277,6 +278,15 @@ SourceLoc DeclRefTypeRepr::getLocImpl() const {
277278
return NameLoc.getBaseNameLoc();
278279
}
279280

281+
SourceLoc DeclRefTypeRepr::getEndLocImpl() const {
282+
const auto range = getAngleBrackets();
283+
if (range.isValid()) {
284+
return range.End;
285+
}
286+
287+
return getNameLoc().getEndLoc();
288+
}
289+
280290
static void printTypeRepr(const TypeRepr *TyR, ASTPrinter &Printer,
281291
const PrintOptions &Opts) {
282292
if (TyR == nullptr)
@@ -476,46 +486,60 @@ TupleTypeRepr *TupleTypeRepr::createEmpty(const ASTContext &C,
476486
return create(C, {}, Parens);
477487
}
478488

489+
UnqualifiedIdentTypeRepr::UnqualifiedIdentTypeRepr(DeclNameRef Name,
490+
DeclNameLoc NameLoc)
491+
: DeclRefTypeRepr(TypeReprKind::UnqualifiedIdent, Name, NameLoc,
492+
/*NumGenericArgs=*/0,
493+
/*HasAngleBrackets=*/false) {}
494+
495+
UnqualifiedIdentTypeRepr::UnqualifiedIdentTypeRepr(
496+
DeclNameRef Name, DeclNameLoc NameLoc, ArrayRef<TypeRepr *> GenericArgs,
497+
SourceRange AngleBrackets)
498+
: DeclRefTypeRepr(TypeReprKind::UnqualifiedIdent, Name, NameLoc,
499+
/*NumGenericArgs=*/GenericArgs.size(),
500+
/*HasAngleBrackets=*/AngleBrackets.isValid()) {
501+
if (AngleBrackets.isValid()) {
502+
*getTrailingObjects<SourceRange>() = AngleBrackets;
503+
}
504+
505+
#ifndef NDEBUG
506+
for (auto *repr : GenericArgs) {
507+
assert(repr);
508+
}
509+
#endif
510+
511+
if (!GenericArgs.empty()) {
512+
std::uninitialized_copy(GenericArgs.begin(), GenericArgs.end(),
513+
getTrailingObjects<TypeRepr *>());
514+
}
515+
}
516+
479517
UnqualifiedIdentTypeRepr *UnqualifiedIdentTypeRepr::create(const ASTContext &C,
480518
DeclNameLoc NameLoc,
481519
DeclNameRef Name) {
482-
return new (C) SimpleIdentTypeRepr(NameLoc, Name);
520+
return new (C) UnqualifiedIdentTypeRepr(Name, NameLoc);
483521
}
484522

485523
UnqualifiedIdentTypeRepr *UnqualifiedIdentTypeRepr::create(
486524
const ASTContext &C, DeclNameLoc NameLoc, DeclNameRef Name,
487525
ArrayRef<TypeRepr *> GenericArgs, SourceRange AngleBrackets) {
488-
if (AngleBrackets.isInvalid() && GenericArgs.empty()) {
489-
return new (C) SimpleIdentTypeRepr(NameLoc, Name);
490-
}
491-
492-
return GenericIdentTypeRepr::create(C, NameLoc, Name, GenericArgs,
493-
AngleBrackets);
526+
const auto size = totalSizeToAlloc<TypeRepr *, SourceRange>(
527+
GenericArgs.size(), AngleBrackets.isValid() ? 1 : 0);
528+
auto *mem = C.Allocate(size, alignof(UnqualifiedIdentTypeRepr));
529+
return new (mem)
530+
UnqualifiedIdentTypeRepr(Name, NameLoc, GenericArgs, AngleBrackets);
494531
}
495532

496-
GenericIdentTypeRepr::GenericIdentTypeRepr(DeclNameLoc Loc, DeclNameRef Id,
497-
ArrayRef<TypeRepr *> GenericArgs,
498-
SourceRange AngleBrackets)
499-
: UnqualifiedIdentTypeRepr(TypeReprKind::GenericIdent, Loc, Id,
500-
/*NumGenericArgs=*/GenericArgs.size(),
501-
/*HasAngleBrackets=*/AngleBrackets.isValid()),
502-
AngleBrackets(AngleBrackets) {
503-
#ifndef NDEBUG
504-
for (auto arg : GenericArgs)
505-
assert(arg != nullptr);
506-
#endif
507-
std::uninitialized_copy(GenericArgs.begin(), GenericArgs.end(),
508-
getTrailingObjects<TypeRepr *>());
533+
ArrayRef<TypeRepr *> UnqualifiedIdentTypeRepr::getGenericArgs() const {
534+
return {getTrailingObjects<TypeRepr *>(), getNumGenericArgs()};
509535
}
510536

511-
GenericIdentTypeRepr *GenericIdentTypeRepr::create(const ASTContext &C,
512-
DeclNameLoc Loc,
513-
DeclNameRef Id,
514-
ArrayRef<TypeRepr*> GenericArgs,
515-
SourceRange AngleBrackets) {
516-
auto size = totalSizeToAlloc<TypeRepr*>(GenericArgs.size());
517-
auto mem = C.Allocate(size, alignof(GenericIdentTypeRepr));
518-
return new (mem) GenericIdentTypeRepr(Loc, Id, GenericArgs, AngleBrackets);
537+
SourceRange UnqualifiedIdentTypeRepr::getAngleBrackets() const {
538+
if (hasAngleBrackets()) {
539+
return *getTrailingObjects<SourceRange>();
540+
}
541+
542+
return SourceRange();
519543
}
520544

521545
MemberTypeRepr::MemberTypeRepr(TypeRepr *Base, DeclNameRef Name,
@@ -532,6 +556,12 @@ MemberTypeRepr::MemberTypeRepr(TypeRepr *Base, DeclNameRef Name,
532556
*getTrailingObjects<SourceRange>() = AngleBrackets;
533557
}
534558

559+
#ifndef NDEBUG
560+
for (auto *repr : GenericArgs) {
561+
assert(repr);
562+
}
563+
#endif
564+
535565
if (!GenericArgs.empty()) {
536566
std::uninitialized_copy(GenericArgs.begin(), GenericArgs.end(),
537567
getTrailingObjects<TypeRepr *>());
@@ -589,15 +619,6 @@ SourceLoc MemberTypeRepr::getStartLocImpl() const {
589619
return getBase()->getStartLoc();
590620
}
591621

592-
SourceLoc MemberTypeRepr::getEndLocImpl() const {
593-
const auto range = getAngleBrackets();
594-
if (range.isValid()) {
595-
return range.End;
596-
}
597-
598-
return getNameLoc().getEndLoc();
599-
}
600-
601622
PackTypeRepr::PackTypeRepr(SourceLoc keywordLoc, SourceRange braceLocs,
602623
ArrayRef<TypeRepr*> elements)
603624
: TypeRepr(TypeReprKind::Pack),

0 commit comments

Comments
 (0)