Skip to content

Commit 715cfdd

Browse files
rudkxrudkx
authored
Merge pull request #10999 from rudkx/enable-type-map
Change typeCheckExpression() to return Type.
2 parents 6633b8f + 3d387dd commit 715cfdd

File tree

7 files changed

+85
-84
lines changed

7 files changed

+85
-84
lines changed

‎lib/Sema/CSApply.cpp

Lines changed: 14 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -495,9 +495,10 @@ namespace {
495495
refExpr = declRefExpr;
496496
}
497497

498-
if (tc.typeCheckExpression(refExpr, cs.DC,
499-
TypeLoc::withoutLoc(expectedFnType),
500-
CTP_CannotFail))
498+
auto resultTy = tc.typeCheckExpression(
499+
refExpr, cs.DC, TypeLoc::withoutLoc(expectedFnType),
500+
CTP_CannotFail);
501+
if (!resultTy)
501502
return nullptr;
502503

503504
cs.cacheExprTypes(refExpr);
@@ -3635,14 +3636,12 @@ namespace {
36353636
Expr *callExpr = CallExpr::createImplicit(ctx, fnRef, { argExpr },
36363637
{ Identifier() });
36373638

3638-
bool invalid = tc.typeCheckExpression(callExpr, cs.DC,
3639-
TypeLoc::withoutLoc(valueType),
3640-
CTP_CannotFail);
3641-
cs.cacheExprTypes(callExpr);
3642-
3643-
(void) invalid;
3644-
assert(!invalid && "conversion cannot fail");
3639+
auto resultTy = tc.typeCheckExpression(
3640+
callExpr, cs.DC, TypeLoc::withoutLoc(valueType), CTP_CannotFail);
3641+
assert(resultTy && "Conversion cannot fail!");
3642+
(void)resultTy;
36453643

3644+
cs.cacheExprTypes(callExpr);
36463645
E->setSemanticExpr(callExpr);
36473646
return E;
36483647
}
@@ -4537,13 +4536,12 @@ getCallerDefaultArg(ConstraintSystem &cs, DeclContext *dc,
45374536

45384537
// Convert the literal to the appropriate type.
45394538
auto defArgType = ownerFn->mapTypeIntoContext(defArg.second);
4540-
bool invalid = tc.typeCheckExpression(init, dc,
4541-
TypeLoc::withoutLoc(defArgType),
4542-
CTP_CannotFail);
4543-
cs.cacheExprTypes(init);
4539+
auto resultTy = tc.typeCheckExpression(
4540+
init, dc, TypeLoc::withoutLoc(defArgType), CTP_CannotFail);
4541+
assert(resultTy && "Conversion cannot fail");
4542+
(void)resultTy;
45444543

4545-
assert(!invalid && "conversion cannot fail");
4546-
(void)invalid;
4544+
cs.cacheExprTypes(init);
45474545

45484546
return {init, defArg.first};
45494547
}

