FULL PRODUCT VERSION :
java version "1.6.0_18-ea"
Java(TM) SE Runtime Environment (build 1.6.0_18-ea-b02)
Java HotSpot(TM) 64-Bit Server VM (build 16.0-b09, mixed mode)

ADDITIONAL OS VERSION INFORMATION :
Microsoft Windows [Version 6.1.7600]

A DESCRIPTION OF THE PROBLEM :
The code below should not compile.

Consider three conditional expressions below.

class Main {
    public static void f(boolean cond) {
        Byte B = 0;
        byte b = 0;
        byte value = cond ? B : b;

        short s = 0;
        Short S = 0;
        short rs = cond ? S : s;

        char c = 0;
        Character C = 0;
        char rc = cond ? C : c;
    }
}

Quoting JLS3 15.25, (I've numbered paragraphs for convenience)
------------
The type of a conditional expression is determined as follows:

1. If the second and third operands have the same type (which may be the null type), then that is the type of the conditional expression.
2. If one of the second and third operands is of type boolean and the type of the other is of type Boolean, then the type of the conditional expression is boolean.
3. If one of the second and third operands is of the null type and the type of the other is a reference type, then the type of the conditional expression is that reference type.
4. Otherwise, if the second and third operands have types that are convertible (§5.1.8) to numeric types, then there are several cases:
 4.1 If one of the operands is of type byte or Byte and the other is of type short or Short, then the type of the conditional expression is short.
 4.2 If one of the operands is of type T where T is byte, short, or char, and the other operand is a constant expression of type int whose value is representable in type T, then the type of the conditional expression is T.
 4.3 If one of the operands is of type Byte and the other operand is a constant expression of type int whose value is representable in type byte, then the type of the conditional expression is byte.
 4.4 If one of the operands is of type Short and the other operand is a constant expression of type int whose value is representable in type short, then the type of the conditional expression is short.
 4.5 If one of the operands is of type; Character and the other operand is a constant expression of type int whose value is representable in type char, then the type of the conditional expression is char.
 4.6 Otherwise, binary numeric promotion (§5.6.2) is applied to the operand types, and the type of the conditional expression is the promoted type of the second and third operands. Note that binary numeric promotion performs unboxing conversion (§5.1.8) and value set conversion (§5.1.13).

5. Otherwise, the second and third operands are of types S1 and S2 respectively. Let T1 be the type that results from applying boxing conversion to S1, and let T2 be the type that results from applying boxing conversion to S2. The type of the conditional expression is the result of applying capture conversion (§5.1.10) to lub(T1, T2) (§15.12.2.7).
-------------

Let's determine type of each conditional expression following steps above.
Paragraph 1 is not applicable here, since second and third operands have different types (one primitive, the other reference)
Paragraph 2 is not applicable here, since neither of operands is of boolean type.
Paragraph 3 is not applicable here, since neither of operands is of null type.
Paragraph 4 is applicable here, since both operands convertible to numeric type.
Sections inside paragraph 4:
Section 4.1 is not applicable here, since our operands are not (byte, short) combination
Section 4.2 is not applicable here, since neither of operands is a constant expression
Section 4.3 is not applicable here, since neither of operands is a constant expression
Section 4.4 is not applicable here, since neither of operands is a constant expression
Section 4.5 is not applicable here, since neither of operands is a constant expression
Therefore, section 4.6 is applicable and binary numeric promotion should be applied.

Quoting JLS3, 5.6.2 (I've numbered paragraphs for convenience)
--------
Binary Numeric Promotion

0. If any of the operands is of a reference type, unboxing conversion (§5.1.8) is
performed. Then:
1. If either operand is of type double, the other is converted to double.
2. Otherwise, if either operand is of type float, the other is converted to float.
3. Otherwise, if either operand is of type long, the other is converted to long.
4. Otherwise, both operands are converted to type int.
-----

Let's apply binary numeric promotion, as described in the steps above, to each operand pair.
According to paragraph 0, unboxing should occur, which will produce (byte,byte), (short,short) and (char,char) operand types, respectively
Then, paragraph 1 is not applicable since neither of our types is double
Then, paragraph 2 is not applicable since neither of our types is float
Then, paragraph 3 is not applicable since neither of our types is long
Therefore, paragraph 4 is applicable here, and both of our operands should be converted to int.


So, each conditional expression should have type int, and, therefore, every assignment statement should not compile since type int is not assignable
to byte, short or char, respectively.

I think this is actually the spec bug, and following paragraph should be added to 15.25:
4.0 if one operand is of primitive type T, and the other is of boxed(T) then the type of conditional expression is T
 

STEPS TO FOLLOW TO REPRODUCE THE PROBLEM :
Compile the code.


EXPECTED VERSUS ACTUAL BEHAVIOR :
EXPECTED -
Should not compile.
Three compilation errors are expected to appear, for assignment operators:
"Incompatible types. required: byte; found: int"
"Incompatible types. required: short; found: int"
"Incompatible types. required: char; found: int"
ACTUAL -
Compiled successfully

REPRODUCIBILITY :
This bug can be reproduced always.

---------- BEGIN SOURCE ----------
class Main {
    public static void f(boolean cond) {
        Byte B = 0;
        byte b = 0;
        byte value = cond ? B : b;

        short s = 0;
        Short S = 0;
        short rs = cond ? S : s;

        char c = 0;
        Character C = 0;
        char rc = cond ? C : c;
    }
}
---------- END SOURCE ----------