Do not rewrite supertypes in AbstractTypeRefining #7720
Merged
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
kripken
reviewed
Jul 14, 2025
src/passes/AbstractTypeRefining.cpp
Outdated
| // supertype, which is not allowed. We could fix this by walking up the | ||
| // supertype chain to find a supertype that is not being rewritten, but | ||
| // changing subtype relationships and keep descriptor chains valid is | ||
| // nontrivial. Instead, avoid changing subtype relationships entirely. |
There was a problem hiding this comment.
Suggested change
| // nontrivial. Instead, avoid changing subtype relationships entirely. | |
| // nontrivial. Instead, avoid changing subtype relationships entirely: | |
| // leave that for Unsubtyping. |
src/passes/AbstractTypeRefining.cpp
Outdated
| // C. But if we rewrote C's supertype, C would declare itself to be its own | ||
| // supertype, which is not allowed. We could fix this by walking up the | ||
| // supertype chain to find a supertype that is not being rewritten, but | ||
| // changing subtype relationships and keep descriptor chains valid is |
There was a problem hiding this comment.
Suggested change
| // changing subtype relationships and keep descriptor chains valid is | |
| // changing subtype relationships and keeping descriptor chains valid is |
| } | ||
| return super; | ||
| // We do not want to update subtype relationships. | ||
| return oldType.getDeclaredSuperType(); |
There was a problem hiding this comment.
This is identical to the function being overridden, so it can be removed. We do not need to declare AbstractTypeRefiningTypeMapper at all, I think.
There was a problem hiding this comment.
No, the function being overridden will rewrite the supertype according to the type mapping.
There was a problem hiding this comment.
Oh right, TypeMapper overrides GlobalTypeRewriter... I looked too far back, sorry.
Speed up Unsubtyping by over 2x via algorithmic and other improvements. The most expensive part of the Unsubtyping analysis is the handling of casts. For each cast source and destination pair, each type that remains a subtype of the source and was originally a subtype of the destination must remain a subtype of the destination for the cast to continue succeeding. Previously, Unsubtyping analyzed these cast relationships for all types as a single unit of work whenever it reached a fixed point from examining other sources of subtyping constraints. This led to duplicated work because the subtype, cast source, and cast destination triples analyzed once would be analyzed again the next time casts were considered. Avoid this duplicated cast analysis by incrementally analyzing casts whenever a new subtyping is discovered. Maintain the invariant that each new subtyping either joins a subtyping tree rooted at the discovered subtype into the discovered supertype's tree, or reparents the subtype below some (possibly indirect) subtype of its old parent. In the former case, the subtype and all of its descendents are evaluated against all casts originating from all their new supertypes in the tree they have joined. In the latter case, they must already have been evaluated against all casts originating at the old supertype and its ancestors, so they need only to be evaluated against their new supertypes up to the old supertype. Once a particular type is evaluated against casts originating from a particular supertype, that type will never be evaluated against those casts again. This algorithmic improvement accounts for most of the speedup. The rest of the speedup is from doing less work while collecting the initial subtyping constraints in a parallel function analysis. The old implementation used an instance of Unsubtyping to collect constraints in each function, which would end up doing some analysis to find additional constraints. The new implementation does not do any analysis of transitively required constraints during the initial parallel function analysis.
Keeping descriptor chains valid while rewriting subtyping is complicated. Make it simpler to optimize descriptor and described types in a future PR by not rewriting supertypes at all in AbstractTypeRefining. To avoid losing optimization power in the default optimization pipelines, run Unsubtyping after AbstractTypeRefining. This makes -O3 slightly faster when optimizing Sheets calcengine (possibly because having fewer subtype relationships leads to less work in later optimizations) and improves code size by 0.1%. The improvements increase when running -O3 -O3, with a 1.7% code size improvement relative to the same pipeline before this change.
tlively
force-pushed
the
abstract-type-refining-desc
branch
from
ff51aee to
f422c68
Compare
tlively
changed the title
|
Note to self: review tests for staleness. |
kripken
approved these changes
Jul 21, 2025
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.
Keeping descriptor chains valid while rewriting subtyping is
complicated. Make it simpler to optimize descriptor and described types
in a future PR by not rewriting supertypes at all in
AbstractTypeRefining.
To avoid losing optimization power in the default optimization
pipelines, run Unsubtyping after AbstractTypeRefining. This makes -O3
slightly faster when optimizing Sheets calcengine (possibly because
having fewer subtype relationships leads to less work in later
optimizations) and improves code size by 0.1%. The improvements increase
when running -O3 -O3, with a 1.7% code size improvement relative to the
same pipeline before this change.