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); }
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; }
public void visitProperty(PropertyNode node) { String name = node.getName(); FieldNode field = node.getField(); Statement getterBlock = node.getGetterBlock(); if (getterBlock == 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); if (!node.isPrivate() && methodNeedsReplacement(getter)) { getterBlock = createGetterBlock(node, field); Statement setterBlock = node.getSetterBlock(); if (setterBlock == null) { if (!node.isPrivate() && !isFinal(accessorModifiers) && methodNeedsReplacement(setter)) { setterBlock = createSetterBlock(node, field); if (node.isStatic()) { getterModifiers = ~Modifier.FINAL & getterModifiers; if (ClassHelper.boolean_TYPE == node.getType() || ClassHelper.Boolean_TYPE == node.getType()) { String secondGetterName = "is" + capitalize(name); visitGetter(node, getterBlock, getterModifiers, secondGetterName); Parameter[] setterParameterTypes = {new Parameter(node.getType(), "value")}; MethodNode setter = new MethodNode(setterName, accessorModifiers, ClassHelper.VOID_TYPE, setterParameterTypes, ClassNode.EMPTY_ARRAY, setterBlock);
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); }
private static void addExplicitProperties(ClassNode cNode, List<PropertyNode> result, Set<String> names, boolean includeStatic) { for (PropertyNode pNode : cNode.getProperties()) { if (includeStatic || !pNode.isStatic()) { if (!names.contains(pNode.getName())) { result.add(pNode); names.add(pNode.getName()); } } } }
String name = node.getName(); FieldNode field = node.getField(); int propNodeModifiers = node.getModifiers(); Statement getterBlock = node.getGetterBlock(); if (getterBlock == null) { MethodNode getter = cNode.getGetterMethod(getterName); if (getter == null && ClassHelper.boolean_TYPE == node.getType()) { String secondGetterName = "is" + Verifier.capitalize(name); getter = cNode.getGetterMethod(secondGetterName); if (!node.isPrivate() && methodNeedsReplacement(cNode, getter)) { getterBlock = new ExpressionStatement(new FieldExpression(field)); Statement setterBlock = node.getSetterBlock(); if (setterBlock == null) { if (!node.isPrivate() && (propNodeModifiers & ACC_FINAL) == 0 && methodNeedsReplacement(cNode, setter)) { new MethodNode(getterName, propNodeModifiers, node.getType(), Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, getterBlock); getter.setSynthetic(true); cNode.addMethod(getter); if (ClassHelper.boolean_TYPE == node.getType() || ClassHelper.Boolean_TYPE == node.getType()) { String secondGetterName = "is" + Verifier.capitalize(name); MethodNode secondGetter = new MethodNode(secondGetterName, propNodeModifiers, node.getType(), Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, getterBlock);
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); } } }
public void visitProperty(PropertyNode node) { visitAnnotations(node); Statement statement = node.getGetterBlock(); visitClassCodeContainer(statement); statement = node.getSetterBlock(); visitClassCodeContainer(statement); Expression init = node.getInitialExpression(); if (init != null) init.visit(this); }
@Override public void visitProperty(PropertyNode node) { final ClassNode classNode = node.getDeclaringClass(); final String setterName = "set" + MetaClassHelper.capitalize(node.getName()); final Statement setterBlock = node.getSetterBlock(); final Parameter parameter = new Parameter(node.getType(), "value"); if (CandidateChecks.isClassInvariantCandidate(node) && (setterBlock == null && classNode.getMethod(setterName, new Parameter[]{ parameter } ) == null)) { final Statement setterBlockStatement = createSetterBlock(classNode, node.getField(), parameter); node.setSetterBlock(setterBlockStatement); } }
private void checkComparable(PropertyNode pNode) { if (pNode.getType().implementsInterface(COMPARABLE_TYPE) || isPrimitiveType(pNode.getType()) || hasAnnotation(pNode.getType(), MY_TYPE)) { return; } addError("Error during " + MY_TYPE_NAME + " processing: property '" + pNode.getName() + "' must be Comparable", 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; }
private Variable findClassMember(ClassNode cn, String name) { if (cn == null) return null; if (cn.isScript()) { return new DynamicVariable(name, false); } for (FieldNode fn : cn.getFields()) { if (fn.getName().equals(name)) return fn; } for (MethodNode mn : cn.getMethods()) { String pName = getPropertyName(mn); if (name.equals(pName)) { PropertyNode property = new PropertyNode(name, mn.getModifiers(), ClassHelper.OBJECT_TYPE, cn, null, null, null); property.getField().setHasNoRealSourcePosition(true); property.getField().setSynthetic(true); property.getField().setDeclaringClass(cn); property.setDeclaringClass(cn); return property; } } for (PropertyNode pn : cn.getProperties()) { if (pn.getName().equals(name)) return pn; } Variable ret = findClassMember(cn.getSuperClass(), name); if (ret != null) return ret; return findClassMember(cn.getOuterClass(), name); }
public ClassNode getOriginType() { return getType(); } }
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")) ); } }
private void adjustPropertyForImmutability(PropertyNode pNode, List<PropertyNode> newNodes) { final FieldNode fNode = pNode.getField(); fNode.setModifiers((pNode.getModifiers() & (~ACC_PUBLIC)) | ACC_FINAL | ACC_PRIVATE); adjustPropertyNode(pNode, createGetterBody(fNode)); newNodes.add(pNode); }
@Override protected void createSetterMethod(final ClassNode declaringClass, final PropertyNode propertyNode, final String setterName, final Statement setterBlock) { super.createSetterMethod(declaringClass, propertyNode, setterName, setterBlock); final String argumentName = "value"; final Statement code = stmt(callThisX(setterName, args(varX(argumentName)))); final MethodNode setter = new MethodNode( propertyNode.getName(), propertyNode.getModifiers(), ClassHelper.VOID_TYPE, params(param(propertyNode.getType(), argumentName)), ClassNode.EMPTY_ARRAY, code); setter.setSynthetic(true); declaringClass.addMethod(setter); } }
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()); } }
if ((!pNode.isStatic() || includeStatic) && !names.contains(pNode.getName())) { result.add(pNode); names.add(pNode.getName()); continue; result.add(new PropertyNode(fNode, fNode.getModifiers(), null, null)); names.add(fNode.getName());