[Evaluator] Separate formation of a request from evaluation of that request #17643
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
…ached(). We had duplicated logic for stats recording and pretty stack traces, including missing one pretty stack trace. Eliminate duplication.
…te table. The bundling of the form of a request (e.g., the storage that makes up a request) with the function that evaluates the request value requires us to perform ad hoc indirection to address the AST —> Sema layering violation. For example, ClassDecl::getSuperclass() calls through the LazyResolver (when available) to form the appropriate request. This means that we cannot use the the request-evaluator’s cache when LazyResolver is null, forcing all cached state into the AST. Provide the evaluator with a zone-based registration system, where each request “zone” (e.g., the type checker’s requests) registers callbacks to evaluate each kind of request within that zone. The evaluator indirects through this table of function pointers, allowing the request classes themselves to be available at a lower level (AST) than the functions that perform the computation when the value isn’t in the cache (e.g., Sema). We are not taking advantage of the indirection yet; that’ll come in a follow-up commit.
Sink the type checker request classes into the AST library, so that various functions in the AST library can form type-checking requests. The actual evaluator functions for these requests continue to live in the Sema library, called via indirection through the function pointer tables registered with the request-evaluator.
Rather than call through the LazyResolver (when available) to satisfy queries that may require type checking, call into the evaluator directly: it will make use of the type checker (via the lazy resolver) when necessary. This change should allow us to use the request-evaluator’s cache for state rather than mutable AST state, as well as the ability to see requests that were evaluated after type checking.
|
@swift-ci please smoke test |
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.
The bundling of the form of a request (e.g., the storage that makes up a request)
with the function that evaluates the request value requires us to perform
ad hoc indirection to address the AST —> Sema layering violation. For
example,
ClassDecl::getSuperclass()calls through theLazyResolver(whenavailable) to form the appropriate request. This means that we cannot
use the the request-evaluator’s cache when
LazyResolveris NULL, forcingall cached state into the AST.
Provide the evaluator with a zone-based registration system, where each
request “zone” (e.g., the type checker’s requests) registers
callbacks to evaluate each kind of request within that zone. The
evaluator indirects through this table of function pointers, allowing
the request classes themselves to be available at a lower level (AST)
than the functions that perform the computation when the value isn’t
in the cache (e.g., Sema).
Leverage this separation so that the AST library can form type-check requests, which are evaluated by the Sema library. We'll still end up jumping through the
LazyResolverwhen we need the type checker... but it's much more localized, and only happens in the "no cached result yet" case.