JLS primitive type in patterns draft
Maurizio Cimadamore
maurizio.cimadamore at oracle.com
Mon Oct 2 16:44:27 UTC 2023
Hi Aggelos, I did a pass on the primitive pattern JEP:
https://cr.openjdk.org/~abimpoudis/instanceof/instanceof-20230913/specs/instanceof-jls.html
Here are some comments:
* `A widening primitive conversion of a byte to an int is
unconditionally exact. Any value that b holds is representable exactly
in an int. As a result, the value of i will always represent, exactly
the same information that the variable b holds:`
Here it is not very clear where does "b" comes from. It is shown in the
code snippet, of course, but the text reads funny because it comes
before the snippet. One simple fix would be to move the snippet around:
```
A widening primitive conversion of a byte to an int is unconditionally
exact:
byte b = ...
int i = (int) b;
Any value that b holds is representable exactly in an int. As a result,
the value of i will always represent, exactly the same information that
the variable b holds.
```
* `A conversion C from a type S to a type P for a value x is exact if
...` - I presume you mean that "x" has type S ? If so, would be helpful
to spell it out clearly?
* `... then |C| is exact if the run-time test |S instanceof P| returns
|true|.` - should't this be `x instanceof P` ?
* In general, when you deal with multiple conversions (e.g. boxing
followed by narrowing followed by XYZ), it is not clear to me that it's
worth spelling out all of the combinations? You have defined when a
widening is exact. And, we are also defining when an unboxing is exact
(e.g. if the source object is not null). Boxing is always exact. As for
narrowing you are defining that using instanceof. So... can't we just
say that any conversion that is composed of multiple exact conversions
is itself exact? (if so, the text can be simplified quite a bit?)
* `... if |S| and |P| are both integral types and either of them is
|char|,` isn't it the case that this must also be a narrowing
conversion? Because if it's widening you already have said that going
from any integral to any integral is also exact.
* `Otherwise, if both S and P are primitive types, then:` - does this
section have to spell out all cases? Or can we say that, again we just
issue `x instanceof P` and then we explain how this behaves somewhere
else (e.g. in chapter 15) ?
* `An inexact conversion may either result in an exception and will not
yield any value or may in no exceptions and will yield a value. In the
latter case, loss of information has occured.` - this sentence seems to
have some issues, especially in the second part (missing "result"?)
* `The narrowing reference conversion` -> `A narrowing reference
conversion` (same for the para below)
* `/P/ contains a pattern with a primitive type /p` /where do we say
that e.g. `int x` covers `int` ? This para seems to be about boxing
* In 14.11.1.2, I see many references to "T", which is not introduced in
this section
* "then the result is true if the value of the RelationalExpression
could be cast to the primitive type exactly, and false otherwise." Maybe
add a reference to the section on exact conversion?
Cheers
Maurizio
//
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://mail.openjdk.org/pipermail/amber-spec-experts/attachments/20231002/c452cc8e/attachment.htm>
More information about the amber-spec-experts
mailing list