public MethodNode getSetterMethod(String setterName) { return getSetterMethod(setterName, true); }
private MethodNode findSetterOfSuperClass(ClassNode classNode, FieldNode fieldNode) { String setterMethodName = "set" + MetaClassHelper.capitalize(fieldNode.getName()); return classNode.getSuperClass().getSetterMethod(setterMethodName); }
public MethodNode getSetterMethod(String setterName, boolean voidOnly) { for (MethodNode method : getDeclaredMethods(setterName)) { if (setterName.equals(method.getName()) && (!voidOnly || ClassHelper.VOID_TYPE==method.getReturnType()) && method.getParameters().length == 1) { return method; } } ClassNode parent = getSuperClass(); if (parent!=null) return parent.getSetterMethod(setterName, voidOnly); return null; }
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")) ); } }
protected void checkGroovyConstructorMap(final Expression receiver, final ClassNode receiverType, final MapExpression mapExpression) { // workaround for map-style checks putting setter info on wrong AST nodes typeCheckingContext.pushEnclosingBinaryExpression(null); for (MapEntryExpression entryExpression : mapExpression.getMapEntryExpressions()) { Expression keyExpr = entryExpression.getKeyExpression(); if (!(keyExpr instanceof ConstantExpression)) { addStaticTypeError("Dynamic keys in map-style constructors are unsupported in static type checking", keyExpr); } else { AtomicReference<ClassNode> lookup = new AtomicReference<ClassNode>(); PropertyExpression pexp = new PropertyExpression(varX("_", receiverType), keyExpr.getText()); boolean hasProperty = existsProperty(pexp, false, new PropertyLookupVisitor(lookup)); if (!hasProperty) { addStaticTypeError("No such property: " + keyExpr.getText() + " for class: " + receiverType.getName(), receiver); } else { ClassNode valueType = getType(entryExpression.getValueExpression()); MethodNode setter = receiverType.getSetterMethod("set" + MetaClassHelper.capitalize(pexp.getPropertyAsString()), false); ClassNode toBeAssignedTo = setter == null ? lookup.get() : setter.getParameters()[0].getType(); if (!isAssignableTo(valueType, toBeAssignedTo) && !extension.handleIncompatibleAssignment(toBeAssignedTo, valueType, entryExpression)) { addAssignmentError(toBeAssignedTo, valueType, entryExpression); } } } } typeCheckingContext.popEnclosingBinaryExpression(); }
private static void wrapSetterMethod(ClassNode classNode, String propertyName) { String getterName = "get" + MetaClassHelper.capitalize(propertyName); MethodNode setter = classNode.getSetterMethod("set" + MetaClassHelper.capitalize(propertyName)); if (setter != null) { // Get the existing code block Statement code = setter.getCode(); Expression oldValue = varX("$oldValue"); Expression newValue = varX("$newValue"); BlockStatement block = new BlockStatement(); // create a local variable to hold the old value from the getter block.addStatement(declS(oldValue, callThisX(getterName))); // call the existing block, which will presumably set the value properly block.addStatement(code); // get the new value to emit in the event block.addStatement(declS(newValue, callThisX(getterName))); // add the firePropertyChange method call block.addStatement(stmt(callThisX("firePropertyChange", args(constX(propertyName), oldValue, newValue)))); // replace the existing code block with our new one setter.setCode(block); } }
if (setterBlock == null) { MethodNode setter = classNode.getSetterMethod(setterName, false); if (!node.isPrivate() && !isFinal(accessorModifiers) && methodNeedsReplacement(setter)) { setterBlock = createSetterBlock(node, field);
/** * Wrap an existing setter. */ private static void wrapSetterMethod(ClassNode classNode, boolean bindable, String propertyName) { String getterName = "get" + MetaClassHelper.capitalize(propertyName); MethodNode setter = classNode.getSetterMethod("set" + MetaClassHelper.capitalize(propertyName)); if (setter != null) { // Get the existing code block Statement code = setter.getCode(); Expression oldValue = varX("$oldValue"); Expression newValue = varX("$newValue"); Expression proposedValue = varX(setter.getParameters()[0].getName()); BlockStatement block = new BlockStatement(); // create a local variable to hold the old value from the getter block.addStatement(declS(oldValue, callThisX(getterName))); // add the fireVetoableChange method call block.addStatement(stmt(callThisX("fireVetoableChange", args( constX(propertyName), oldValue, proposedValue)))); // call the existing block, which will presumably set the value properly block.addStatement(code); if (bindable) { // get the new value to emit in the event block.addStatement(declS(newValue, callThisX(getterName))); // add the firePropertyChange method call block.addStatement(stmt(callThisX("firePropertyChange", args(constX(propertyName), oldValue, newValue)))); } // replace the existing code block with our new one setter.setCode(block); } }
MethodNode setterMethod = receiverType.getSetterMethod(setter, false); ClassNode declaringClass = setterMethod!=null?setterMethod.getDeclaringClass():null; if (isThisExpression && declaringClass!=null && declaringClass.equals(controller.getClassNode())) {
if (setterBlock == null) { MethodNode setter = cNode.getSetterMethod(setterName, false); if (!node.isPrivate() && (propNodeModifiers & ACC_FINAL) == 0 &&
public MethodNode getSetterMethod(String setterName) { return getSetterMethod(setterName, true); }
public static MethodNode getSetter(ClassNode classNode, FieldNode fieldNode) { return classNode.getSetterMethod(GroovyUtils.getsetName(GroovyUtils.GetSet.SET, fieldNode.getName())); }
public MethodNode getSetterMethod(String setterName) { for (Iterator iter = getDeclaredMethods(setterName).iterator(); iter.hasNext();) { MethodNode method = (MethodNode) iter.next(); if (setterName.equals(method.getName()) && ClassHelper.VOID_TYPE==method.getReturnType() && method.getParameters().length == 1) { return method; } } ClassNode parent = getSuperClass(); if (parent!=null) return parent.getSetterMethod(setterName); return null; }
public MethodNode getSetterMethod(String setterName, boolean voidOnly) { for (MethodNode method : getDeclaredMethods(setterName)) { if (setterName.equals(method.getName()) && (!voidOnly || ClassHelper.VOID_TYPE==method.getReturnType()) && method.getParameters().length == 1) { return method; } } ClassNode parent = getSuperClass(); if (parent!=null) return parent.getSetterMethod(setterName, voidOnly); return null; }
public MethodNode getSetterMethod(String setterName) { for (Object o : getDeclaredMethods(setterName)) { MethodNode method = (MethodNode) o; if (setterName.equals(method.getName()) && ClassHelper.VOID_TYPE==method.getReturnType() && method.getParameters().length == 1) { return method; } } ClassNode parent = getSuperClass(); if (parent!=null) return parent.getSetterMethod(setterName); return null; }
public MethodNode getSetterMethod(String setterName) { for (Object o : getDeclaredMethods(setterName)) { MethodNode method = (MethodNode) o; if (setterName.equals(method.getName()) && ClassHelper.VOID_TYPE==method.getReturnType() && method.getParameters().length == 1) { return method; } } ClassNode parent = getSuperClass(); if (parent!=null) return parent.getSetterMethod(setterName); return null; }
@Override public void visitPropertyExpression(final PropertyExpression exp) { // TODO: spread if (exp.getObjectExpression() instanceof VariableExpression && ((VariableExpression) exp.getObjectExpression()).isThisExpression() && exp.getProperty() instanceof ConstantExpression && classNode.getSetterMethod("set" + Verifier.capitalize((String) ((ConstantExpression) exp.getProperty()).getValue()), false) != null) { makeNode("attribute", new Runnable() { @Override public void run() { loc(exp); visit(exp.getObjectExpression()); visit(exp.getProperty()); literal(exp.isSafe()); } }); } else { makeNode("property", new Runnable() { @Override public void run() { loc(exp); visit(exp.getObjectExpression()); visit(exp.getProperty()); literal(exp.isSafe()); } }); } }
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 FieldExpression(fieldNode), name), Token.newSymbol(Types.EQUAL, -1, -1), new VariableExpression("value")))); } }
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")))); } }
private static void wrapSetterMethod(ClassNode classNode, String propertyName) { String getterName = getGetterName(propertyName); MethodNode setter = classNode.getSetterMethod(getSetterName(propertyName)); if (setter != null) { // Get the existing code block Statement code = setter.getCode(); VariableExpression oldValue = new VariableExpression("$oldValue"); VariableExpression newValue = new VariableExpression("$newValue"); BlockStatement block = new BlockStatement(); // create a local variable to hold the old value from the getter block.addStatement(decls(oldValue, call(THIS, getterName, NO_ARGS))); // call the existing block, which will presumably set the value properly block.addStatement(code); // get the new value to emit in the event block.addStatement(decls(newValue, call(THIS, getterName, NO_ARGS))); // add the firePropertyChange method call block.addStatement(stmnt(call( THIS, METHOD_FIRE_PROPERTY_CHANGE, args(constx(propertyName), oldValue, newValue)))); // replace the existing code block with our new one setter.setCode(block); } }