Skip to content

Commit 988075f

Browse files
CodaFiCodaFi
authored
Merge pull request #31447 from CodaFi/opt-ical-illusion
[NFC] Internalize TypeResolutionOptions in TypeResolution
2 parents 8410e86 + 31d2330 commit 988075f

14 files changed

+194
-184
lines changed

‎lib/Sema/CSGen.cpp

Lines changed: 21 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));
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)))
17221721
return Type();
17231722

17241723
CS.addConstraint(ConstraintKind::Bind,
@@ -2660,10 +2659,10 @@ 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))) {
26672666
return false;
26682667
}
26692668

@@ -2986,10 +2985,9 @@ namespace {
29862985
// Validate the resulting type.
29872986
TypeResolutionOptions options(TypeResolverContext::ExplicitCastExpr);
29882987
options |= TypeResolutionFlags::AllowUnboundGenerics;
2989-
if (TypeChecker::validateType(CS.getASTContext(),
2990-
expr->getCastTypeLoc(),
2991-
TypeResolution::forContextual(CS.DC),
2992-
options))
2988+
if (TypeChecker::validateType(
2989+
CS.getASTContext(), expr->getCastTypeLoc(),
2990+
TypeResolution::forContextual(CS.DC, options)))
29932991
return nullptr;
29942992

29952993
// Open the type we're casting to.
@@ -3016,10 +3014,9 @@ namespace {
30163014
// Validate the resulting type.
30173015
TypeResolutionOptions options(TypeResolverContext::ExplicitCastExpr);
30183016
options |= TypeResolutionFlags::AllowUnboundGenerics;
3019-
if (TypeChecker::validateType(CS.getASTContext(),
3020-
expr->getCastTypeLoc(),
3021-
TypeResolution::forContextual(CS.DC),
3022-
options))
3017+
if (TypeChecker::validateType(
3018+
CS.getASTContext(), expr->getCastTypeLoc(),
3019+
TypeResolution::forContextual(CS.DC, options)))
30233020
return nullptr;
30243021

30253022
// Open the type we're casting to.
@@ -3053,10 +3050,9 @@ namespace {
30533050
// Validate the resulting type.
30543051
TypeResolutionOptions options(TypeResolverContext::ExplicitCastExpr);
30553052
options |= TypeResolutionFlags::AllowUnboundGenerics;
3056-
if (TypeChecker::validateType(ctx,
3057-
expr->getCastTypeLoc(),
3058-
TypeResolution::forContextual(CS.DC),
3059-
options))
3053+
if (TypeChecker::validateType(
3054+
ctx, expr->getCastTypeLoc(),
3055+
TypeResolution::forContextual(CS.DC, options)))
30603056
return nullptr;
30613057

30623058
// Open the type we're casting to.
@@ -3084,10 +3080,9 @@ namespace {
30843080
auto &ctx = CS.getASTContext();
30853081
TypeResolutionOptions options(TypeResolverContext::ExplicitCastExpr);
30863082
options |= TypeResolutionFlags::AllowUnboundGenerics;
3087-
if (TypeChecker::validateType(ctx,
3088-
expr->getCastTypeLoc(),
3089-
TypeResolution::forContextual(CS.DC),
3090-
options))
3083+
if (TypeChecker::validateType(
3084+
ctx, expr->getCastTypeLoc(),
3085+
TypeResolution::forContextual(CS.DC, options)))
30913086
return nullptr;
30923087

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

‎lib/Sema/CSSolver.cpp

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -993,9 +993,8 @@ 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);
997-
auto coercionType =
998-
resolution.resolveType(coercionRepr, None);
996+
auto resolution = TypeResolution::forContextual(CS.DC, None);
997+
auto coercionType = resolution.resolveType(coercionRepr);
999998

1000999
// Looks like coercion type is invalid, let's skip this sub-tree.
10011000
if (coercionType->hasError())

‎lib/Sema/ConstraintSystem.cpp

Lines changed: 5 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,9 @@ 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+
/*isSpecialized=*/false);
10971096

10981097
checkNestedTypeConstraints(*this, type, locator);
10991098

‎lib/Sema/TypeCheckAttr.cpp

Lines changed: 10 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -2619,8 +2619,8 @@ ResolveTypeEraserTypeRequest::evaluate(Evaluator &evaluator,
26192619
ProtocolDecl *PD,
26202620
TypeEraserAttr *attr) const {
26212621
if (auto *typeEraserRepr = attr->getParsedTypeEraserTypeRepr()) {
2622-
auto resolution = TypeResolution::forContextual(PD);
2623-
return resolution.resolveType(typeEraserRepr, /*options=*/None);
2622+
auto resolution = TypeResolution::forContextual(PD, None);
2623+
return resolution.resolveType(typeEraserRepr);
26242624
} else {
26252625
auto *LazyResolver = attr->Resolver;
26262626
assert(LazyResolver && "type eraser was neither parsed nor deserialized?");
@@ -2806,8 +2806,8 @@ void AttributeChecker::visitImplementsAttr(ImplementsAttr *attr) {
28062806
TypeResolutionOptions options = None;
28072807
options |= TypeResolutionFlags::AllowUnboundGenerics;
28082808

2809-
auto resolution = TypeResolution::forContextual(DC);
2810-
T = resolution.resolveType(ProtoTypeLoc.getTypeRepr(), options);
2809+
auto resolution = TypeResolution::forContextual(DC, options);
2810+
T = resolution.resolveType(ProtoTypeLoc.getTypeRepr());
28112811
ProtoTypeLoc.setType(T);
28122812
}
28132813

@@ -4467,12 +4467,13 @@ 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;
4475-
baseType = resolution.resolveType(baseTypeRepr, options);
4474+
auto resolution =
4475+
TypeResolution::forContextual(derivative->getDeclContext(), options);
4476+
baseType = resolution.resolveType(baseTypeRepr);
44764477
}
44774478
if (baseType && baseType->hasError())
44784479
return true;
@@ -4980,10 +4981,11 @@ 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())
4986-
baseType = resolution.resolveType(attr->getBaseTypeRepr(), None);
4988+
baseType = resolution.resolveType(attr->getBaseTypeRepr());
49874989
auto lookupOptions =
49884990
(attr->getBaseTypeRepr() ? defaultMemberLookupOptions
49894991
: defaultUnqualifiedLookupOptions) |

‎lib/Sema/TypeCheckConstraints.cpp

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

13961396
if (BaseTy && BaseTy->mayHaveMembers()) {
13971397
auto lookupOptions = defaultMemberLookupOptions;
@@ -1918,7 +1918,7 @@ 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));
19221922

19231923
if (hadError)
19241924
return nullptr;

‎lib/Sema/TypeCheckDecl.cpp

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

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

822823
return Type();
@@ -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)))
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))) {
17741775
typeAlias->setInvalid();
17751776
return ErrorType::get(typeAlias->getASTContext());
17761777
}
@@ -2018,9 +2019,9 @@ ResultTypeRequest::evaluate(Evaluator &evaluator, ValueDecl *decl) const {
20182019
}
20192020

