How to use

getProperty

method

in

org.codehaus.groovy.ast.ClassNode

public boolean hasProperty(String name) {
  return getProperty(name) != null;
}

  private static boolean isExistingProperty(final String methodName, final ClassNode cNode, final Parameter[] params) {
    String propertyName = methodName;
    boolean getter = false;
    if (methodName.startsWith("get")) {
      propertyName = propertyName.substring(3);
      getter = true;
    } else if (methodName.startsWith("is")) {
      propertyName = propertyName.substring(2);
      getter = true;
    } else if (methodName.startsWith("set")) {
      propertyName = propertyName.substring(3);
    } else {
      return false;
    }
    if (getter && params.length>0) {
      return false;
    }
    if (!getter && params.length!=1) {
      return false;
    }
    if (propertyName.length()==0) {
      return false;
    }
    propertyName = MetaClassHelper.convertPropertyName(propertyName);
    PropertyNode pNode = cNode.getProperty(propertyName);
    return pNode != null;
  }
}

public static List<FieldNode> getInstanceNonPropertyFields(ClassNode cNode) {
  final List<FieldNode> result = new ArrayList<FieldNode>();
  for (FieldNode fNode : cNode.getFields()) {
    if (!fNode.isStatic() && cNode.getProperty(fNode.getName()) == null) {
      result.add(fNode);
    }
  }
  return result;
}

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

public static List<FieldNode> getSuperNonPropertyFields(ClassNode cNode) {
  final List<FieldNode> result;
  if (cNode == ClassHelper.OBJECT_TYPE) {
    result = new ArrayList<FieldNode>();
  } else {
    result = getSuperNonPropertyFields(cNode.getSuperClass());
  }
  for (FieldNode fNode : cNode.getFields()) {
    if (!fNode.isStatic() && cNode.getProperty(fNode.getName()) == null) {
      result.add(fNode);
    }
  }
  return result;
}

  private static void addIfMissing(ClassNode cNode, List<PropertyNode> result, Set<String> names, MethodNode mNode, ClassNode returnType, String propName, Statement getter, Statement setter) {
    if (cNode.getProperty(propName) != null) return;
    if (names.contains(propName)) {
      for (PropertyNode pn : result) {
        if (pn.getName().equals(propName) && getter != null && pn.getGetterBlock() == null) {
          pn.setGetterBlock(getter);
        }
        if (pn.getName().equals(propName) && setter != null && pn.getSetterBlock() == null) {
          pn.setSetterBlock(setter);
        }
      }
    } else {
      result.add(new PropertyNode(propName, mNode.getModifiers(), returnType, cNode, null, getter, setter));
      names.add(propName);
    }
  }
}

@Override
public void visitField(FieldNode gField) {
 PropertyNode owner = spec.getAst().getProperty(gField.getName());
 if (gField.isStatic()) return;
 Field field = new Field(spec, gField, fieldCount++);
 field.setShared(AstUtil.hasAnnotation(gField, Shared.class));
 field.setOwner(owner);
 spec.getFields().add(field);
}

