void TypeChecker::markInvalidGenericSignature(ValueDecl *VD) {
GenericParamList *genericParams;
if (auto *AFD = dyn_cast<AbstractFunctionDecl>(VD))
genericParams = AFD->getGenericParams();
else
genericParams = cast<GenericTypeDecl>(VD)->getGenericParams();
// If there aren't any generic parameters at this level, we're done.
if (genericParams == nullptr)
return;
DeclContext *DC = VD->getDeclContext();
ArchetypeBuilder builder = createArchetypeBuilder(DC->getParentModule());
if (auto sig = DC->getGenericSignatureOfContext())
builder.addGenericSignature(sig, true);
// Visit each of the generic parameters.
for (auto param : *genericParams)
builder.addGenericParameter(param);
// Wire up the archetypes.
for (auto GP : *genericParams)
GP->setArchetype(builder.getArchetype(GP));
genericParams->setAllArchetypes(
Context.AllocateCopy(builder.getAllArchetypes()));
}
/// Add the generic parameters and requirements from the parent context to the
/// archetype builder.
static void addContextParamsAndRequirements(ArchetypeBuilder &builder,
DeclContext *dc,
bool adoptArchetypes) {
if (!dc->isTypeContext())
return;
if (auto sig = dc->getGenericSignatureOfContext()) {
// Add generic signature from this context.
builder.addGenericSignature(sig, adoptArchetypes);
}
}
GenericSignature *TypeChecker::validateGenericSignature(
GenericParamList *genericParams,
DeclContext *dc,
GenericSignature *outerSignature,
std::function<bool(ArchetypeBuilder &)> inferRequirements,
bool &invalid) {
assert(genericParams && "Missing generic parameters?");
// Create the archetype builder.
Module *module = dc->getParentModule();
ArchetypeBuilder builder = createArchetypeBuilder(module);
if (outerSignature)
builder.addGenericSignature(outerSignature, true);
// Type check the generic parameters, treating all generic type
// parameters as dependent, unresolved.
DependentGenericTypeResolver dependentResolver(builder);
if (checkGenericParamList(&builder, genericParams, dc,
false, &dependentResolver)) {
invalid = true;
}
/// Perform any necessary requirement inference.
if (inferRequirements && inferRequirements(builder)) {
invalid = true;
}
// Finalize the generic requirements.
(void)builder.finalize(genericParams->getSourceRange().Start);
// The archetype builder now has all of the requirements, although there might
// still be errors that have not yet been diagnosed. Revert the signature
// and type-check it again, completely.
revertGenericParamList(genericParams);
CompleteGenericTypeResolver completeResolver(*this, builder);
if (checkGenericParamList(nullptr, genericParams, dc,
false, &completeResolver)) {
invalid = true;
}
// The generic signature is complete and well-formed. Gather the
// generic parameter types at all levels.
SmallVector<GenericTypeParamType *, 4> allGenericParams;
collectGenericParamTypes(genericParams, dc, allGenericParams);
// Collect the requirements placed on the generic parameter types.
// FIXME: This ends up copying all of the requirements from outer scopes,
// which is mostly harmless (but quite annoying).
SmallVector<Requirement, 4> requirements;
collectRequirements(builder, allGenericParams, requirements);
// Record the generic type parameter types and the requirements.
auto sig = GenericSignature::get(allGenericParams, requirements);
// Debugging of the archetype builder and generic signature generation.
if (Context.LangOpts.DebugGenericSignatures) {
dc->printContext(llvm::errs());
llvm::errs() << "\n";
builder.dump(llvm::errs());
llvm::errs() << "Generic signature: ";
sig->print(llvm::errs());
llvm::errs() << "\n";
llvm::errs() << "Canonical generic signature: ";
sig->getCanonicalSignature()->print(llvm::errs());
llvm::errs() << "\n";
llvm::errs() << "Canonical generic signature for mangling: ";
sig->getCanonicalManglingSignature(*dc->getParentModule())
->print(llvm::errs());
llvm::errs() << "\n";
}
return sig;
}