How to use

getGetterMethod

method

in

org.codehaus.groovy.ast.ClassNode

public MethodNode getGetterMethod(String getterName) {
  return getGetterMethod(getterName, true);
}

private static void extractAccessorInfo(ClassNode owner, String name, Reference<Boolean> willHaveGetAccessor, Reference<Boolean> willHaveIsAccessor) {
  String suffix = Verifier.capitalize(name);
  boolean hasGetAccessor = owner.getGetterMethod("get" + suffix) != null;
  boolean hasIsAccessor = owner.getGetterMethod("is" + suffix) != null;
  PropertyNode prop = owner.getProperty(name);
  willHaveGetAccessor.set(hasGetAccessor || (prop != null && !hasIsAccessor));
  willHaveIsAccessor.set(hasIsAccessor || (prop != null && !hasGetAccessor && prop.getOriginType().equals(ClassHelper.boolean_TYPE)));
}

private MethodNode findGetter(ClassNode current, String name, boolean searchOuterClasses) {
  MethodNode getterMethod = current.getGetterMethod(name);
  if (getterMethod == null && searchOuterClasses && current instanceof InnerClassNode) {
    return findGetter(current.getOuterClass(), name, true);
  }
  return getterMethod;
}

private MethodNode findValidGetter(ClassNode classNode, String name) {
  MethodNode getterMethod = classNode.getGetterMethod(name);
  if (getterMethod != null && (getterMethod.isPublic() || getterMethod.isProtected())) {
    return getterMethod;
  }
  return null;
}

private MethodNode findGetterOfSuperClass(ClassNode classNode, FieldNode fieldNode) {
  String getterMethodName = "get" + MetaClassHelper.capitalize(fieldNode.getName());
  return classNode.getSuperClass().getGetterMethod(getterMethodName);
}

private static void addGetterIfNeeded(DelegateDescription delegate, PropertyNode prop, String name, boolean allNames) {
  boolean isPrimBool = prop.getOriginType().equals(ClassHelper.boolean_TYPE);
  // do a little bit of pre-work since Groovy compiler hasn't added property accessors yet
  boolean willHaveGetAccessor = true;
  boolean willHaveIsAccessor = isPrimBool;
  String suffix = Verifier.capitalize(name);
  if (isPrimBool) {
    ClassNode cNode = prop.getDeclaringClass();
    if (cNode.getGetterMethod("is" + suffix) != null && cNode.getGetterMethod("get" + suffix) == null)
      willHaveGetAccessor = false;
    if (cNode.getGetterMethod("get" + suffix) != null && cNode.getGetterMethod("is" + suffix) == null)
      willHaveIsAccessor = false;
  }
  Reference<Boolean> ownerWillHaveGetAccessor = new Reference<Boolean>();
  Reference<Boolean> ownerWillHaveIsAccessor = new Reference<Boolean>();
  extractAccessorInfo(delegate.owner, name, ownerWillHaveGetAccessor, ownerWillHaveIsAccessor);
  for (String prefix : new String[]{"get", "is"}) {
    String getterName = prefix + suffix;
    if ((prefix.equals("get") && willHaveGetAccessor && !ownerWillHaveGetAccessor.get()
        || prefix.equals("is") && willHaveIsAccessor && !ownerWillHaveIsAccessor.get())
        && !shouldSkipPropertyMethod(name, getterName, delegate.excludes, delegate.includes, allNames)) {
      addGeneratedMethod(delegate.owner, getterName,
          ACC_PUBLIC,
          GenericsUtils.nonGeneric(prop.getType()),
          Parameter.EMPTY_ARRAY,
          null,
          returnS(propX(delegate.getOp, name)));
    }
  }
}

public MethodNode getGetterMethod(String getterName, boolean searchSuperClasses) {
  MethodNode getterMethod = null;
  boolean booleanReturnOnly = getterName.startsWith("is");
  for (MethodNode method : getDeclaredMethods(getterName)) {
    if (getterName.equals(method.getName())
        && ClassHelper.VOID_TYPE!=method.getReturnType()
        && method.getParameters().length == 0
        && (!booleanReturnOnly || ClassHelper.Boolean_TYPE.equals(ClassHelper.getWrapper(method.getReturnType())))) {
      // GROOVY-7363: There can be multiple matches for a getter returning a generic parameter type, due to
      // the generation of a bridge method. The real getter is really the non-bridge, non-synthetic one as it
      // has the most specific and exact return type of the two. Picking the bridge method results in loss of
      // type information, as it down-casts the return type to the lower bound of the generic parameter.
      if (getterMethod == null || getterMethod.isSynthetic()) {
        getterMethod = method;
      }
    }
  }
  if (getterMethod != null) return getterMethod;
  if (searchSuperClasses) {
    ClassNode parent = getSuperClass();
    if (parent != null) return parent.getGetterMethod(getterName);
  }
  return null;
}

