Skip to content

Commit 4130170

Browse files
CodaFiCodaFi
committed
[NFC] Internalize TypeCheckerOptions in a TypeResolution Object
Add the appropriate assertions to ensure that the now-redundant options parameters are being kept in sync so they can be retracted. The eventual goal is to have TypeResolution requestified.
1 parent b309c62 commit 4130170

13 files changed

+136
-92
lines changed

‎lib/Sema/CSGen.cpp

Lines changed: 22 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -1453,8 +1453,8 @@ namespace {
14531453
TypeResolutionOptions options(TypeResolverContext::InExpression);
14541454
options |= TypeResolutionFlags::AllowUnboundGenerics;
14551455
bool hadError = TypeChecker::validateType(
1456-
CS.getASTContext(), loc, TypeResolution::forContextual(CS.DC),
1457-
options);
1456+
CS.getASTContext(), loc,
1457+
TypeResolution::forContextual(CS.DC, options), options);
14581458
return hadError ? Type() : loc.getType();
14591459
}
14601460

@@ -1715,10 +1715,9 @@ namespace {
17151715
TypeResolutionOptions options(TypeResolverContext::InExpression);
17161716
options |= TypeResolutionFlags::AllowUnboundGenerics;
17171717
auto tyLoc = TypeLoc{specializations[i]};
1718-
if (TypeChecker::validateType(CS.getASTContext(),
1719-
tyLoc,
1720-
TypeResolution::forContextual(CS.DC),
1721-
options))
1718+
if (TypeChecker::validateType(
1719+
CS.getASTContext(), tyLoc,
1720+
TypeResolution::forContextual(CS.DC, options), options))
17221721
return Type();
17231722

17241723
CS.addConstraint(ConstraintKind::Bind,
@@ -2660,10 +2659,11 @@ namespace {
26602659
// of is-patterns applied to an irrefutable pattern.
26612660
pattern = pattern->getSemanticsProvidingPattern();
26622661
while (auto isp = dyn_cast<IsPattern>(pattern)) {
2663-
if (TypeChecker::validateType(CS.getASTContext(),
2664-
isp->getCastTypeLoc(),
2665-
TypeResolution::forContextual(CS.DC),
2666-
TypeResolverContext::InExpression)) {
2662+
if (TypeChecker::validateType(
2663+
CS.getASTContext(), isp->getCastTypeLoc(),
2664+
TypeResolution::forContextual(
2665+
CS.DC, TypeResolverContext::InExpression),
2666+
TypeResolverContext::InExpression)) {
26672667
return false;
26682668
}
26692669

@@ -2986,10 +2986,9 @@ namespace {
29862986
// Validate the resulting type.
29872987
TypeResolutionOptions options(TypeResolverContext::ExplicitCastExpr);
29882988
options |= TypeResolutionFlags::AllowUnboundGenerics;
2989-
if (TypeChecker::validateType(CS.getASTContext(),
2990-
expr->getCastTypeLoc(),
2991-
TypeResolution::forContextual(CS.DC),
2992-
options))
2989+
if (TypeChecker::validateType(
2990+
CS.getASTContext(), expr->getCastTypeLoc(),
2991+
TypeResolution::forContextual(CS.DC, options), options))
29932992
return nullptr;
29942993

29952994
// Open the type we're casting to.
@@ -3016,10 +3015,9 @@ namespace {
30163015
// Validate the resulting type.
30173016
TypeResolutionOptions options(TypeResolverContext::ExplicitCastExpr);
30183017
options |= TypeResolutionFlags::AllowUnboundGenerics;
3019-
if (TypeChecker::validateType(CS.getASTContext(),
3020-
expr->getCastTypeLoc(),
3021-
TypeResolution::forContextual(CS.DC),
3022-
options))
3018+
if (TypeChecker::validateType(
3019+
CS.getASTContext(), expr->getCastTypeLoc(),
3020+
TypeResolution::forContextual(CS.DC, options), options))
30233021
return nullptr;
30243022

30253023
// Open the type we're casting to.
@@ -3053,10 +3051,9 @@ namespace {
30533051
// Validate the resulting type.
30543052
TypeResolutionOptions options(TypeResolverContext::ExplicitCastExpr);
30553053
options |= TypeResolutionFlags::AllowUnboundGenerics;
3056-
if (TypeChecker::validateType(ctx,
3057-
expr->getCastTypeLoc(),
3058-
TypeResolution::forContextual(CS.DC),
3059-
options))
3054+
if (TypeChecker::validateType(
3055+
ctx, expr->getCastTypeLoc(),
3056+
TypeResolution::forContextual(CS.DC, options), options))
30603057
return nullptr;
30613058

30623059
// Open the type we're casting to.
@@ -3084,10 +3081,9 @@ namespace {
30843081
auto &ctx = CS.getASTContext();
30853082
TypeResolutionOptions options(TypeResolverContext::ExplicitCastExpr);
30863083
options |= TypeResolutionFlags::AllowUnboundGenerics;
3087-
if (TypeChecker::validateType(ctx,
3088-
expr->getCastTypeLoc(),
3089-
TypeResolution::forContextual(CS.DC),
3090-
options))
3084+
if (TypeChecker::validateType(
3085+
ctx, expr->getCastTypeLoc(),
3086+
TypeResolution::forContextual(CS.DC, options), options))
30913087
return nullptr;
30923088

30933089
// Open up the type we're checking.

‎lib/Sema/CSSolver.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -993,7 +993,7 @@ void ConstraintSystem::shrink(Expr *expr) {
993993
// instead of cloning representative.
994994
auto coercionRepr = typeRepr->clone(CS.getASTContext());
995995
// Let's try to resolve coercion type from cloned representative.
996-
auto resolution = TypeResolution::forContextual(CS.DC);
996+
auto resolution = TypeResolution::forContextual(CS.DC, None);
997997
auto coercionType =
998998
resolution.resolveType(coercionRepr, None);
999999

‎lib/Sema/ConstraintSystem.cpp

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -651,8 +651,8 @@ Type ConstraintSystem::openUnboundGenericType(UnboundGenericType *unbound,
651651
// handle generic TypeAliases elsewhere, this can just become a
652652
// call to BoundGenericType::get().
653653
return TypeChecker::applyUnboundGenericArguments(
654-
unbound, unboundDecl,
655-
SourceLoc(), TypeResolution::forContextual(DC), arguments);
654+
unbound, unboundDecl, SourceLoc(),
655+
TypeResolution::forContextual(DC, None), arguments);
656656
}
657657

658658
static void checkNestedTypeConstraints(ConstraintSystem &cs, Type type,
@@ -1090,10 +1090,10 @@ ConstraintSystem::getTypeOfReference(ValueDecl *value,
10901090
if (auto typeDecl = dyn_cast<TypeDecl>(value)) {
10911091
// Resolve the reference to this type declaration in our current context.
10921092
auto type = TypeChecker::resolveTypeInContext(
1093-
typeDecl, nullptr,
1094-
TypeResolution::forContextual(useDC),
1095-
TypeResolverContext::InExpression,
1096-
/*isSpecialized=*/false);
1093+
typeDecl, nullptr,
1094+
TypeResolution::forContextual(useDC, TypeResolverContext::InExpression),
1095+
TypeResolverContext::InExpression,
1096+
/*isSpecialized=*/false);
10971097

10981098
checkNestedTypeConstraints(*this, type, locator);
10991099

‎lib/Sema/TypeCheckAttr.cpp

Lines changed: 6 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -2619,7 +2619,7 @@ ResolveTypeEraserTypeRequest::evaluate(Evaluator &evaluator,
26192619
ProtocolDecl *PD,
26202620
TypeEraserAttr *attr) const {
26212621
if (auto *typeEraserRepr = attr->getParsedTypeEraserTypeRepr()) {
2622-
auto resolution = TypeResolution::forContextual(PD);
2622+
auto resolution = TypeResolution::forContextual(PD, None);
26232623
return resolution.resolveType(typeEraserRepr, /*options=*/None);
26242624
} else {
26252625
auto *LazyResolver = attr->Resolver;
@@ -2806,7 +2806,7 @@ void AttributeChecker::visitImplementsAttr(ImplementsAttr *attr) {
28062806
TypeResolutionOptions options = None;
28072807
options |= TypeResolutionFlags::AllowUnboundGenerics;
28082808

2809-
auto resolution = TypeResolution::forContextual(DC);
2809+
auto resolution = TypeResolution::forContextual(DC, options);
28102810
T = resolution.resolveType(ProtoTypeLoc.getTypeRepr(), options);
28112811
ProtoTypeLoc.setType(T);
28122812
}
@@ -4467,11 +4467,12 @@ static bool typeCheckDerivativeAttr(ASTContext &Ctx, Decl *D,
44674467
return derivative->getParent() == func->getParent();
44684468
};
44694469

4470-
auto resolution = TypeResolution::forContextual(derivative->getDeclContext());
44714470
Type baseType;
44724471
if (auto *baseTypeRepr = attr->getBaseTypeRepr()) {
44734472
TypeResolutionOptions options = None;
44744473
options |= TypeResolutionFlags::AllowModule;
4474+
auto resolution =
4475+
TypeResolution::forContextual(derivative->getDeclContext(), options);
44754476
baseType = resolution.resolveType(baseTypeRepr, options);
44764477
}
44774478
if (baseType && baseType->hasError())
@@ -4980,7 +4981,8 @@ void AttributeChecker::visitTransposeAttr(TransposeAttr *attr) {
49804981
std::function<bool(AbstractFunctionDecl *)> hasValidTypeContext =
49814982
[&](AbstractFunctionDecl *decl) { return true; };
49824983

4983-
auto resolution = TypeResolution::forContextual(transpose->getDeclContext());
4984+
auto resolution =
4985+
TypeResolution::forContextual(transpose->getDeclContext(), None);
49844986
Type baseType;
49854987
if (attr->getBaseTypeRepr())
49864988
baseType = resolution.resolveType(attr->getBaseTypeRepr(), None);

‎lib/Sema/TypeCheckConstraints.cpp

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1390,7 +1390,7 @@ TypeExpr *PreCheckExpression::simplifyNestedTypeExpr(UnresolvedDotExpr *UDE) {
13901390
TypeResolutionOptions options(TypeResolverContext::InExpression);
13911391
options |= TypeResolutionFlags::AllowUnboundGenerics;
13921392
options |= TypeResolutionFlags::AllowUnavailable;
1393-
auto resolution = TypeResolution::forContextual(DC);
1393+
auto resolution = TypeResolution::forContextual(DC, options);
13941394
auto BaseTy = resolution.resolveType(InnerTypeRepr, options);
13951395

13961396
if (BaseTy && BaseTy->mayHaveMembers()) {
@@ -1918,7 +1918,8 @@ Expr *PreCheckExpression::simplifyTypeConstructionWithLiteralArg(Expr *E) {
19181918

19191919
typeLoc = TypeLoc(typeExpr->getTypeRepr(), Type());
19201920
bool hadError = TypeChecker::validateType(
1921-
getASTContext(), typeLoc, TypeResolution::forContextual(DC), options);
1921+
getASTContext(), typeLoc, TypeResolution::forContextual(DC, options),
1922+
options);
19221923

19231924
if (hadError)
19241925
return nullptr;

‎lib/Sema/TypeCheckDecl.cpp

Lines changed: 11 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -815,7 +815,8 @@ DefaultDefinitionTypeRequest::evaluate(Evaluator &evaluator,
815815

816816
TypeRepr *defaultDefinition = assocType->getDefaultDefinitionTypeRepr();
817817
if (defaultDefinition) {
818-
auto resolution = TypeResolution::forInterface(assocType->getDeclContext());
818+
auto resolution =
819+
TypeResolution::forInterface(assocType->getDeclContext(), None);
819820
return resolution.resolveType(defaultDefinition, None);
820821
}
821822

@@ -1434,8 +1435,8 @@ static NominalTypeDecl *resolveSingleNominalTypeDecl(
14341435

14351436
TypeResolutionOptions options = TypeResolverContext::TypeAliasDecl;
14361437
options |= flags;
1437-
if (TypeChecker::validateType(Ctx, typeLoc,
1438-
TypeResolution::forInterface(DC), options))
1438+
if (TypeChecker::validateType(
1439+
Ctx, typeLoc, TypeResolution::forInterface(DC, options), options))
14391440
return nullptr;
14401441

14411442
return typeLoc.getType()->getAnyNominal();
@@ -1768,9 +1769,9 @@ UnderlyingTypeRequest::evaluate(Evaluator &evaluator,
17681769
}
17691770

17701771
auto underlyingLoc = TypeLoc(typeAlias->getUnderlyingTypeRepr());
1771-
if (TypeChecker::validateType(typeAlias->getASTContext(), underlyingLoc,
1772-
TypeResolution::forInterface(typeAlias),
1773-
options)) {
1772+
if (TypeChecker::validateType(
1773+
typeAlias->getASTContext(), underlyingLoc,
1774+
TypeResolution::forInterface(typeAlias, options), options)) {
17741775
typeAlias->setInvalid();
17751776
return ErrorType::get(typeAlias->getASTContext());
17761777
}
@@ -2018,7 +2019,8 @@ ResultTypeRequest::evaluate(Evaluator &evaluator, ValueDecl *decl) const {
20182019
}
20192020

20202021
auto *dc = decl->getInnermostDeclContext();
2021-
auto resolution = TypeResolution::forInterface(dc);
2022+
auto resolution =
2023+
TypeResolution::forInterface(dc, TypeResolverContext::FunctionResult);
20222024
return resolution.resolveType(
20232025
resultTyRepr, TypeResolverContext::FunctionResult);
20242026
}
@@ -2096,7 +2098,6 @@ ParamSpecifierRequest::evaluate(Evaluator &evaluator,
20962098

20972099
static Type validateParameterType(ParamDecl *decl) {
20982100
auto *dc = decl->getDeclContext();
2099-
auto resolution = TypeResolution::forInterface(dc);
21002101

21012102
TypeResolutionOptions options(None);
21022103
if (isa<AbstractClosureExpr>(dc)) {
@@ -2123,6 +2124,7 @@ static Type validateParameterType(ParamDecl *decl) {
21232124
auto TL = TypeLoc(decl->getTypeRepr());
21242125

21252126
auto &ctx = dc->getASTContext();
2127+
auto resolution = TypeResolution::forInterface(dc, options);
21262128
if (TypeChecker::validateType(ctx, TL, resolution, options)) {
21272129
decl->setInvalid();
21282130
return ErrorType::get(ctx);
@@ -2542,7 +2544,7 @@ ExtendedTypeRequest::evaluate(Evaluator &eval, ExtensionDecl *ext) const {
25422544
// Compute the extended type.
25432545
TypeResolutionOptions options(TypeResolverContext::ExtensionBinding);
25442546
options |= TypeResolutionFlags::AllowUnboundGenerics;
2545-
auto tr = TypeResolution::forStructural(ext->getDeclContext());
2547+
auto tr = TypeResolution::forStructural(ext->getDeclContext(), options);
25462548
auto extendedType = tr.resolveType(extendedRepr, options);
25472549

25482550
if (extendedType->hasError())

‎lib/Sema/TypeCheckGeneric.cpp

Lines changed: 11 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -134,7 +134,7 @@ OpaqueResultTypeRequest::evaluate(Evaluator &evaluator,
134134
TypeLoc constraintTypeLoc(repr->getConstraint());
135135
// Pass along the error type if resolving the repr failed.
136136
auto resolution = TypeResolution::forInterface(
137-
dc, dc->getGenericSignatureOfContext());
137+
dc, dc->getGenericSignatureOfContext(), options);
138138
bool validationError
139139
= TypeChecker::validateType(ctx, constraintTypeLoc, resolution, options);
140140
auto constraintType = constraintTypeLoc.getType();
@@ -657,12 +657,11 @@ GenericSignatureRequest::evaluate(Evaluator &evaluator,
657657
// note them as inference sources.
658658
if (subscr || func) {
659659
// Gather requirements from the parameter list.
660-
auto resolution = TypeResolution::forStructural(GC);
661-
662660
TypeResolutionOptions options =
663661
(func ? TypeResolverContext::AbstractFunctionDecl
664662
: TypeResolverContext::SubscriptDecl);
665663

664+
auto resolution = TypeResolution::forStructural(GC, options);
666665
auto params = func ? func->getParameters() : subscr->getIndices();
667666
for (auto param : *params) {
668667
auto *typeRepr = param->getTypeRepr();
@@ -675,7 +674,8 @@ GenericSignatureRequest::evaluate(Evaluator &evaluator,
675674
: TypeResolverContext::FunctionInput);
676675
paramOptions |= TypeResolutionFlags::Direct;
677676

678-
auto type = resolution.resolveType(typeRepr, paramOptions);
677+
auto type = resolution.withOptions(paramOptions)
678+
.resolveType(typeRepr, paramOptions);
679679

680680
if (auto *specifier = dyn_cast<SpecifierTypeRepr>(typeRepr))
681681
typeRepr = specifier->getBase();
@@ -694,8 +694,10 @@ GenericSignatureRequest::evaluate(Evaluator &evaluator,
694694
}
695695
}();
696696
if (resultTypeRepr && !isa<OpaqueReturnTypeRepr>(resultTypeRepr)) {
697-
auto resultType = resolution.resolveType(
698-
resultTypeRepr, TypeResolverContext::FunctionResult);
697+
auto resultType =
698+
resolution.withOptions(TypeResolverContext::FunctionResult)
699+
.resolveType(resultTypeRepr,
700+
TypeResolverContext::FunctionResult);
699701

700702
inferenceSources.emplace_back(resultTypeRepr, resultType);
701703
}
@@ -924,11 +926,11 @@ RequirementRequest::evaluate(Evaluator &evaluator,
924926
Optional<TypeResolution> resolution;
925927
switch (stage) {
926928
case TypeResolutionStage::Structural:
927-
resolution = TypeResolution::forStructural(owner.dc);
929+
resolution = TypeResolution::forStructural(owner.dc, options);
928930
break;
929931

930932
case TypeResolutionStage::Interface:
931-
resolution = TypeResolution::forInterface(owner.dc);
933+
resolution = TypeResolution::forInterface(owner.dc, options);
932934
break;
933935

934936
case TypeResolutionStage::Contextual:
@@ -989,7 +991,7 @@ Type StructuralTypeRequest::evaluate(Evaluator &evaluator,
989991
return ErrorType::get(ctx);
990992
}
991993

992-
auto resolution = TypeResolution::forStructural(typeAlias);
994+
auto resolution = TypeResolution::forStructural(typeAlias, options);
993995
auto type = resolution.resolveType(underlyingTypeRepr, options);
994996

995997
auto genericSig = typeAlias->getGenericSignature();

‎lib/Sema/TypeCheckPattern.cpp

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -465,7 +465,7 @@ class ResolvePattern : public ASTVisitor<ResolvePattern,
465465

466466
// See if the repr resolves to a type.
467467
Type ty = TypeChecker::resolveIdentifierType(
468-
TypeResolution::forContextual(DC), repr, options);
468+
TypeResolution::forContextual(DC, options), repr, options);
469469

470470
auto *enumDecl = dyn_cast_or_null<EnumDecl>(ty->getAnyNominal());
471471
if (!enumDecl)
@@ -563,8 +563,8 @@ class ResolvePattern : public ASTVisitor<ResolvePattern,
563563
auto *prefixRepr = IdentTypeRepr::create(Context, components);
564564

565565
// See first if the entire repr resolves to a type.
566-
Type enumTy = TypeChecker::resolveIdentifierType(TypeResolution::forContextual(DC),
567-
prefixRepr, options);
566+
Type enumTy = TypeChecker::resolveIdentifierType(
567+
TypeResolution::forContextual(DC, options), prefixRepr, options);
568568
if (!dyn_cast_or_null<EnumDecl>(enumTy->getAnyNominal()))
569569
return nullptr;
570570

@@ -761,7 +761,7 @@ Type PatternTypeRequest::evaluate(Evaluator &evaluator,
761761
// If we see an explicit type annotation, coerce the sub-pattern to
762762
// that type.
763763
case PatternKind::Typed: {
764-
auto resolution = TypeResolution::forContextual(dc);
764+
auto resolution = TypeResolution::forContextual(dc, options);
765765
TypedPattern *TP = cast<TypedPattern>(P);
766766
return validateTypedPattern(resolution, TP, options);
767767
}
@@ -1210,7 +1210,7 @@ Pattern *TypeChecker::coercePatternToType(ContextualPattern pattern,
12101210

12111211
// Type-check the type parameter.
12121212
TypeResolutionOptions paramOptions(TypeResolverContext::InExpression);
1213-
TypeResolution resolution = TypeResolution::forContextual(dc);
1213+
TypeResolution resolution = TypeResolution::forContextual(dc, paramOptions);
12141214
if (validateType(Context, IP->getCastTypeLoc(), resolution, paramOptions))
12151215
return nullptr;
12161216

‎lib/Sema/TypeCheckPropertyWrapper.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -560,11 +560,11 @@ Type AttachedPropertyWrapperTypeRequest::evaluate(Evaluator &evaluator,
560560
if (!customAttr)
561561
return Type();
562562

563-
auto resolution =
564-
TypeResolution::forContextual(var->getDeclContext());
565563
TypeResolutionOptions options(TypeResolverContext::PatternBindingDecl);
566564
options |= TypeResolutionFlags::AllowUnboundGenerics;
567565

566+
auto resolution =
567+
TypeResolution::forContextual(var->getDeclContext(), options);
568568
if (TypeChecker::validateType(var->getASTContext(),
569569
customAttr->getTypeLoc(),
570570
resolution, options)) {

‎lib/Sema/TypeCheckRequestFunctions.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -49,11 +49,11 @@ InheritedTypeRequest::evaluate(
4949
Optional<TypeResolution> resolution;
5050
switch (stage) {
5151
case TypeResolutionStage::Structural:
52-
resolution = TypeResolution::forStructural(dc);
52+
resolution = TypeResolution::forStructural(dc, options);
5353
break;
5454

5555
case TypeResolutionStage::Interface:
56-
resolution = TypeResolution::forInterface(dc);
56+
resolution = TypeResolution::forInterface(dc, options);
5757
break;
5858

5959
case TypeResolutionStage::Contextual: {

0 commit comments

Comments
 (0)