20202021
auto *dc = decl->getInnermostDeclContext();
2021-
auto resolution = TypeResolution::forInterface(dc);
2022-
return resolution.resolveType(
2023-
resultTyRepr, TypeResolverContext::FunctionResult);
2022+
auto resolution =
2023+
TypeResolution::forInterface(dc, TypeResolverContext::FunctionResult);
2024+
return resolution.resolveType(resultTyRepr);
20242025
}
20252026

20262027
ParamSpecifier
@@ -2096,7 +2097,6 @@ ParamSpecifierRequest::evaluate(Evaluator &evaluator,
20962097

20972098
static Type validateParameterType(ParamDecl *decl) {
20982099
auto *dc = decl->getDeclContext();
2099-
auto resolution = TypeResolution::forInterface(dc);
21002100

21012101
TypeResolutionOptions options(None);
21022102
if (isa<AbstractClosureExpr>(dc)) {
@@ -2123,7 +2123,8 @@ static Type validateParameterType(ParamDecl *decl) {
21232123
auto TL = TypeLoc(decl->getTypeRepr());
21242124

21252125
auto &ctx = dc->getASTContext();
2126-
if (TypeChecker::validateType(ctx, TL, resolution, options)) {
2126+
auto resolution = TypeResolution::forInterface(dc, options);
2127+
if (TypeChecker::validateType(ctx, TL, resolution)) {
21272128
decl->setInvalid();
21282129
return ErrorType::get(ctx);
21292130
}
@@ -2542,8 +2543,8 @@ ExtendedTypeRequest::evaluate(Evaluator &eval, ExtensionDecl *ext) const {
25422543
// Compute the extended type.
25432544
TypeResolutionOptions options(TypeResolverContext::ExtensionBinding);
25442545
options |= TypeResolutionFlags::AllowUnboundGenerics;
2545-
auto tr = TypeResolution::forStructural(ext->getDeclContext());
2546-
auto extendedType = tr.resolveType(extendedRepr, options);
2546+
auto tr = TypeResolution::forStructural(ext->getDeclContext(), options);
2547+
auto extendedType = tr.resolveType(extendedRepr);
25472548

25482549
if (extendedType->hasError())
25492550
return error();

‎lib/Sema/TypeCheckGeneric.cpp

Lines changed: 13 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -134,9 +134,9 @@ 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
139-
= TypeChecker::validateType(ctx, constraintTypeLoc, resolution, options);
139+
= TypeChecker::validateType(ctx, constraintTypeLoc, resolution);
140140
auto constraintType = constraintTypeLoc.getType();
141141
if (validationError)
142142
return nullptr;
@@ -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,7 @@ 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).resolveType(typeRepr);
679678

680679
if (auto *specifier = dyn_cast<SpecifierTypeRepr>(typeRepr))
681680
typeRepr = specifier->getBase();
@@ -694,8 +693,9 @@ GenericSignatureRequest::evaluate(Evaluator &evaluator,
694693
}
695694
}();
696695
if (resultTypeRepr && !isa<OpaqueReturnTypeRepr>(resultTypeRepr)) {
697-
auto resultType = resolution.resolveType(
698-
resultTypeRepr, TypeResolverContext::FunctionResult);
696+
auto resultType =
697+
resolution.withOptions(TypeResolverContext::FunctionResult)
698+
.resolveType(resultTypeRepr);
699699

700700
inferenceSources.emplace_back(resultTypeRepr, resultType);
701701
}
@@ -924,11 +924,11 @@ RequirementRequest::evaluate(Evaluator &evaluator,
924924
Optional<TypeResolution> resolution;
925925
switch (stage) {
926926
case TypeResolutionStage::Structural:
927-
resolution = TypeResolution::forStructural(owner.dc);
927+
resolution = TypeResolution::forStructural(owner.dc, options);
928928
break;
929929

930930
case TypeResolutionStage::Interface:
931-
resolution = TypeResolution::forInterface(owner.dc);
931+
resolution = TypeResolution::forInterface(owner.dc, options);
932932
break;
933933

934934
case TypeResolutionStage::Contextual:
@@ -938,7 +938,7 @@ RequirementRequest::evaluate(Evaluator &evaluator,
938938
auto resolveType = [&](TypeLoc &typeLoc) -> Type {
939939
Type result;
940940
if (auto typeRepr = typeLoc.getTypeRepr())
941-
result = resolution->resolveType(typeRepr, options);
941+
result = resolution->resolveType(typeRepr);
942942
else
943943
result = typeLoc.getType();
944944

@@ -989,9 +989,9 @@ Type StructuralTypeRequest::evaluate(Evaluator &evaluator,
989989
return ErrorType::get(ctx);
990990
}
991991

992-
auto resolution = TypeResolution::forStructural(typeAlias);
993-
auto type = resolution.resolveType(underlyingTypeRepr, options);
994-
992+
auto resolution = TypeResolution::forStructural(typeAlias, options);
993+
auto type = resolution.resolveType(underlyingTypeRepr);
994+
995995
auto genericSig = typeAlias->getGenericSignature();
996996
SubstitutionMap subs;
997997
if (genericSig)

0 commit comments

Comments
 (0)