Rework flow analysis of == and !=.
#1134
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
Previously, we specified flow states `null()` and `nonNull()` (similar to `true()` and `false()`), and the special behaviors of `== null` and `!= null` checks fell out of a general analysis of `E1 == E2`. But it didn't work in practice, because it required doing joins like `join(null(E1), null(E2))`, which isn't sound in general (because it carries the flow control implication that either E1 or E2 is evaluated but not both). Because of these problems, the implementation never matched this specification, and instead used ad-hoc pattern matching to recognize `== null` and `!= null`. In the new formulation, we remove the flow states `null()` and `nonNull()` and retain the ad-hoc pattern matching for `== null` and `!= null`, consistent with the current implementation. However, we also add cases to recognize when an equality test is guaranteed to evaluate to `true` or `false`; this addresses dart-lang/sdk#41985 and ensures that we recognize dead code associated with unnecessary null checks.
|
I will follow up with an implementation change that brings the implementation in line with these spec changes. A few small changes to the Flutter SDK will be necessary, to ignore dead code warnings that result from the fact that dead code analysis now detects unnecessary null checks. |
|
Implementation change: https://dart-review.googlesource.com/c/sdk/+/155926 |
13 tasks
|
Necessary Flutter changes are here: flutter/flutter#63007 |
munificent
approved these changes
Aug 7, 2020
eernstg
approved these changes
Aug 7, 2020
dart-bot
pushed a commit
to dart-lang/sdk
that referenced
this pull request
Aug 14, 2020
The new logic classifies the LHS and RHS of the equality check as either null, non-nullable, or potentially nullable, and then either promotes, treats the expression as equivalent to a boolean, or does nothing, as appropriate. This means, for example, that a comparison between a non-nullable value and `null` is now known to evaluate to `true` for reachability analysis. Note: as part of this change, it was tempting to trigger promotion whenever a varialbe is equality compared to an expression of type `Null`, but this would be unsound (consider `(int? x) => x == (x = null) ? true : x.isEven`). So we still only promote when the variable is compared to a literal `null`. Fixes #41985. There's a corresponding spec change out for review: dart-lang/language#1134 Change-Id: Id7f1d4eaa3b0fa57124445bb8352eef32c304feb Bug: #41985 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/155926 Reviewed-by: Konstantin Shcheglov <[email protected]> Reviewed-by: Johnni Winther <[email protected]>
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.
Previously, we specified flow states
null()andnonNull()(similarto
true()andfalse()), and the special behaviors of== nulland!= nullchecks fell out of a general analysis ofE1 == E2. But itdidn't work in practice, because it required doing joins like
join(null(E1), null(E2)), which isn't sound in general (because itcarries the flow control implication that either E1 or E2 is evaluated
but not both). Because of these problems, the implementation never
matched this specification, and instead used ad-hoc pattern matching
to recognize
== nulland!= null.In the new formulation, we remove the flow states
null()andnonNull()and retain the ad-hoc pattern matching for== nulland!= null, consistent with the current implementation. However, wealso add cases to recognize when an equality test is guaranteed to
evaluate to
trueorfalse; this addressesdart-lang/sdk#41985 and ensures that we
recognize dead code associated with unnecessary null checks.