If a hex literal has an 'd' of 'f' in it, such as '0xf' or '0xd', the compiler fails with illegal tree structure.

The other hex literals work.  The issue is probably related to using `f` and `d` in float and double literals.

```
    public void testHexCollisionDouble() {
        assertEquals(13, exec("return 0xd"));
    }

    public void testHexCollisionFloat() {
        assertEquals(15, exec("return 0xf"));
    }

    public void testHex() throws Exception {
        for (int i = 0; i <= 15; i++) {
            String hex = Integer.toHexString(i);
            if ("d".equals(hex) || "f".equals(hex)) {
                continue;
            }
            assertEquals(i, exec("return 0x" + hex));
            assertEquals(i, exec("return 0x" + hex.toUpperCase(Locale.ROOT)));
            assertEquals(i, exec("return 0X" + hex));
            assertEquals(i, exec("return 0X" + hex.toUpperCase(Locale.ROOT)));
        }
    }
```
modules/lang-painless/src/main/java/org/elasticsearch/painless/phase/DefaultSemanticAnalysisPhase.java
public void decorateWithCast(AExpression userExpressionNode, SemanticScope semanticScope) {
        Location location = userExpressionNode.getLocation();
        Class<?> valueType = semanticScope.getDecoration(userExpressionNode, ValueType.class).valueType();
        Class<?> targetType = semanticScope.getDecoration(userExpressionNode, TargetType.class).targetType();
        boolean isExplicitCast = semanticScope.getCondition(userExpressionNode, Explicit.class);
        boolean isInternalCast = semanticScope.getCondition(userExpressionNode, Internal.class);
        PainlessCast painlessCast = AnalyzerCaster.getLegalCast(location, valueType, targetType, isExplicitCast, isInternalCast);
        if (painlessCast != null) {
            semanticScope.putDecoration(userExpressionNode, new ExpressionPainlessCast(painlessCast));
        }
    }
    /**
     * Shortcut to visit a user tree node with a null check.
     */
    public void visit(ANode userNode, SemanticScope semanticScope) {
        if (userNode != null) {
            userNode.visit(this, semanticScope);
        }
    }
    /**
     * Shortcut to visit a user expression node with additional checks common to most expression nodes. These
     * additional checks include looking for an escaped partial canonical type, an unexpected static type, and an
     * unexpected value type.
     */
    public void checkedVisit(AExpression userExpressionNode, SemanticScope semanticScope) {
        if (userExpressionNode != null) {
            userExpressionNode.visit(this, semanticScope);
            if (semanticScope.hasDecoration(userExpressionNode, PartialCanonicalTypeName.class)) {
                throw userExpressionNode.createError(
                    new IllegalArgumentException(