Wrapper classes - why integer literals fail for Long but work for anything smaller

Question

Just trying to understand auto-boxing, which I do apart from one thing:

Short s = 250;
Long l = 250;

The assignment to Long l

Answer 1

Ideally, no auto narrowing should be allowed.

But since there are no byte/short literals, we can't write

byte b = 0b;

and it seems silly to

byte b = (byte)0;

so auto narrowing of constant integer is allowed so we can write

byte b = 0;

which is carried over to autoboxing case.

For long/Long, since there are long literals, this is less of a problem. Still, it should be allowed, since auto widening of signed integer is always safe.

Answer 2

Normally, you cannot apply multiple (implicit) conversions in assignment (JLS §5.2 Assignment Conversion):

Assignment conversion occurs when the value of an expression is assigned (§15.26) to a variable: the type of the expression must be converted to the type of the variable. Assignment contexts allow the use of one of the following:

• an identity conversion (§5.1.1)
• a widening primitive conversion (§5.1.2)
• a widening reference conversion (§5.1.5)
• a boxing conversion (§5.1.7) optionally followed by a widening reference conversion
• an unboxing conversion (§5.1.8) optionally followed by a widening primitive conversion.

Long l=250; requires two conversions (widening primitive conversion followed by boxing conversion), that's why it doesn't compile.

Long l=250l; compiles because it requires a single boxing conversion.

But narrowing conversion of a constant expression is a special case, that's why Short s=250; compiles:

In addition, if the expression is a constant expression (§15.28) of type byte, short, char or int :

• A narrowing primitive conversion may be used if the type of the variable is byte, short, or char, and the value of the constant expression is representable in the type of the variable.
• A narrowing primitive conversion followed by a boxing conversion may be used if the type of the variable is :
  • Byte and the value of the constant expression is representable in the type byte.
  • Short and the value of the constant expression is representable in the type short.
  • Character and the value of the constant expression is representable in the type char.