public ClassNode getOutermostClass() { if (outermostClass == null) { outermostClass = classNode; while (outermostClass instanceof InnerClassNode) { outermostClass = outermostClass.getOuterClass(); } } return outermostClass; }
public boolean isInClosureConstructor() { return constructorNode != null && classNode.getOuterClass() != null && classNode.getSuperClass() == ClassHelper.CLOSURE_TYPE; }
public ClassNode getOuterMostClass() { ClassNode outerClass = getOuterClass(); while (outerClass instanceof InnerClassNode) { outerClass = outerClass.getOuterClass(); } return outerClass; }
protected static boolean isClassInnerClassOrEqualTo(ClassNode toBeChecked, ClassNode start) { if (start == toBeChecked) return true; if (start instanceof InnerClassNode) { return isClassInnerClassOrEqualTo(toBeChecked, start.getOuterClass()); } return false; }
public boolean isInClosure() { return classNode.getOuterClass() != null && classNode.getSuperClass() == ClassHelper.CLOSURE_TYPE; }
private static boolean isTraitHelper(ClassNode node) { return node instanceof InnerClassNode && Traits.isTrait(node.getOuterClass()); }
public List<ClassNode> getOuterClasses() { if (!(this instanceof InnerClassNode)) { return Collections.emptyList(); } List<ClassNode> result = new LinkedList<>(); ClassNode outestClass = ((InnerClassNode) this).getOuterMostClass(); ClassNode cn = this; do { result.add(cn = cn.getOuterClass()); } while (!cn.equals(outestClass)); return result; }
/** * Detect whether a given ClassNode is a inner class (non-static). * * @param cNode the ClassNode of interest * @return true if the given node is a (non-static) inner class, else false */ public static boolean isInnerClass(ClassNode cNode) { return cNode.redirect().getOuterClass() != null && !Modifier.isStatic(cNode.getModifiers()); }
private static void doAddDelegateReceiver(final List<Receiver<String>> receivers, final StringBuilder path, final ClassNode delegate) { receivers.add(new Receiver<String>(delegate, path.toString())); if (isTraitHelper(delegate)) { receivers.add(new Receiver<String>(delegate.getOuterClass(), path.toString())); } }
private MethodNode findGetter(ClassNode current, String name, boolean searchOuterClasses) { MethodNode getterMethod = current.getGetterMethod(name); if (getterMethod == null && searchOuterClasses && current instanceof InnerClassNode) { return findGetter(current.getOuterClass(), name, true); } return getterMethod; }
private void insertThis0ToSuperCall(final ConstructorCallExpression call, final ClassNode cn) { // calculate outer class which we need for this$0 ClassNode parent = classNode; int level = 0; for (; parent != null && parent != cn.getOuterClass(); parent = parent.getOuterClass()) { level++; } // if constructor call is not in outer class, don't pass 'this' implicitly. Return. if (parent == null) return; //add this parameter to node Expression argsExp = call.getArguments(); if (argsExp instanceof TupleExpression) { TupleExpression argsListExp = (TupleExpression) argsExp; Expression this0 = VariableExpression.THIS_EXPRESSION; for (int i = 0; i != level; ++i) this0 = new PropertyExpression(this0, "this$0"); argsListExp.getExpressions().add(0, this0); } } }
protected static boolean isPrivateBridgeMethodsCallAllowed(ClassNode receiver, ClassNode caller) { if (receiver == null) return false; if (receiver.redirect() == caller) return true; if (caller.redirect() instanceof InnerClassNode) return isPrivateBridgeMethodsCallAllowed(receiver, caller.redirect().getOuterClass()) || isPrivateBridgeMethodsCallAllowed(receiver.getOuterClass(), caller); return false; }
protected void createInterfaceSyntheticStaticFields() { ClassNode icl = controller.getInterfaceClassLoadingClass(); if (referencedClasses.isEmpty()) { Iterator<InnerClassNode> it = icl.getOuterClass().getInnerClasses(); while(it.hasNext()) { InnerClassNode inner = it.next(); if (inner==icl) { it.remove(); return; } } return; } addInnerClass(icl); for (Map.Entry<String, ClassNode> entry : referencedClasses.entrySet()) { // generate a field node String staticFieldName = entry.getKey(); ClassNode cn = entry.getValue(); icl.addField(staticFieldName, ACC_STATIC + ACC_SYNTHETIC, ClassHelper.CLASS_Type.getPlainNodeReference(), new ClassExpression(cn)); } }
public void testOuterClass() { assertNull(classNode.getOuterClass()); assertNotNull(innerClassNode.getOuterClass()); }
private static Map<GenericsTypeName, GenericsType> getGenericsParameterMapOfThis(ClassNode cn) { if (cn == null) return null; Map<GenericsTypeName, GenericsType> map = null; if (cn.getEnclosingMethod() != null) { map = extractGenericsParameterMapOfThis(cn.getEnclosingMethod()); } else if (cn.getOuterClass() != null) { map = getGenericsParameterMapOfThis(cn.getOuterClass()); } map = mergeGenerics(map, cn.getGenericsTypes()); return map; }
private boolean shouldImplicitlyPassThisPara(ConstructorCallExpression cce) { boolean pass = false; ClassNode superCN = classNode.getSuperClass(); if (cce.isThisCall()) { pass = true; } else if (cce.isSuperCall()) { // if the super class is another non-static inner class in the same outer class hierarchy, implicit this // needs to be passed if (!superCN.isEnum() && !superCN.isInterface() && superCN instanceof InnerClassNode) { InnerClassNode superInnerCN = (InnerClassNode) superCN; if (!isStatic(superInnerCN) && classNode.getOuterClass().isDerivedFrom(superCN.getOuterClass())) { pass = true; } } } return pass; }
private boolean isInnerConstructor(ClassNode receiver, ClassNode parent) { return receiver.isRedirectNode() && receiver.redirect() instanceof InnerClassNode && receiver.redirect().getOuterClass().equals(parent); }
public void makeCall( Expression origin, Expression receiver, Expression message, Expression arguments, MethodCallerMultiAdapter adapter, boolean safe, boolean spreadSafe, boolean implicitThis ) { ClassNode cn = controller.getClassNode(); if (controller.isInClosure() && !implicitThis && AsmClassGenerator.isThisExpression(receiver)) cn=cn.getOuterClass(); makeCall(origin, new ClassExpression(cn), receiver, message, arguments, adapter, safe, spreadSafe, implicitThis); }
private void updateStaticCompileFlag(final MethodNode mn) { ClassNode classNode = getClassNode(); AnnotatedNode node = mn; if (classNode.implementsInterface(ClassHelper.GENERATED_CLOSURE_Type)) { node = classNode.getOuterClass(); } isInStaticallyCheckedMethod = mn != null && ( StaticCompilationVisitor.isStaticallyCompiled(node) || classNode.implementsInterface(ClassHelper.GENERATED_CLOSURE_Type)&&classNode.getNodeMetaData(StaticCompilationMetadataKeys.STATIC_COMPILE_NODE)!=null); }
private static boolean isDirectAccessAllowed(FieldNode a, ClassNode receiver, boolean isSamePackage) { ClassNode declaringClass = a.getDeclaringClass().redirect(); ClassNode receiverType = receiver.redirect(); // first, direct access from within the class or inner class nodes if (declaringClass.equals(receiverType)) return true; if (receiverType instanceof InnerClassNode) { while (receiverType instanceof InnerClassNode) { if (declaringClass.equals(receiverType)) return true; receiverType = receiverType.getOuterClass(); } } // no getter return a.isPublic() || (a.isProtected() && isSamePackage); }