@Override public List<PropertyNode> getProperties() { List<PropertyNode> nodes = new LinkedList<PropertyNode>(); for (ClassNode delegate : delegates) { List<PropertyNode> properties = delegate.getProperties(); if (properties != null) nodes.addAll(properties); } return nodes; }
public PropertyNode getProperty(String name) { for (PropertyNode pn : getProperties()) { if (pn.getName().equals(name)) return pn; } return null; }
public static List<PropertyNode> getInstanceProperties(ClassNode cNode) { final List<PropertyNode> result = new ArrayList<PropertyNode>(); for (PropertyNode pNode : cNode.getProperties()) { if (!pNode.isStatic()) { result.add(pNode); } } return result; }
private static void generatePropertyMethods(final ClassNode cNode) { for (PropertyNode node : cNode.getProperties()) { processProperty(cNode, node); } }
public static List<PropertyNode> getAllProperties(ClassNode type) { ClassNode node = type; List<PropertyNode> result = new ArrayList<PropertyNode>(); while (node != null) { result.addAll(node.getProperties()); node = node.getSuperClass(); } return result; }
public static List<FieldNode> getInstancePropertyFields(ClassNode cNode) { final List<FieldNode> result = new ArrayList<FieldNode>(); for (PropertyNode pNode : cNode.getProperties()) { if (!pNode.isStatic()) { result.add(pNode.getField()); } } return result; }
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()); } } } }
public static List<FieldNode> getSuperPropertyFields(ClassNode cNode) { final List<FieldNode> result; if (cNode == ClassHelper.OBJECT_TYPE) { result = new ArrayList<FieldNode>(); } else { result = getSuperPropertyFields(cNode.getSuperClass()); } for (PropertyNode pNode : cNode.getProperties()) { if (!pNode.isStatic()) { result.add(pNode.getField()); } } return result; }
private static void visitFieldNode(FieldNode fNode) { final ClassNode cNode = fNode.getDeclaringClass(); final List<PropertyNode> pList = cNode.getProperties(); PropertyNode foundProp = null; for (PropertyNode pNode : pList) { if (pNode.getName().equals(fNode.getName())) { foundProp = pNode; break; } } if (foundProp != null) { revertVisibility(fNode); pList.remove(foundProp); } }
/** * Detect whether a static property with the given name is within the class * or a super class. * * @param cNode the ClassNode of interest * @param propName the property name * @return the static property if found or else null */ public static PropertyNode getStaticProperty(ClassNode cNode, String propName) { ClassNode classNode = cNode; while (classNode != null) { for (PropertyNode pn : classNode.getProperties()) { if (pn.getName().equals(propName) && pn.isStatic()) return pn; } classNode = classNode.getSuperClass(); } return null; }
/** * If we are in a constructor, that is static compiled, but in a class, that * is not, it may happen that init code from object initializers, fields * or properties is added into the constructor code. The backend assumes * a purely static constructor, so it may fail if it encounters dynamic * code here. Thus we make this kind of code fail */ private void checkForConstructorWithCSButClassWithout(MethodNode node) { if (!(node instanceof ConstructorNode)) return; Object meta = node.getNodeMetaData(STATIC_COMPILE_NODE); if (!Boolean.TRUE.equals(meta)) return; ClassNode clz = typeCheckingContext.getEnclosingClassNode(); meta = clz.getNodeMetaData(STATIC_COMPILE_NODE); if (Boolean.TRUE.equals(meta)) return; if ( clz.getObjectInitializerStatements().isEmpty() && clz.getFields().isEmpty() && clz.getProperties().isEmpty()) { return; } addStaticTypeError("Cannot statically compile constructor implicitly including non static elements from object initializers, properties or fields.",node); }
@Override public void visitClass(final ClassNode node) { List<Statement> savedStatements = new ArrayList<Statement>(node.getObjectInitializerStatements()); super.visitClass(node); node.getObjectInitializerStatements().addAll(savedStatements); for (ClassNode inode : node.getAllInterfaces()) { if (Traits.isTrait(inode)) { List<PropertyNode> traitProps = inode.getProperties(); for (PropertyNode pn : traitProps) { super.visitProperty(pn); } } } }
@Override public void visitProperty(final PropertyNode node) { if (visitor!=null) visitor.visitProperty(node); ClassNode declaringClass = node.getDeclaringClass(); if (declaringClass!=null) { if (StaticTypeCheckingSupport.implementsInterfaceOrIsSubclassOf(declaringClass, ClassHelper.LIST_TYPE)) { List<PropertyNode> properties = declaringClass.getProperties(); boolean spread = true; for (PropertyNode propertyNode : properties) { if (propertyNode==node) { spread = false; break; } } // it's no real property but a property of the component pexp.setSpreadSafe(spread); } rType.set(declaringClass); } } };
private void checkDuplicateProperties(PropertyNode node) { ClassNode cn = node.getDeclaringClass(); String name = node.getName(); String getterName = "get" + MetaClassHelper.capitalize(name); if (Character.isUpperCase(name.charAt(0))) { for (PropertyNode propNode : cn.getProperties()) { String otherName = propNode.getField().getName(); String otherGetterName = "get" + MetaClassHelper.capitalize(otherName); if (node != propNode && getterName.equals(otherGetterName)) { String msg = "The field " + name + " and " + otherName + " on the class " + cn.getName() + " will result in duplicate JavaBean properties, which is not allowed"; addError(msg, node); } } } }
public void visitContents(GroovyClassVisitor visitor) { // now let's visit the contents of the class for (PropertyNode pn : getProperties()) { visitor.visitProperty(pn); } for (FieldNode fn : getFields()) { visitor.visitField(fn); } for (ConstructorNode cn : getDeclaredConstructors()) { visitor.visitConstructor(cn); } for (MethodNode mn : getMethods()) { visitor.visitMethod(mn); } }
private static boolean ensureNoInstanceFieldOrProperty(final SourceUnit source, final ClassNode parent) { boolean valid = true; for (FieldNode fieldNode : parent.getFields()) { if (!fieldNode.isStatic() && fieldNode.getLineNumber()>0) { // if <0, probably an AST transform or internal code (like generated metaclass field, ...) addUnsupportedError(fieldNode, source); valid = false; } } for (PropertyNode propertyNode : parent.getProperties()) { if (!propertyNode.isStatic() && propertyNode.getLineNumber()>0) { // if <0, probably an AST transform or internal code (like generated metaclass field, ...) addUnsupportedError(propertyNode, source); valid = false; } } return valid; }
private void addListenerToClass(SourceUnit source, ClassNode classNode) { if (needsPropertyChangeSupport(classNode, source)) { addPropertyChangeSupport(classNode); } for (PropertyNode propertyNode : classNode.getProperties()) { FieldNode field = propertyNode.getField(); // look to see if per-field handlers will catch this one... if (hasBindableAnnotation(field) || ((field.getModifiers() & Opcodes.ACC_FINAL) != 0) || field.isStatic() || VetoableASTTransformation.hasVetoableAnnotation(field)) { // explicitly labeled properties are already handled, // don't transform final properties // don't transform static properties // VetoableASTTransformation will handle both @Bindable and @Vetoable continue; } createListenerSetter(classNode, propertyNode); } }
private void addListenerToClass(SourceUnit source, ClassNode classNode) { boolean bindable = BindableASTTransformation.hasBindableAnnotation(classNode); for (PropertyNode propertyNode : classNode.getProperties()) { if (!hasVetoableAnnotation(propertyNode.getField()) && !propertyNode.getField().isFinal() && !propertyNode.getField().isStatic()) { createListenerSetter(source, bindable || BindableASTTransformation.hasBindableAnnotation(propertyNode.getField()), classNode, propertyNode); } } }
static void visitField(ErrorCollecting xform, AnnotationNode node, FieldNode fieldNode) { final Expression soft = node.getMember("soft"); final Expression init = getInitExpr(xform, fieldNode); String backingFieldName = "$" + fieldNode.getName(); fieldNode.rename(backingFieldName); fieldNode.setModifiers(ACC_PRIVATE | (fieldNode.getModifiers() & (~(ACC_PUBLIC | ACC_PROTECTED)))); PropertyNode pNode = fieldNode.getDeclaringClass().getProperty(backingFieldName); if (pNode != null) { fieldNode.getDeclaringClass().getProperties().remove(pNode); } if (soft instanceof ConstantExpression && ((ConstantExpression) soft).getValue().equals(true)) { createSoft(fieldNode, init); } else { create(fieldNode, init); // @Lazy not meaningful with primitive so convert to wrapper if needed if (ClassHelper.isPrimitiveType(fieldNode.getType())) { fieldNode.setType(ClassHelper.getWrapper(fieldNode.getType())); } } }
private static BlockStatement processArgsBlock(ClassNode cNode, VariableExpression namedArgs) { BlockStatement block = new BlockStatement(); for (PropertyNode pNode : cNode.getProperties()) { if (pNode.isStatic()) continue; // if namedArgs.containsKey(propertyName) setProperty(propertyName, namedArgs.get(propertyName)); Statement ifStatement = ifS( callX(namedArgs, "containsKey", constX(pNode.getName())), assignS(varX(pNode), propX(namedArgs, pNode.getName()))); block.addStatement(ifStatement); } block.addStatement(stmt(callX(CHECK_METHOD_TYPE, "checkPropNames", args(varX("this"), namedArgs)))); return block; }