void
TypeChecker::validateGenericSubscriptSignature(SubscriptDecl *subscript) {
auto *dc = subscript->getDeclContext();
GenericSignature *sig;
if (auto *gp = subscript->getGenericParams()) {
gp->setOuterParameters(dc->getGenericParamsOfContext());
prepareGenericParamList(gp, subscript);
// Create the generic signature builder.
GenericSignatureBuilder builder(Context);
// Type check the function declaration, treating all generic type
// parameters as dependent, unresolved.
checkGenericSubscriptSignature(*this, &builder, subscript,
TypeResolution::forStructural(subscript));
// The generic subscript signature is complete and well-formed. Determine
// the type of the generic subscript.
sig =
std::move(builder).computeGenericSignature(subscript->getLoc());
// The generic signature builder now has all of the requirements, although
// there might still be errors that have not yet been diagnosed. Revert the
// generic function signature and type-check it again, completely.
revertGenericSubscriptSignature(subscript);
revertGenericParamList(*this, gp);
// Debugging of generic signature generation.
if (Context.LangOpts.DebugGenericSignatures) {
subscript->dumpRef(llvm::errs());
llvm::errs() << "\n";
llvm::errs() << "Generic signature: ";
sig->print(llvm::errs());
llvm::errs() << "\n";
llvm::errs() << "Canonical generic signature: ";
sig->getCanonicalSignature()->print(llvm::errs());
llvm::errs() << "\n";
}
subscript->setGenericEnvironment(sig->createGenericEnvironment());
} else {
// Inherit the signature of our environment.
sig = dc->getGenericSignatureOfContext();
subscript->setGenericEnvironment(dc->getGenericEnvironmentOfContext());
}
checkGenericSubscriptSignature(*this, nullptr, subscript,
TypeResolution::forInterface(subscript, sig));
subscript->computeType();
}
GenericEnvironment *TypeChecker::checkGenericEnvironment(
GenericParamList *genericParams,
DeclContext *dc,
GenericSignature *parentSig,
bool allowConcreteGenericParams,
ExtensionDecl *ext,
llvm::function_ref<void(GenericSignatureBuilder &)>
inferRequirements,
bool mustInferRequirements) {
assert(genericParams && "Missing generic parameters?");
bool recursivelyVisitGenericParams =
genericParams->getOuterParameters() && !parentSig;
GenericSignature *sig;
if (!ext || mustInferRequirements || ext->getTrailingWhereClause() ||
getExtendedTypeGenericDepth(ext) != genericParams->getDepth()) {
// Collect the generic parameters.
SmallVector<GenericTypeParamType *, 4> allGenericParams;
if (recursivelyVisitGenericParams) {
visitOuterToInner(genericParams,
[&](GenericParamList *gpList) {
addGenericParamTypes(gpList, allGenericParams);
});
} else {
if (parentSig) {
allGenericParams.append(parentSig->getGenericParams().begin(),
parentSig->getGenericParams().end());
}
addGenericParamTypes(genericParams, allGenericParams);
}
// Create the generic signature builder.
GenericSignatureBuilder builder(Context);
// Type check the generic parameters, treating all generic type
// parameters as dependent, unresolved.
if (recursivelyVisitGenericParams) {
visitOuterToInner(genericParams,
[&](GenericParamList *gpList) {
auto genericParamsDC = gpList->begin()[0]->getDeclContext();
TypeResolution structuralResolution =
TypeResolution::forStructural(genericParamsDC);
checkGenericParamList(*this, &builder, gpList, nullptr,
structuralResolution);
});
} else {
auto genericParamsDC = genericParams->begin()[0]->getDeclContext();
TypeResolution structuralResolution =
TypeResolution::forStructural(genericParamsDC);
checkGenericParamList(*this, &builder, genericParams, parentSig,
structuralResolution);
}
/// Perform any necessary requirement inference.
inferRequirements(builder);
// Record the generic type parameter types and the requirements.
sig = std::move(builder).computeGenericSignature(
genericParams->getSourceRange().Start,
allowConcreteGenericParams);
// The generic signature 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.
if (recursivelyVisitGenericParams) {
visitOuterToInner(genericParams,
[&](GenericParamList *gpList) {
revertGenericParamList(*this, gpList);
});
} else {
revertGenericParamList(*this, genericParams);
}
// Debugging of the generic signature builder and generic signature
// generation.
if (Context.LangOpts.DebugGenericSignatures) {
dc->printContext(llvm::errs());
llvm::errs() << "\n";
llvm::errs() << "Generic signature: ";
sig->print(llvm::errs());
llvm::errs() << "\n";
llvm::errs() << "Canonical generic signature: ";
sig->getCanonicalSignature()->print(llvm::errs());
llvm::errs() << "\n";
}
} else {
// Re-use the signature of the type being extended.
sig = ext->getSelfNominalTypeDecl()->getGenericSignatureOfContext();
}
if (recursivelyVisitGenericParams) {
visitOuterToInner(genericParams,
[&](GenericParamList *gpList) {
auto paramsDC = gpList->getParams().front()->getDeclContext();
TypeResolution interfaceResolution =
TypeResolution::forInterface(paramsDC, sig);
checkGenericParamList(*this, nullptr, gpList, nullptr,
interfaceResolution);
});
} else {
auto paramsDC = genericParams->getParams().front()->getDeclContext();
TypeResolution interfaceResolution =
TypeResolution::forInterface(paramsDC, sig);
checkGenericParamList(*this, nullptr, genericParams, parentSig,
interfaceResolution);
}
// Form the generic environment.
return sig->createGenericEnvironment();
}
