public static List<FieldNode> getInstancePropertyFields(ClassNode cNode) { final List<FieldNode> result = new ArrayList<FieldNode>(); for (PropertyNode pNode : cNode.getProperties()) { if (!pNode.isStatic()) { result.add(pNode.getField()); } } return result; }
private void addListenerToClass(SourceUnit source, ClassNode classNode) { boolean bindable = BindableASTTransformation.hasBindableAnnotation(classNode); for (PropertyNode propertyNode : classNode.getProperties()) { if (!hasVetoableAnnotation(propertyNode.getField()) && !propertyNode.getField().isFinal() && !propertyNode.getField().isStatic()) { createListenerSetter(source, bindable || BindableASTTransformation.hasBindableAnnotation(propertyNode.getField()), classNode, propertyNode); } } }
public void addProperty(PropertyNode node) { node.setDeclaringClass(redirect()); FieldNode field = node.getField(); addField(field); final ClassNode r = redirect(); if (r.properties == null) r.properties = new ArrayList<PropertyNode> (); r.properties.add(node); }
static boolean isSpecialNamedArgCase(List<PropertyNode> list, boolean checkSize) { if (checkSize && list.size() != 1) return false; if (list.size() == 0) return false; ClassNode firstParamType = list.get(0).getField().getType(); if (firstParamType.equals(ClassHelper.MAP_TYPE)) { return true; } ClassNode candidate = HMAP_TYPE; while (candidate != null) { if (candidate.equals(firstParamType)) { return true; } candidate = candidate.getSuperClass(); } return false; }
public static List<FieldNode> getSuperPropertyFields(ClassNode cNode) { final List<FieldNode> result; if (cNode == ClassHelper.OBJECT_TYPE) { result = new ArrayList<FieldNode>(); } else { result = getSuperPropertyFields(cNode.getSuperClass()); } for (PropertyNode pNode : cNode.getProperties()) { if (!pNode.isStatic()) { result.add(pNode.getField()); } } return result; }
public void visitProperty(PropertyNode statement) { // the verifier created the field and the setter/getter methods, so here is // not really something to do onLineNumber(statement, "visitProperty:" + statement.getField().getName()); controller.setMethodNode(null); }
private static void adjustPropertyForImmutability(PropertyNode pNode, List<PropertyNode> newNodes, PropertyHandler handler) { final FieldNode fNode = pNode.getField(); fNode.setModifiers((pNode.getModifiers() & (~ACC_PUBLIC)) | ACC_FINAL | ACC_PRIVATE); pNode.setSetterBlock(null); Statement getter = handler.createPropGetter(pNode); if (getter != null) { pNode.setGetterBlock(getter); } newNodes.add(pNode); }
public void visitProperty(PropertyNode node) { Map<GenericsTypeName, GenericsType> oldPNames = genericParameterNames; if (node.isStatic() && !Traits.isTrait(node.getDeclaringClass())) { genericParameterNames = new HashMap<GenericsTypeName, GenericsType>(); } ClassNode t = node.getType(); resolveOrFail(t, node); super.visitProperty(node); fieldTypesChecked.add(node.getField()); genericParameterNames = oldPNames; }
@Override public void visitProperty(PropertyNode node) { final FieldNode field = node.getField(); final Expression init = field.getInitialExpression(); field.setInitialValueExpression(null); super.visitProperty(node); field.setInitialValueExpression(init); }
private void checkDuplicateProperties(PropertyNode node) { ClassNode cn = node.getDeclaringClass(); String name = node.getName(); String getterName = "get" + MetaClassHelper.capitalize(name); if (Character.isUpperCase(name.charAt(0))) { for (PropertyNode propNode : cn.getProperties()) { String otherName = propNode.getField().getName(); String otherGetterName = "get" + MetaClassHelper.capitalize(otherName); if (node != propNode && getterName.equals(otherGetterName)) { String msg = "The field " + name + " and " + otherName + " on the class " + cn.getName() + " will result in duplicate JavaBean properties, which is not allowed"; addError(msg, node); } } } }
private void createListenerSetter(ClassNode classNode, PropertyNode propertyNode) { String setterName = "set" + MetaClassHelper.capitalize(propertyNode.getName()); if (classNode.getMethods(setterName).isEmpty()) { Statement setterBlock = createBindableStatement(propertyNode, fieldX(propertyNode.getField())); // create method void <setter>(<type> fieldName) createSetterMethod(classNode, propertyNode, setterName, setterBlock); } else { wrapSetterMethod(classNode, propertyNode.getName()); } }
@Override public Statement createPropInit(AbstractASTTransformation xform, AnnotationNode anno, ClassNode cNode, PropertyNode pNode, Parameter namedArgsMap) { FieldNode fNode = pNode.getField(); if (fNode.isFinal() && fNode.isStatic()) return null; if (fNode.isFinal() && fNode.getInitialExpression() != null) { return checkFinalArgNotOverridden(cNode, fNode); } return createLegacyConstructorStatementMapSpecial(fNode); } }
@Override public Statement createPropInit(AbstractASTTransformation xform, AnnotationNode anno, ClassNode cNode, PropertyNode pNode, Parameter namedArgsMap) { FieldNode fNode = pNode.getField(); if (fNode.isFinal() && fNode.isStatic()) return null; if (fNode.isFinal() && fNode.getInitialExpression() != null) { return checkFinalArgNotOverridden(cNode, fNode); } return createConstructorStatement(xform, cNode, pNode, namedArgsMap != null); }
private static void addProperty(ClassNode cNode, PropertyNode pNode) { final FieldNode fn = pNode.getField(); cNode.getFields().remove(fn); cNode.addProperty(pNode.getName(), pNode.getModifiers() | ACC_FINAL, pNode.getType(), pNode.getInitialExpression(), pNode.getGetterBlock(), pNode.getSetterBlock()); final FieldNode newfn = cNode.getField(fn.getName()); cNode.getFields().remove(newfn); cNode.addField(fn); }
@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); } } }
@Override public Statement createPropGetter(PropertyNode pNode) { FieldNode fNode = pNode.getField(); BlockStatement body = new BlockStatement(); final ClassNode fieldType = fNode.getType(); final Statement statement; if (fieldType.isArray() || implementsCloneable(fieldType)) { statement = createGetterBodyArrayOrCloneable(fNode); } else if (derivesFromDate(fieldType)) { statement = createGetterBodyDate(fNode); } else { statement = createGetterBodyDefault(fNode); } body.addStatement(statement); return body; }
private void addListenerToClass(SourceUnit source, ClassNode classNode) { if (needsPropertyChangeSupport(classNode, source)) { addPropertyChangeSupport(classNode); } for (PropertyNode propertyNode : classNode.getProperties()) { FieldNode field = propertyNode.getField(); // look to see if per-field handlers will catch this one... if (hasBindableAnnotation(field) || ((field.getModifiers() & Opcodes.ACC_FINAL) != 0) || field.isStatic() || VetoableASTTransformation.hasVetoableAnnotation(field)) { // explicitly labeled properties are already handled, // don't transform final properties // don't transform static properties // VetoableASTTransformation will handle both @Bindable and @Vetoable continue; } createListenerSetter(classNode, propertyNode); } }
public PropertyNode addProperty(String name, int modifiers, ClassNode type, Expression initialValueExpression, Statement getterBlock, Statement setterBlock) { for (PropertyNode pn : getProperties()) { if (pn.getName().equals(name)) { if (pn.getInitialExpression() == null && initialValueExpression != null) pn.getField().setInitialValueExpression(initialValueExpression); if (pn.getGetterBlock() == null && getterBlock != null) pn.setGetterBlock(getterBlock); if (pn.getSetterBlock() == null && setterBlock != null) pn.setSetterBlock(setterBlock); return pn; } } PropertyNode node = new PropertyNode(name, modifiers, type, redirect(), initialValueExpression, getterBlock, setterBlock); addProperty(node); return node; }
private void createListenerSetter(SourceUnit source, boolean bindable, ClassNode declaringClass, PropertyNode propertyNode) { if (bindable && needsPropertyChangeSupport(declaringClass, source)) { addPropertyChangeSupport(declaringClass); } if (needsVetoableChangeSupport(declaringClass, source)) { addVetoableChangeSupport(declaringClass); } String setterName = "set" + MetaClassHelper.capitalize(propertyNode.getName()); if (declaringClass.getMethods(setterName).isEmpty()) { Expression fieldExpression = fieldX(propertyNode.getField()); BlockStatement setterBlock = new BlockStatement(); setterBlock.addStatement(createConstrainedStatement(propertyNode, fieldExpression)); if (bindable) { setterBlock.addStatement(createBindableStatement(propertyNode, fieldExpression)); } else { setterBlock.addStatement(createSetStatement(fieldExpression)); } // create method void <setter>(<type> fieldName) createSetterMethod(declaringClass, propertyNode, setterName, setterBlock); } else { wrapSetterMethod(declaringClass, bindable, propertyNode.getName()); } }
protected Statement createConstructorStatement(AbstractASTTransformation xform, ClassNode cNode, PropertyNode pNode, boolean namedArgs) { final List<String> knownImmutableClasses = ImmutablePropertyUtils.getKnownImmutableClasses(xform, cNode); final List<String> knownImmutables = ImmutablePropertyUtils.getKnownImmutables(xform, cNode); FieldNode fNode = pNode.getField(); final ClassNode fType = fNode.getType(); Statement statement; if (ImmutablePropertyUtils.isKnownImmutableType(fType, knownImmutableClasses) || isKnownImmutable(pNode.getName(), knownImmutables)) { statement = createConstructorStatementDefault(fNode, namedArgs); } else if (fType.isArray() || implementsCloneable(fType)) { statement = createConstructorStatementArrayOrCloneable(fNode, namedArgs); } else if (derivesFromDate(fType)) { statement = createConstructorStatementDate(fNode, namedArgs); } else if (isOrImplements(fType, COLLECTION_TYPE) || fType.isDerivedFrom(COLLECTION_TYPE) || isOrImplements(fType, MAP_TYPE) || fType.isDerivedFrom(MAP_TYPE)) { statement = createConstructorStatementCollection(fNode, namedArgs); } else if (fType.isResolved()) { xform.addError(ImmutablePropertyUtils.createErrorMessage(cNode.getName(), fNode.getName(), fType.getName(), "compiling"), fNode); statement = EmptyStatement.INSTANCE; } else { statement = createConstructorStatementGuarded(cNode, fNode, namedArgs, knownImmutables, knownImmutableClasses); } return statement; }