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