How to use

hasMethod

method

in

org.codehaus.groovy.ast.ClassNode

if (an.getClassNode().hasMethod(name, Parameter.EMPTY_ARRAY)) {
  unusedNames.remove(name);
  an.setMember(name, aliasAnnotationUsage.getMember(name));

AnnotationNode internalAnnotation = shouldAnnotate ? new AnnotationNode(ClassHelper.make(INTERNAL_ANNOTATION)) : null;
if (!node.hasMethod("getMetaClass", Parameter.EMPTY_ARRAY)) {
  metaClassField = setMetaClassFieldIfNotExists(node, metaClassField);
  MethodNode methodNode = addMethod(node, !isAbstract(node.getModifiers()),
if (!node.hasMethod("setMetaClass", parameters)) {
  metaClassField = setMetaClassFieldIfNotExists(node, metaClassField);
  Statement setMetaClassCode;
if (!node.hasMethod("invokeMethod", INVOKE_METHOD_PARAMS)) {
  VariableExpression vMethods = new VariableExpression("method");
  VariableExpression vArguments = new VariableExpression("arguments");
if (!node.hasMethod("getProperty", GET_PROPERTY_PARAMS)) {
  MethodNode methodNode = addMethod(node, !isAbstract(node.getModifiers()),
      "getProperty",
if (!node.hasMethod("setProperty", SET_PROPERTY_PARAMS)) {
  MethodNode methodNode = addMethod(node, !isAbstract(node.getModifiers()),
      "setProperty",

if (cNode.hasMethod(mNode.getName(), genParamsArray)) {
  addError("Error during " + MY_TYPE_NAME + " processing. Class " + cNode.getNameWithoutPackage() +
      " already has a named-arg " + (mNode instanceof ConstructorNode ? "constructor" : "method") +

protected static boolean hasSimilarMethod(MethodNode declaredMethod, ClassNode groovyMethods) {
  return groovyMethods.hasMethod(declaredMethod.getName(), declaredMethod.getParameters());
}

static protected boolean hasDeclaredMethod(ClassNode classNode, MethodNode mixinMethod) {
  return classNode.hasMethod(mixinMethod.getName(), mixinMethod.getParameters());
}

public static boolean isAddableMethod(MethodNode declaredMethod) {
  ClassNode groovyMethods = GROOVY_OBJECT_CLASS_NODE;
  String methodName = declaredMethod.getName();
  return !declaredMethod.isSynthetic() &&
      !methodName.contains("$") &&
      Modifier.isPublic(declaredMethod.getModifiers()) &&
      !Modifier.isAbstract(declaredMethod.getModifiers()) &&
      !groovyMethods.hasMethod(declaredMethod.getName(), declaredMethod.getParameters());
}

/**
 * Adds a method to the class node passed as first argument only
 * if it wasn't present in the first place
 *
 * @param classNode the class we want to add the method to
 * @param methodNode the method we want to add
 * @since 0.3.0
 */
public void addMethodIfNotPresent(final ClassNode classNode, final MethodNode methodNode) {
  if (!classNode.hasMethod(methodNode.getName(), methodNode.getParameters())) {
    classNode.addMethod(methodNode);
  }
}

private static String findSuitablePrivateMethodName(final ClassNode owner, final MethodNode original) {
  String newMethodName = InternalActor.METHOD_NAME_PREFIX + original.getName();
  int counter = 1;
  while (owner.hasMethod(newMethodName, original.getParameters())) {
    newMethodName = InternalActor.METHOD_NAME_PREFIX + original.getName() + counter;
    counter++;
  }
  return newMethodName;
}

private static boolean isCandidateMethod(MethodNode declaredMethod) {
  ClassNode groovyMethods = GROOVY_OBJECT_CLASS_NODE;
  String methodName = declaredMethod.getName();
  return !declaredMethod.isSynthetic() &&
    !methodName.contains("$") &&
    Modifier.isPublic(declaredMethod.getModifiers()) &&
    !groovyMethods.hasMethod(declaredMethod.getName(), declaredMethod.getParameters());
}

FieldNode metaClassField = getMetaClassField(node);
if (!node.hasMethod("getMetaClass", Parameter.EMPTY_ARRAY)) {
  metaClassField = setMetaClassFieldIfNotExists(node, metaClassField);
  addMethod(node, !Modifier.isAbstract(node.getModifiers()),
if (!node.hasMethod("setMetaClass", parameters)) {
  metaClassField = setMetaClassFieldIfNotExists(node, metaClassField);
  Statement setMetaClassCode;
if (!node.hasMethod("invokeMethod", INVOKE_METHOD_PARAMS)) {
  VariableExpression vMethods = new VariableExpression("method");
  VariableExpression vArguments = new VariableExpression("arguments");
if (!node.hasMethod("getProperty", GET_PROPERTY_PARAMS)) {
  addMethod(node, !Modifier.isAbstract(node.getModifiers()),
      "getProperty",
if (!node.hasMethod("setProperty", SET_PROPERTY_PARAMS)) {
  addMethod(node, !Modifier.isAbstract(node.getModifiers()),
      "setProperty",

final String classInternalName = BytecodeHelper.getClassInternalName(node);
if (!node.hasMethod("getMetaClass", Parameter.EMPTY_ARRAY)) {
  metaClassField=setMetaClassFieldIfNotExists(node,metaClassField);
  StaticMethodCallExpression initMetaClassCall = new StaticMethodCallExpression(
if (!node.hasMethod("setMetaClass", SET_METACLASS_PARAMS)) {
  metaClassField=setMetaClassFieldIfNotExists(node,metaClassField);
  Statement setMetaClassCode;                
if (!node.hasMethod("invokeMethod",INVOKE_METHOD_PARAMS)) {
  VariableExpression vMethods = new VariableExpression("method");
  VariableExpression vArguments = new VariableExpression("arguments");
if (!node.hasMethod("getProperty", GET_PROPERTY_PARAMS)) {
  List instructions = new ArrayList();
  instructions.add(new BytecodeInstruction() {
if (!node.hasMethod("setProperty", SET_PROPERTY_PARAMS)) {
  List instructions = new ArrayList();
  instructions.add(new BytecodeInstruction() {

FieldNode metaClassField = getMetaClassField(node);
if (!node.hasMethod("getMetaClass", Parameter.EMPTY_ARRAY)) {
  metaClassField = setMetaClassFieldIfNotExists(node, metaClassField);
  addMethod(node,!Modifier.isAbstract(node.getModifiers()),
if (!node.hasMethod("setMetaClass", parameters)) {
  metaClassField=setMetaClassFieldIfNotExists(node,metaClassField);
  Statement setMetaClassCode;                
if (!node.hasMethod("invokeMethod",INVOKE_METHOD_PARAMS)) {
  VariableExpression vMethods = new VariableExpression("method");
  VariableExpression vArguments = new VariableExpression("arguments");
if (!node.hasMethod("getProperty", GET_PROPERTY_PARAMS)) {
  addMethod(node,!Modifier.isAbstract(node.getModifiers()),
      "getProperty",
if (!node.hasMethod("setProperty", SET_PROPERTY_PARAMS)) {
  addMethod(node,!Modifier.isAbstract(node.getModifiers()),
      "setProperty",

FieldNode metaClassField = getMetaClassField(node);
if (!node.hasMethod("getMetaClass", Parameter.EMPTY_ARRAY)) {
  metaClassField = setMetaClassFieldIfNotExists(node, metaClassField);
  node.addSyntheticMethod(
if (!node.hasMethod("setMetaClass", parameters)) {
  metaClassField=setMetaClassFieldIfNotExists(node,metaClassField);
  Statement setMetaClassCode;                
if (!node.hasMethod("invokeMethod",INVOKE_METHOD_PARAMS)) {
  VariableExpression vMethods = new VariableExpression("method");
  VariableExpression vArguments = new VariableExpression("arguments");
if (!node.hasMethod("getProperty", GET_PROPERTY_PARAMS)) {
  node.addSyntheticMethod(
      "getProperty",
if (!node.hasMethod("setProperty", SET_PROPERTY_PARAMS)) {
  node.addSyntheticMethod(
      "setProperty",