Skip to content

Commit 214f9d5

Browse files
DougGregorDougGregor
committed
[GSB] Eliminate the penultimate caller to PotentialArchetype::getBuilder().
1 parent a510e9b commit 214f9d5

File tree

2 files changed

+63
-50
lines changed

2 files changed

+63
-50
lines changed

‎include/swift/AST/GenericSignatureBuilder.h

Lines changed: 12 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -213,6 +213,16 @@ class GenericSignatureBuilder {
213213
ProtocolDecl *proto,
214214
FloatingRequirementSource source);
215215

216+
/// Record a same-type constraint between \c type1 and \c type2 determined
217+
/// via the given source.
218+
///
219+
/// \returns true if this same-type constraint merges two equivalence
220+
/// classes, and false otherwise.
221+
bool recordSameTypeConstraint(GenericSignatureBuilder &builder,
222+
PotentialArchetype *type1,
223+
PotentialArchetype *type2,
224+
const RequirementSource *source);
225+
216226
/// Find a source of the same-type constraint that maps a potential
217227
/// archetype in this equivalence class to a concrete type along with
218228
/// that concrete type as written.
@@ -1655,7 +1665,8 @@ class GenericSignatureBuilder::PotentialArchetype {
16551665
}
16561666

16571667
/// Retrieve or create the equivalence class.
1658-
EquivalenceClass *getOrCreateEquivalenceClass() const;
1668+
EquivalenceClass *getOrCreateEquivalenceClass(
1669+
GenericSignatureBuilder &builder) const;
16591670

