@SuppressWarnings("unchecked") private static void addPrivateFieldOrMethodAccess(Expression source, ClassNode cn, StaticTypesMarker type, ASTNode accessedMember) { Set<ASTNode> set = (Set<ASTNode>) cn.getNodeMetaData(type); if (set == null) { set = new LinkedHashSet<ASTNode>(); cn.putNodeMetaData(type, set); } set.add(accessedMember); source.putNodeMetaData(type, accessedMember); }
private void addDynamicOuterClassAccessorsCallback(final ClassNode outer) { if (outer != null && !isStaticallyCompiled(outer) && outer.getNodeMetaData(StaticCompilationMetadataKeys.DYNAMIC_OUTER_NODE_CALLBACK) == null) { outer.putNodeMetaData(StaticCompilationMetadataKeys.DYNAMIC_OUTER_NODE_CALLBACK, new CompilationUnit.PrimaryClassNodeOperation() { @Override public void call(SourceUnit source, GeneratorContext context, ClassNode classNode) throws CompilationFailedException { if (classNode == outer) { addPrivateBridgeMethods(classNode); addPrivateFieldsAccessors(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 checkSuperCallFromClosure(Expression call, MethodNode directCallTarget) { if (call instanceof MethodCallExpression && typeCheckingContext.getEnclosingClosure() != null) { Expression objectExpression = ((MethodCallExpression) call).getObjectExpression(); if (objectExpression instanceof VariableExpression) { VariableExpression var = (VariableExpression) objectExpression; if (var.isSuperExpression()) { ClassNode current = typeCheckingContext.getEnclosingClassNode(); LinkedList<MethodNode> list = current.getNodeMetaData(StaticTypesMarker.SUPER_MOP_METHOD_REQUIRED); if (list == null) { list = new LinkedList<MethodNode>(); current.putNodeMetaData(StaticTypesMarker.SUPER_MOP_METHOD_REQUIRED, list); } list.add(directCallTarget); call.putNodeMetaData(StaticTypesMarker.SUPER_MOP_METHOD_REQUIRED, current); } } } }
@Override protected ClassNode createClosureClass(final ClosureExpression expression, final int mods) { ClassNode closureClass = super.createClosureClass(expression, mods); List<MethodNode> methods = closureClass.getDeclaredMethods("call"); List<MethodNode> doCall = closureClass.getMethods("doCall"); if (doCall.size() != 1) { throw new GroovyBugError("Expected to find one (1) doCall method on generated closure, but found " + doCall.size()); } MethodNode doCallMethod = doCall.get(0); if (methods.isEmpty() && doCallMethod.getParameters().length == 1) { createDirectCallMethod(closureClass, doCallMethod); } MethodTargetCompletionVisitor visitor = new MethodTargetCompletionVisitor(doCallMethod); Object dynamic = expression.getNodeMetaData(StaticTypesMarker.DYNAMIC_RESOLUTION); if (dynamic != null) { doCallMethod.putNodeMetaData(StaticTypesMarker.DYNAMIC_RESOLUTION, dynamic); } for (MethodNode method : methods) { visitor.visitMethod(method); } closureClass.putNodeMetaData(StaticCompilationMetadataKeys.STATIC_COMPILE_NODE, Boolean.TRUE); return closureClass; }
@Override public void visitClass(final ClassNode node) { boolean skip = shouldSkipClassNode(node); if (!skip && !anyMethodSkip(node)) { node.putNodeMetaData(MopWriter.Factory.class, StaticCompilationMopWriter.FACTORY); } ClassNode oldCN = classNode; classNode = node; Iterator<InnerClassNode> innerClasses = classNode.getInnerClasses(); while (innerClasses.hasNext()) { InnerClassNode innerClassNode = innerClasses.next(); boolean innerStaticCompile = !(skip || isSkippedInnerClass(innerClassNode)); innerClassNode.putNodeMetaData(STATIC_COMPILE_NODE, innerStaticCompile); innerClassNode.putNodeMetaData(WriterControllerFactory.class, node.getNodeMetaData(WriterControllerFactory.class)); if (innerStaticCompile && !anyMethodSkip(innerClassNode)) { innerClassNode.putNodeMetaData(MopWriter.Factory.class, StaticCompilationMopWriter.FACTORY); } } super.visitClass(node); addPrivateFieldAndMethodAccessors(node); if (isStaticallyCompiled(node)) addDynamicOuterClassAccessorsCallback(node.getOuterClass()); classNode = oldCN; }
node.putNodeMetaData(StaticTypesMarker.INFERRED_TYPE, node);
visitor.setCompilationUnit(compilationUnit); addTypeCheckingExtensions(visitor, extensions); classNode.putNodeMetaData(WriterControllerFactory.class, factory); node.putNodeMetaData(STATIC_COMPILE_NODE, !visitor.isSkipMode(node)); visitor.initialize(); methodNode.putNodeMetaData(STATIC_COMPILE_NODE, !visitor.isSkipMode(node)); if (declaringClass.getNodeMetaData(WriterControllerFactory.class) == null) { declaringClass.putNodeMetaData(WriterControllerFactory.class, factory);
Expression result = new EmptyExpression(); result.setSourcePosition(bin); classNode.putNodeMetaData(MarkupTemplateEngine.MODELTYPES_ASTKEY, modelTypes); return result;
ClassNode declaringClass = directMethodCallCandidate.getDeclaringClass(); if (declaringClass.isInterface() && directMethodCallCandidate.isStatic() && !(directMethodCallCandidate instanceof ExtensionMethodNode)) { typeCheckingContext.getEnclosingClassNode().putNodeMetaData(MINIMUM_BYTECODE_VERSION, Opcodes.V1_8);
@Override public void performInjectionOnAnnotatedClass(SourceUnit source, ClassNode classNode) { if( classNode.getNodeMetaData(Slf4j.class) != null) return; String packageName = Slf4j.class.getPackage().getName(); // if already annotated skip for (AnnotationNode annotationNode : classNode.getAnnotations()) { if(annotationNode.getClassNode().getPackageName().equals(packageName)) { return; } } FieldNode logField = classNode.getField("log"); if(logField != null) { if(!Modifier.isPrivate(logField.getModifiers())) { return; } } AnnotationNode annotationNode = new AnnotationNode(ClassHelper.make(Slf4j.class)); LogASTTransformation logASTTransformation = new LogASTTransformation(); logASTTransformation.setCompilationUnit( new CompilationUnit(new GroovyClassLoader(getClass().getClassLoader())) ); logASTTransformation.visit(new ASTNode[]{ annotationNode, classNode}, source); classNode.putNodeMetaData(Slf4j.class, annotationNode); }
Expression result = new EmptyExpression(); result.setSourcePosition(bin); classNode.putNodeMetaData(MarkupTemplateEngine.MODELTYPES_ASTKEY, modelTypes); return result;