private static String getSetterName(String name) { return "set" + Verifier.capitalize(name); } }
public static String getSetterName(String name) { return "set" + Verifier.capitalize(name); }
public static String getGetterName(PropertyNode pNode) { return "get" + Verifier.capitalize(pNode.getName()); }
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 void testCapitalize() { assertEquals("Foo", Verifier.capitalize("foo")); assertEquals("Foo", Verifier.capitalize("Foo")); assertEquals("fOo", Verifier.capitalize("fOo")); assertEquals("fOO", Verifier.capitalize("fOO")); assertEquals("F", Verifier.capitalize("f")); }
private static void addGetterIfNeeded(DelegateDescription delegate, PropertyNode prop, String name, boolean allNames) { boolean isPrimBool = prop.getOriginType().equals(ClassHelper.boolean_TYPE); // do a little bit of pre-work since Groovy compiler hasn't added property accessors yet boolean willHaveGetAccessor = true; boolean willHaveIsAccessor = isPrimBool; String suffix = Verifier.capitalize(name); if (isPrimBool) { ClassNode cNode = prop.getDeclaringClass(); if (cNode.getGetterMethod("is" + suffix) != null && cNode.getGetterMethod("get" + suffix) == null) willHaveGetAccessor = false; if (cNode.getGetterMethod("get" + suffix) != null && cNode.getGetterMethod("is" + suffix) == null) willHaveIsAccessor = false; } Reference<Boolean> ownerWillHaveGetAccessor = new Reference<Boolean>(); Reference<Boolean> ownerWillHaveIsAccessor = new Reference<Boolean>(); extractAccessorInfo(delegate.owner, name, ownerWillHaveGetAccessor, ownerWillHaveIsAccessor); for (String prefix : new String[]{"get", "is"}) { String getterName = prefix + suffix; if ((prefix.equals("get") && willHaveGetAccessor && !ownerWillHaveGetAccessor.get() || prefix.equals("is") && willHaveIsAccessor && !ownerWillHaveIsAccessor.get()) && !shouldSkipPropertyMethod(name, getterName, delegate.excludes, delegate.includes, allNames)) { addGeneratedMethod(delegate.owner, getterName, ACC_PUBLIC, GenericsUtils.nonGeneric(prop.getType()), Parameter.EMPTY_ARRAY, null, returnS(propX(delegate.getOp, name))); } } }
String propName = Verifier.capitalize(propertyNode.getField().getName()); String shortName = name.substring(name.startsWith("is") ? 2 : 3); if (propName.equals(shortName)) {
FieldNode field = node.getField(); String getterName = "get" + capitalize(name); String setterName = "set" + capitalize(name); MethodNode getter = classNode.getGetterMethod(getterName, !node.isStatic()); if (getter == null && ClassHelper.boolean_TYPE == node.getType()) { String secondGetterName = "is" + capitalize(name); getter = classNode.getGetterMethod(secondGetterName); String secondGetterName = "is" + capitalize(name); visitGetter(node, getterBlock, getterModifiers, secondGetterName);
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")) ); } }
/** * Given a field node, checks if we are accessing or setting a private field from an inner class. */ private void checkOrMarkPrivateAccess(Expression source, FieldNode fn, boolean lhsOfAssignment) { ClassNode enclosingClassNode = typeCheckingContext.getEnclosingClassNode(); ClassNode declaringClass = fn.getDeclaringClass(); if (fn != null && Modifier.isPrivate(fn.getModifiers()) && (declaringClass != enclosingClassNode || typeCheckingContext.getEnclosingClosure() != null) && declaringClass.getModule() == enclosingClassNode.getModule()) { if (!lhsOfAssignment && enclosingClassNode.isDerivedFrom(declaringClass)) { // check for a public/protected getter since JavaBean getters haven't been recognised as properties // at this point and we don't want private field access for that case which will be handled later boolean isPrimBool = fn.getOriginType().equals(ClassHelper.boolean_TYPE); String suffix = Verifier.capitalize(fn.getName()); MethodNode getterNode = findValidGetter(enclosingClassNode, "get" + suffix); if (getterNode == null && isPrimBool) { getterNode = findValidGetter(enclosingClassNode, "is" + suffix); } if (getterNode != null) { source.putNodeMetaData(StaticTypesMarker.INFERRED_TYPE, getterNode.getReturnType()); return; } } StaticTypesMarker marker = lhsOfAssignment ? StaticTypesMarker.PV_FIELDS_MUTATION : StaticTypesMarker.PV_FIELDS_ACCESS; addPrivateFieldOrMethodAccess(source, declaringClass, marker, fn); } }
int propNodeModifiers = node.getModifiers(); String getterName = "get" + Verifier.capitalize(name); String setterName = "set" + Verifier.capitalize(name); MethodNode getter = cNode.getGetterMethod(getterName); if (getter == null && ClassHelper.boolean_TYPE == node.getType()) { String secondGetterName = "is" + Verifier.capitalize(name); getter = cNode.getGetterMethod(secondGetterName); String secondGetterName = "is" + Verifier.capitalize(name); MethodNode secondGetter = new MethodNode(secondGetterName, propNodeModifiers, node.getType(), Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, getterBlock);
paramField.setOriginType(ClassHelper.getWrapper(param.getOriginType())); paramField.setHolder(true); String methodName = Verifier.capitalize(paramName);
private static BooleanExpression notEqualsPropertyExpr(PropertyNode pNode, Expression other) { String getterName = "get" + Verifier.capitalize(pNode.getName()); Expression selfGetter = new MethodCallExpression(VariableExpression.THIS_EXPRESSION, getterName, MethodCallExpression.NO_ARGUMENTS); Expression otherGetter = new MethodCallExpression(other, getterName, MethodCallExpression.NO_ARGUMENTS); return new BooleanExpression(new BinaryExpression(selfGetter, COMPARE_NOT_EQUAL, otherGetter)); }
private void addGetterIfNeeded(FieldNode fieldNode, ClassNode owner, PropertyNode prop, String name) { String getterName = "get" + Verifier.capitalize(name); if (owner.getGetterMethod(getterName) == null) { owner.addMethod(getterName, ACC_PUBLIC, nonGeneric(prop.getType()), Parameter.EMPTY_ARRAY, null, new ReturnStatement( new PropertyExpression( new FieldExpression(fieldNode), name))); } }
private void addGetterIfNeeded(FieldNode fieldNode, ClassNode owner, PropertyNode prop, String name) { String getterName = "get" + Verifier.capitalize(name); if (owner.getGetterMethod(getterName) == null) { owner.addMethod(getterName, ACC_PUBLIC, nonGeneric(prop.getType()), Parameter.EMPTY_ARRAY, null, new ReturnStatement( new PropertyExpression( new VariableExpression(fieldNode), name))); } }
ref instanceof PropertyNode || ref instanceof FieldNode) { if (ref instanceof FieldNode && classNode.getGetterMethod("get" + Verifier.capitalize(exp.getName())) != null) { makeNode("attribute", new Runnable() { @Override
@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")))); } }
if (shouldSkip(pNode.getName(), excludes, includes)) continue; first = appendPrefix(body, result, first, pNode.getName(), includeNames); String getterName = "get" + Verifier.capitalize(pNode.getName()); Expression getter = new MethodCallExpression(VariableExpression.THIS_EXPRESSION, getterName, MethodCallExpression.NO_ARGUMENTS); body.addStatement(append(result, new StaticMethodCallExpression(INVOKER_TYPE, "toString", getter)));