Refine search
private static ClassNode getSerializeClass(ClassNode alias) { List<AnnotationNode> annotations = alias.getAnnotations(ClassHelper.make(AnnotationCollector.class)); if (!annotations.isEmpty()) { AnnotationNode annotationNode = annotations.get(0); Expression member = annotationNode.getMember("serializeClass"); if (member instanceof ClassExpression) { ClassExpression ce = (ClassExpression) member; if (!ce.getType().getName().equals(AnnotationCollector.class.getName())) { alias = ce.getType(); } } } return alias; }
public static ClassNode nonGeneric(ClassNode type) { if (type.isUsingGenerics()) { final ClassNode nonGen = ClassHelper.makeWithoutCaching(type.getName()); nonGen.setRedirect(type); nonGen.setGenericsTypes(null); nonGen.setUsingGenerics(false); return nonGen; } if (type.isArray() && type.getComponentType().isUsingGenerics()) { return type.getComponentType().getPlainNodeReference().makeArray(); } return type; }
private boolean compatibleArgumentType(ClassNode argumentType, ClassNode paramType) { if (argumentType == null) return false; if (ClassHelper.getWrapper(argumentType).equals(ClassHelper.getWrapper(paramType))) return true; if (paramType.isInterface()) return argumentType.implementsInterface(paramType); if (paramType.isArray() && argumentType.isArray()) return compatibleArgumentType(argumentType.getComponentType(), paramType.getComponentType()); return ClassHelper.getWrapper(argumentType).isDerivedFrom(ClassHelper.getWrapper(paramType)); }
/** * Returns a wrapped type if, and only if, the provided class node is a primitive type. * This method differs from {@link ClassHelper#getWrapper(org.codehaus.groovy.ast.ClassNode)} as it will * return the same instance if the provided type is not a generic type. * * @param type * @return the wrapped type */ protected static ClassNode wrapTypeIfNecessary(ClassNode type) { if (isPrimitiveType(type)) return getWrapper(type); return type; }
public static ClassNode getSuperClass(ClassNode type, ClassNode target) { ClassNode superClass = ClassHelper.getNextSuperClass(type, target); if (superClass == null) { if (ClassHelper.isPrimitiveType(type)) { superClass = ClassHelper.getNextSuperClass(ClassHelper.getWrapper(type), target); } } return superClass; }
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; }
if (a.isArray() && b.isArray()) { return lowestUpperBound(a.getComponentType(), b.getComponentType(), interfacesImplementedByA, interfacesImplementedByB).makeArray(); if (a.equals(OBJECT_TYPE) || b.equals(OBJECT_TYPE)) { boolean isPrimitiveA = isPrimitiveType(a); boolean isPrimitiveB = isPrimitiveType(b); if (isPrimitiveA && !isPrimitiveB) { return lowestUpperBound(getWrapper(a), b, null, null); return lowestUpperBound(a, getWrapper(b), null, null); return b; return a.equals(b)?a:lowestUpperBound(getWrapper(a), getWrapper(b), null, null); if (isNumberType(a.redirect()) && isNumberType(b.redirect())) { ClassNode ua = getUnwrapper(a); ClassNode ub = getUnwrapper(b); Integer pa = NUMBER_TYPES_PRECEDENCE.get(ua); Integer pb = NUMBER_TYPES_PRECEDENCE.get(ub);
if (!implementsInterfaceOrIsSubclassOf(expressionType, Collection_TYPE) && !expressionType.isArray()) { addStaticTypeError("Spread operator can only be used on collection types", objectExpression); return; ClassNode listNode = LIST_TYPE.getPlainNodeReference(); listNode.setGenericsTypes(new GenericsType[]{new GenericsType(wrapTypeIfNecessary(subcallReturnType))}); storeType(call, listNode); if (NUMBER_OPS.containsKey(name) && isNumberType(receiver) && argumentList.getExpressions().size() == 1 && isNumberType(getType(argumentList.getExpression(0)))) { ClassNode right = getType(argumentList.getExpression(0)); ClassNode resultType = getMathResultType(NUMBER_OPS.get(name), receiver, right, name);
protected ClassNode createStatementsClass() { ClassNode classNode = getScriptClassDummy(); if (classNode.getName().endsWith("package-info")) { return classNode; classNode.addMethod( new MethodNode( "main", ACC_PUBLIC | ACC_STATIC, ClassHelper.VOID_TYPE, new Parameter[] { new Parameter(ClassHelper.STRING_TYPE.makeArray(), "args")}, ClassNode.EMPTY_ARRAY, new ExpressionStatement( new MethodCallExpression( new ClassExpression(ClassHelper.make(InvokerHelper.class)), "runScript", new ArgumentListExpression( classNode.addConstructor( ACC_PUBLIC, new Parameter[] { new Parameter(ClassHelper.make(Binding.class), "context")}, ClassNode.EMPTY_ARRAY, stmt);
public static boolean checkCompatibleAssignmentTypes(ClassNode left, ClassNode right, Expression rightExpression, boolean allowConstructorCoercion) { ClassNode leftRedirect = left.redirect(); ClassNode rightRedirect = right.redirect(); if (leftRedirect == rightRedirect) return true; if (leftRedirect.isArray() && rightRedirect.isArray()) { return checkCompatibleAssignmentTypes(leftRedirect.getComponentType(), rightRedirect.getComponentType(), rightExpression, false); if ((isNumberType(rightRedirect) || WideningCategories.isNumberCategory(rightRedirect))) { if (BigDecimal_TYPE == leftRedirect) { return WideningCategories.isBigIntCategory(getUnwrapper(rightRedirect)) || rightRedirect.isDerivedFrom(BigInteger_TYPE); if (rightExpressionIsNull && !isPrimitiveType(left)) { return true; if (isPrimitiveType(leftRedirect) && isPrimitiveType(rightRedirect)) return true; if (isNumberType(leftRedirect) && isNumberType(rightRedirect)) return true;
} else if (target.isPrivate() || ((receiver instanceof VariableExpression && ((VariableExpression) receiver).isSuperExpression()))) { opcode = INVOKESPECIAL; } else if (declaringClass.isInterface()) { opcode = INVOKEINTERFACE; && !classNode.isDerivedFrom(declaringClass) && !classNode.implementsInterface(declaringClass) && classNode instanceof InnerClassNode) { new VariableExpression("thisObject").visit(controller.getAcg()); } else { Expression expr = new PropertyExpression(new ClassExpression(declaringClass), "this"); expr.visit(controller.getAcg()); && !receiverType.isArray() && !receiverType.isInterface() && !ClassHelper.isPrimitiveType(receiverType) // e.g int.getClass() && receiverType.isDerivedFrom(declaringClass)) {
Type t = Type.getType(BytecodeHelper.getTypeDescription(closureClass)); av.visit(null, t); } else if (type.isArray()) { AnnotationVisitor avl = av.visitArray(null); ClassNode componentType = type.getComponentType(); if (exp instanceof ListExpression) { ListExpression list = (ListExpression) exp; visitAnnotationDefaultExpression(avl, componentType, exp); } else if (ClassHelper.isPrimitiveType(type) || type.equals(ClassHelper.STRING_TYPE)) { ConstantExpression constExp = (ConstantExpression) exp; av.visit(null, constExp.getValue()); PropertyExpression pExp = (PropertyExpression) exp; ClassExpression cExp = (ClassExpression) pExp.getObjectExpression(); String desc = BytecodeHelper.getTypeDescription(cExp.getType()); String name = pExp.getPropertyAsString(); av.visitEnum(null, desc, name);
public void checkReturnType(ClassNode attrType, ASTNode node) { if (attrType.isArray()) { checkReturnType(attrType.getComponentType(), node); } else if (ClassHelper.isPrimitiveType(attrType)) { } else if (ClassHelper.STRING_TYPE.equals(attrType)) { } else if (ClassHelper.CLASS_Type.equals(attrType)) { } else if (attrType.isDerivedFrom(ClassHelper.Enum_Type)) { } else if (isValidAnnotationClass(attrType)) { } else { addError("Unexpected return type " + attrType.getName(), node); } }
public static ClassNode makeEnumNode(String name, int modifiers, ClassNode[] interfaces, ClassNode outerClass) { modifiers = modifiers | Opcodes.ACC_FINAL | Opcodes.ACC_ENUM; ClassNode enumClass; if (outerClass==null) { enumClass = new ClassNode(name,modifiers,null,interfaces,MixinNode.EMPTY_ARRAY); } else { name = outerClass.getName() + "$" + name; modifiers |= Opcodes.ACC_STATIC; enumClass = new InnerClassNode(outerClass,name,modifiers,null,interfaces,MixinNode.EMPTY_ARRAY); } // set super class and generics info // "enum X" -> class X extends Enum<X> GenericsType gt = new GenericsType(enumClass); ClassNode superClass = ClassHelper.makeWithoutCaching("java.lang.Enum"); superClass.setGenericsTypes(new GenericsType[]{gt}); enumClass.setSuperClass(superClass); superClass.setRedirect(ClassHelper.Enum_Type); return enumClass; }
protected ClassNode makeType(AST typeNode) { ClassNode answer = ClassHelper.DYNAMIC_TYPE; AST node = typeNode.getFirstChild(); if (node != null) { if (isType(INDEX_OP, node) || isType(ARRAY_DECLARATOR, node)) { answer = makeType(node).makeArray(); } else { checkTypeArgs(node, false); answer = ClassHelper.make(qualifiedName(node)); if (answer.isUsingGenerics()) { ClassNode newAnswer = ClassHelper.makeWithoutCaching(answer.getName()); newAnswer.setRedirect(answer); answer = newAnswer; } } configureAST(answer, node); } return answer; }
protected boolean checkCast(final ClassNode targetType, final Expression source) { boolean sourceIsNull = isNullConstant(source); ClassNode expressionType = getType(source); if (targetType.isArray() && expressionType.isArray()) { return checkCast(targetType.getComponentType(), varX("foo", expressionType.getComponentType())); } else if (targetType.equals(char_TYPE) && expressionType == STRING_TYPE && source instanceof ConstantExpression && source.getText().length() == 1) { // ex: (char) 'c' } else if (targetType.equals(Character_TYPE) && (expressionType == STRING_TYPE || sourceIsNull) && (sourceIsNull || source instanceof ConstantExpression && source.getText().length() == 1)) { // ex : (Character) 'c' } else if (isNumberCategory(getWrapper(targetType)) && (isNumberCategory(getWrapper(expressionType)) || char_TYPE == expressionType)) { // ex: short s = (short) 0 } else if (sourceIsNull && !isPrimitiveType(targetType)) { // ex: (Date)null } else if (char_TYPE == targetType && isPrimitiveType(expressionType) && isNumberType(expressionType)) { // char c = (char) ... } else if (sourceIsNull && isPrimitiveType(targetType) && !boolean_TYPE.equals(targetType)) { return false; } else if ((expressionType.getModifiers() & Opcodes.ACC_FINAL) == 0 && targetType.isInterface()) { return true; } else if ((targetType.getModifiers() & Opcodes.ACC_FINAL) == 0 && expressionType.isInterface()) { return true; } else if (!isAssignableTo(targetType, expressionType) && !implementsInterfaceOrIsSubclassOf(expressionType, targetType)) { return false; } return true; }
protected ClassNode inferMapExpressionType(final MapExpression map) { ClassNode mapType = LINKEDHASHMAP_CLASSNODE.getPlainNodeReference(); List<MapEntryExpression> entryExpressions = map.getMapEntryExpressions(); if (entryExpressions.isEmpty()) return mapType; GenericsType[] genericsTypes = mapType.getGenericsTypes(); if (genericsTypes == null || genericsTypes.length < 2 || (genericsTypes.length == 2 && OBJECT_TYPE.equals(genericsTypes[0].getType()) && OBJECT_TYPE.equals(genericsTypes[1].getType()))) { List<ClassNode> keyTypes = new LinkedList<ClassNode>(); List<ClassNode> valueTypes = new LinkedList<ClassNode>(); for (MapEntryExpression entryExpression : entryExpressions) { keyTypes.add(getType(entryExpression.getKeyExpression())); valueTypes.add(getType(entryExpression.getValueExpression())); } ClassNode keyType = getWrapper(lowestUpperBound(keyTypes)); // to be used in generics, type must be boxed ClassNode valueType = getWrapper(lowestUpperBound(valueTypes)); // to be used in generics, type must be boxed if (!OBJECT_TYPE.equals(keyType) || !OBJECT_TYPE.equals(valueType)) { ClassNode inferred = mapType.getPlainNodeReference(); inferred.setGenericsTypes(new GenericsType[]{new GenericsType(wrapTypeIfNecessary(keyType)), new GenericsType(wrapTypeIfNecessary(valueType))}); return inferred; } } return mapType; }
@Override public void visitRangeExpression(final RangeExpression expression) { super.visitRangeExpression(expression); ClassNode fromType = getWrapper(getType(expression.getFrom())); ClassNode toType = getWrapper(getType(expression.getTo())); if (Integer_TYPE.equals(fromType) && Integer_TYPE.equals(toType)) { storeType(expression, ClassHelper.make(IntRange.class)); } else { ClassNode rangeType = ClassHelper.make(Range.class).getPlainNodeReference(); rangeType.setGenericsTypes(new GenericsType[]{new GenericsType(WideningCategories.lowestUpperBound(fromType, toType))}); storeType(expression, rangeType); } }
/** * Creates a ClassNode using a given class. * A new ClassNode object is only created if the class * is not one of the predefined ones * * @param c class used to created the ClassNode * @return ClassNode instance created from the given class */ public static ClassNode make(Class c) { return make(c, true); }
public ClassNode getPlainNodeReference() { if (ClassHelper.isPrimitiveType(this)) return this; ClassNode n = new ClassNode(name, modifiers, superClass,null,null); n.isPrimaryNode = false; n.setRedirect(redirect()); if (isArray()) { n.componentType = redirect().getComponentType(); } return n; }