public MethodNode getGetterMethod(String getterName) { return getGetterMethod(getterName, true); }
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))); }
private MethodNode findGetter(ClassNode current, String name, boolean searchOuterClasses) { MethodNode getterMethod = current.getGetterMethod(name); if (getterMethod == null && searchOuterClasses && current instanceof InnerClassNode) { return findGetter(current.getOuterClass(), name, true); } return getterMethod; }
private MethodNode findValidGetter(ClassNode classNode, String name) { MethodNode getterMethod = classNode.getGetterMethod(name); if (getterMethod != null && (getterMethod.isPublic() || getterMethod.isProtected())) { return getterMethod; } return null; }
private MethodNode findGetterOfSuperClass(ClassNode classNode, FieldNode fieldNode) { String getterMethodName = "get" + MetaClassHelper.capitalize(fieldNode.getName()); return classNode.getSuperClass().getGetterMethod(getterMethodName); }
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))); } } }
public MethodNode getGetterMethod(String getterName, boolean searchSuperClasses) { MethodNode getterMethod = null; boolean booleanReturnOnly = getterName.startsWith("is"); for (MethodNode method : getDeclaredMethods(getterName)) { if (getterName.equals(method.getName()) && ClassHelper.VOID_TYPE!=method.getReturnType() && method.getParameters().length == 0 && (!booleanReturnOnly || ClassHelper.Boolean_TYPE.equals(ClassHelper.getWrapper(method.getReturnType())))) { // GROOVY-7363: There can be multiple matches for a getter returning a generic parameter type, due to // the generation of a bridge method. The real getter is really the non-bridge, non-synthetic one as it // has the most specific and exact return type of the two. Picking the bridge method results in loss of // type information, as it down-casts the return type to the lower bound of the generic parameter. if (getterMethod == null || getterMethod.isSynthetic()) { getterMethod = method; } } } if (getterMethod != null) return getterMethod; if (searchSuperClasses) { ClassNode parent = getSuperClass(); if (parent != null) return parent.getGetterMethod(getterName); } return 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);
private boolean makeGetPropertyWithGetter(final Expression receiver, final ClassNode receiverType, final String methodName, final boolean safe, final boolean implicitThis) { MethodNode getterNode = receiverType.getGetterMethod(getterName); if (getterNode==null) { getterName = "is" + MetaClassHelper.capitalize(methodName); getterNode = receiverType.getGetterMethod(getterName);
MethodNode getterMethod = null; for (ClassNode anInterface : allInterfaces) { getterMethod = anInterface.getGetterMethod(getterName); if (getterMethod == null) getterMethod = anInterface.getGetterMethod(altGetterName); if (getterMethod != null) break; getterMethod = OBJECT_TYPE.getGetterMethod(getterName);
MethodNode getter = cNode.getGetterMethod(getterName); if (getter == null && ClassHelper.boolean_TYPE == node.getType()) { String secondGetterName = "is" + Verifier.capitalize(name); getter = cNode.getGetterMethod(secondGetterName);
public static MethodNode getGetter(ClassNode classNode, FieldNode fieldNode) { return classNode.getGetterMethod(GroovyUtils.getsetName(GroovyUtils.GetSet.GET, fieldNode.getName())); }
public MethodNode getGetterMethod(String getterName) { for (Iterator iter = getDeclaredMethods(getterName).iterator(); iter.hasNext();) { MethodNode method = (MethodNode) iter.next(); if (getterName.equals(method.getName()) && ClassHelper.VOID_TYPE!=method.getReturnType() && method.getParameters().length == 0) { return method; } } ClassNode parent = getSuperClass(); if (parent!=null) return parent.getGetterMethod(getterName); return null; }
public MethodNode getGetterMethod(String getterName) { for (MethodNode method : getDeclaredMethods(getterName)) { if (getterName.equals(method.getName()) && ClassHelper.VOID_TYPE!=method.getReturnType() && method.getParameters().length == 0) { return method; } } ClassNode parent = getSuperClass(); if (parent!=null) return parent.getGetterMethod(getterName); return null; }
public MethodNode getGetterMethod(String getterName) { for (Object o : getDeclaredMethods(getterName)) { MethodNode method = (MethodNode) o; if (getterName.equals(method.getName()) && ClassHelper.VOID_TYPE!=method.getReturnType() && method.getParameters().length == 0) { return method; } } ClassNode parent = getSuperClass(); if (parent!=null) return parent.getGetterMethod(getterName); return null; }
public MethodNode getGetterMethod(String getterName) { for (Object o : getDeclaredMethods(getterName)) { MethodNode method = (MethodNode) o; if (getterName.equals(method.getName()) && ClassHelper.VOID_TYPE!=method.getReturnType() && method.getParameters().length == 0) { return method; } } ClassNode parent = getSuperClass(); if (parent!=null) return parent.getGetterMethod(getterName); return null; }
String name = propertyNode.getName(); name = Character.toUpperCase(name.charAt(0)) + name.substring(1); MethodNode getter = classNode.getGetterMethod("get" + name); // NOI18N if (getter != null) { genMethod(classNode, getter, out, false);
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))); } }
MethodNode getter = classNode.getGetterMethod(getterName); if(getter == null && ClassHelper.boolean_TYPE==node.getType()) { String secondGetterName = "is" + capitalize(name); getter = classNode.getGetterMethod(secondGetterName);