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(); }