private static boolean isExtended(ClassNode owner, Iterator<InnerClassNode> classes) { while (classes.hasNext()) { InnerClassNode next = classes.next(); if (next!=owner && next.isDerivedFrom(owner)) return true; } if (owner.getInnerClasses().hasNext()) { return isExtended(owner, owner.getInnerClasses()); } return false; }
@Override public void visitClass(final ClassNode node) { ClassNode prec = classNode; classNode = node; super.visitClass(node); Iterator<InnerClassNode> innerClasses = classNode.getInnerClasses(); while (innerClasses.hasNext()) { InnerClassNode innerClassNode = innerClasses.next(); visitClass(innerClassNode); } classNode = prec; }
private void addPrivateFieldAndMethodAccessors(ClassNode node) { addPrivateBridgeMethods(node); addPrivateFieldsAccessors(node); Iterator<InnerClassNode> it = node.getInnerClasses(); while (it.hasNext()) { addPrivateFieldAndMethodAccessors(it.next()); } }
private boolean helperClassNotCreatedYet(final ClassNode traitReceiver) { return !traitReceiver.redirect().getInnerClasses().hasNext() && this.unit.getAST().getClasses().contains(traitReceiver.redirect()); } private boolean isTraitSuperPropertyExpression(Expression exp) {
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)); } }
private void checkInnerClasses(final ClassNode cNode) { Iterator<InnerClassNode> it = cNode.getInnerClasses(); while (it.hasNext()) { InnerClassNode origin = it.next(); if ((origin.getModifiers() & ACC_STATIC) == 0) { unit.addError(new SyntaxException("Cannot have non-static inner class inside a trait ("+origin.getName()+")", origin.getLineNumber(), origin.getColumnNumber())); } } }
public void visitClass(ClassNode node) { // AIC are already done, doing them here again will lead to wrong scopes if (node instanceof InnerClassNode) { InnerClassNode in = (InnerClassNode) node; if (in.isAnonymous() && !in.isEnum()) return; } pushState(); prepareVisit(node); super.visitClass(node); if (recurseInnerClasses) { Iterator<InnerClassNode> innerClasses = node.getInnerClasses(); while (innerClasses.hasNext()) { visitClass(innerClasses.next()); } } popState(); }
ClassNode fieldHelperClassNode = null; ClassNode staticFieldHelperClassNode = null; Iterator<InnerClassNode> innerClasses = trait.redirect().getInnerClasses(); if (innerClasses != null && innerClasses.hasNext()) {
printMethods(out, classNode, isEnum); for (Iterator<InnerClassNode> inner = classNode.getInnerClasses(); inner.hasNext(); ) {
@Override public void visitClass(ClassNode node) { this.classNode = node; thisField = null; InnerClassNode innerClass = null; if (!node.isEnum() && !node.isInterface() && node instanceof InnerClassNode) { innerClass = (InnerClassNode) node; thisField = innerClass.getField("this$0"); if (innerClass.getVariableScope() == null && innerClass.getDeclaredConstructors().isEmpty()) { // add dummy constructor innerClass.addConstructor(ACC_PUBLIC, Parameter.EMPTY_ARRAY, null, null); } } if (node.isEnum() || node.isInterface()) return; // use Iterator.hasNext() to check for available inner classes if (node.getInnerClasses().hasNext()) addDispatcherMethods(node); if (innerClass == null) return; super.visitClass(node); addDefaultMethods(innerClass); }
private void processClass(ClassNode cNode, final ClassCodeVisitorSupport visitor) { if (!isEnabled(cNode)) return; if (cNode.isInterface()) { addError("Error processing interface '" + cNode.getName() + "'. " + MY_TYPE_NAME + " only allowed for classes.", cNode); return; } for (ConstructorNode cn : cNode.getDeclaredConstructors()) { if (hasNoExplicitAutoFinal(cn)) { processConstructorOrMethod(cn, visitor); } } for (MethodNode mn : cNode.getAllDeclaredMethods()) { if (hasNoExplicitAutoFinal(mn)) { processConstructorOrMethod(mn, visitor); } } Iterator<InnerClassNode> it = cNode.getInnerClasses(); while (it.hasNext()) { InnerClassNode in = it.next(); if (in.getAnnotations(MY_TYPE).isEmpty()) { processClass(in, visitor); } } visitor.visitClass(cNode); }
typeCheckingContext.alreadyVisitedMethods = new LinkedHashSet<MethodNode>(); super.visitClass(node); Iterator<InnerClassNode> innerClasses = node.getInnerClasses(); while (innerClasses.hasNext()) { InnerClassNode innerClassNode = innerClasses.next();
@Override public void visitClass(final ClassNode node) { boolean skip = shouldSkipClassNode(node); if (!skip && !anyMethodSkip(node)) { node.putNodeMetaData(MopWriter.Factory.class, StaticCompilationMopWriter.FACTORY); } ClassNode oldCN = classNode; classNode = node; Iterator<InnerClassNode> innerClasses = classNode.getInnerClasses(); while (innerClasses.hasNext()) { InnerClassNode innerClassNode = innerClasses.next(); boolean innerStaticCompile = !(skip || isSkippedInnerClass(innerClassNode)); innerClassNode.putNodeMetaData(STATIC_COMPILE_NODE, innerStaticCompile); innerClassNode.putNodeMetaData(WriterControllerFactory.class, node.getNodeMetaData(WriterControllerFactory.class)); if (innerStaticCompile && !anyMethodSkip(innerClassNode)) { innerClassNode.putNodeMetaData(MopWriter.Factory.class, StaticCompilationMopWriter.FACTORY); } } super.visitClass(node); addPrivateFieldAndMethodAccessors(node); if (isStaticallyCompiled(node)) addDynamicOuterClassAccessorsCallback(node.getOuterClass()); classNode = oldCN; }
if (context == null || context.phase < phase || (context.phase == phase && !context.phaseComplete)) { int offset = 1; for (Iterator<InnerClassNode> iterator = classNode.getInnerClasses(); iterator.hasNext(); ) { iterator.next(); offset++;
Iterator<InnerClassNode> innerClasses = node.getInnerClasses(); if (innerClasses.hasNext()) { thatType = innerClasses.next();
for (Iterator<InnerClassNode> iter = classNode.getInnerClasses(); iter.hasNext();) { InnerClassNode innerClass = iter.next(); makeInnerClassEntry(innerClass);
|| (top instanceof InnerClassNode && Modifier.isPrivate(top.getModifiers()) && !isExtended(top, top.getOuterClass().getInnerClasses())) ) { CompareToNullExpression expr = new CompareToNullExpression(
@Override public void visitClass(final ClassNode node) { super.visitClass(node); Iterator<InnerClassNode> it = node.getInnerClasses(); while (it.hasNext()) { InnerClassNode next = it.next(); visitClass(next); } }
protected void createInterfaceSyntheticStaticFields() { ClassNode icl = controller.getInterfaceClassLoadingClass(); if (referencedClasses.isEmpty()) { Iterator<InnerClassNode> it = controller.getClassNode().getInnerClasses(); while(it.hasNext()) { InnerClassNode inner = it.next(); if (inner==icl) { it.remove(); return; } } return; } addInnerClass(icl); for (String staticFieldName : referencedClasses.keySet()) { // generate a field node icl.addField(staticFieldName, ACC_STATIC + ACC_SYNTHETIC, ClassHelper.CLASS_Type.getPlainNodeReference(), new ClassExpression(referencedClasses.get(staticFieldName))); } }
if (context == null || context.phase < phase || (context.phase == phase && !context.phaseComplete)) { int offset = 1; Iterator<InnerClassNode> iterator = classNode.getInnerClasses(); while (iterator.hasNext()) { iterator.next();