How to use org.codehaus.groovy.ast

@Override
public void visitConstructor(ConstructorNode node) {
 addNode(constructors, node.getDeclaringClass().getNameWithoutPackage(), node);
 super.visitConstructor(node);
}

@Override
public void visitProperty(PropertyNode node) {
 addNode(properties, node.getName(), node);
 super.visitProperty(node);
}

@Override
public void visitClass(ClassNode node) {
 addNode(classes, node.getNameWithoutPackage(), node);
 super.visitClass(node);
}

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);
}

protected void visitConstructorOrMethod(MethodNode node, boolean isConstructor) {
  for (Parameter p : node.getParameters()) {
    if (p.hasInitialExpression()) {
      Expression init = p.getInitialExpression();
      p.setInitialExpression(transform(init));
    }
  }
  super.visitConstructorOrMethod(node, isConstructor);
}

public void testPrimitiveOriginTypeConstructorParameter() {
  Parameter boolParameter = new Parameter(ClassHelper.boolean_TYPE,"foo");
  Parameter intParameter = new Parameter(ClassHelper.int_TYPE,"foo");
  VariableExpression newBoolExpression = new VariableExpression(boolParameter);
  VariableExpression newIntExpression = new VariableExpression(intParameter);
  assertEquals(newBoolExpression.getOriginType().getName(),"boolean");
  assertEquals(newIntExpression.getOriginType().getName(),"int"); 
}
 

private void addDummyConstructor(ClassNode node) {
  // constructors should not be treated as errors (they have no real meaning for interfaces anyway)
  node.addMethod(new MethodNode("<clinit>", ACC_PUBLIC | ACC_STATIC, ClassHelper.OBJECT_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, null));
}

@Override
public void visitMethod(MethodNode node) {
 addNode(methods, node.getName(), node);
 super.visitMethod(node);
}

public void testIsImplicitThisOnObject() {
  ModuleNode root = getAST("string.substring(2)", Phases.SEMANTIC_ANALYSIS);
  methodCallVisitor.visitClass(root.getClasses().get(0));
  assertTrue(visited);
  assertFalse(isImplicitThis);
}
 

@Override
public void visitField(FieldNode node) {
 addNode(fields, node.getName(), node);
 super.visitField(node);
}

  public void testPackageName() {
    assertEquals("Package", null, classNode.getPackageName());

    ClassNode packageNode = new ClassNode("com.acme.Foo", ACC_PUBLIC, ClassHelper.OBJECT_TYPE);
    assertEquals("Package", "com.acme", packageNode.getPackageName());
  }
}

public void visitClass(ClassNode node) {
  visitType(node);
  visitType(node.getUnresolvedSuperClass());
  visitTypes(node.getInterfaces());
  super.visitClass(node);
}

public void visit(ASTNode[] nodes, SourceUnit sourceUnit) {
  ClassNode classNode = (ClassNode) nodes[1];
  classNode.addField(new FieldNode("f1", ACC_PUBLIC, ClassHelper.OBJECT_TYPE, classNode, null));
}

public void visitMethodCallExpression(MethodCallExpression call) {
  visitNode(call);
  super.visitMethodCallExpression(call);
}

public void visitGStringExpression(GStringExpression expression) {
  visitNode(expression);
  super.visitGStringExpression(expression);
}

  public void visitClosureListExpression(ClosureListExpression cle) {
    visitNode(cle);
    super.visitClosureListExpression(cle);
  }
}

public void visitNotExpression(NotExpression expression) {
  visitNode(expression);
  super.visitNotExpression(expression);
}

public void visitListExpression(ListExpression expression) {
  visitNode(expression);
  super.visitListExpression(expression);
}

public void visitSpreadExpression(SpreadExpression expression) {
  visitNode(expression);
  super.visitSpreadExpression(expression);
}

public void visitShortTernaryExpression(ElvisOperatorExpression expression) {
  visitNode(expression);
  super.visitShortTernaryExpression(expression);
}