MethodNode getter = classNode.getGetterMethod(getterName, !node.isStatic());
if (getter == null && ClassHelper.boolean_TYPE == node.getType()) {
  String secondGetterName = "is" + capitalize(name);
  getter = classNode.getGetterMethod(secondGetterName);

private boolean makeGetPropertyWithGetter(final Expression receiver, final ClassNode receiverType, final String methodName, final boolean safe, final boolean implicitThis) {
  MethodNode getterNode = receiverType.getGetterMethod(getterName);
  if (getterNode==null) {
    getterName = "is" + MetaClassHelper.capitalize(methodName);
    getterNode = receiverType.getGetterMethod(getterName);

MethodNode getterMethod = null;
for (ClassNode anInterface : allInterfaces) {
  getterMethod = anInterface.getGetterMethod(getterName);
  if (getterMethod == null) getterMethod = anInterface.getGetterMethod(altGetterName);
  if (getterMethod != null) break;
  getterMethod = OBJECT_TYPE.getGetterMethod(getterName);

MethodNode getter = cNode.getGetterMethod(getterName);
if (getter == null && ClassHelper.boolean_TYPE == node.getType()) {
  String secondGetterName = "is" + Verifier.capitalize(name);
  getter = cNode.getGetterMethod(secondGetterName);

public static MethodNode getGetter(ClassNode classNode, FieldNode fieldNode) {
 return classNode.getGetterMethod(GroovyUtils.getsetName(GroovyUtils.GetSet.GET, fieldNode.getName()));
}

public MethodNode getGetterMethod(String getterName) {
  for (Iterator iter = getDeclaredMethods(getterName).iterator(); iter.hasNext();) {
    MethodNode method = (MethodNode) iter.next();
    if (getterName.equals(method.getName())
        && ClassHelper.VOID_TYPE!=method.getReturnType()
        && method.getParameters().length == 0) {
      return method;
    }
  }
  ClassNode parent = getSuperClass(); 
  if (parent!=null) return parent.getGetterMethod(getterName); 
  return null;
}

public MethodNode getGetterMethod(String getterName) {
  for (MethodNode method : getDeclaredMethods(getterName)) {
    if (getterName.equals(method.getName())
        && ClassHelper.VOID_TYPE!=method.getReturnType()
        && method.getParameters().length == 0) {
      return method;
    }
  }
  ClassNode parent = getSuperClass();
  if (parent!=null) return parent.getGetterMethod(getterName);
  return null;
}

public MethodNode getGetterMethod(String getterName) {
  for (Object o : getDeclaredMethods(getterName)) {
    MethodNode method = (MethodNode) o;
    if (getterName.equals(method.getName())
        && ClassHelper.VOID_TYPE!=method.getReturnType()
        && method.getParameters().length == 0) {
      return method;
    }
  }
  ClassNode parent = getSuperClass();
  if (parent!=null) return parent.getGetterMethod(getterName);
  return null;
}

public MethodNode getGetterMethod(String getterName) {
  for (Object o : getDeclaredMethods(getterName)) {
    MethodNode method = (MethodNode) o;
    if (getterName.equals(method.getName())
        && ClassHelper.VOID_TYPE!=method.getReturnType()
        && method.getParameters().length == 0) {
      return method;
    }
  }
  ClassNode parent = getSuperClass();
  if (parent!=null) return parent.getGetterMethod(getterName);
  return null;
}

String name = propertyNode.getName();
name = Character.toUpperCase(name.charAt(0)) + name.substring(1);
MethodNode getter = classNode.getGetterMethod("get" + name); // NOI18N
if (getter != null) {
  genMethod(classNode, getter, out, false);

private void addGetterIfNeeded(FieldNode fieldNode, ClassNode owner, PropertyNode prop, String name) {
  String getterName = "get" + Verifier.capitalize(name);
  if (owner.getGetterMethod(getterName) == null) {
    owner.addMethod(getterName,
        ACC_PUBLIC,
        nonGeneric(prop.getType()),
        Parameter.EMPTY_ARRAY,
        null,
        new ReturnStatement(
            new PropertyExpression(
                new FieldExpression(fieldNode),
                name)));
  }
}

private void addGetterIfNeeded(FieldNode fieldNode, ClassNode owner, PropertyNode prop, String name) {
  String getterName = "get" + Verifier.capitalize(name);
  if (owner.getGetterMethod(getterName) == null) {
    owner.addMethod(getterName,
        ACC_PUBLIC,
        nonGeneric(prop.getType()),
        Parameter.EMPTY_ARRAY,
        null,
        new ReturnStatement(
            new PropertyExpression(
                new VariableExpression(fieldNode),
                name)));
  }
}

MethodNode getter = classNode.getGetterMethod(getterName);
if(getter == null && ClassHelper.boolean_TYPE==node.getType()) {
  String secondGetterName = "is" + capitalize(name);
  getter = classNode.getGetterMethod(secondGetterName);