Skip to content

Commit 835d1a2

Browse files
davezarzyckidavezarzycki
committed
NFC: Use 'enum class' for TypeResolutionFlags
1 parent 115a362 commit 835d1a2

13 files changed

+251
-249
lines changed

‎lib/Sema/CSGen.cpp

Lines changed: 15 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -1329,8 +1329,8 @@ namespace {
13291329
}
13301330

13311331
Type resolveTypeReferenceInExpression(TypeRepr *rep) {
1332-
TypeResolutionOptions options = TR_AllowUnboundGenerics;
1333-
options |= TR_InExpression;
1332+
TypeResolutionOptions options = TypeResolutionFlags::AllowUnboundGenerics;
1333+
options |= TypeResolutionFlags::InExpression;
13341334
return CS.TC.resolveType(rep, CS.DC, options);
13351335
}
13361336

@@ -1553,9 +1553,9 @@ namespace {
15531553
// open type.
15541554
auto locator = CS.getConstraintLocator(expr);
15551555
for (size_t i = 0, size = specializations.size(); i < size; ++i) {
1556-
if (tc.validateType(specializations[i], CS.DC,
1557-
(TR_InExpression |
1558-
TR_AllowUnboundGenerics)))
1556+
TypeResolutionOptions options = TypeResolutionFlags::InExpression;
1557+
options |= TypeResolutionFlags::AllowUnboundGenerics;
1558+
if (tc.validateType(specializations[i], CS.DC, options))
15591559
return Type();
15601560

15611561
CS.addConstraint(ConstraintKind::Equal,
@@ -2169,7 +2169,7 @@ namespace {
21692169
pattern = pattern->getSemanticsProvidingPattern();
21702170
while (auto isp = dyn_cast<IsPattern>(pattern)) {
21712171
if (CS.TC.validateType(isp->getCastTypeLoc(), CS.DC,
2172-
TR_InExpression))
2172+
TypeResolutionFlags::InExpression))
21732173
return false;
21742174

21752175
if (!isp->hasSubPattern()) {
@@ -2189,7 +2189,7 @@ namespace {
21892189
Type exnType = CS.TC.getExceptionType(CS.DC, clause->getCatchLoc());
21902190
if (!exnType ||
21912191
CS.TC.coercePatternToType(pattern, CS.DC, exnType,
2192-
TR_InExpression)) {
2192+
TypeResolutionFlags::InExpression)) {
21932193
return false;
21942194
}
21952195

@@ -2500,8 +2500,8 @@ namespace {
25002500
return nullptr;
25012501

25022502
// Validate the resulting type.
2503-
TypeResolutionOptions options = TR_AllowUnboundGenerics;
2504-
options |= TR_InExpression;
2503+
TypeResolutionOptions options = TypeResolutionFlags::AllowUnboundGenerics;
2504+
options |= TypeResolutionFlags::InExpression;
25052505
if (tc.validateType(expr->getCastTypeLoc(), CS.DC, options))
25062506
return nullptr;
25072507

@@ -2523,8 +2523,8 @@ namespace {
25232523
auto &tc = CS.getTypeChecker();
25242524

25252525
// Validate the resulting type.
2526-
TypeResolutionOptions options = TR_AllowUnboundGenerics;
2527-
options |= TR_InExpression;
2526+
TypeResolutionOptions options = TypeResolutionFlags::AllowUnboundGenerics;
2527+
options |= TypeResolutionFlags::InExpression;
25282528
if (tc.validateType(expr->getCastTypeLoc(), CS.DC, options))
25292529
return nullptr;
25302530

@@ -2548,8 +2548,8 @@ namespace {
25482548
return nullptr;
25492549

25502550
// Validate the resulting type.
2551-
TypeResolutionOptions options = TR_AllowUnboundGenerics;
2552-
options |= TR_InExpression;
2551+
TypeResolutionOptions options = TypeResolutionFlags::AllowUnboundGenerics;
2552+
options |= TypeResolutionFlags::InExpression;
25532553
if (tc.validateType(expr->getCastTypeLoc(), CS.DC, options))
25542554
return nullptr;
25552555

@@ -2567,8 +2567,8 @@ namespace {
25672567
Type visitIsExpr(IsExpr *expr) {
25682568
// Validate the type.
25692569
auto &tc = CS.getTypeChecker();
2570-
TypeResolutionOptions options = TR_AllowUnboundGenerics;
2571-
options |= TR_InExpression;
2570+
TypeResolutionOptions options = TypeResolutionFlags::AllowUnboundGenerics;
2571+
options |= TypeResolutionFlags::InExpression;
25722572
if (tc.validateType(expr->getCastTypeLoc(), CS.DC, options))
25732573
return nullptr;
25742574

‎lib/Sema/ConstraintSystem.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -893,7 +893,7 @@ ConstraintSystem::getTypeOfReference(ValueDecl *value,
893893
if (auto typeDecl = dyn_cast<TypeDecl>(value)) {
894894
// Resolve the reference to this type declaration in our current context.
895895
auto type = TC.resolveTypeInContext(typeDecl, nullptr, DC,
896-
TR_InExpression,
896+
TypeResolutionFlags::InExpression,
897897
/*isSpecialized=*/false);
898898

899899
// Open the type.

‎lib/Sema/ITCDecl.cpp

Lines changed: 12 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -37,9 +37,9 @@ decomposeInheritedClauseDecl(
3737
inheritanceClause = typeDecl->getInherited();
3838
if (auto nominal = dyn_cast<NominalTypeDecl>(typeDecl)) {
3939
dc = nominal;
40-
options |= (TR_GenericSignature |
41-
TR_InheritanceClause |
42-
TR_AllowUnavailableProtocol);
40+
options |= TypeResolutionFlags::GenericSignature;
41+
options |= TypeResolutionFlags::InheritanceClause;
42+
options |= TypeResolutionFlags::AllowUnavailableProtocol;
4343
} else {
4444
dc = typeDecl->getDeclContext();
4545

@@ -48,13 +48,13 @@ decomposeInheritedClauseDecl(
4848
// signature of the enclosing entity.
4949
if (auto nominal = dyn_cast<NominalTypeDecl>(dc)) {
5050
dc = nominal;
51-
options |= TR_GenericSignature;
51+
options |= TypeResolutionFlags::GenericSignature;
5252
} else if (auto ext = dyn_cast<ExtensionDecl>(dc)) {
5353
dc = ext;
54-
options |= TR_GenericSignature;
54+
options |= TypeResolutionFlags::GenericSignature;
5555
} else if (auto func = dyn_cast<AbstractFunctionDecl>(dc)) {
5656
dc = func;
57-
options |= TR_GenericSignature;
57+
options |= TypeResolutionFlags::GenericSignature;
5858
} else if (!dc->isModuleScopeContext()) {
5959
// Skip the generic parameter's context entirely.
6060
dc = dc->getParent();
@@ -65,9 +65,9 @@ decomposeInheritedClauseDecl(
6565
auto ext = decl.get<ExtensionDecl *>();
6666
inheritanceClause = ext->getInherited();
6767
dc = ext;
68-
options |= (TR_GenericSignature |
69-
TR_InheritanceClause |
70-
TR_AllowUnavailableProtocol);
68+
options |= TypeResolutionFlags::GenericSignature;
69+
options |= TypeResolutionFlags::InheritanceClause;
70+
options |= TypeResolutionFlags::AllowUnavailableProtocol;
7171
}
7272

7373
return std::make_tuple(options, dc, inheritanceClause);
@@ -340,9 +340,10 @@ void IterativeTypeChecker::processResolveTypeDecl(
340340
if (auto typeAliasDecl = dyn_cast<TypeAliasDecl>(typeDecl)) {
341341
if (typeAliasDecl->getDeclContext()->isModuleScopeContext() &&
342342
typeAliasDecl->getGenericParams() == nullptr) {
343-
TypeResolutionOptions options = TR_TypeAliasUnderlyingType;
343+
TypeResolutionOptions options =
344+
TypeResolutionFlags::TypeAliasUnderlyingType;
344345
if (typeAliasDecl->getFormalAccess() <= AccessLevel::FilePrivate)
345-
options |= TR_KnownNonCascadingDependency;
346+
options |= TypeResolutionFlags::KnownNonCascadingDependency;
346347

347348
// Note: recursion into old type checker is okay when passing in an
348349
// unsatisfied-dependency callback.

‎lib/Sema/ITCType.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -54,7 +54,7 @@ bool IterativeTypeChecker::isResolveTypeReprSatisfied(
5454
// If we're only looking to resolve the structure of the type,
5555
// don't walk into generic arguments. They don't affect the
5656
// structure.
57-
if (Options.contains(TR_ResolveStructure) &&
57+
if (Options.contains(TypeResolutionFlags::ResolveStructure) &&
5858
isa<GenericIdentTypeRepr>(ident))
5959
return false;
6060
}

‎lib/Sema/TypeCheckAttr.cpp

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1979,8 +1979,7 @@ void AttributeChecker::visitDiscardableResultAttr(DiscardableResultAttr *attr) {
19791979

19801980
void AttributeChecker::visitImplementsAttr(ImplementsAttr *attr) {
19811981
TypeLoc &ProtoTypeLoc = attr->getProtocolType();
1982-
TypeResolutionOptions options;
1983-
options |= TR_AllowUnboundGenerics;
1982+
auto options = TypeResolutionFlags::AllowUnboundGenerics;
19841983

19851984
DeclContext *DC = D->getDeclContext();
19861985
Type T = TC.resolveType(ProtoTypeLoc.getTypeRepr(),

‎lib/Sema/TypeCheckConstraints.cpp

Lines changed: 17 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -1009,10 +1009,10 @@ bool PreCheckExpression::walkToClosureExprPre(ClosureExpr *closure) {
10091009

10101010
// Validate the parameters.
10111011
TypeResolutionOptions options;
1012-
options |= TR_AllowUnspecifiedTypes;
1013-
options |= TR_AllowUnboundGenerics;
1014-
options |= TR_InExpression;
1015-
options |= TR_AllowIUO;
1012+
options |= TypeResolutionFlags::AllowUnspecifiedTypes;
1013+
options |= TypeResolutionFlags::AllowUnboundGenerics;
1014+
options |= TypeResolutionFlags::InExpression;
1015+
options |= TypeResolutionFlags::AllowIUO;
10161016
bool hadParameterError = false;
10171017

10181018
GenericTypeToArchetypeResolver resolver(closure);
@@ -1030,7 +1030,7 @@ bool PreCheckExpression::walkToClosureExprPre(ClosureExpr *closure) {
10301030
// Validate the result type, if present.
10311031
if (closure->hasExplicitResultType() &&
10321032
TC.validateType(closure->getExplicitResultTypeLoc(), DC,
1033-
TR_InExpression, &resolver)) {
1033+
TypeResolutionFlags::InExpression, &resolver)) {
10341034
closure->setType(ErrorType::get(TC.Context));
10351035
return false;
10361036
}
@@ -1112,9 +1112,9 @@ TypeExpr *PreCheckExpression::simplifyNestedTypeExpr(UnresolvedDotExpr *UDE) {
11121112
// Resolve the TypeRepr to get the base type for the lookup.
11131113
// Disable availability diagnostics here, because the final
11141114
// TypeRepr will be resolved again when generating constraints.
1115-
TypeResolutionOptions options = TR_AllowUnboundGenerics;
1116-
options |= TR_InExpression;
1117-
options |= TR_AllowUnavailable;
1115+
TypeResolutionOptions options = TypeResolutionFlags::AllowUnboundGenerics;
1116+
options |= TypeResolutionFlags::InExpression;
1117+
options |= TypeResolutionFlags::AllowUnavailable;
11181118
auto BaseTy = TC.resolveType(InnerTypeRepr, DC, options);
11191119

11201120
if (BaseTy && BaseTy->mayHaveMembers()) {
@@ -2210,11 +2210,10 @@ bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
22102210
}
22112211

22122212
if (resultTy) {
2213-
TypeResolutionOptions options;
2214-
options |= TR_OverrideType;
2215-
options |= TR_InExpression;
2213+
TypeResolutionOptions options = TypeResolutionFlags::OverrideType;
2214+
options |= TypeResolutionFlags::InExpression;
22162215
if (isa<EditorPlaceholderExpr>(initializer->getSemanticsProvidingExpr())) {
2217-
options |= TR_EditorPlaceholder;
2216+
options |= TypeResolutionFlags::EditorPlaceholder;
22182217
}
22192218

22202219
// FIXME: initTy should be the same as resultTy; now that typeCheckExpression()
@@ -2433,10 +2432,9 @@ bool TypeChecker::typeCheckForEachBinding(DeclContext *dc, ForEachStmt *stmt) {
24332432

24342433
// Apply the solution to the iteration pattern as well.
24352434
Pattern *pattern = Stmt->getPattern();
2436-
TypeResolutionOptions options;
2437-
options |= TR_OverrideType;
2438-
options |= TR_EnumerationVariable;
2439-
options |= TR_InExpression;
2435+
TypeResolutionOptions options = TypeResolutionFlags::OverrideType;
2436+
options |= TypeResolutionFlags::EnumerationVariable;
2437+
options |= TypeResolutionFlags::InExpression;
24402438
if (tc.coercePatternToType(pattern, cs.DC, InitType, options)) {
24412439
return nullptr;
24422440
}
@@ -2606,9 +2604,9 @@ bool TypeChecker::typeCheckStmtCondition(StmtCondition &cond, DeclContext *dc,
26062604

26072605
// Check the pattern, it allows unspecified types because the pattern can
26082606
// provide type information.
2609-
TypeResolutionOptions options = TR_InExpression;
2610-
options |= TR_AllowUnspecifiedTypes;
2611-
options |= TR_AllowUnboundGenerics;
2607+
TypeResolutionOptions options = TypeResolutionFlags::InExpression;
2608+
options |= TypeResolutionFlags::AllowUnspecifiedTypes;
2609+
options |= TypeResolutionFlags::AllowUnboundGenerics;
26122610
if (typeCheckPattern(pattern, dc, options)) {
26132611
typeCheckPatternFailed();
26142612
continue;

‎lib/Sema/TypeCheckDecl.cpp

Lines changed: 21 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -297,27 +297,27 @@ void TypeChecker::checkInheritanceClause(Decl *decl,
297297
DeclContext *DC;
298298
if (auto nominal = dyn_cast<NominalTypeDecl>(decl)) {
299299
DC = nominal;
300-
options |= (TR_GenericSignature |
301-
TR_InheritanceClause |
302-
TR_AllowUnavailableProtocol);
300+
options |= TypeResolutionFlags::GenericSignature;
301+
options |= TypeResolutionFlags::InheritanceClause;
302+
options |= TypeResolutionFlags::AllowUnavailableProtocol;
303303
} else if (auto ext = dyn_cast<ExtensionDecl>(decl)) {
304304
DC = ext;
305-
options |= (TR_GenericSignature |
306-
TR_InheritanceClause |
307-
TR_AllowUnavailableProtocol);
305+
options |= TypeResolutionFlags::GenericSignature;
306+
options |= TypeResolutionFlags::InheritanceClause;
307+
options |= TypeResolutionFlags::AllowUnavailableProtocol;
308308
} else if (isa<GenericTypeParamDecl>(decl)) {
309309
// For generic parameters, we want name lookup to look at just the
310310
// signature of the enclosing entity.
311311
DC = decl->getDeclContext();
312312
if (auto nominal = dyn_cast<NominalTypeDecl>(DC)) {
313313
DC = nominal;
314-
options |= TR_GenericSignature;
314+
options |= TypeResolutionFlags::GenericSignature;
315315
} else if (auto ext = dyn_cast<ExtensionDecl>(DC)) {
316316
DC = ext;
317-
options |= TR_GenericSignature;
317+
options |= TypeResolutionFlags::GenericSignature;
318318
} else if (auto func = dyn_cast<AbstractFunctionDecl>(DC)) {
319319
DC = func;
320-
options |= TR_GenericSignature;
320+
options |= TypeResolutionFlags::GenericSignature;
321321
} else if (!DC->isModuleScopeContext()) {
322322
// Skip the generic parameter's context entirely.
323323
DC = DC->getParent();
@@ -1117,13 +1117,13 @@ static void validatePatternBindingEntry(TypeChecker &tc,
11171117
// In particular, it's /not/ correct to check the PBD's DeclContext because
11181118
// top-level variables in a script file are accessible from other files,
11191119
// even though the PBD is inside a TopLevelCodeDecl.
1120-
TypeResolutionOptions options = TR_InExpression;
1120+
TypeResolutionOptions options = TypeResolutionFlags::InExpression;
11211121

1122-
options |= TR_AllowIUO;
1122+
options |= TypeResolutionFlags::AllowIUO;
11231123
if (binding->getInit(entryNumber)) {
11241124
// If we have an initializer, we can also have unknown types.
1125-
options |= TR_AllowUnspecifiedTypes;
1126-
options |= TR_AllowUnboundGenerics;
1125+
options |= TypeResolutionFlags::AllowUnspecifiedTypes;
1126+
options |= TypeResolutionFlags::AllowUnboundGenerics;
11271127
}
11281128
if (tc.typeCheckPattern(pattern, binding->getDeclContext(), options)) {
11291129
setBoundVarsTypeError(pattern, tc.Context);
@@ -4284,10 +4284,10 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
42844284
GenericTypeToArchetypeResolver resolver(SD);
42854285

42864286
bool isInvalid = TC.validateType(SD->getElementTypeLoc(), SD,
4287-
TR_AllowIUO,
4287+
TypeResolutionFlags::AllowIUO,
42884288
&resolver);
42894289
TypeResolutionOptions options;
4290-
options |= TR_SubscriptParameters;
4290+
options |= TypeResolutionFlags::SubscriptParameters;
42914291

42924292
isInvalid |= TC.typeCheckParameterList(SD->getIndices(), SD,
42934293
options,
@@ -4863,9 +4863,9 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
48634863

48644864
bool badType = false;
48654865
if (!FD->getBodyResultTypeLoc().isNull()) {
4866-
TypeResolutionOptions options = TR_AllowIUO;
4866+
TypeResolutionOptions options = TypeResolutionFlags::AllowIUO;
48674867
if (FD->hasDynamicSelf())
4868-
options |= TR_DynamicSelfResult;
4868+
options |= TypeResolutionFlags::DynamicSelfResult;
48694869

48704870
if (TC.validateType(FD->getBodyResultTypeLoc(), FD, options,
48714871
&resolver)) {
@@ -6830,7 +6830,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
68306830

68316831
if (!EED->getArgumentTypeLoc().isNull()) {
68326832
if (TC.validateType(EED->getArgumentTypeLoc(), EED->getDeclContext(),
6833-
TR_EnumCase)) {
6833+
TypeResolutionFlags::EnumCase)) {
68346834
EED->setInterfaceType(ErrorType::get(TC.Context));
68356835
EED->setInvalid();
68366836
return;
@@ -7357,9 +7357,9 @@ static Optional<ObjCReason> shouldMarkClassAsObjC(TypeChecker &TC,
73577357

73587358
/// Validate the underlying type of the given typealias.
73597359
static void validateTypealiasType(TypeChecker &tc, TypeAliasDecl *typeAlias) {
7360-
TypeResolutionOptions options = TR_TypeAliasUnderlyingType;
7360+
TypeResolutionOptions options = TypeResolutionFlags::TypeAliasUnderlyingType;
73617361
if (typeAlias->getFormalAccess() <= AccessLevel::FilePrivate)
7362-
options |= TR_KnownNonCascadingDependency;
7362+
options |= TypeResolutionFlags::KnownNonCascadingDependency;
73637363

73647364
if (typeAlias->getDeclContext()->isModuleScopeContext() &&
73657365
typeAlias->getGenericParams() == nullptr) {
@@ -7842,7 +7842,7 @@ void TypeChecker::validateDeclForNameLookup(ValueDecl *D) {
78427842

78437843
validateAccessControl(typealias);
78447844
if (typealias->getFormalAccess() <= AccessLevel::FilePrivate)
7845-
options |= TR_KnownNonCascadingDependency;
7845+
options |= TypeResolutionFlags::KnownNonCascadingDependency;
78467846

78477847
if (validateType(typealias->getUnderlyingTypeLoc(),
78487848
typealias, options, &resolver)) {

‎lib/Sema/TypeCheckGeneric.cpp

Lines changed: 5 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -262,7 +262,7 @@ void TypeChecker::checkGenericParamList(GenericSignatureBuilder *builder,
262262
isa<AbstractFunctionDecl>(lookupDC) ||
263263
isa<SubscriptDecl>(lookupDC)) &&
264264
"not a proper generic parameter context?");
265-
options = TR_GenericSignature;
265+
options = TypeResolutionFlags::GenericSignature;
266266
}
267267

268268
// First, add the generic parameters to the generic signature builder.
@@ -513,9 +513,9 @@ static bool checkGenericFuncSignature(TypeChecker &tc,
513513
if (auto fn = dyn_cast<FuncDecl>(func)) {
514514
if (!fn->getBodyResultTypeLoc().isNull()) {
515515
// Check the result type of the function.
516-
TypeResolutionOptions options = TR_AllowIUO;
516+
TypeResolutionOptions options = TypeResolutionFlags::AllowIUO;
517517
if (fn->hasDynamicSelf())
518-
options |= TR_DynamicSelfResult;
518+
options |= TypeResolutionFlags::DynamicSelfResult;
519519

520520
if (tc.validateType(fn->getBodyResultTypeLoc(), fn, options, &resolver)) {
521521
badType = true;
@@ -973,7 +973,7 @@ static bool checkGenericSubscriptSignature(TypeChecker &tc,
973973

974974
// Check the element type.
975975
badType |= tc.validateType(subscript->getElementTypeLoc(), subscript,
976-
TR_AllowIUO, &resolver);
976+
TypeResolutionFlags::AllowIUO, &resolver);
977977

978978
// Infer requirements from it.
979979
if (genericParams && builder) {
@@ -988,9 +988,7 @@ static bool checkGenericSubscriptSignature(TypeChecker &tc,
988988

989989
// Check the indices.
990990
auto params = subscript->getIndices();
991-
992-
TypeResolutionOptions options;
993-
options |= TR_SubscriptParameters;
991+
TypeResolutionOptions options = TypeResolutionFlags::SubscriptParameters;
994992

995993
badType |= tc.typeCheckParameterList(params, subscript,
996994
options,

0 commit comments

Comments
 (0)