/** * When constant expressions are created, the value is always wrapped to a non primitive type. * Some constant expressions are optimized to return primitive types, but not all primitives are * handled. This method guarantees to return a similar constant expression but with a primitive type * instead of a boxed type. * <p/> * Additionally, single char strings are converted to 'char' types. * * @param constantExpression a constant expression * @return the same instance of constant expression if the type is already primitive, or a primitive * constant if possible. */ public static ConstantExpression transformToPrimitiveConstantIfPossible(ConstantExpression constantExpression) { Object value = constantExpression.getValue(); if (value == null) return constantExpression; ConstantExpression result; ClassNode type = constantExpression.getType(); if (ClassHelper.isPrimitiveType(type)) return constantExpression; if (value instanceof String && ((String) value).length() == 1) { result = new ConstantExpression(((String) value).charAt(0)); result.setType(ClassHelper.char_TYPE); } else { type = ClassHelper.getUnwrapper(type); result = new ConstantExpression(value, true); result.setType(type); } return result; }
/** * add various getAt and setAt methods for primitive arrays * * @param receiver the receiver class * @param name the name of the method * @param args the argument classes */ private static void addArrayMethods(List<MethodNode> methods, ClassNode receiver, String name, ClassNode[] args) { if (args.length != 1) return; if (!receiver.isArray()) return; if (!isIntCategory(getUnwrapper(args[0]))) return; if ("getAt".equals(name)) { MethodNode node = new MethodNode(name, Opcodes.ACC_PUBLIC, receiver.getComponentType(), new Parameter[]{new Parameter(args[0], "arg")}, null, null); node.setDeclaringClass(receiver.redirect()); methods.add(node); } else if ("setAt".equals(name)) { MethodNode node = new MethodNode(name, Opcodes.ACC_PUBLIC, VOID_TYPE, new Parameter[]{new Parameter(args[0], "arg")}, null, null); node.setDeclaringClass(receiver.redirect()); methods.add(node); } }
private static boolean matchWithOrWithourBoxing(final ClassNode argType, final Class aClass) { final boolean match; ClassNode type = ClassHelper.make(aClass); if (ClassHelper.isPrimitiveType(type) && !ClassHelper.isPrimitiveType(argType)) { type = ClassHelper.getWrapper(type); } else if (ClassHelper.isPrimitiveType(argType) && !ClassHelper.isPrimitiveType(type)) { type = ClassHelper.getUnwrapper(type); } match = argType.equals(type); return match; }
private void negativeOrPositiveUnary(Expression expression, String name) { ClassNode type = getType(expression); ClassNode typeRe = type.redirect(); ClassNode resultType; if (isDoubleCategory(ClassHelper.getUnwrapper(typeRe))) { resultType = type; } else if (typeRe == ArrayList_TYPE) { resultType = ArrayList_TYPE; } else { MethodNode mn = findMethodOrFail(expression, type, name); if (mn != null) { resultType = mn.getReturnType(); } else { resultType = type; } } storeType(expression, resultType); }
ClassNode ua = getUnwrapper(a); ClassNode ub = getUnwrapper(b); Integer pa = NUMBER_TYPES_PRECEDENCE.get(ua); Integer pb = NUMBER_TYPES_PRECEDENCE.get(ub);
getAtNode = current.getDeclaredMethod("getAt", new Parameter[]{new Parameter(getUnwrapper(aType), "index")}); if (getAtNode == null) { getAtNode = getCompatibleMethod(current, "getAt", getUnwrapper(aType));
return Number_TYPE; } else if (isBitOperator(op) || op == INTDIV || op == INTDIV_EQUAL) { if (isIntCategory(getUnwrapper(leftRedirect)) && isIntCategory(getUnwrapper(rightRedirect))) return int_TYPE; if (isLongCategory(getUnwrapper(leftRedirect)) && isLongCategory(getUnwrapper(rightRedirect))) return long_TYPE; if (isBigIntCategory(getUnwrapper(leftRedirect)) && isBigIntCategory(getUnwrapper(rightRedirect))) return BigInteger_TYPE; } else if (isCompareToBoolean(op) || op == COMPARE_EQUAL || op == COMPARE_NOT_EQUAL) {
componentType = inferLoopElementType(collectionType); if (ClassHelper.getUnwrapper(componentType) == forLoopVariableType) {
ClassNode unwrapReceiver = getUnwrapper(receiver); ClassNode unwrapCompare = getUnwrapper(compare); if (isPrimitiveType(unwrapReceiver) && isPrimitiveType(unwrapCompare)
Object value = expression.getValue(); ClassNode origType = expression.getType().redirect(); ClassNode type = ClassHelper.getUnwrapper(origType); boolean boxing = origType!=type; boolean asPrimitive = boxing || ClassHelper.isPrimitiveType(type);
ClassNode declarationType = ((VariableExpression) leftExpression).getOriginType(); if (rightExpression instanceof ConstantExpression) { ClassNode unwrapper = ClassHelper.getUnwrapper(declarationType); ClassNode wrapper = ClassHelper.getWrapper(declarationType); if (!rightExpression.getType().equals(declarationType)
ClassNode exprType = getType(innerExpression); String name = operationType == PLUS_PLUS ? "next" : operationType == MINUS_MINUS ? "previous" : null; if (isPrimitiveType(exprType) || isPrimitiveType(getUnwrapper(exprType))) { if (operationType == PLUS_PLUS || operationType == MINUS_MINUS) { if (!isPrimitiveType(exprType)) {
return WideningCategories.isBigIntCategory(getUnwrapper(rightRedirect)) || rightRedirect.isDerivedFrom(BigInteger_TYPE);
return getUnwrapper(right);
/** * When constant expressions are created, the value is always wrapped to a non primitive type. * Some constant expressions are optimized to return primitive types, but not all primitives are * handled. This method guarantees to return a similar constant expression but with a primitive type * instead of a boxed type. * * Additionaly, single char strings are converted to 'char' types. * * @param constantExpression a constant expression * @return the same instance of constant expression if the type is already primitive, or a primitive * constant if possible. */ public static ConstantExpression transformToPrimitiveConstantIfPossible(ConstantExpression constantExpression) { Object value = constantExpression.getValue(); if (value ==null) return constantExpression; ConstantExpression result; ClassNode type = constantExpression.getType(); if (ClassHelper.isPrimitiveType(type)) return constantExpression; if (value instanceof String && ((String)value).length()==1) { result = new ConstantExpression(((String)value).charAt(0)); result.setType(ClassHelper.char_TYPE); } else { type = ClassHelper.getUnwrapper(type); result = new ConstantExpression(value, true); result.setType(type); } return result; }
ClassNode type2 = getLHSType(right); if (ClassHelper.isNumberType(type1) && ClassHelper.isNumberType(type2)) { ClassNode prim1 = ClassHelper.getUnwrapper(type1); ClassNode prim2 = ClassHelper.getUnwrapper(type2);
ClassNode type2 = getLHSType(right); if (ClassHelper.isNumberType(type1) && ClassHelper.isNumberType(type2)) { ClassNode prim1 = ClassHelper.getUnwrapper(type1); ClassNode prim2 = ClassHelper.getUnwrapper(type2);
ClassNode prim1 = ClassHelper.getUnwrapper(type1); ClassNode prim2 = ClassHelper.getUnwrapper(type2);
ClassNode prim1 = ClassHelper.getUnwrapper(type1); ClassNode prim2 = ClassHelper.getUnwrapper(type2);
|| value instanceof Double ) { ClassNode primType = ClassHelper.getUnwrapper(type); pushPrimitiveConstant(mv, value, primType); } else { mv.visitLdcInsn(value); BytecodeHelper.box(mv, ClassHelper.getUnwrapper(type)); // does not change this.stack field contents BytecodeHelper.doCast(mv, type);