docs: public static ConstantExpression transformBinaryConstantExpression(BinaryExpression be, ClassNode targetType) {
          ClassNode wrapperType = ClassHelper.getWrapper(targetType);
          if (isTypeOrArrayOfType(targetType, ClassHelper.STRING_TYPE, false)) {
              if (be.getOperation().getType() == PLUS) {
                  Expression left = transformInlineConstants(be.getLeftExpression(), targetType);
                  Expression right = transformInlineConstants(be.getRightExpression(), targetType);
                  if (left instanceof ConstantExpression && right instanceof ConstantExpression) {
                      return configure(be, new ConstantExpression((String) ((ConstantExpression) left).getValue() +
                              ((ConstantExpression) right).getValue()));
                  }
              }
          } else if (isNumberOrArrayOfNumber(wrapperType, false)) {
              int type = be.getOperation().getType();
              if (handledTypes.contains(type)) {
                  Expression leftX = transformInlineConstants(be.getLeftExpression(), targetType);
                  Expression rightX = transformInlineConstants(be.getRightExpression(), 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(type) {
                          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) {
                          if (ClassHelper.Byte_TYPE.equals(wrapperType)) {
                              return configure(be, new ConstantExpression(result.byteValue(), true));
                          }
                          if (ClassHelper.Short_TYPE.equals(wrapperType)) {
                              return configure(be, new ConstantExpression(result.shortValue(), true));
                          }
                          if (ClassHelper.Long_TYPE.equals(wrapperType)) {
                              return configure(be, new ConstantExpression(result.longValue(), true));
                          }
                          if (ClassHelper.Integer_TYPE.equals(wrapperType) || ClassHelper.Character_TYPE.equals(wrapperType)) {
                              return configure(be, new ConstantExpression(result.intValue(), true));
                          }
                          if (ClassHelper.Float_TYPE.equals(wrapperType)) {
                              return configure(be, new ConstantExpression(result.floatValue(), true));
                          }
                          if (ClassHelper.Double_TYPE.equals(wrapperType)) {
                              return configure(be, new ConstantExpression(result.doubleValue(), true));
                          }
                          return configure(be, new ConstantExpression(result, true));
                      }
                  }
              }
          }
          return null;
      }