[Archetype builder] Make archetype construction more lazy #6007
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This eliminates the really gross registration of archetype builders within the ASTContext, and is another little step toward lazily constructing archetypes.
…ater. Force archetypes to be created when forming the generic environment, making the operation slightly more lazy.
…n function The "core" data structure used to record the substitutions to be performed is a TypeSubstitutionMap, which is a DenseMap. This is a fairly heavyweight, static data structure for something where * We occasionally want a more dynamic, lazily-populated data structure, and * We can usually provide more efficient storage than a DenseMap. So, introduce a Type::subst() variant that takes a TypeSubstitutionFn, which is just a function that maps a SubstitutableType * to a Type (or nothing). Use this as the core variant of subst(). with an adapter for existing TypeSubstitutionMaps. Over time, TypeSubstitutionMap should go away.
Rather than storing a heavyweight DenseMap for the mapping from interface types (which are always generic type parameters) to their corresponding context types, tail-allocate the array of context types as an array parallel to the generic type parameters array. Use GenericParamKey's lookup facilities and the new type-substitution-function-based version of Type::subst() to handle queries efficiently.
Teach GenericEnvironment to lazily populate its mapping from generic parameters to context types when queried (e.g., during substitutition) rather than assuming that will be pre-populated before any queries occur. We're still forcing all of the archetypes when the generic environment is created by the archetype builder; baby steps!
…o-context. Now that the generic environment is lazily populated (within ArchetypeBuilder::getGenericEnvironment(), of course!), we can use a normal Type::subst() to map interface types recorded within the potential archetypes into a particular environment.
Silences a warning on newer Clang versions.
|
@swift-ci please smoke test and merge |
This code was trying and failing to solve a problem that we do not have. The "problem" would have been that archetypes show up in superclass constraints, and the attempted solution---mapping them out to interface types---wouldn't actually work because resolveArchetype() doesn't work that way.
|
@swift-ci please smoke test and merge |
1 similar comment
|
@swift-ci please smoke test and merge |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Another checkpoint along the road toward lazily-constructed archetypes, which includes:
GenericEnvironmenthow to use anArchetypeBuilderto lazily fill in context types, rather than computing them prior to creation of theGenericEnvironment.ArchetypeBuilder::getGenericEnvironment(). To make it truly lazy, we need the archetype builder to persist for the life of the AST (which requires still more work)Type::transform().Type::subst()that uses an arbitrary callback to map substitutable types to their replacement types, which is necessary when the mapping might be lazily constructed (seeGenericEnvironment's use ofType::subst().Type::subst()makes it easy to introduce alternate storage mechanisms for the substitutable type -> replacement type mapping, so use a tail-allocated flat array of context types inGenericEnvironmentthat is parallel with the generic parameters list.