static void typeCheckFunctionsAndExternalDecls(SourceFile &SF, TypeChecker &TC) {
unsigned currentFunctionIdx = 0;
unsigned currentExternalDef = TC.Context.LastCheckedExternalDefinition;
unsigned currentSynthesizedDecl = SF.LastCheckedSynthesizedDecl;
do {
// Type check conformance contexts.
for (unsigned i = 0; i != TC.ConformanceContexts.size(); ++i) {
auto decl = TC.ConformanceContexts[i];
if (auto *ext = dyn_cast<ExtensionDecl>(decl))
TC.checkConformancesInContext(ext, ext);
else {
auto *ntd = cast<NominalTypeDecl>(decl);
TC.checkConformancesInContext(ntd, ntd);
// Finally, we can check classes for missing initializers.
if (auto *classDecl = dyn_cast<ClassDecl>(ntd))
TC.maybeDiagnoseClassWithoutInitializers(classDecl);
}
}
TC.ConformanceContexts.clear();
// Type check the body of each of the function in turn. Note that outside
// functions must be visited before nested functions for type-checking to
// work correctly.
for (unsigned n = TC.definedFunctions.size(); currentFunctionIdx != n;
++currentFunctionIdx) {
auto *AFD = TC.definedFunctions[currentFunctionIdx];
TC.typeCheckAbstractFunctionBody(AFD);
}
// Synthesize any necessary function bodies.
// FIXME: If we're not planning to run SILGen, this is wasted effort.
while (!TC.FunctionsToSynthesize.empty()) {
auto function = TC.FunctionsToSynthesize.back().second;
TC.FunctionsToSynthesize.pop_back();
if (function.getDecl()->isInvalid() || TC.Context.hadError())
continue;
TC.synthesizeFunctionBody(function);
}
// Type check external definitions.
for (unsigned n = TC.Context.ExternalDefinitions.size();
currentExternalDef != n;
++currentExternalDef) {
auto decl = TC.Context.ExternalDefinitions[currentExternalDef];
if (auto *AFD = dyn_cast<AbstractFunctionDecl>(decl)) {
TC.typeCheckAbstractFunctionBody(AFD);
TC.checkFunctionErrorHandling(AFD);
continue;
}
if (auto nominal = dyn_cast<NominalTypeDecl>(decl)) {
(void)nominal->getAllConformances();
continue;
}
if (isa<VarDecl>(decl))
continue;
llvm_unreachable("Unhandled external definition kind");
}
// Complete any protocol requirement signatures that were delayed
// because the protocol was validated via validateDeclForNameLookup().
while (!TC.DelayedRequirementSignatures.empty()) {
auto decl = TC.DelayedRequirementSignatures.pop_back_val();
if (decl->isInvalid() || TC.Context.hadError())
continue;
TC.validateDecl(decl);
}
// Validate any referenced declarations for SIL's purposes.
// Note: if we ever start putting extension members in vtables, we'll need
// to validate those members too.
// FIXME: If we're not planning to run SILGen, this is wasted effort.
while (TC.NextDeclToFinalize < TC.DeclsToFinalize.size()) {
auto decl = TC.DeclsToFinalize[TC.NextDeclToFinalize++];
if (decl->isInvalid())
continue;
// If we've already encountered an error, don't finalize declarations
// from other source files.
if (TC.Context.hadError() &&
decl->getDeclContext()->getParentSourceFile() != &SF)
continue;
TC.finalizeDecl(decl);
}
// Type check synthesized functions and their bodies.
for (unsigned n = SF.SynthesizedDecls.size();
currentSynthesizedDecl != n;
++currentSynthesizedDecl) {
auto decl = SF.SynthesizedDecls[currentSynthesizedDecl];
TC.typeCheckDecl(decl);
}
// Ensure that the requirements of the given conformance are
// fully checked.
for (unsigned i = 0; i != TC.PartiallyCheckedConformances.size(); ++i) {
auto conformance = TC.PartiallyCheckedConformances[i];
TC.checkConformanceRequirements(conformance);
}
TC.PartiallyCheckedConformances.clear();
// Complete any conformances that we used.
for (unsigned i = 0; i != TC.UsedConformances.size(); ++i) {
auto conformance = TC.UsedConformances[i];
if (conformance->isIncomplete())
TC.checkConformance(conformance);
}
TC.UsedConformances.clear();
} while (currentFunctionIdx < TC.definedFunctions.size() ||
currentExternalDef < TC.Context.ExternalDefinitions.size() ||
currentSynthesizedDecl < SF.SynthesizedDecls.size() ||
!TC.FunctionsToSynthesize.empty() ||
TC.NextDeclToFinalize < TC.DeclsToFinalize.size() ||
!TC.ConformanceContexts.empty() ||
!TC.DelayedRequirementSignatures.empty() ||
!TC.UsedConformances.empty() ||
!TC.PartiallyCheckedConformances.empty());
// FIXME: Horrible hack. Store this somewhere more appropriate.
TC.Context.LastCheckedExternalDefinition = currentExternalDef;
SF.LastCheckedSynthesizedDecl = currentSynthesizedDecl;
// Now that all types have been finalized, run any delayed
// circularity checks.
// This has been written carefully to fail safe + finitely if
// for some reason a type gets re-delayed in a non-assertions
// build in an otherwise successful build.
// Types can be redelayed in a failing build because we won't
// type-check required declarations from different files.
for (size_t i = 0, e = TC.DelayedCircularityChecks.size(); i != e; ++i) {
TC.checkDeclCircularity(TC.DelayedCircularityChecks[i]);
assert((e == TC.DelayedCircularityChecks.size() ||
TC.Context.hadError()) &&
"circularity checking for type was re-delayed!");
}
TC.DelayedCircularityChecks.clear();
// Compute captures for functions and closures we visited.
for (AnyFunctionRef closure : TC.ClosuresWithUncomputedCaptures) {
TC.computeCaptures(closure);
}
TC.ClosuresWithUncomputedCaptures.clear();
for (AbstractFunctionDecl *FD : reversed(TC.definedFunctions)) {
TC.computeCaptures(FD);
}
// Check error-handling correctness for all the functions defined in
// this file. This can depend on all of their interior function
// bodies having been type-checked.
for (AbstractFunctionDecl *FD : TC.definedFunctions) {
TC.checkFunctionErrorHandling(FD);
}
TC.definedFunctions.clear();
}
