RFR: 8332463: Byte conditional pattern case element dominates short constant case element

[David Alayachew]

Got it, ty vm.

I had assumed that Byte to Integer was already implemented logic. I had
heard that discussion in Valhalla many times.

Ok, makes perfect sense now. So, when Valhalla reevaluates the relationship
between the various wrapper classes, this might change?

On Wed, May 22, 2024 at 5:41 AM Aggelos Biboudis <abimpoudis at openjdk.org>
wrote:

> On Mon, 20 May 2024 08:26:43 GMT, Aggelos Biboudis <abimpoudis at openjdk.org>
> wrote:
>
> > It seems that the compiler introduced a rule that does not exist in the
> spec. The fix is simple, and it will fix the behaviour of JDK 23 according
> to the spec. For example the following is accepted by JDK 22 and needs to
> continue to be accepted by JDK 23:
> >
> >
> > public static int test() {
> >     Byte i = (byte) 42;
> >     return switch (i) {
> >         case Byte ib   -> 1;
> >         case (short) 0 -> 2; // OK - not dominated
> >     };
> > }
> >
> >
> > Similarly for primitive type patterns:
> >
> >
> > public static int test() {
> >     Byte i = (byte) 42;
> >     return switch (i) {
> >         case Byte ib  -> 1;
> >         case short s  -> 2; // Also not dominated since there is no
> unconditionally exact conversion from short to Byte
> >     };
> > }
> >
> > public static int test() {
> >     int i = 42;
> >     return switch (i) {
> >         case Integer ib -> 1;
> >         case byte ip    -> 2; // Also not dominated since there is no
> unconditionally exact conversion from byte to Integer
> >     };
> > }
>
> While `byte` --> `Byte` is boxing indeed, `Byte` --> `Integer` is  not a
> widening reference conversion. From the spec:
>
> > A widening reference conversion exists from any reference type S to any
> reference type T, provided S is a subtype of T (§4.10).
>
> and
>
> > A class or interface is disjoint from another class or interface if it
> can be determined statically that they have no instances in common (other
> than the null value)
>
> The two reference types in the second conversion are disjoint. Evident
> that you cannot even ask if a Byte is instanceof Integer.
>
>
> jshell> Byte b = 42
> b ==> 42
>
> jshell> b instanceof Integer
> |  Error:
> |  incompatible types: java.lang.Byte cannot be converted to
> java.lang.Integer
> |  b instanceof Integer
> |  ^
>
>
> What you are really asking is whether or not `Byte` can be converted to
> `Integer` since we know that both can be null and also all possible
> reference values of the first also belong to the domain of the second. So
> actually maybe null is the only problematic value (because it witnesses
> that both types are reference types)? Today we manage conversions by those
> tables in Chapter 5. With the arrival of valhalla we will need to think
> what place the conversion of Byte! to Integer! has. (a `Byte` will be a
> null-widened `Byte!`.
>
> -------------
>
> PR Comment: https://git.openjdk.org/jdk/pull/19301#issuecomment-2124327985
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://mail.openjdk.org/pipermail/compiler-dev/attachments/20240522/784916d7/attachment.htm>