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
scriptScope.getCompilerSettings().asMap(),
                        false
                    );
                    semanticScope.putDecoration(userFunctionRefNode, new ReferenceDecoration(ref));
                }
            }
        }
        semanticScope.putDecoration(userFunctionRefNode, new ValueType(valueType));
    }
    /**
     * Visits a new array function ref expression which covers only a new array function reference
     * and generates an internal method to define the new array.
     * Checks: type validation
     */
    @Override
    public void visitNewArrayFunctionRef(ENewArrayFunctionRef userNewArrayFunctionRefNode, SemanticScope semanticScope) {
        String canonicalTypeName = userNewArrayFunctionRefNode.getCanonicalTypeName();
        if (semanticScope.getCondition(userNewArrayFunctionRefNode, Write.class)) {
            throw userNewArrayFunctionRefNode.createError(
                new IllegalArgumentException(
                    "cannot assign a value to new array function reference with target type [ + " + canonicalTypeName + "]"
                )
            );
        }
        if (semanticScope.getCondition(userNewArrayFunctionRefNode, Read.class) == false) {
            throw userNewArrayFunctionRefNode.createError(
                new IllegalArgumentException(
                    "not a statement: new array function reference with target type [" + canonicalTypeName + "] not used"
                )
            );