‎lib/Sema/CSDiag.cpp

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -3357,7 +3357,7 @@ Expr *FailureDiagnosis::typeCheckChildIndependently(
33573357
// important, isn't itself sufficient because of AST mutation.
33583358
eraseOpenedExistentials(subExpr);
33593359

3360-
bool hadError = CS.TC.typeCheckExpression(
3360+
auto resultTy = CS.TC.typeCheckExpression(
33613361
subExpr, CS.DC, TypeLoc::withoutLoc(convertType), convertTypePurpose,
33623362
TCEOptions, listener, &CS);
33633363

@@ -3371,12 +3371,12 @@ Expr *FailureDiagnosis::typeCheckChildIndependently(
33713371

33723372
// If recursive type checking failed, then an error was emitted. Return
33733373
// null to indicate this to the caller.
3374-
if (hadError)
3374+
if (!resultTy)
33753375
return nullptr;
33763376

33773377
// If we type checked the result but failed to get a usable output from it,
33783378
// just pretend as though nothing happened.
3379-
if (subExpr->getType()->is<ErrorType>()) {
3379+
if (resultTy->is<ErrorType>()) {
33803380
subExpr = preCheckedExpr;
33813381
SavedTypeData.restore();
33823382
}

‎lib/Sema/TypeCheckConstraints.cpp

Lines changed: 25 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -1771,7 +1771,7 @@ namespace {
17711771
} // end anonymous namespace
17721772

17731773
#pragma mark High-level entry points
1774-
bool TypeChecker::typeCheckExpression(Expr *&expr, DeclContext *dc,
1774+
Type TypeChecker::typeCheckExpression(Expr *&expr, DeclContext *dc,
17751775
TypeLoc convertType,
17761776
ContextualTypePurpose convertTypePurpose,
17771777
TypeCheckExprOptions options,
@@ -1782,7 +1782,7 @@ bool TypeChecker::typeCheckExpression(Expr *&expr, DeclContext *dc,
17821782
// First, pre-check the expression, validating any types that occur in the
17831783
// expression and folding sequence expressions.
17841784
if (preCheckExpression(expr, dc))
1785-
return true;
1785+
return Type();
17861786

17871787
// Construct a constraint system from this expression.
17881788
ConstraintSystemOptions csOptions = ConstraintSystemFlags::AllowFixes;
@@ -1833,29 +1833,28 @@ bool TypeChecker::typeCheckExpression(Expr *&expr, DeclContext *dc,
18331833
SmallVector<Solution, 4> viable;
18341834
if (solveForExpression(expr, dc, convertType.getType(),
18351835
allowFreeTypeVariables, listener, cs, viable, options))
1836-
return true;
1836+
return Type();
18371837

18381838
// If the client allows the solution to have unresolved type expressions,
18391839
// check for them now. We cannot apply the solution with unresolved TypeVars,
18401840
// because they will leak out into arbitrary places in the resultant AST.
18411841
if (options.contains(TypeCheckExprFlags::AllowUnresolvedTypeVariables) &&
18421842
(viable.size() != 1 ||
18431843
(convertType.getType() && convertType.getType()->hasUnresolvedType()))) {
1844-
expr->setType(ErrorType::get(Context));
1845-
return false;
1844+
return ErrorType::get(Context);
18461845
}
18471846

18481847
auto result = expr;
18491848
auto &solution = viable[0];
18501849
if (listener) {
18511850
result = listener->foundSolution(solution, result);
18521851
if (!result)
1853-
return true;
1852+
return Type();
18541853
}
18551854

18561855
if (options.contains(TypeCheckExprFlags::SkipApplyingSolution)) {
18571856
cleanup.disable();
1858-
return false;
1857+
return cs.getType(expr);
18591858
}
18601859

18611860
// Apply the solution to the expression.
@@ -1866,7 +1865,7 @@ bool TypeChecker::typeCheckExpression(Expr *&expr, DeclContext *dc,
18661865
skipClosures);
18671866
if (!result) {
18681867
// Failure already diagnosed, above, as part of applying the solution.
1869-
return true;
1868+
return Type();
18701869
}
18711870

18721871
if (getLangOpts().DebugConstraintSolver) {
@@ -1879,7 +1878,7 @@ bool TypeChecker::typeCheckExpression(Expr *&expr, DeclContext *dc,
18791878
if (listener) {
18801879
result = listener->appliedSolution(solution, result);
18811880
if (!result) {
1882-
return true;
1881+
return Type();
18831882
}
18841883
}
18851884

@@ -1893,7 +1892,7 @@ bool TypeChecker::typeCheckExpression(Expr *&expr, DeclContext *dc,
18931892

18941893
expr = result;
18951894
cleanup.disable();
1896-
return false;
1895+
return cs.getType(expr);
18971896
}
18981897

18991898
Optional<Type> TypeChecker::
@@ -2241,12 +2240,9 @@ bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
22412240
if (skipApplyingSolution)
22422241
flags |= TypeCheckExprFlags::SkipApplyingSolution;
22432242

2244-
bool hadError = typeCheckExpression(initializer, DC, contextualType,
2245-
contextualPurpose,
2246-
flags,
2247-
&listener);
2248-
2249-
if (!hadError) {
2243+
auto resultTy = typeCheckExpression(initializer, DC, contextualType,
2244+
contextualPurpose, flags, &listener);
2245+
if (resultTy) {
22502246
TypeResolutionOptions options;
22512247
options |= TR_OverrideType;
22522248
options |= TR_InExpression;
@@ -2260,15 +2256,14 @@ bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
22602256
}
22612257
}
22622258

2263-
if (hadError && !initializer->getType())
2259+
if (!resultTy && !initializer->getType())
22642260
initializer->setType(ErrorType::get(Context));
22652261

22662262
// If the type of the pattern is inferred, assign error types to the pattern
22672263
// and its variables, to prevent it from being referenced by the constraint
22682264
// system.
2269-
if (hadError &&
2270-
(!pattern->hasType() ||
2271-
pattern->getType()->hasUnboundGenericType())) {
2265+
if (!resultTy &&
2266+
(!pattern->hasType() || pattern->getType()->hasUnboundGenericType())) {
22722267
pattern->setType(ErrorType::get(Context));
22732268
pattern->forEachVariable([&](VarDecl *var) {
22742269
// Don't change the type of a variable that we've been able to
@@ -2282,7 +2277,7 @@ bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
22822277
});
22832278
}
22842279

2285-
return hadError;
2280+
return !resultTy;
22862281
}
22872282

22882283
bool TypeChecker::typeCheckPatternBinding(PatternBindingDecl *PBD,
@@ -2484,7 +2479,8 @@ bool TypeChecker::typeCheckForEachBinding(DeclContext *dc, ForEachStmt *stmt) {
24842479
assert(seq && "type-checking an uninitialized for-each statement?");
24852480

24862481
// Type-check the for-each loop sequence and element pattern.
2487-
return typeCheckExpression(seq, dc, &listener);
2482+
auto resultTy = typeCheckExpression(seq, dc, &listener);
2483+
return !resultTy;
24882484
}
24892485

24902486
/// \brief Compute the rvalue type of the given expression, which is the
@@ -2545,9 +2541,11 @@ bool TypeChecker::typeCheckCondition(Expr *&expr, DeclContext *dc) {
25452541
// If this expression is already typechecked and has an i1 type, then it has
25462542
// already got its conversion from Boolean back to i1. Just re-typecheck
25472543
// it.
2548-
if (expr->getType() && expr->getType()->isBuiltinIntegerType(1))
2549-
return typeCheckExpression(expr, dc);
2550-
2544+
if (expr->getType() && expr->getType()->isBuiltinIntegerType(1)) {
2545+
auto resultTy = typeCheckExpression(expr, dc);
2546+
return !resultTy;
2547+
}
2548+
25512549
/// Expression type checking listener for conditions.
25522550
class ConditionListener : public ExprTypeCheckListener {
25532551
Expr *OrigExpr = nullptr;
@@ -2585,7 +2583,8 @@ bool TypeChecker::typeCheckCondition(Expr *&expr, DeclContext *dc) {
25852583
};
25862584

25872585
ConditionListener listener;
2588-
return typeCheckExpression(expr, dc, &listener);
2586+
auto resultTy = typeCheckExpression(expr, dc, &listener);
2587+
return !resultTy;
25892588
}
25902589

25912590
bool TypeChecker::typeCheckStmtCondition(StmtCondition &cond, DeclContext *dc,

‎lib/Sema/TypeCheckDecl.cpp

Lines changed: 11 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -3108,9 +3108,10 @@ static void checkEnumRawValues(TypeChecker &TC, EnumDecl *ED) {
31083108
// Check the raw value expr, if we have one.
31093109
if (auto *rawValue = elt->getRawValueExpr()) {
31103110
Expr *typeCheckedExpr = rawValue;
3111-
if (!TC.typeCheckExpression(typeCheckedExpr, ED,
3112-
TypeLoc::withoutLoc(rawTy),
3113-
CTP_EnumCaseRawValue)) {
3111+
auto resultTy = TC.typeCheckExpression(typeCheckedExpr, ED,
3112+
TypeLoc::withoutLoc(rawTy),
3113+
CTP_EnumCaseRawValue);
3114+
if (resultTy) {
31143115
elt->setTypeCheckedRawValueExpr(typeCheckedExpr);
31153116
}
31163117
lastExplicitValueElt = elt;
@@ -3125,9 +3126,9 @@ static void checkEnumRawValues(TypeChecker &TC, EnumDecl *ED) {
31253126
}
31263127
elt->setRawValueExpr(nextValue);
31273128
Expr *typeChecked = nextValue;
3128-
if (!TC.typeCheckExpression(typeChecked, ED,
3129-
TypeLoc::withoutLoc(rawTy),
3130-
CTP_EnumCaseRawValue))
3129+
auto resultTy = TC.typeCheckExpression(
3130+
typeChecked, ED, TypeLoc::withoutLoc(rawTy), CTP_EnumCaseRawValue);
3131+
if (resultTy)
31313132
elt->setTypeCheckedRawValueExpr(typeChecked);
31323133
}
31333134
prevValue = elt->getRawValueExpr();
@@ -8431,10 +8432,10 @@ void TypeChecker::addImplicitEnumConformances(EnumDecl *ED) {
84318432
if (elt->getTypeCheckedRawValueExpr()) continue;
84328433
Expr *typeChecked = elt->getRawValueExpr();
84338434
Type rawTy = ED->mapTypeIntoContext(ED->getRawType());
8434-
bool error = typeCheckExpression(typeChecked, ED,
8435-
TypeLoc::withoutLoc(rawTy),
8436-
CTP_EnumCaseRawValue);
8437-
assert(!error); (void)error;
8435+
auto resultTy = typeCheckExpression(
8436+
typeChecked, ED, TypeLoc::withoutLoc(rawTy), CTP_EnumCaseRawValue);
8437+
assert(resultTy);
8438+
(void)resultTy;
84388439
elt->setTypeCheckedRawValueExpr(typeChecked);
84398440
checkEnumElementErrorHandling(elt);
84408441
}

‎lib/Sema/TypeCheckStmt.cpp

Lines changed: 19 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -442,12 +442,11 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
442442
RS->isImplicit());
443443
}
444444

445-
auto hadTypeError = TC.typeCheckExpression(E, DC,
446-
TypeLoc::withoutLoc(ResultTy),
447-
CTP_ReturnStmt);
445+
auto exprTy = TC.typeCheckExpression(E, DC, TypeLoc::withoutLoc(ResultTy),
446+
CTP_ReturnStmt);
448447
RS->setResult(E);
449-
450-
if (hadTypeError) {
448+
449+
if (!exprTy) {
451450
tryDiagnoseUnnecessaryCastOverOptionSet(TC.Context, E, ResultTy,
452451
DC->getParentModule());
453452
}
@@ -463,7 +462,7 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
463462

464463
Type exnType = TC.getExceptionType(DC, TS->getThrowLoc());
465464
if (!exnType) return TS;
466-
465+
467466
TC.typeCheckExpression(E, DC, TypeLoc::withoutLoc(exnType), CTP_ThrowStmt);
468467
TS->setSubExpr(E);
469468

@@ -849,11 +848,10 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
849848
}
850849

851850
Stmt *visitSwitchStmt(SwitchStmt *S) {
852-
bool hadError = false;
853-
854851
// Type-check the subject expression.
855852
Expr *subjectExpr = S->getSubjectExpr();
856-
hadError |= TC.typeCheckExpression(subjectExpr, DC);
853+
auto resultTy = TC.typeCheckExpression(subjectExpr, DC);
854+
auto hadError = !resultTy;
857855
if (Expr *newSubjectExpr = TC.coerceToRValue(subjectExpr))
858856
subjectExpr = newSubjectExpr;
859857
S->setSubjectExpr(subjectExpr);
@@ -1261,8 +1259,8 @@ Stmt *StmtChecker::visitBraceStmt(BraceStmt *BS) {
12611259
if (isDiscarded)
12621260
options |= TypeCheckExprFlags::IsDiscarded;
12631261

1264-
bool hadTypeError = TC.typeCheckExpression(SubExpr, DC, TypeLoc(),
1265-
CTP_Unused, options);
1262+
auto resultTy =
1263+
TC.typeCheckExpression(SubExpr, DC, TypeLoc(), CTP_Unused, options);
12661264

12671265
// If a closure expression is unused, the user might have intended
12681266
// to write "do { ... }".
@@ -1275,7 +1273,7 @@ Stmt *StmtChecker::visitBraceStmt(BraceStmt *BS) {
12751273
TC.diagnose(CE->getStartLoc(), diag::brace_stmt_suggest_do)
12761274
.fixItInsert(CE->getStartLoc(), "do ");
12771275
}
1278-
} else if (isDiscarded && !hadTypeError)
1276+
} else if (isDiscarded && resultTy)
12791277
TC.checkIgnoredExpr(SubExpr);
12801278

12811279
elem = SubExpr;
@@ -1331,10 +1329,10 @@ static void checkDefaultArguments(TypeChecker &tc,
13311329
->changeResilienceExpansion(expansion);
13321330

13331331
// Type-check the initializer, then flag that we did so.
1334-
bool hadError = tc.typeCheckExpression(e, initContext,
1335-
TypeLoc::withoutLoc(param->getType()),
1336-
CTP_DefaultParameter);
1337-
if (!hadError) {
1332+
auto resultTy = tc.typeCheckExpression(
1333+
e, initContext, TypeLoc::withoutLoc(param->getType()),
1334+
CTP_DefaultParameter);
1335+
if (resultTy) {
13381336
param->setDefaultValue(e);
13391337
} else {
13401338
param->setDefaultValue(nullptr);
@@ -1422,9 +1420,11 @@ Expr* TypeChecker::constructCallToSuperInit(ConstructorDecl *ctor,
14221420
if (ctor->hasThrows())
14231421
r = new (Context) TryExpr(SourceLoc(), r, Type(), /*implicit=*/true);
14241422

1425-
if (typeCheckExpression(r, ctor, TypeLoc(), CTP_Unused,
1426-
TypeCheckExprFlags::IsDiscarded |
1427-
TypeCheckExprFlags::SuppressDiagnostics))
1423+
auto resultTy =
1424+
typeCheckExpression(r, ctor, TypeLoc(), CTP_Unused,
1425+
TypeCheckExprFlags::IsDiscarded |
1426+
TypeCheckExprFlags::SuppressDiagnostics);
1427+
if (!resultTy)
14281428
return nullptr;
14291429

14301430
return r;

‎lib/Sema/TypeChecker.cpp

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -918,12 +918,14 @@ bool swift::typeCheckExpression(DeclContext *DC, Expr *&parsedExpr) {
918918
auto &ctx = DC->getASTContext();
919919
if (ctx.getLazyResolver()) {
920920
TypeChecker *TC = static_cast<TypeChecker *>(ctx.getLazyResolver());
921-
return TC->typeCheckExpression(parsedExpr, DC);
921+
auto resultTy = TC->typeCheckExpression(parsedExpr, DC);
922+
return !resultTy;
922923
} else {
923924
// Set up a diagnostics engine that swallows diagnostics.
924925
DiagnosticEngine diags(ctx.SourceMgr);
925926
TypeChecker TC(ctx, diags);
926-
return TC.typeCheckExpression(parsedExpr, DC);
927+
auto resultTy = TC.typeCheckExpression(parsedExpr, DC);
928+
return !resultTy;
927929
}
928930
}
929931

0 commit comments

Comments
 (0)