public static List<MethodNode> getAllMethods(ClassNode type) { ClassNode node = type; List<MethodNode> result = new ArrayList<MethodNode>(); while (node != null) { result.addAll(node.getMethods()); node = node.getSuperClass(); } return result; }
public boolean isInClosureConstructor() { return constructorNode != null && classNode.getOuterClass() != null && classNode.getSuperClass() == ClassHelper.CLOSURE_TYPE; }
private static boolean classNodeUsesReferences(ClassNode classNode) { boolean ret = classNode.getSuperClass() == ClassHelper.CLOSURE_TYPE; if (ret) return ret; if (classNode instanceof InnerClassNode) { InnerClassNode inner = (InnerClassNode) classNode; return inner.isAnonymous(); } return false; }
private boolean resolveToNestedOfCurrentClassAndSuperClasses(ClassNode type) { // GROOVY-8531: Fail to resolve type defined in super class written in Java for (ClassNode enclosingClassNode = currentClass; ClassHelper.OBJECT_TYPE != enclosingClassNode && null != enclosingClassNode; enclosingClassNode = enclosingClassNode.getSuperClass()) { if(resolveToNested(enclosingClassNode, type)) return true; } return false; }
public static List<PropertyNode> getAllProperties(ClassNode type) { ClassNode node = type; List<PropertyNode> result = new ArrayList<PropertyNode>(); while (node != null) { result.addAll(node.getProperties()); node = node.getSuperClass(); } return result; }
private static void extractInterfaces(ClassNode node, Set<ClassNode> interfaces) { if (node==null) return; Collections.addAll(interfaces, node.getInterfaces()); extractInterfaces(node.getSuperClass(), interfaces); }
public static FieldNode getDeclaredFieldOfCurrentClassOrAccessibleFieldOfSuper(ClassNode accessingNode, ClassNode current, String name, boolean skipCurrent) { if (!skipCurrent) { FieldNode currentClassField = current.getDeclaredField(name); if (isValidFieldNodeForByteCodeAccess(currentClassField, accessingNode)) return currentClassField; } for (ClassNode node = current.getSuperClass(); node!=null; node = node.getSuperClass()) { FieldNode fn = node.getDeclaredField(name); if (isValidFieldNodeForByteCodeAccess(fn, accessingNode)) return fn; } return null; }
private boolean directlyImplementsTrait(ClassNode trait) { ClassNode[] interfaces = currentClass.getInterfaces(); if (interfaces==null) { return currentClass.getSuperClass().equals(trait); } for (ClassNode node : interfaces) { if (node.equals(trait)) { return true; } } return currentClass.getSuperClass().equals(trait); }
private void checkClassForOverwritingFinal(ClassNode cn) { ClassNode superCN = cn.getSuperClass(); if (superCN == null) return; if (!isFinal(superCN.getModifiers())) return; String msg = "You are not allowed to overwrite the final " + getDescription(superCN) + "."; addError(msg, cn); }
private int computeDepth(ClassNode node) { if (node.equals(ClassHelper.OBJECT_TYPE) || node.equals(nodeCache.Specification)) return -1; return computeDepth(node.getSuperClass()) + 1; }
private MethodNode findSetterOfSuperClass(ClassNode classNode, FieldNode fieldNode) { String setterMethodName = "set" + MetaClassHelper.capitalize(fieldNode.getName()); return classNode.getSuperClass().getSetterMethod(setterMethodName); }
private MethodNode findGetterOfSuperClass(ClassNode classNode, FieldNode fieldNode) { String getterMethodName = "get" + MetaClassHelper.capitalize(fieldNode.getName()); return classNode.getSuperClass().getGetterMethod(getterMethodName); }
public MethodNode getSetterMethod(String setterName, boolean voidOnly) { for (MethodNode method : getDeclaredMethods(setterName)) { if (setterName.equals(method.getName()) && (!voidOnly || ClassHelper.VOID_TYPE==method.getReturnType()) && method.getParameters().length == 1) { return method; } } ClassNode parent = getSuperClass(); if (parent!=null) return parent.getSetterMethod(setterName, voidOnly); return null; }
private ClassNode makeSuper() { ClassNode ret = typeCheckingContext.getEnclosingClassNode().getSuperClass(); if (typeCheckingContext.isInStaticContext) { ClassNode staticRet = CLASS_Type.getPlainNodeReference(); GenericsType gt = new GenericsType(ret); staticRet.setGenericsTypes(new GenericsType[]{gt}); ret = staticRet; } return ret; }
private boolean storeTypeForSuper(VariableExpression vexp) { if (vexp == VariableExpression.SUPER_EXPRESSION) return true; if (!vexp.isSuperExpression()) return false; ClassNode superClassNode = typeCheckingContext.getEnclosingClassNode().getSuperClass(); storeType(vexp, makeType(superClassNode, typeCheckingContext.isInStaticContext)); return true; }
private ClassNode getCommonSuperClassNode(ClassNode c, ClassNode d) { // adapted from ClassWriter code if (c.isDerivedFrom(d)) return d; if (d.isDerivedFrom(c)) return c; if (c.isInterface() || d.isInterface()) return ClassHelper.OBJECT_TYPE; do { c = c.getSuperClass(); } while (c!=null && !d.isDerivedFrom(c)); if (c==null) return ClassHelper.OBJECT_TYPE; return c; } @Override
private void visitSpecialConstructorCall(ConstructorCallExpression call) { if (controller.getClosureWriter().addGeneratedClosureConstructorCall(call)) return; ClassNode callNode = controller.getClassNode(); if (call.isSuperCall()) callNode = callNode.getSuperClass(); List<ConstructorNode> constructors = sortConstructors(call, callNode); if (!makeDirectConstructorCall(constructors, call, callNode)) { makeMOPBasedConstructorCall(constructors, call, callNode); } }
private static boolean hasUsableImplementation(ClassNode c, MethodNode m) { if (c == m.getDeclaringClass()) return false; MethodNode found = c.getDeclaredMethod(m.getName(), m.getParameters()); if (found == null) return false; int asp = found.getModifiers() & ABSTRACT_STATIC_PRIVATE; int visible = found.getModifiers() & VISIBILITY; if (visible != 0 && asp == 0) return true; if (c.equals(OBJECT_TYPE)) return false; return hasUsableImplementation(c.getSuperClass(), m); }
private void checkImplementsAndExtends(ClassNode node) { ClassNode cn = node.getSuperClass(); if (cn.isInterface() && !node.isInterface()) { addError("You are not allowed to extend the " + getDescription(cn) + ", use implements instead.", node); } for (ClassNode anInterface : node.getInterfaces()) { cn = anInterface; if (!cn.isInterface()) { addError("You are not allowed to implement the " + getDescription(cn) + ", use extends instead.", node); } } }
private void checkMethodsForOverridingFinal(ClassNode cn) { for (MethodNode method : cn.getMethods()) { Parameter[] params = method.getParameters(); for (MethodNode superMethod : cn.getSuperClass().getMethods(method.getName())) { Parameter[] superParams = superMethod.getParameters(); if (!hasEqualParameterTypes(params, superParams)) continue; if (!superMethod.isFinal()) break; addInvalidUseOfFinalError(method, params, superMethod.getDeclaringClass()); return; } } }