/** * Fields within the AST that have no explicit visibility are deemed to be properties * and represented by a PropertyNode. The Groovy compiler creates accessor methods and * a backing field for such property nodes. During this process, all modifiers * from the property are carried over to the backing field (so a property marked as * {@code transient} will have a {@code transient} backing field) but when creating * the accessor methods we don't carry over modifier values which don't make sense for * methods (this includes VOLATILE and TRANSIENT) but other modifiers are carried over, * for example {@code static}. * * @param propNode the original property node * @return the modifiers which make sense for an accessor method */ public static int adjustPropertyModifiersForMethod(PropertyNode propNode) { // GROOVY-3726: clear volatile, transient modifiers so that they don't get applied to methods return ~(Modifier.TRANSIENT | Modifier.VOLATILE) & propNode.getModifiers(); } }
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 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); }
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 = receiverType.getProperty(property); if (propertyNode != null) { int mods = propertyNode.getModifiers(); if (!Modifier.isFinal(mods)) { setterMethod = new MethodNode(
String name = node.getName(); FieldNode field = node.getField(); int propNodeModifiers = node.getModifiers();
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); }
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); }
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); }
/** * Creates a getter method and adds it to the declaring class. * * @param declaringClass The class to which the method is added * @param propertyNode The property node being accessed by this getter * @param getterName The name of the getter method * @param getterBlock The code body of the method */ protected void createGetterMethod(ClassNode declaringClass, PropertyNode propertyNode, String getterName, Statement getterBlock) { int mod = propertyNode.getModifiers() | Opcodes.ACC_FINAL; MethodNode getter = new MethodNode(getterName, mod, propertyNode.getType(), Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, getterBlock); getter.setSynthetic(true); declaringClass.addMethod(getter); }
/** * Creates a setter method with the given body. * * @param declaringClass the class to which we will add the setter * @param propertyNode the field to back the setter * @param setterName the name of the setter * @param setterBlock the statement representing the setter block */ protected void createSetterMethod(ClassNode declaringClass, PropertyNode propertyNode, String setterName, Statement setterBlock) { Parameter[] setterParameterTypes = {new Parameter(propertyNode.getType(), "value")}; MethodNode setter = new MethodNode(setterName, propertyNode.getModifiers(), ClassHelper.VOID_TYPE, setterParameterTypes, ClassNode.EMPTY_ARRAY, setterBlock); setter.setSynthetic(true); // add it to the class declaringClass.addMethod(setter); }
private static void createSetterMethod(ClassNode declaringClass, PropertyNode propertyNode, String setterName, Statement setterBlock) { MethodNode setter = new MethodNode( setterName, propertyNode.getModifiers(), VOID_TYPE, params(param(propertyNode.getType(), VALUE)), new ClassNode[]{PROPERTY_VETO_EXCEPTION_CNODE}, setterBlock); setter.setSynthetic(true); // add it to the class declaringClass.addMethod(setter); }
private static void createSetterMethod(ClassNode declaringClass, PropertyNode propertyNode, String setterName, Statement setterBlock) { MethodNode setter = new MethodNode( setterName, propertyNode.getModifiers(), VOID_TYPE, params(param(propertyNode.getType(), VALUE)), NO_EXCEPTIONS, setterBlock); setter.setSynthetic(true); // add it to the class declaringClass.addMethod(setter); }
/** * Creates a setter method with the given body. * * @param declaringClass the class to which we will add the setter * @param propertyNode the field to back the setter * @param setterName the name of the setter * @param setterBlock the statement representing the setter block */ protected void createSetterMethod(ClassNode declaringClass, PropertyNode propertyNode, String setterName, Statement setterBlock) { Parameter[] setterParameterTypes = {new Parameter(propertyNode.getType(), "value")}; MethodNode setter = new MethodNode(setterName, propertyNode.getModifiers(), ClassHelper.VOID_TYPE, setterParameterTypes, ClassNode.EMPTY_ARRAY, setterBlock); setter.setSynthetic(true); // add it to the class declaringClass.addMethod(setter); }
private 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); }
private 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); }
private 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); }
/** * Creates a setter method with the given body. * <p/> * This differs from normal setters in that we need to add a declared * exception java.beans.PropertyVetoException * * @param declaringClass the class to which we will add the setter * @param propertyNode the field to back the setter * @param setterName the name of the setter * @param setterBlock the statement representing the setter block */ protected void createSetterMethod(ClassNode declaringClass, PropertyNode propertyNode, String setterName, Statement setterBlock) { Parameter[] setterParameterTypes = {new Parameter(propertyNode.getType(), "value")}; ClassNode[] exceptions = {new ClassNode(PropertyVetoException.class)}; MethodNode setter = new MethodNode(setterName, propertyNode.getModifiers(), ClassHelper.VOID_TYPE, setterParameterTypes, exceptions, setterBlock); setter.setSynthetic(true); // add it to the class declaringClass.addMethod(setter); }
@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 addSetterIfNeeded(FieldNode fieldNode, ClassNode owner, PropertyNode prop, String name) { String setterName = "set" + Verifier.capitalize(name); if ((prop.getModifiers() & ACC_FINAL) == 0 && owner.getSetterMethod(setterName) == null) { owner.addMethod(setterName, ACC_PUBLIC, ClassHelper.VOID_TYPE, new Parameter[]{new Parameter(nonGeneric(prop.getType()), "value")}, null, new ExpressionStatement( new BinaryExpression( new PropertyExpression( new VariableExpression(fieldNode), name), Token.newSymbol(Types.EQUAL, -1, -1), new VariableExpression("value")))); } }