Skip to content

Commit 6226644

Browse files
CodaFiCodaFi
committed
Drop the TypeChecker dependency from some helpers
1 parent 5964ce4 commit 6226644

File tree

5 files changed

+55
-53
lines changed

5 files changed

+55
-53
lines changed

‎lib/Sema/CSApply.cpp

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -7342,7 +7342,7 @@ bool swift::exprNeedsParensInsideFollowingOperator(
73427342
TypeChecker &TC, DeclContext *DC, Expr *expr,
73437343
PrecedenceGroupDecl *followingPG) {
73447344
if (expr->isInfixOperator()) {
7345-
auto exprPG = TC.lookupPrecedenceGroupForInfixOperator(DC, expr);
7345+
auto exprPG = TypeChecker::lookupPrecedenceGroupForInfixOperator(DC, expr);
73467346
if (!exprPG) return true;
73477347

73487348
return TC.Context.associateInfixOperators(exprPG, followingPG)
@@ -7376,7 +7376,8 @@ bool swift::exprNeedsParensOutsideFollowingOperator(
73767376
return false;
73777377

73787378
if (parent->isInfixOperator()) {
7379-
auto parentPG = TC.lookupPrecedenceGroupForInfixOperator(DC, parent);
7379+
auto parentPG = TypeChecker::lookupPrecedenceGroupForInfixOperator(DC,
7380+
parent);
73807381
if (!parentPG) return true;
73817382

73827383
// If the index is 0, this is on the LHS of the parent.
@@ -7395,20 +7396,19 @@ bool swift::exprNeedsParensOutsideFollowingOperator(
73957396
bool swift::exprNeedsParensBeforeAddingNilCoalescing(TypeChecker &TC,
73967397
DeclContext *DC,
73977398
Expr *expr) {
7398-
auto asPG =
7399-
TC.lookupPrecedenceGroup(DC, DC->getASTContext().Id_NilCoalescingPrecedence,
7400-
SourceLoc());
7401-
if (!asPG) return true;
7399+
auto asPG = TypeChecker::lookupPrecedenceGroup(
7400+
DC, DC->getASTContext().Id_NilCoalescingPrecedence, SourceLoc());
7401+
if (!asPG)
7402+
return true;
74027403
return exprNeedsParensInsideFollowingOperator(TC, DC, expr, asPG);
74037404
}
74047405

74057406
bool swift::exprNeedsParensAfterAddingNilCoalescing(TypeChecker &TC,
74067407
DeclContext *DC,
74077408
Expr *expr,
74087409
Expr *rootExpr) {
7409-
auto asPG =
7410-
TC.lookupPrecedenceGroup(DC, DC->getASTContext().Id_NilCoalescingPrecedence,
7411-
SourceLoc());
7410+
auto asPG = TypeChecker::lookupPrecedenceGroup(
7411+
DC, DC->getASTContext().Id_NilCoalescingPrecedence, SourceLoc());
74127412
if (!asPG) return true;
74137413
return exprNeedsParensOutsideFollowingOperator(TC, DC, expr, rootExpr, asPG);
74147414
}

‎lib/Sema/CSDiagnostics.h

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -794,7 +794,7 @@ class MissingExplicitConversionFailure final : public ContextualFailure {
794794
auto *DC = getDC();
795795
auto &TC = getTypeChecker();
796796

797-
auto asPG = TC.lookupPrecedenceGroup(
797+
auto asPG = TypeChecker::lookupPrecedenceGroup(
798798
DC, DC->getASTContext().Id_CastingPrecedence, SourceLoc());
799799
if (!asPG)
800800
return true;
@@ -805,7 +805,7 @@ class MissingExplicitConversionFailure final : public ContextualFailure {
805805
auto *DC = getDC();
806806
auto &TC = getTypeChecker();
807807

808-
auto asPG = TC.lookupPrecedenceGroup(
808+
auto asPG = TypeChecker::lookupPrecedenceGroup(
809809
DC, DC->getASTContext().Id_CastingPrecedence, SourceLoc());
810810
if (!asPG)
811811
return true;

‎lib/Sema/TypeCheckDecl.cpp

Lines changed: 12 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1764,20 +1764,22 @@ void TypeChecker::validateDecl(PrecedenceGroupDecl *PGD) {
17641764

17651765
bool isInvalid = false;
17661766

1767+
auto &Diags = PGD->getASTContext().Diags;
1768+
17671769
// Validate the higherThan relationships.
17681770
bool addedHigherThan = false;
17691771
for (auto &rel : PGD->getMutableHigherThan()) {
17701772
if (rel.Group) continue;
17711773

1772-
auto group = lookupPrecedenceGroupPrimitive(PGD->getDeclContext(),
1773-
rel.Name, rel.NameLoc);
1774+
auto group = TypeChecker::lookupPrecedenceGroup(PGD->getDeclContext(),
1775+
rel.Name, rel.NameLoc);
17741776
if (group) {
17751777
rel.Group = group;
17761778
validateDecl(group);
17771779
addedHigherThan = true;
17781780
} else if (!PGD->isInvalid()) {
1779-
diagnose(rel.NameLoc, diag::unknown_precedence_group, rel.Name);
1780-
isInvalid = true;
1781+
Diags.diagnose(rel.NameLoc, diag::unknown_precedence_group, rel.Name);
1782+
PGD->setInvalid();
17811783
}
17821784
}
17831785

@@ -1786,7 +1788,7 @@ void TypeChecker::validateDecl(PrecedenceGroupDecl *PGD) {
17861788
if (rel.Group) continue;
17871789

17881790
auto dc = PGD->getDeclContext();
1789-
auto group = lookupPrecedenceGroupPrimitive(dc, rel.Name, rel.NameLoc);
1791+
auto group = TypeChecker::lookupPrecedenceGroup(dc, rel.Name, rel.NameLoc);
17901792
if (group) {
17911793
if (group->getDeclContext()->getParentModule()
17921794
== dc->getParentModule()) {
@@ -1828,14 +1830,14 @@ PrecedenceGroupDecl *TypeChecker::lookupPrecedenceGroup(DeclContext *dc,
18281830
}
18291831

18301832
static NominalTypeDecl *resolveSingleNominalTypeDecl(
1831-
DeclContext *DC, SourceLoc loc, Identifier ident, TypeChecker &tc,
1833+
DeclContext *DC, SourceLoc loc, Identifier ident, ASTContext &Ctx,
18321834
TypeResolutionFlags flags = TypeResolutionFlags(0)) {
1833-
auto *TyR = new (tc.Context) SimpleIdentTypeRepr(loc, ident);
1835+
auto *TyR = new (Ctx) SimpleIdentTypeRepr(loc, ident);
18341836
TypeLoc typeLoc = TypeLoc(TyR);
18351837

18361838
TypeResolutionOptions options = TypeResolverContext::TypeAliasDecl;
18371839
options |= flags;
1838-
if (TypeChecker::validateType(tc.Context, typeLoc,
1840+
if (TypeChecker::validateType(Ctx, typeLoc,
18391841
TypeResolution::forInterface(DC), options))
18401842
return nullptr;
18411843

@@ -1845,23 +1847,22 @@ static NominalTypeDecl *resolveSingleNominalTypeDecl(
18451847
static bool checkDesignatedTypes(OperatorDecl *OD,
18461848
ArrayRef<Identifier> identifiers,
18471849
ArrayRef<SourceLoc> identifierLocs,
1848-
TypeChecker &TC) {
1850+
ASTContext &ctx) {
18491851
assert(identifiers.size() == identifierLocs.size());
18501852

18511853
SmallVector<NominalTypeDecl *, 1> designatedNominalTypes;
18521854
auto *DC = OD->getDeclContext();
18531855

18541856
for (auto index : indices(identifiers)) {
18551857
auto *decl = resolveSingleNominalTypeDecl(DC, identifierLocs[index],
1856-
identifiers[index], TC);
1858+
identifiers[index], ctx);
18571859

18581860
if (!decl)
18591861
return true;
18601862

18611863
designatedNominalTypes.push_back(decl);
18621864
}
18631865

1864-
auto &ctx = TC.Context;
18651866
OD->setDesignatedNominalTypes(ctx.AllocateCopy(designatedNominalTypes));
18661867
return false;
18671868
}

‎lib/Sema/TypeCheckExpr.cpp

Lines changed: 28 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -124,64 +124,64 @@ Expr *TypeChecker::substituteInputSugarTypeForResult(ApplyExpr *E) {
124124
return E;
125125
}
126126

127-
/// Look up the builtin precedence group with the given name.
128-
static PrecedenceGroupDecl *
129-
getBuiltinPrecedenceGroup(TypeChecker &TC, DeclContext *DC, Identifier name,
130-
SourceLoc loc) {
131-
auto group = TC.lookupPrecedenceGroup(DC, name,
132-
/*suppress diags*/ SourceLoc());
133-
if (!group) {
134-
TC.diagnose(loc, diag::missing_builtin_precedence_group, name);
135-
}
136-
return group;
137-
}
138-
139-
static PrecedenceGroupDecl *
140-
lookupPrecedenceGroupForOperator(TypeChecker &TC, DeclContext *DC,
141-
Identifier name, SourceLoc loc) {
127+
static PrecedenceGroupDecl *lookupPrecedenceGroupForOperator(DeclContext *DC,
128+
Identifier name,
129+
SourceLoc loc) {
142130
SourceFile *SF = DC->getParentSourceFile();
143131
bool isCascading = DC->isCascadingContextForLookup(true);
144132
if (auto op = SF->lookupInfixOperator(name, isCascading, loc)) {
145-
TC.validateDecl(op);
146133
return op->getPrecedenceGroup();
147134
} else {
148-
TC.diagnose(loc, diag::unknown_binop);
135+
DC->getASTContext().Diags.diagnose(loc, diag::unknown_binop);
149136
}
150137
return nullptr;
151138
}
152139

153140
PrecedenceGroupDecl *
154141
TypeChecker::lookupPrecedenceGroupForInfixOperator(DeclContext *DC, Expr *E) {
142+
/// Look up the builtin precedence group with the given name.
143+
144+
auto getBuiltinPrecedenceGroup = [](DeclContext *DC, Identifier name,
145+
SourceLoc loc) {
146+
auto group = TypeChecker::lookupPrecedenceGroup(DC, name, loc);
147+
if (!group) {
148+
DC->getASTContext().Diags.diagnose(
149+
loc, diag::missing_builtin_precedence_group, name);
150+
}
151+
return group;
152+
};
153+
154+
auto &Context = DC->getASTContext();
155155
if (auto ifExpr = dyn_cast<IfExpr>(E)) {
156156
// Ternary has fixed precedence.
157-
return getBuiltinPrecedenceGroup(*this, DC, Context.Id_TernaryPrecedence,
157+
return getBuiltinPrecedenceGroup(DC, Context.Id_TernaryPrecedence,
158158
ifExpr->getQuestionLoc());
159159
}
160160

161161
if (auto assignExpr = dyn_cast<AssignExpr>(E)) {
162162
// Assignment has fixed precedence.
163-
return getBuiltinPrecedenceGroup(*this, DC, Context.Id_AssignmentPrecedence,
163+
return getBuiltinPrecedenceGroup(DC, Context.Id_AssignmentPrecedence,
164164
assignExpr->getEqualLoc());
165165
}
166166

167167
if (auto castExpr = dyn_cast<ExplicitCastExpr>(E)) {
168168
// 'as' and 'is' casts have fixed precedence.
169-
return getBuiltinPrecedenceGroup(*this, DC, Context.Id_CastingPrecedence,
169+
return getBuiltinPrecedenceGroup(DC, Context.Id_CastingPrecedence,
170170
castExpr->getAsLoc());
171171
}
172172

173173
if (auto *DRE = dyn_cast<DeclRefExpr>(E)) {
174174
Identifier name = DRE->getDecl()->getBaseName().getIdentifier();
175-
return lookupPrecedenceGroupForOperator(*this, DC, name, DRE->getLoc());
175+
return lookupPrecedenceGroupForOperator(DC, name, DRE->getLoc());
176176
}
177177

178178
if (auto *OO = dyn_cast<OverloadedDeclRefExpr>(E)) {
179179
Identifier name = OO->getDecls()[0]->getBaseName().getIdentifier();
180-
return lookupPrecedenceGroupForOperator(*this, DC, name, OO->getLoc());
180+
return lookupPrecedenceGroupForOperator(DC, name, OO->getLoc());
181181
}
182182

183183
if (auto arrowExpr = dyn_cast<ArrowExpr>(E)) {
184-
return getBuiltinPrecedenceGroup(*this, DC,
184+
return getBuiltinPrecedenceGroup(DC,
185185
Context.Id_FunctionArrowPrecedence,
186186
arrowExpr->getArrowLoc());
187187
}
@@ -198,13 +198,13 @@ TypeChecker::lookupPrecedenceGroupForInfixOperator(DeclContext *DC, Expr *E) {
198198

199199
if (auto *MRE = dyn_cast<MemberRefExpr>(E)) {
200200
Identifier name = MRE->getDecl().getDecl()->getBaseName().getIdentifier();
201-
return lookupPrecedenceGroupForOperator(*this, DC, name, MRE->getLoc());
201+
return lookupPrecedenceGroupForOperator(DC, name, MRE->getLoc());
202202
}
203203

204204
// If E is already an ErrorExpr, then we've diagnosed it as invalid already,
205205
// otherwise emit an error.
206206
if (!isa<ErrorExpr>(E))
207-
diagnose(E->getLoc(), diag::unknown_binop);
207+
Context.Diags.diagnose(E->getLoc(), diag::unknown_binop);
208208

209209
return nullptr;
210210
}
@@ -217,7 +217,7 @@ TypeChecker::lookupPrecedenceGroupForInfixOperator(DeclContext *DC, Expr *E) {
217217
/// 'findLHS(DC, expr, "<<")' returns 'B'.
218218
/// 'findLHS(DC, expr, '==')' returns nullptr.
219219
Expr *TypeChecker::findLHS(DeclContext *DC, Expr *E, Identifier name) {
220-
auto right = lookupPrecedenceGroupForOperator(*this, DC, name, E->getEndLoc());
220+
auto right = lookupPrecedenceGroupForOperator(DC, name, E->getEndLoc());
221221
if (!right)
222222
return nullptr;
223223

@@ -445,7 +445,7 @@ static Expr *foldSequence(TypeChecker &TC, DeclContext *DC,
445445
Expr *op = S[0];
446446

447447
// If the operator's precedence is lower than the minimum, stop here.
448-
auto opPrecedence = TC.lookupPrecedenceGroupForInfixOperator(DC, op);
448+
auto opPrecedence = TypeChecker::lookupPrecedenceGroupForInfixOperator(DC, op);
449449
if (!precedenceBound.shouldConsider(TC, opPrecedence))
450450
return {nullptr, nullptr};
451451
return {op, opPrecedence};
@@ -476,7 +476,7 @@ static Expr *foldSequence(TypeChecker &TC, DeclContext *DC,
476476
}
477477

478478
// Pull out the next binary operator.
479-
Op op2 = { S[0], TC.lookupPrecedenceGroupForInfixOperator(DC, S[0]) };
479+
Op op2{ S[0], TypeChecker::lookupPrecedenceGroupForInfixOperator(DC, S[0]) };
480480

481481
// If the second operator's precedence is lower than the
482482
// precedence bound, break out of the loop.

‎lib/Sema/TypeChecker.h

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1635,11 +1635,12 @@ class TypeChecker final : public LazyResolver {
16351635

16361636
/// Given an expression that's known to be an infix operator,
16371637
/// look up its precedence group.
1638-
PrecedenceGroupDecl *
1638+
static PrecedenceGroupDecl *
16391639
lookupPrecedenceGroupForInfixOperator(DeclContext *dc, Expr *op);
16401640

1641-
PrecedenceGroupDecl *lookupPrecedenceGroup(DeclContext *dc, Identifier name,
1642-
SourceLoc nameLoc);
1641+
static PrecedenceGroupDecl *lookupPrecedenceGroup(DeclContext *dc,
1642+
Identifier name,
1643+
SourceLoc nameLoc);
16431644

16441645
/// Given an pre-folded expression, find LHS from the expression if a binary
16451646
/// operator \c name appended to the expression.

0 commit comments

Comments
 (0)