How to use

getMethod

method

in

org.codehaus.groovy.ast.ClassNode

/**
 * @see #getMethod(String, Parameter[])
 */
public boolean hasMethod(String name, Parameter[] parameters) {
  MethodNode other = getMethod(name, parameters);
  return other != null;
}

List<MethodNode> traitMethods = node.getMethods();
for (MethodNode traitMethod : traitMethods) {
  MethodNode method = classNode.getMethod(traitMethod.getName(), traitMethod.getParameters());
  if (method == null) {
    for (MethodNode methodNode : propertyMethods) {

BlockStatement code = new BlockStatement();
MethodCallExpression cloneCall = new MethodCallExpression(new FieldExpression(values), "clone", MethodCallExpression.NO_ARGUMENTS);
cloneCall.setMethodTarget(values.getType().getMethod("clone", Parameter.EMPTY_ARRAY));
code.addStatement(new ReturnStatement(cloneCall));
valuesMethod.setCode(code);

private static String getterName(ClassNode annotatedNode, PropertyNode pNode) {
  String getterName = "get" + MetaClassHelper.capitalize(pNode.getName());
  boolean existingExplicitGetter = annotatedNode.getMethod(getterName, Parameter.EMPTY_ARRAY) != null;
  if (ClassHelper.boolean_TYPE.equals(pNode.getOriginType()) && !existingExplicitGetter) {
    getterName = "is" + MetaClassHelper.capitalize(pNode.getName());
  }
  return getterName;
}

public static boolean addMethod(ClassNode classNode, MethodNode methodNode, boolean replace) {
  MethodNode oldMethod = classNode.getMethod(methodNode.getName(), methodNode.getParameters());
  if (oldMethod == null) {
    classNode.addMethod(methodNode);
    return true;
  } else if (replace) {
    classNode.getMethods().remove(oldMethod);
    classNode.addMethod(methodNode);
    return true;
  }
  return false;
}

cn.getModule().addClass(helper);
helper.addAnnotation(new AnnotationNode(COMPILESTATIC_CLASSNODE));
MethodNode serializeClass = collector.getClassNode().getMethod("serializeClass", Parameter.EMPTY_ARRAY);
collector.setMember("serializeClass", new ClassExpression(helper.getPlainNodeReference()));

private void checkNoAbstractMethodsNonabstractClass(ClassNode node) {
  if (isAbstract(node.getModifiers())) return;
  List<MethodNode> abstractMethods = node.getAbstractMethods();
  if (abstractMethods == null) return;
  for (MethodNode method : abstractMethods) {
    MethodNode sameArgsMethod = node.getMethod(method.getName(), method.getParameters());
    if (sameArgsMethod==null || method.getReturnType().equals(sameArgsMethod.getReturnType())) {
      addError("Can't have an abstract method in a non-abstract class." +
          " The " + getDescription(node) + " must be declared abstract or" +
          " the " + getDescription(method) + " must be implemented.", node);
    } else {
      addError("Abstract "+getDescription(method)+" is not implemented but a " +
              "method of the same name but different return type is defined: "+
              (sameArgsMethod.isStatic()?"static ":"")+
              getDescription(sameArgsMethod), method
      );
    }
  }
}

ClassNode type;
if (isMethod) {
  target = node.getMethod(name, paraTypes);
  if (target==null) return;
  if (!target.getDeclaringClass().equals(node)) return;

System.arraycopy(methodNode.getParameters(), 1, params, 0, params.length);
Map<String,ClassNode> methodGenericsSpec = new LinkedHashMap<String, ClassNode>(genericsSpec);
MethodNode originalMethod = trait.getMethod(name, params);

private void createSharedFieldGetter(Field field) {
 String getterName = "get" + MetaClassHelper.capitalize(field.getName());
 MethodNode getter = spec.getAst().getMethod(getterName, Parameter.EMPTY_ARRAY);
 if (getter != null) {
  errorReporter.error(field.getAst(),
    "@Shared field '%s' conflicts with method '%s'; please rename either of them",
    field.getName(), getter.getName());
  return;
 }
 BlockStatement getterBlock = new BlockStatement();
 getter = new MethodNode(getterName, determineVisibilityForSharedFieldAccessor(field) | Opcodes.ACC_SYNTHETIC,
   field.getAst().getType(), Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, getterBlock);
 getterBlock.addStatement(
   new ReturnStatement(
     new ExpressionStatement(
       new AttributeExpression(
         getSharedInstance(),
         // use internal name
         new ConstantExpression(field.getAst().getName())))));
 getter.setSourcePosition(field.getAst());
 spec.getAst().addMethod(getter);
}

private void createSharedFieldSetter(Field field) {
 String setterName = "set" + MetaClassHelper.capitalize(field.getName());
 Parameter[] params = new Parameter[] { new Parameter(field.getAst().getType(), "$spock_value") };
 MethodNode setter = spec.getAst().getMethod(setterName, params);
 if (setter != null) {
  errorReporter.error(field.getAst(),
       "@Shared field '%s' conflicts with method '%s'; please rename either of them",
       field.getName(), setter.getName());
  return;
 }
 BlockStatement setterBlock = new BlockStatement();
 setter = new MethodNode(setterName, determineVisibilityForSharedFieldAccessor(field) | Opcodes.ACC_SYNTHETIC,
   ClassHelper.VOID_TYPE, params, ClassNode.EMPTY_ARRAY, setterBlock);
 setterBlock.addStatement(
   new ExpressionStatement(
     new BinaryExpression(
       new AttributeExpression(
         getSharedInstance(),
         // use internal name
         new ConstantExpression(field.getAst().getName())),
       Token.newSymbol(Types.ASSIGN, -1, -1),
       new VariableExpression("$spock_value"))));
 setter.setSourcePosition(field.getAst());
 spec.getAst().addMethod(setter);
}

iterator.setMethodTarget(collectionType.getMethod("iterator", Parameter.EMPTY_ARRAY));
iterator.setImplicitThis(false);
iterator.visit(controller.getAcg());

 @Override
 public void visit(ASTNode[] nodes, SourceUnit source) {
  for (ClassNode classNode : source.getAST().getClasses()) {
   if (classNode.isDerivedFrom(GROOVY_SCRIPT_COMMAND)) {
    MethodNode run = classNode.getMethod("run", new Parameter[0]);
    Statement code = run.getCode();
    if (code instanceof BlockStatement) {
     BlockStatement block = (BlockStatement)code;
     List<Statement> statements = block.getStatements();
     int size = statements.size();
     if (size > 0) {
      Statement last = statements.get(size - 1);
      if (last instanceof ReturnStatement) {
       classNode.addField(new FieldNode(
         FIELD_NAME,
         Modifier.PUBLIC | Modifier.STATIC,
         ClassHelper.Boolean_TYPE,
         classNode,
         null));
      }
     }
    }
   }
  }
 }
}

/**
 * @see #getMethod(String, Parameter[])
 */
public boolean hasMethod(String name, Parameter[] parameters) {
  MethodNode other = getMethod(name, parameters);
  return other != null;
}

/**
 * @see #getMethod(String, Parameter[])
 */
public boolean hasMethod(String name, Parameter[] parameters) {
  MethodNode other = getMethod(name, parameters);
  return other != null;
}

/**
 * @see #getMethod(String, Parameter[])
 */
public boolean hasMethod(String name, Parameter[] parameters) {
  MethodNode other = getMethod(name, parameters);
  return other != null;
}

/**
 * @see #getMethod(String, Parameter[])
 */
public boolean hasMethod(String name, Parameter[] parameters) {
  MethodNode other = getMethod(name, parameters);
  return other != null;
}

private static void validatePoolClass(final Expression classExpression, final AnnotatedNode fieldNode, final SourceUnit source) {
  final Parameter[] parameters = {new Parameter(ClassHelper.CLOSURE_TYPE, "a1"),
      new Parameter(ClassHelper.boolean_TYPE, "a2")};
  final MethodNode asyncFunMethod = classExpression.getType().getMethod("asyncFun", parameters);
  if (asyncFunMethod == null || !asyncFunMethod.isStatic())
    addError("Supplied pool class has no static asyncFun(Closure, boolean) method", fieldNode, source);
}

 public static boolean isChromatticAnnotedInHierarchy(ClassNode classNode, FieldNode fieldNode) {
  if (classNode == null) classNode = fieldNode.getDeclaringClass();
  ClassNode superClassNode = classNode.getSuperClass(); 
  if (!superClassNode.equals(ClassHelper.OBJECT_TYPE)) {
   MethodNode superMethodNode = superClassNode.getMethod(getsetName(GetSet.GET, fieldNode.getName()), new Parameter[]{});
   if (superMethodNode != null) return true;
   else isChromatticAnnotedInHierarchy(superClassNode, fieldNode);
  }
  return false;
 }
}

@Override
public void visitProperty(PropertyNode node) {
  final ClassNode classNode = node.getDeclaringClass();
  final String setterName = "set" + MetaClassHelper.capitalize(node.getName());
  final Statement setterBlock = node.getSetterBlock();
  final Parameter parameter = new Parameter(node.getType(), "value");
  if (CandidateChecks.isClassInvariantCandidate(node) && (setterBlock == null && classNode.getMethod(setterName, new Parameter[]{ parameter } ) == null)) {
    final Statement setterBlockStatement = createSetterBlock(classNode, node.getField(), parameter);
    node.setSetterBlock(setterBlockStatement);
  }
}