This PR is a prototype to stimulate discussion of
[JDK-8261669](https://bugs.openjdk.org/browse/JDK-8261669), which seeks to add
more warnings when an implicit cast of a primitive value might lose
information. This can possibly happen when converting an `int` to `float`, or
when converting a `long` to `float` or `double`. Java does not require an
explicit cast for such assignments, even though they may result in information
loss.
I'm interested in feedback both on whether this is a good idea and also the
approach taken - thanks!
Currently, we generate this warning, but only for assignment operators, e.g.:
int x = 0;
x += 1.0f; // warning here
This PR would add warnings for two additional cases, (a) regular assignments
and (b) method parameters, e.g.:
void method(float f) { }
...
float a = 0x10000001; // warning here
method(0x10000001); // warning here
It would _not_ generate a warning in cases (a) and (b) when the value is a
constant value and we can determine that no information would be lost, e.g.:
float f1 = 0x10000000; // no warning here
The definition of "no information would be lost" is that a round trip results
in the same value, e.g., `(int)(float)x == x`. In the examples above,
`0x10000000` survives the round trip but `0x10000001` does not.
As usual, warnings can be suppressed via `@SuppressWarnings` or by adding an
explicit cast:
float a = (float)0x10000001; // no warning here
-------------
Commit messages:
- Warn for more widening primitive conversions that lose information.
Changes: https://git.openjdk.org/jdk/pull/23718/files
Webrev: https://webrevs.openjdk.org/?repo=jdk&pr=23718&range=00
Issue: https://bugs.openjdk.org/browse/JDK-8261669
Stats: 187 lines in 15 files changed: 149 ins; 0 del; 38 mod
Patch: https://git.openjdk.org/jdk/pull/23718.diff
Fetch: git fetch https://git.openjdk.org/jdk.git pull/23718/head:pull/23718
PR: https://git.openjdk.org/jdk/pull/23718
