public static ConstantExpression transformBinaryConstantExpression()

in src/main/java/org/apache/groovy/ast/tools/ExpressionUtils.java [107:187]
79 lines of code
40 McCabe index (conditional complexity)

    public static ConstantExpression transformBinaryConstantExpression(final BinaryExpression be, final ClassNode targetType) {
        ClassNode wrapperType;
        if (isTypeOrArrayOfType(targetType, ClassHelper.STRING_TYPE, false)) {
            final int opType = be.getOperation().getType();
            if (opType == PLUS) {
                Expression left = transformInlineConstants(be.getLeftExpression(), targetType);
                Expression right = transformInlineConstants(be.getRightExpression(), targetType);
                if (left instanceof ConstantExpression && right instanceof ConstantExpression) {
                    Object leftV = ((ConstantExpression) left).getValue();
                    if (leftV == null) leftV = "null";
                    if (leftV instanceof String) {
                        return configure(be, new ConstantExpression(((String)leftV) + ((ConstantExpression) right).getValue()));
                    }
                }
            }
        } else if (isNumberOrArrayOfNumber(wrapperType = ClassHelper.getWrapper(targetType), false)) {
            final int opType = be.getOperation().getType();
            if (opType == PLUS || opType == MINUS || opType == MULTIPLY || opType == DIVIDE
                || opType == POWER || opType == BITWISE_OR || opType == BITWISE_AND || opType == BITWISE_XOR
                || opType == LEFT_SHIFT || opType == RIGHT_SHIFT || opType == RIGHT_SHIFT_UNSIGNED) {

                Expression leftX = be.getLeftExpression();
                if (!(leftX instanceof ConstantExpression)) {
                    leftX = transformInlineConstants(leftX, targetType);
                }
                Expression rightX = be.getRightExpression();
                if (!(rightX instanceof ConstantExpression)) {
                    boolean isShift = (opType >= LEFT_SHIFT && opType <= RIGHT_SHIFT_UNSIGNED); // GROOVY-9336
                    rightX = transformInlineConstants(rightX, isShift ? ClassHelper.int_TYPE : targetType);
                }
                if (leftX instanceof ConstantExpression && rightX instanceof ConstantExpression) {
                    Number left  = safeNumber((ConstantExpression) leftX);
                    Number right = safeNumber((ConstantExpression) rightX);
                    if (left == null || right == null) return null;
                    Number result = null;
                    switch (opType) {
                      case PLUS:
                        result = NumberMath.add(left, right);
                        break;
                      case MINUS:
                        result = NumberMath.subtract(left, right);
                        break;
                      case MULTIPLY:
                        result = NumberMath.multiply(left, right);
                        break;
                      case DIVIDE:
                        result = NumberMath.divide(left, right);
                        break;
                      case LEFT_SHIFT:
                        result = NumberMath.leftShift(left, right);
                        break;
                      case RIGHT_SHIFT:
                        result = NumberMath.rightShift(left, right);
                        break;
                      case RIGHT_SHIFT_UNSIGNED:
                        result = NumberMath.rightShiftUnsigned(left, right);
                        break;
                      case BITWISE_AND:
                        result = NumberMath.and(left, right);
                        break;
                      case BITWISE_OR:
                        result = NumberMath.or(left, right);
                        break;
                      case BITWISE_XOR:
                        result = NumberMath.xor(left, right);
                        break;
                      case POWER:
                        result = DefaultGroovyMethods.power(left, right);
                        break;
                    }
                    if (result != null) {
                        ConstantExpression constantExpression = transformNumberConstantExpression(be, wrapperType, result);
                        if (constantExpression != null) return constantExpression;

                        return configure(be, new ConstantExpression(result, true));
                    }
                }
            }
        }
        return null;
    }