Skip to content

Commit d3db1b6

Browse files
slavapestovslavapestov
committed
RequirementMachine: EquivalenceClassMap => PropertyMap
EquivalenceClass is now PropertyBag.
1 parent 0533b78 commit d3db1b6

12 files changed

+196
-197
lines changed

‎lib/AST/CMakeLists.txt‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -73,8 +73,8 @@ add_swift_host_library(swiftAST STATIC
7373
ProtocolConformance.cpp
7474
RawComment.cpp
7575
RequirementEnvironment.cpp
76-
RequirementMachine/EquivalenceClassMap.cpp
7776
RequirementMachine/GenericSignatureQueries.cpp
77+
RequirementMachine/PropertyMap.cpp
7878
RequirementMachine/ProtocolGraph.cpp
7979
RequirementMachine/RequirementMachine.cpp
8080
RequirementMachine/RewriteContext.cpp

‎lib/AST/RequirementMachine/GenericSignatureQueries.cpp‎

Lines changed: 54 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -23,7 +23,7 @@
2323
#include <vector>
2424

2525
#include "RequirementMachineImpl.h"
26-
#include "EquivalenceClassMap.h"
26+
#include "PropertyMap.h"
2727
#include "ProtocolGraph.h"
2828
#include "RewriteContext.h"
2929
#include "RewriteSystem.h"
@@ -47,25 +47,25 @@ RequirementMachine::getLocalRequirements(
4747
GenericSignature::LocalRequirements result;
4848
result.anchor = Impl->Context.getTypeForTerm(term, genericParams, protos);
4949

50-
auto *equivClass = Impl->Map.lookUpEquivalenceClass(term);
51-
if (!equivClass)
50+
auto *props = Impl->Map.lookUpProperties(term);
51+
if (!props)
5252
return result;
5353

54-
if (equivClass->isConcreteType()) {
55-
result.concreteType = equivClass->getConcreteType({}, protos,
56-
Impl->Context);
54+
if (props->isConcreteType()) {
55+
result.concreteType = props->getConcreteType({}, protos,
56+
Impl->Context);
5757
return result;
5858
}
5959

60-
if (equivClass->hasSuperclassBound()) {
61-
result.superclass = equivClass->getSuperclassBound({}, protos,
62-
Impl->Context);
60+
if (props->hasSuperclassBound()) {
61+
result.superclass = props->getSuperclassBound({}, protos,
62+
Impl->Context);
6363
}
6464

65-
for (const auto *proto : equivClass->getConformsToExcludingSuperclassConformances())
65+
for (const auto *proto : props->getConformsToExcludingSuperclassConformances())
6666
result.protos.push_back(const_cast<ProtocolDecl *>(proto));
6767

68-
result.layout = equivClass->getLayoutConstraint();
68+
result.layout = props->getLayoutConstraint();
6969

7070
return result;
7171
}
@@ -76,14 +76,14 @@ bool RequirementMachine::requiresClass(Type depType) const {
7676
Impl->System.simplify(term);
7777
Impl->verify(term);
7878

79-
auto *equivClass = Impl->Map.lookUpEquivalenceClass(term);
80-
if (!equivClass)
79+
auto *props = Impl->Map.lookUpProperties(term);
80+
if (!props)
8181
return false;
8282

83-
if (equivClass->isConcreteType())
83+
if (props->isConcreteType())
8484
return false;
8585

86-
auto layout = equivClass->getLayoutConstraint();
86+
auto layout = props->getLayoutConstraint();
8787
return (layout && layout->isClass());
8888
}
8989

@@ -93,11 +93,11 @@ LayoutConstraint RequirementMachine::getLayoutConstraint(Type depType) const {
9393
Impl->System.simplify(term);
9494
Impl->verify(term);
9595

96-
auto *equivClass = Impl->Map.lookUpEquivalenceClass(term);
97-
if (!equivClass)
96+
auto *props = Impl->Map.lookUpProperties(term);
97+
if (!props)
9898
return LayoutConstraint();
9999

100-
return equivClass->getLayoutConstraint();
100+
return props->getLayoutConstraint();
101101
}
102102

103103
bool RequirementMachine::requiresProtocol(Type depType,
@@ -107,14 +107,14 @@ bool RequirementMachine::requiresProtocol(Type depType,
107107
Impl->System.simplify(term);
108108
Impl->verify(term);
109109

110-
auto *equivClass = Impl->Map.lookUpEquivalenceClass(term);
111-
if (!equivClass)
110+
auto *props = Impl->Map.lookUpProperties(term);
111+
if (!props)
112112
return false;
113113

114-
if (equivClass->isConcreteType())
114+
if (props->isConcreteType())
115115
return false;
116116

117-
for (auto *otherProto : equivClass->getConformsTo()) {
117+
for (auto *otherProto : props->getConformsTo()) {
118118
if (otherProto == proto)
119119
return true;
120120
}
@@ -129,15 +129,15 @@ RequirementMachine::getRequiredProtocols(Type depType) const {
129129
Impl->System.simplify(term);
130130
Impl->verify(term);
131131

132-
auto *equivClass = Impl->Map.lookUpEquivalenceClass(term);
133-
if (!equivClass)
132+
auto *props = Impl->Map.lookUpProperties(term);
133+
if (!props)
134134
return { };
135135

136-
if (equivClass->isConcreteType())
136+
if (props->isConcreteType())
137137
return { };
138138

139139
GenericSignature::RequiredProtocols result;
140-
for (auto *otherProto : equivClass->getConformsTo()) {
140+
for (auto *otherProto : props->getConformsTo()) {
141141
result.push_back(const_cast<ProtocolDecl *>(otherProto));
142142
}
143143

@@ -152,15 +152,15 @@ Type RequirementMachine::getSuperclassBound(Type depType) const {
152152
Impl->System.simplify(term);
153153
Impl->verify(term);
154154

155-
auto *equivClass = Impl->Map.lookUpEquivalenceClass(term);
156-
if (!equivClass)
155+
auto *props = Impl->Map.lookUpProperties(term);
156+
if (!props)
157157
return Type();
158158

159-
if (!equivClass->hasSuperclassBound())
159+
if (!props->hasSuperclassBound())
160160
return Type();
161161

162162
auto &protos = Impl->System.getProtocols();
163-
return equivClass->getSuperclassBound({ }, protos, Impl->Context);
163+
return props->getSuperclassBound({ }, protos, Impl->Context);
164164
}
165165

166166
bool RequirementMachine::isConcreteType(Type depType) const {
@@ -169,11 +169,11 @@ bool RequirementMachine::isConcreteType(Type depType) const {
169169
Impl->System.simplify(term);
170170
Impl->verify(term);
171171

172-
auto *equivClass = Impl->Map.lookUpEquivalenceClass(term);
173-
if (!equivClass)
172+
auto *props = Impl->Map.lookUpProperties(term);
173+
if (!props)
174174
return false;
175175

176-
return equivClass->isConcreteType();
176+
return props->isConcreteType();
177177
}
178178

179179
Type RequirementMachine::getConcreteType(Type depType) const {
@@ -182,15 +182,15 @@ Type RequirementMachine::getConcreteType(Type depType) const {
182182
Impl->System.simplify(term);
183183
Impl->verify(term);
184184

185-
auto *equivClass = Impl->Map.lookUpEquivalenceClass(term);
186-
if (!equivClass)
185+
auto *props = Impl->Map.lookUpProperties(term);
186+
if (!props)
187187
return Type();
188188

189-
if (!equivClass->isConcreteType())
189+
if (!props->isConcreteType())
190190
return Type();
191191

192192
auto &protos = Impl->System.getProtocols();
193-
return equivClass->getConcreteType({ }, protos, Impl->Context);
193+
return props->getConcreteType({ }, protos, Impl->Context);
194194
}
195195

196196
bool RequirementMachine::areSameTypeParameterInContext(Type depType1,
@@ -231,11 +231,11 @@ RequirementMachine::Implementation::getLongestValidPrefix(const MutableTerm &ter
231231
break;
232232

233233
case Symbol::Kind::AssociatedType: {
234-
const auto *equivClass = Map.lookUpEquivalenceClass(prefix);
235-
if (!equivClass)
234+
const auto *props = Map.lookUpProperties(prefix);
235+
if (!props)
236236
return prefix;
237237

238-
auto conformsTo = equivClass->getConformsTo();
238+
auto conformsTo = props->getConformsTo();
239239

240240
for (const auto *proto : symbol.getProtocols()) {
241241
if (!System.getProtocols().isKnownProtocol(proto))
@@ -284,11 +284,11 @@ bool RequirementMachine::isCanonicalTypeInContext(Type type) const {
284284
Impl->System.simplify(term);
285285
Impl->verify(term);
286286

287-
auto *equivClass = Impl->Map.lookUpEquivalenceClass(term);
288-
if (!equivClass)
287+
auto *props = Impl->Map.lookUpProperties(term);
288+
if (!props)
289289
return false;
290290

291-
if (equivClass->isConcreteType())
291+
if (props->isConcreteType())
292292
return true;
293293

294294
auto anchor = Impl->Context.getTypeForTerm(term, {}, protos);
@@ -352,10 +352,10 @@ Type RequirementMachine::getCanonicalTypeInContext(
352352
auto prefixType = [&]() -> Type {
353353
Impl->verify(prefix);
354354

355-
auto *equivClass = Impl->Map.lookUpEquivalenceClass(prefix);
356-
if (equivClass && equivClass->isConcreteType()) {
357-
auto concreteType = equivClass->getConcreteType(genericParams,
358-
protos, Impl->Context);
355+
auto *props = Impl->Map.lookUpProperties(prefix);
356+
if (props && props->isConcreteType()) {
357+
auto concreteType = props->getConcreteType(genericParams,
358+
protos, Impl->Context);
359359
if (!concreteType->hasTypeParameter())
360360
return concreteType;
361361

@@ -619,15 +619,15 @@ RequirementMachine::lookupNestedType(Type depType, Identifier name) const {
619619
Impl->System.simplify(term);
620620
Impl->verify(term);
621621

622-
auto *equivClass = Impl->Map.lookUpEquivalenceClass(term);
623-
if (!equivClass)
622+
auto *props = Impl->Map.lookUpProperties(term);
623+
if (!props)
624624
return nullptr;
625625

626626
// Look for types with the given name in protocols that we know about.
627627
AssociatedTypeDecl *bestAssocType = nullptr;
628628
SmallVector<TypeDecl *, 4> concreteDecls;
629629

630-
for (const auto *proto : equivClass->getConformsTo()) {
630+
for (const auto *proto : props->getConformsTo()) {
631631
// Look for an associated type and/or concrete type with this name.
632632
for (auto member : const_cast<ProtocolDecl *>(proto)->lookupDirect(name)) {
633633
// If this is an associated type, record whether it is the best
@@ -656,10 +656,10 @@ RequirementMachine::lookupNestedType(Type depType, Identifier name) const {
656656
// FIXME: Shouldn't we always look here?
657657
if (!bestAssocType && concreteDecls.empty()) {
658658
Type typeToSearch;
659-
if (equivClass->isConcreteType())
660-
typeToSearch = equivClass->getConcreteType();
661-
else if (equivClass->hasSuperclassBound())
662-
typeToSearch = equivClass->getSuperclassBound();
659+
if (props->isConcreteType())
660+
typeToSearch = props->getConcreteType();
661+
else if (props->hasSuperclassBound())
662+
typeToSearch = props->getSuperclassBound();
663663

664664
if (typeToSearch)
665665
if (auto *decl = typeToSearch->getAnyNominal())

0 commit comments

Comments
 (0)