private static void implementComparable(ClassNode classNode) { if (!classNode.implementsInterface(COMPARABLE_TYPE)) { classNode.addInterface(makeClassSafeWithGenerics(Comparable.class, classNode)); } }
public ClassNode getOrAddClosureClass(ClosureExpression expression, int mods) { ClassNode closureClass = closureClassMap.get(expression); if (closureClass == null) { closureClass = createClosureClass(expression, mods); closureClassMap.put(expression, closureClass); controller.getAcg().addInnerClass(closureClass); closureClass.addInterface(ClassHelper.GENERATED_CLOSURE_Type); closureClass.putNodeMetaData(WriterControllerFactory.class, factory); } return closureClass; }
private void replaceExtendsByImplements(final ClassNode cNode) { ClassNode superClass = cNode.getUnresolvedSuperClass(); if (Traits.isTrait(superClass)) { // move from super class to interface; cNode.setSuperClass(ClassHelper.OBJECT_TYPE); cNode.setUnresolvedSuperClass(ClassHelper.OBJECT_TYPE); cNode.addInterface(superClass); resolveScope(cNode); } }
public void visit(ASTNode[] nodes, SourceUnit source) { init(nodes, source); AnnotatedNode parent = (AnnotatedNode) nodes[1]; AnnotationNode anno = (AnnotationNode) nodes[0]; if (!MY_TYPE.equals(anno.getClassNode())) return; if (parent instanceof ClassNode) { ClassNode cNode = (ClassNode) parent; if (!checkNotInterface(cNode, MY_TYPE_NAME)) return; cNode.addInterface(EXTERNALIZABLE_TYPE); boolean includeFields = memberHasValue(anno, "includeFields", true); List<String> excludes = getMemberStringList(anno, "excludes"); if (!checkPropertyList(cNode, excludes, "excludes", anno, MY_TYPE_NAME, includeFields)) return; List<FieldNode> list = getInstancePropertyFields(cNode); if (includeFields) { list.addAll(getInstanceNonPropertyFields(cNode)); } createWriteExternal(cNode, excludes, list); createReadExternal(cNode, excludes, list); } }
ClassNode cNode = (ClassNode) parent; if (!checkNotInterface(cNode, MY_TYPE_NAME)) return; cNode.addInterface(CLONEABLE_TYPE); boolean includeFields = memberHasValue(anno, "includeFields", true); AutoCloneStyle style = getStyle(anno, "style");
@Override public void visitClass(ClassNode node) { this.classNode = node; thisField = null; InnerClassNode innerClass = null; if (!node.isEnum() && !node.isInterface() && node instanceof InnerClassNode) { innerClass = (InnerClassNode) node; if (!isStatic(innerClass) && innerClass.getVariableScope() == null) { thisField = innerClass.addField("this$0", PUBLIC_SYNTHETIC, node.getOuterClass().getPlainNodeReference(), null); } } super.visitClass(node); if (node.isEnum() || node.isInterface()) return; if (innerClass == null) return; if (node.getSuperClass().isInterface() || Traits.isAnnotatedWithTrait(node.getSuperClass())) { node.addInterface(node.getUnresolvedSuperClass()); node.setUnresolvedSuperClass(ClassHelper.OBJECT_TYPE); } }
if (fieldHelperClassNode != null && !cNode.declaresInterface(fieldHelperClassNode)) { cNode.addInterface(fieldHelperClassNode);
classNode.addAnnotations(annotations); classNode.setGenericsTypes(genericsType); classNode.addInterface(ClassHelper.Annotation_TYPE); configureAST(classNode, classDef);
protected void addGroovyObjectInterfaceAndMethods(ClassNode node, final String classInternalName) { if (!node.isDerivedFromGroovyObject()) node.addInterface(ClassHelper.make(GroovyObject.class)); FieldNode metaClassField = getMetaClassField(node);
/** * Makes the {@link ClassNode} to implement the interfaces passed * as arguments. * * @param classNode the {@link ClassNode} we want to implement * certain interfaces * @param interfaces the interfaces we want our {@link ClassNode} * to implement * @since 0.3.0 */ public void addInterfaces(final ClassNode classNode, final ClassNode... interfaces) { for (final ClassNode nextInterface : interfaces) { classNode.addInterface(nextInterface); } }
/** * Adds the {@link IPluginEvent} interface to the class so that it can show at runtime * that it is an event enumeration. * @param classNode */ private void addInterface(ClassNode classNode) { classNode.addInterface(new ClassNode(IPluginEvent.class)); } }
public static void injectInterface(ClassNode classNode, ClassNode type, boolean deep) { if (classNode.implementsInterface(type)) { return; } if (deep) { getFurthestParent(classNode).addInterface(type); } else { classNode.addInterface(type); } }
/** * Makes the {@link ClassNode} to implement the interfaces passed * as arguments * <br><br> * <b>IMPORTANT</b>: Dont use this method at any {@link CompilePhase} * before SEMANTIC_ANALYSIS. Classes may have not been set at this * point. * * @param classNode The class we want to add the interfaces to * @param interfaces the interfaces we want the class node to be * implementing * @since 0.3.0 */ public void addInterfaces(final ClassNode classNode, final Class... interfaces) { for (final Class clazz : interfaces) { final ClassNode nextInterface = ClassHelper.make(clazz, false); classNode.addInterface(nextInterface); } }
public ClassNode getOrAddClosureClass(ClosureExpression expression, int mods) { ClassNode closureClass = closureClassMap.get(expression); if (closureClass == null) { closureClass = createClosureClass(expression, mods); closureClassMap.put(expression, closureClass); controller.getAcg().addInnerClass(closureClass); closureClass.addInterface(ClassHelper.GENERATED_CLOSURE_Type); } return closureClass; }
public void setGroovyInterceptable(ClassNode classNode) { for (ClassNode interfaceNode : classNode.getInterfaces()) if (interfaceNode.getTypeClass().equals(GroovyInterceptable.class)) return; // classNode.addInterface(new ClassNode(GroovyInterceptable.class)); }
public void visitMethod(MethodNode node){ if(isTag && !node.isStatic() && node.getName().equals(TAG) && node.getParameters().length==2 && node.getReturnType().equals(ClassHelper.OBJECT_TYPE)){ ClassNode taggableNode = new ClassNode(Taggable.class); if(!classNode.declaresInterface(taggableNode)){ classNode.addInterface(taggableNode); } } super.visitMethod(node); } }
public void visitMethod(MethodNode node){ if(isTag && !node.isStatic() && node.getName().equals(TAG) && node.getParameters().length==2 && node.getReturnType().equals(ClassHelper.OBJECT_TYPE)){ ClassNode taggableNode = new ClassNode(Taggable.class); if(!classNode.declaresInterface(taggableNode)){ classNode.addInterface(taggableNode); } } super.visitMethod(node); } }
@Override public void visitBlockStatement(BlockStatement block) { if (block.isEmpty() || this.xformed) { return; } ClosureExpression closure = beans(block); if (closure != null) { // Add a marker interface to the current script this.classNode.addInterface(ClassHelper.make(SOURCE_INTERFACE)); // Implement the interface by adding a public read-only property with the // same name as the method in the interface (getBeans). Make it return the // closure. this.classNode.addProperty( new PropertyNode(BEANS, Modifier.PUBLIC | Modifier.FINAL, ClassHelper.CLOSURE_TYPE.getPlainNodeReference(), this.classNode, closure, null, null)); // Only do this once per class this.xformed = true; } }
public void visit(ASTNode[] nodes, SourceUnit source) { init(nodes, source); AnnotatedNode parent = (AnnotatedNode) nodes[1]; AnnotationNode anno = (AnnotationNode) nodes[0]; if (!MY_TYPE.equals(anno.getClassNode())) return; if (parent instanceof ClassNode) { ClassNode cNode = (ClassNode) parent; checkNotInterface(cNode, MY_TYPE_NAME); cNode.addInterface(EXTERNALIZABLE_TYPE); boolean includeFields = memberHasValue(anno, "includeFields", true); List<String> excludes = tokenize((String) getMemberValue(anno, "excludes")); List<FieldNode> list = getInstancePropertyFields(cNode); if (includeFields) { list.addAll(getInstanceNonPropertyFields(cNode)); } createWriteExternal(cNode, excludes, list); createReadExternal(cNode, excludes, list); } }
@Override public void visitBlockStatement(BlockStatement block) { if (block.isEmpty() || this.xformed) { return; } ClosureExpression closure = ratpack(block); if (closure != null) { this.classNode.addAnnotation(new AnnotationNode(ClassHelper .make("Component"))); // Add a marker interface to the current script this.classNode.addInterface(ClassHelper.make(SOURCE_INTERFACE)); // Implement the interface by adding a public read-only property with the // same name as the method in the interface (getRatpack). Make it return the // closure. this.classNode.addProperty(new PropertyNode(RATPACK, Modifier.PUBLIC | Modifier.FINAL, ClassHelper.CLOSURE_TYPE .getPlainNodeReference(), this.classNode, closure, null, null)); // Only do this once per class this.xformed = true; } }