16601671
/// Retrieve the equivalence class containing this potential archetype.
16611672
TinyPtrVector<PotentialArchetype *> getEquivalenceClassMembers() const {
@@ -1670,11 +1681,6 @@ class GenericSignatureBuilder::PotentialArchetype {
16701681
/// potential archetype computations.
16711682
PotentialArchetype *getArchetypeAnchor(GenericSignatureBuilder &builder);
16721683

1673-
/// Add a same-type constraint between this archetype and the given
1674-
/// other archetype.
1675-
void addSameTypeConstraint(PotentialArchetype *otherPA,
1676-
const RequirementSource *source);
1677-
16781684
/// Retrieve the same-type constraints.
16791685
ArrayRef<Constraint<PotentialArchetype *>> getSameTypeConstraints() const {
16801686
if (auto equivClass = getEquivalenceClassIfPresent()) {

‎lib/AST/GenericSignatureBuilder.cpp

Lines changed: 51 additions & 44 deletions
Original file line numberDiff line numberDiff line change
@@ -1594,12 +1594,14 @@ class GenericSignatureBuilder::ResolvedType {
15941594
}
15951595

15961596
/// Retrieve the equivalence class into which a resolved type refers.
1597-
EquivalenceClass *getEquivalenceClass() const {
1597+
EquivalenceClass *getEquivalenceClass(
1598+
GenericSignatureBuilder &builder) const {
15981599
assert(*this && "Only for resolved types");
15991600
if (equivClass) return equivClass;
16001601

16011602
// Create the equivalence class now.
1602-
return type.get<PotentialArchetype *>()->getOrCreateEquivalenceClass();
1603+
return type.get<PotentialArchetype *>()
1604+
->getOrCreateEquivalenceClass(builder);
16031605
}
16041606

16051607
/// Retrieve the unresolved result.
@@ -1655,6 +1657,23 @@ bool EquivalenceClass::recordConformanceConstraint(
16551657
return inserted;
16561658
}
16571659

1660+
bool EquivalenceClass::recordSameTypeConstraint(
1661+
GenericSignatureBuilder &builder,
1662+
PotentialArchetype *type1,
1663+
PotentialArchetype *type2,
1664+
const RequirementSource *source) {
1665+
sameTypeConstraints[type1].push_back({type1, type2, source});
1666+
++NumSameTypeConstraints;
1667+
1668+
if (type1 != type2) {
1669+
type2->getOrCreateEquivalenceClass(builder)
1670+
->sameTypeConstraints[type2].push_back({type2, type1, source});
1671+
++NumSameTypeConstraints;
1672+
}
1673+
1674+
return true;
1675+
}
1676+
16581677
template<typename T>
16591678
Type Constraint<T>::getSubjectDependentType() const {
16601679
if (auto type = subject.dyn_cast<Type>())
@@ -2238,7 +2257,7 @@ static void addConditionalRequirements(GenericSignatureBuilder &builder,
22382257
const RequirementSource *
22392258
GenericSignatureBuilder::resolveConcreteConformance(ResolvedType type,
22402259
ProtocolDecl *proto) {
2241-
auto equivClass = type.getEquivalenceClass();
2260+
auto equivClass = type.getEquivalenceClass(*this);
22422261
auto concrete = equivClass->concreteType;
22432262
if (!concrete) return nullptr;
22442263

@@ -2280,7 +2299,7 @@ const RequirementSource *GenericSignatureBuilder::resolveSuperConformance(
22802299
ResolvedType type,
22812300
ProtocolDecl *proto) {
22822301
// Get the superclass constraint.
2283-
auto equivClass = type.getEquivalenceClass();
2302+
auto equivClass = type.getEquivalenceClass(*this);
22842303
Type superclass = equivClass->superclass;
22852304
if (!superclass) return nullptr;
22862305

@@ -2375,20 +2394,21 @@ static void maybeAddSameTypeRequirementForNestedType(
23752394
GenericSignatureBuilder::UnresolvedHandlingKind::GenerateConstraints);
23762395
}
23772396

2378-
auto PotentialArchetype::getOrCreateEquivalenceClass() const
2397+
auto PotentialArchetype::getOrCreateEquivalenceClass(
2398+
GenericSignatureBuilder &builder) const
23792399
-> EquivalenceClass * {
23802400
// The equivalence class is stored on the representative.
23812401
auto representative = getRepresentative();
23822402
if (representative != this)
2383-
return representative->getOrCreateEquivalenceClass();
2403+
return representative->getOrCreateEquivalenceClass(builder);
23842404

23852405
// If we already have an equivalence class, return it.
23862406
if (auto equivClass = getEquivalenceClassIfPresent())
23872407
return equivClass;
23882408

23892409
// Create a new equivalence class.
23902410
auto equivClass =
2391-
getBuilder()->Impl->allocateEquivalenceClass(
2411+
builder.Impl->allocateEquivalenceClass(
23922412
const_cast<PotentialArchetype *>(this));
23932413
representativeOrEquivClass = equivClass;
23942414
return equivClass;
@@ -2696,8 +2716,8 @@ PotentialArchetype *PotentialArchetype::getNestedArchetypeAnchor(
26962716
ArchetypeResolutionKind kind) {
26972717
SmallVector<TypeDecl *, 4> concreteDecls;
26982718
auto bestType =
2699-
getOrCreateEquivalenceClass()->lookupNestedType(builder, name,
2700-
&concreteDecls);
2719+
getOrCreateEquivalenceClass(builder)->lookupNestedType(builder, name,
2720+
&concreteDecls);
27012721

27022722
// We didn't find any type with this name.
27032723
if (!bestType) return nullptr;
@@ -2772,7 +2792,7 @@ PotentialArchetype *PotentialArchetype::updateNestedTypeForConformance(
27722792
case ArchetypeResolutionKind::WellFormed: {
27732793
// Creating a new potential archetype in an equivalence class is a
27742794
// modification.
2775-
getOrCreateEquivalenceClass()->modified(builder);
2795+
getOrCreateEquivalenceClass(builder)->modified(builder);
27762796

27772797
void *mem = builder.Impl->Allocator.Allocate<PotentialArchetype>();
27782798
if (assocType)
@@ -3135,7 +3155,7 @@ ResolvedType GenericSignatureBuilder::maybeResolveEquivalenceClass(
31353155
if (!resolvedBase) return resolvedBase;
31363156

31373157
// Find the nested type declaration for this.
3138-
auto baseEquivClass = resolvedBase.getEquivalenceClass();
3158+
auto baseEquivClass = resolvedBase.getEquivalenceClass(*this);
31393159
TypeDecl *nestedTypeDecl;
31403160
if (auto assocType = depMemTy->getAssocType()) {
31413161
nestedTypeDecl = assocType;
@@ -3183,7 +3203,7 @@ ResolvedType GenericSignatureBuilder::maybeResolveEquivalenceClass(
31833203
}
31843204

31853205
return ResolvedType(resolvedMemberType,
3186-
nestedPA->getOrCreateEquivalenceClass());
3206+
nestedPA->getOrCreateEquivalenceClass(*this));
31873207
}
31883208

31893209
// If it's not a type parameter, it won't directly resolve to one.
@@ -3208,7 +3228,7 @@ EquivalenceClass *GenericSignatureBuilder::resolveEquivalenceClass(
32083228
if (auto resolved =
32093229
maybeResolveEquivalenceClass(type, resolutionKind,
32103230
/*wantExactPotentialArchetype=*/false))
3211-
return resolved.getEquivalenceClass();
3231+
return resolved.getEquivalenceClass(*this);
32123232

32133233
return nullptr;
32143234
}
@@ -3617,7 +3637,7 @@ ConstraintResult GenericSignatureBuilder::addConformanceRequirement(
36173637
FloatingRequirementSource source) {
36183638
// Add the conformance requirement, bailing out earlier if we've already
36193639
// seen it.
3620-
auto equivClass = type.getEquivalenceClass();
3640+
auto equivClass = type.getEquivalenceClass(*this);
36213641
if (!equivClass->recordConformanceConstraint(*this, type, proto, source))
36223642
return ConstraintResult::Resolved;
36233643

@@ -3630,7 +3650,7 @@ ConstraintResult GenericSignatureBuilder::addLayoutRequirementDirect(
36303650
ResolvedType type,
36313651
LayoutConstraint layout,
36323652
FloatingRequirementSource source) {
3633-
auto equivClass = type.getEquivalenceClass();
3653+
auto equivClass = type.getEquivalenceClass(*this);
36343654

36353655
// Update the layout in the equivalence class, if we didn't have one already.
36363656
bool anyChanges = false;
@@ -3697,7 +3717,7 @@ bool GenericSignatureBuilder::updateSuperclass(
36973717
ResolvedType type,
36983718
Type superclass,
36993719
FloatingRequirementSource source) {
3700-
auto equivClass = type.getEquivalenceClass();
3720+
auto equivClass = type.getEquivalenceClass(*this);
37013721

37023722
// Local function to handle the update of superclass conformances
37033723
// when the superclass constraint changes.
@@ -3776,7 +3796,7 @@ ConstraintResult GenericSignatureBuilder::addSuperclassRequirementDirect(
37763796
auto resolvedSource = source.getSource(*this, type.getDependentType());
37773797

37783798
// Record the constraint.
3779-
auto equivClass = type.getEquivalenceClass();
3799+
auto equivClass = type.getEquivalenceClass(*this);
37803800
equivClass->superclassConstraints.push_back(
37813801
ConcreteConstraint{type.getUnresolvedType(), superclass, resolvedSource});
37823802
equivClass->modified(*this);
@@ -3924,22 +3944,6 @@ ConstraintResult GenericSignatureBuilder::addTypeRequirement(
39243944
source);
39253945
}
39263946

3927-
void GenericSignatureBuilder::PotentialArchetype::addSameTypeConstraint(
3928-
PotentialArchetype *otherPA,
3929-
const RequirementSource *source) {
3930-
// Update the same-type constraints of this PA to reference the other PA.
3931-
getOrCreateEquivalenceClass()->sameTypeConstraints[this]
3932-
.push_back({this, otherPA, source});
3933-
++NumSameTypeConstraints;
3934-
3935-
if (this != otherPA) {
3936-
// Update the same-type constraints of the other PA to reference this PA.
3937-
otherPA->getOrCreateEquivalenceClass()->sameTypeConstraints[otherPA]
3938-
.push_back({otherPA, this, source});
3939-
++NumSameTypeConstraints;
3940-
}
3941-
}
3942-
39433947
void GenericSignatureBuilder::addedNestedType(PotentialArchetype *nestedPA) {
39443948
// If there was already another type with this name within the parent
39453949
// potential archetype, equate this type with that one.
@@ -3982,16 +3986,16 @@ GenericSignatureBuilder::addSameTypeRequirementBetweenArchetypes(
39823986
PotentialArchetype *OrigT2,
39833987
const RequirementSource *Source)
39843988
{
3985-
// Record the same-type constraint.
3986-
OrigT1->addSameTypeConstraint(OrigT2, Source);
3987-
39883989
// Operate on the representatives
39893990
auto T1 = OrigT1->getRepresentative();
39903991
auto T2 = OrigT2->getRepresentative();
39913992

39923993
// If the representatives are already the same, we're done.
3993-
if (T1 == T2)
3994+
if (T1 == T2) {
3995+
T1->getOrCreateEquivalenceClass(*this)
3996+
->recordSameTypeConstraint(*this, OrigT1, OrigT2, Source);
39943997
return ConstraintResult::Resolved;
3998+
}
39953999

39964000
unsigned nestingDepth1 = T1->getNestingDepth();
39974001
unsigned nestingDepth2 = T2->getNestingDepth();
@@ -4005,9 +4009,12 @@ GenericSignatureBuilder::addSameTypeRequirementBetweenArchetypes(
40054009
}
40064010

40074011
// Merge the equivalence classes.
4008-
auto equivClass = T1->getOrCreateEquivalenceClass();
4012+
auto equivClass = T1->getOrCreateEquivalenceClass(*this);
40094013
equivClass->modified(*this);
40104014

4015+
// Record the same-type constraint.
4016+
equivClass->recordSameTypeConstraint(*this, OrigT1, OrigT2, Source);
4017+
40114018
auto equivClass1Members = equivClass->members;
40124019
auto equivClass2Members = T2->getEquivalenceClassMembers();
40134020
for (auto equiv : equivClass2Members)
@@ -4137,7 +4144,7 @@ ConstraintResult GenericSignatureBuilder::addSameTypeRequirementToConcrete(
41374144
Type Concrete,
41384145
const RequirementSource *Source) {
41394146
auto rep = T->getRepresentative();
4140-
auto equivClass = rep->getOrCreateEquivalenceClass();
4147+
auto equivClass = rep->getOrCreateEquivalenceClass(*this);
41414148

41424149
// Record the concrete type and its source.
41434150
equivClass->concreteTypeConstraints.push_back(
@@ -4889,7 +4896,7 @@ GenericSignatureBuilder::finalize(SourceLoc loc,
48894896

48904897
// Don't allow a generic parameter to be equivalent to a concrete type,
48914898
// because then we don't actually have a parameter.
4892-
auto equivClass = rep->getOrCreateEquivalenceClass();
4899+
auto equivClass = rep->getOrCreateEquivalenceClass(*this);
48934900
if (equivClass->concreteType) {
48944901
if (auto constraint = equivClass->findAnyConcreteConstraintAsWritten()){
48954902
Impl->HadAnyError = true;
@@ -5436,7 +5443,7 @@ static void computeDerivedSameTypeComponents(
54365443
PotentialArchetype *rep,
54375444
llvm::SmallDenseMap<PotentialArchetype *, unsigned> &componentOf){
54385445
// Perform a depth-first search to identify the components.
5439-
auto equivClass = rep->getOrCreateEquivalenceClass();
5446+
auto equivClass = rep->getOrCreateEquivalenceClass(builder);
54405447
auto &components = equivClass->derivedSameTypeComponents;
54415448
for (auto pa : rep->getEquivalenceClassMembers()) {
54425449
// If we've already seen this potential archetype, there's nothing else to
@@ -6044,7 +6051,7 @@ void GenericSignatureBuilder::checkSameTypeConstraints(
60446051
void GenericSignatureBuilder::checkConcreteTypeConstraints(
60456052
ArrayRef<GenericTypeParamType *> genericParams,
60466053
PotentialArchetype *representative) {
6047-
auto equivClass = representative->getOrCreateEquivalenceClass();
6054+
auto equivClass = representative->getOrCreateEquivalenceClass(*this);
60486055
assert(equivClass->concreteType && "No concrete type to check");
60496056

60506057
checkConstraintList<Type>(
@@ -6081,7 +6088,7 @@ void GenericSignatureBuilder::checkConcreteTypeConstraints(
60816088
void GenericSignatureBuilder::checkSuperclassConstraints(
60826089
ArrayRef<GenericTypeParamType *> genericParams,
60836090
PotentialArchetype *representative) {
6084-
auto equivClass = representative->getOrCreateEquivalenceClass();
6091+
auto equivClass = representative->getOrCreateEquivalenceClass(*this);
60856092
assert(equivClass->superclass && "No superclass constraint?");
60866093

60876094
// FIXME: We should be substituting in the canonical type in context so
@@ -6236,7 +6243,7 @@ void GenericSignatureBuilder::enumerateRequirements(llvm::function_ref<
62366243
//
62376244
// FIXME: O(n) in the number of implied connected components within the
62386245
// equivalence class. The equivalence class should be small, but...
6239-
auto equivClass = archetype->getOrCreateEquivalenceClass();
6246+
auto equivClass = archetype->getOrCreateEquivalenceClass(*this);
62406247

62416248
assert(!equivClass->derivedSameTypeComponents.empty() &&
62426249
"Didn't compute derived same-type components?");

0 commit comments

Comments
 (0)