public void visitClass(ClassNode klassNode) { ClassNode oldClass = classNode; classNode = klassNode; super.visitClass(classNode); classNode = oldClass; }
public void visitClass(ClassNode node, SourceUnit source) { this.source = source; super.visitClass(node); }
@Override public void visitClass(ClassNode node) { addNode(classes, node.getNameWithoutPackage(), node); super.visitClass(node); }
public void visitClass(ClassNode node, SourceUnit source) { this.source = source; this.inAnnotationDef = node.isAnnotationDefinition(); super.visitClass(node); this.inAnnotationDef = false; }
@Override public void visitClass(ClassNode node) { this.optimizeMethodCall = !node.implementsInterface(GROOVY_INTERCEPTABLE_TYPE); this.node = node; this.scope = nonStaticScope; super.visitClass(node); this.scope=null; this.node=null; }
@Override public void visitClass(ClassNode node) { Set<String> old = current; current = cache.get(node.getName()); addToCache(node); super.visitClass(node); current = old; } @Override
super.visitClass(classNode);
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(); }
public void testIsImplicitThisExplicitThis() { ModuleNode root = getAST("this.println()", Phases.SEMANTIC_ANALYSIS); methodCallVisitor.visitClass(root.getClasses().get(0)); assertTrue(visited); assertFalse(isImplicitThis); }
public void testIsImplicitThisOnObject() { ModuleNode root = getAST("string.substring(2)", Phases.SEMANTIC_ANALYSIS); methodCallVisitor.visitClass(root.getClasses().get(0)); assertTrue(visited); assertFalse(isImplicitThis); }
public void testIsImplicitThisNoObject() { ModuleNode root = getAST("println()", Phases.SEMANTIC_ANALYSIS); methodCallVisitor.visitClass(root.getClasses().get(0)); assertTrue(visited); assertTrue(isImplicitThis); } }
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); }
Set<MethodNode> oldVisitedMethod = typeCheckingContext.alreadyVisitedMethods; typeCheckingContext.alreadyVisitedMethods = new LinkedHashSet<MethodNode>(); super.visitClass(node); Iterator<InnerClassNode> innerClasses = node.getInnerClasses(); while (innerClasses.hasNext()) {
public void visitClass(ClassNode node) { visitType(node); visitType(node.getUnresolvedSuperClass()); visitTypes(node.getInterfaces()); super.visitClass(node); }
public void visitClass(ClassNode node) { ClassNode oldClass = currentClass; currentClass = node; checkImplementsAndExtends(node); if (source != null && !source.getErrorCollector().hasErrors()) { checkClassForIncorrectModifiers(node); checkInterfaceMethodVisibility(node); checkAbstractMethodVisibility(node); checkClassForOverwritingFinal(node); checkMethodsForIncorrectModifiers(node); checkMethodsForIncorrectName(node); checkMethodsForWeakerAccess(node); checkMethodsForOverridingFinal(node); checkNoAbstractMethodsNonabstractClass(node); checkClassExtendsAllSelfTypes(node); checkNoStaticMethodWithSameSignatureAsNonStatic(node); checkGenericsUsage(node, node.getUnresolvedInterfaces()); checkGenericsUsage(node, node.getUnresolvedSuperClass()); } super.visitClass(node); currentClass = oldClass; }
@Override public void visitClass(ClassNode node) { if (isInside(node, line, column)) { super.visitClass(node); } }
public final void visitClass(final ClassNode node) { currentClassNode = node; visitClassEx(node); super.visitClass(node); visitClassComplete(node); currentClassNode = null; }
@Override public void visitClass(final ClassNode node) { pushContext(node); super.visitClass(node); popContext(); }
@Override public void visitClass(ClassNode node) { Set<String> old = current; current = cache.get(node.getName()); addToCache(node); super.visitClass(node); current = old; } @Override
public void visitClass(ClassNode node) { pushState(); currentClass = node; boolean dynamicMode = node.isScript(); currentScope.setDynamicResolving(dynamicMode); currentScope.setClassScope(node); super.visitClass(node); popState(); }