Add TDD tests for CFG-based type narrowing #4378
Open
+711
−2
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
Add failing test and fixture for flow-sensitive type narrowing that will pass once CFG integration is implemented in the type checker. Covers isinstance narrowing, None narrowing, negative narrowing in else branches, join-point type restoration, and chained elif narrowing.
Add stack-based type narrowing to the type checker that narrows union
types inside conditional branches (isinstance, is None, is not None).
Types widen back at join points after if/else blocks.
- Add narrowing_stack, get_narrowed_type, extract_narrowing_predicates,
and exclude_type_from_union to TypeEvaluator
- Modify type expression cache to bypass for Name nodes under narrowing
- Add enter/exit handlers for IfStmt, ElseIf, ElseStmt in TypeCheckPass
- Support early-return narrowing (if x is None { return; } -> x is non-None)
- Support elif chain narrowing with cumulative type exclusion
Replace the stack-based narrowing approach with a demand-driven backward CFG walk that uses bb_in/bb_out edges already built by CFGBuildPass. This provides a robust foundation for production-grade flow-sensitive type checking. Key changes: - Add NarrowingPredicate to represent narrowing operations declaratively - Implement _compute_narrowed_at for recursive backward CFG traversal - Implement _classify_edge to infer true/false from unlabeled CFG edges - Implement _find_predicate_for to pattern-match isinstance/is None guards - Implement _apply_narrowing for positive and negative type exclusion - Remove 6 enter/exit handlers for if_stmt, else_if, else_stmt from TypeCheckPass (narrowing is now fully in the evaluator) - Remove narrowing_stack and early_return_narrowing_depth The CFG approach handles elif chains, early returns, and join-point widening naturally through graph structure rather than stack manipulation.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
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.
Summary
test_type_narrowing) and fixture (checker_type_narrowing.jac) that will pass once CFG-based type narrowing is implemented in the type checkeris not None,is None+ early return, join-point type restoration, and chained elif narrowingd: Dog = animal) to verify narrowed types, since union member access is currently lenientDetails
The fixture currently produces 11 type errors because the type checker does not use the CFG for flow-sensitive analysis. After narrowing is implemented, 10 of those errors should disappear — only the join-point assignment (
fail: Dog = animalafter an if/else whereanimalisDog | Cat) should remain.Test plan