if ((fNode.isStatic() && !includeStatic) || fNode.isSynthetic() || cNode.getProperty(fNode.getName()) != null || names.contains(fNode.getName())) {
  continue;

@Override
public Statement createPropInit(AbstractASTTransformation xform, AnnotationNode anno, ClassNode cNode, PropertyNode pNode, Parameter namedArgsMap) {
  String name = pNode.getName();
  FieldNode fNode = pNode.getField();
  boolean useSetters = xform.memberHasValue(anno, "useSetters", true);
  boolean hasSetter = cNode.getProperty(name) != null && !fNode.isFinal();
  if (namedArgsMap != null) {
    return assignFieldS(useSetters, namedArgsMap, name);
  } else {
    Expression var = varX(name);
    if (useSetters && hasSetter) {
      return setViaSetterS(name, var);
    } else {
      return assignToFieldS(name, var);
    }
  }
}

static void visitField(ErrorCollecting xform, AnnotationNode node, FieldNode fieldNode) {
  final Expression soft = node.getMember("soft");
  final Expression init = getInitExpr(xform, fieldNode);
  String backingFieldName = "$" + fieldNode.getName();
  fieldNode.rename(backingFieldName);
  fieldNode.setModifiers(ACC_PRIVATE | (fieldNode.getModifiers() & (~(ACC_PUBLIC | ACC_PROTECTED))));
  PropertyNode pNode = fieldNode.getDeclaringClass().getProperty(backingFieldName);
  if (pNode != null) {
    fieldNode.getDeclaringClass().getProperties().remove(pNode);
  }
  if (soft instanceof ConstantExpression && ((ConstantExpression) soft).getValue().equals(true)) {
    createSoft(fieldNode, init);
  } else {
    create(fieldNode, init);
    // @Lazy not meaningful with primitive so convert to wrapper if needed
    if (ClassHelper.isPrimitiveType(fieldNode.getType())) {
      fieldNode.setType(ClassHelper.getWrapper(fieldNode.getType()));
    }
  }
}

ClassNode curNode = receiver;
while (property == null && curNode != null) {
  property = curNode.getProperty(pname);
  ClassNode svCur = curNode;
  while (property == null && svCur instanceof InnerClassNode && !svCur.isStaticClass()) {
    svCur = svCur.getOuterClass();
    property = svCur.getProperty(pname);
    if (property != null) {
      receiver = svCur;
PropertyNode property = null;
while (property == null && curNode != null) {
  property = curNode.getProperty(pname);
  curNode = curNode.getSuperClass();

private static void addSetterIfNeeded(DelegateDescription delegate, PropertyNode prop, String name, boolean allNames) {
  String setterName = "set" + Verifier.capitalize(name);
  if ((prop.getModifiers() & ACC_FINAL) == 0
      && delegate.owner.getSetterMethod(setterName) == null && delegate.owner.getProperty(name) == null
      && !shouldSkipPropertyMethod(name, setterName, delegate.excludes, delegate.includes, allNames)) {
    addGeneratedMethod(delegate.owner, setterName,
        ACC_PUBLIC,
        ClassHelper.VOID_TYPE,
        params(new Parameter(GenericsUtils.nonGeneric(prop.getType()), "value")),
        null,
        assignS(propX(delegate.getOp, name), varX("value"))
    );
  }
}

PropertyNode propertyNode = current.getProperty(propertyName);
propertyNode = allowStaticAccessToMember(propertyNode, staticOnly);

public void visit(ASTNode[] nodes, SourceUnit source) {
  init(nodes, source);
  AnnotatedNode parent = (AnnotatedNode) nodes[1];
  AnnotationNode node = (AnnotationNode) nodes[0];
  if (!MY_TYPE.equals(node.getClassNode())) return;
  if (parent instanceof FieldNode) {
    FieldNode fNode = (FieldNode) parent;
    ClassNode cNode = fNode.getDeclaringClass();
    if (cNode.getProperty(fNode.getName()) == null) {
      addError("Error during " + MY_TYPE_NAME + " processing. Field '" + fNode.getName() +
          "' doesn't appear to be a property; incorrect visibility?", fNode);
      return;
    }
    ClassNode fType = fNode.getType();
    if (fType.isArray()) {
      addArraySetter(fNode);
      addArrayGetter(fNode);
    } else if (fType.isDerivedFrom(LIST_TYPE)) {
      addListSetter(fNode);
      addListGetter(fNode);
    } else {
      addError("Error during " + MY_TYPE_NAME + " processing. Non-Indexable property '" + fNode.getName() +
          "' found. Type must be array or list but found " + fType.getName(), fNode);
    }
  }
}

PropertyNode pn = classNode.getProperty(name);
if (pn != null && pn.getField().isSynthetic()) {
  classNode.getFields().remove(pn.getField());

PropertyNode propertyNode = receiverType.getProperty(property);
if (propertyNode != null) {
  int mods = propertyNode.getModifiers();

PropertyNode propertyNode = receiverType.getProperty(methodName);
if (getterNode == null && propertyNode != null) {

@Override
protected void performInjectionInternal(String apiInstanceProperty, SourceUnit source, ClassNode classNode) {
  final PropertyNode errorsProperty = classNode.getProperty(GrailsDomainClassProperty.ERRORS);
  if (errorsProperty == null) {
    addErrorsProperty(classNode);
  }
}

public static List<FieldNode> getInstanceNonPropertyFields(ClassNode cNode) {
  final List<FieldNode> result = new ArrayList<FieldNode>();
  for (FieldNode fNode : cNode.getFields()) {
    if (!fNode.isStatic() && cNode.getProperty(fNode.getName()) == null) {
      result.add(fNode);
    }
  }
  return result;
}

private void createConstructorMapCommon(ClassNode cNode, FieldExpression constructorStyle, BlockStatement body) {
  final List<FieldNode> fList = cNode.getFields();
  for (FieldNode fNode : fList) {
    if (!fNode.isPublic() && !fNode.getName().contains("$") && (cNode.getProperty(fNode.getName()) == null)) {
      body.addStatement(createConstructorStatementDefault(fNode));
    }
  }
  body.addStatement(assignStatement(constructorStyle, ConstantExpression.TRUE));
  final Parameter[] params = new Parameter[]{new Parameter(HASHMAP_TYPE, "args")};
  cNode.addConstructor(new ConstructorNode(ACC_PUBLIC, params, ClassNode.EMPTY_ARRAY, new IfStatement(
      equalsNullExpr(new VariableExpression("args")),
      new EmptyStatement(),
      body)));
}