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
* Checks: control flow
     */
    @Override
    public void visitBreak(SBreak userBreakNode, SemanticScope semanticScope) {
        if (semanticScope.getCondition(userBreakNode, InLoop.class) == false) {
            throw userBreakNode.createError(new IllegalArgumentException("invalid break statement: not inside loop"));
        }
        semanticScope.setCondition(userBreakNode, AllEscape.class);
        semanticScope.setCondition(userBreakNode, LoopEscape.class);
        semanticScope.setCondition(userBreakNode, AnyBreak.class);
    }
    /**
     * Visits an assignment expression which handles both assignment and compound assignment.
     * Checks: type validation
     */
    @Override
    public void visitAssignment(EAssignment userAssignmentNode, SemanticScope semanticScope) {
        AExpression userLeftNode = userAssignmentNode.getLeftNode();
        semanticScope.replicateCondition(userAssignmentNode, userLeftNode, Read.class);
        semanticScope.setCondition(userLeftNode, Write.class);
        checkedVisit(userLeftNode, semanticScope);
        Class<?> leftValueType = semanticScope.getDecoration(userLeftNode, Decorations.ValueType.class).valueType();
        AExpression userRightNode = userAssignmentNode.getRightNode();
        semanticScope.setCondition(userRightNode, Read.class);
        Operation operation = userAssignmentNode.getOperation();
        if (operation != null) {
            checkedVisit(userRightNode, semanticScope);
            Class<?> rightValueType = semanticScope.getDecoration(userRightNode, ValueType.class).valueType();
            Class<?> compoundType;
            boolean isConcatenation = false;