i22587 Divergence check for Match Types #24661
Draft
+125
−1
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
bishabosha
reviewed
Dec 4, 2025
| case AnyVal => Wrap[List[Int]] | ||
|
|
||
| @main def test03(): Unit = | ||
| val e1: Wrap[Int] = ??? // error |
Member
There was a problem hiding this comment.
List[Int] is not AnyVal , so then it stops there right?
Contributor
Author
There was a problem hiding this comment.
You're absolutely right. I've fixed the test case.
The divergence check currently applies even to match types that do not strictly reduce (stuck matches). Instead of simply stopping and returning NoType (or the stuck type), the algorithm detects the increasing size of the scrutinee and correctly returns an ErrorType.
Thanks for the catch! I would have missed that otherwise.
This is the first step towards implementing the full divergence check algorithm for Match Types. The logic enforces that recursive reduction steps must have a strictly smaller size than the sum of the type sizes of the scrutinee. This check applies to match types during reduction as well as those that do not reduce. When the algorithm detects a non-decreasing size, it returns an ErrorType to prevent infinite recursion. This work is part of the research project specified by Martin Odersky in issue scala#22587.
Lluc24
force-pushed
the
i22587-divergence-check-MT
branch
from
7de6009 to
3423338
Compare
This commit relaxes the previous strict size-decreasing constraint for
Match Type reduction, allowing for more expressive recursive types while
maintaining termination guarantees.
Key changes:
1. Lexicographical Comparison: Instead of comparing the sum of argument
sizes, the algorithm now compares the list of argument sizes
lexicographically. This provides a more precise metric for progress.
2. Bounded Variation: Reductions are no longer required to strictly
decrease in size at every step. Same-size reductions are now allowed,
provided the sequence of arguments has not been seen before in the
current reduction chain (cycle detection).
3. History Stack: A stack of previously seen argument lists is maintained
for the current size baseline.
- If size strictly decreases: The stack is cleared (progress made).
- If size increases: An ErrorType is returned (divergence).
- If size is equal: The arguments are checked against the stack.
Repeating arguments trigger a cycle error; new arguments are added
to the stack.
Since the number of type combinations is finite, disallowing growth
while preventing cycles guarantees the algorithm will eventually terminate.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
2 participants
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.
Closes #22587: Implement Divergence Checking for Match Types
StackOverflowErrorto handle infinite recursion, which is unsafe and slow.ApplyTypesandMatchTypes.Propertyin theContextto track the history of types currently being reduced.Error Typewhen divergence is detected.