private static boolean isGroovyObject(Expression objectExpression) { return isThisExpression(objectExpression) || objectExpression.getType().isDerivedFromGroovyObject() && !(objectExpression instanceof ClassExpression); }
AsmClassGenerator generator = new AsmClassGenerator(source, context, visitor, sourceName); generator.visitClass(classNode); LinkedList innerClasses = generator.getInnerClasses(); while (!innerClasses.isEmpty()) { classgen.call(source, context, (ClassNode) innerClasses.removeFirst());
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 static boolean isThisOrSuper(Expression expression) { return isThisExpression(expression) || isSuperExpression(expression); }
public void visitArgumentlistExpression(ArgumentListExpression ale) { if (containsSpreadExpression(ale)) { despreadList(ale.getExpressions(), true); } else { visitTupleExpression(ale, true); } }
private void visitAnnotations(AnnotatedNode targetNode, AnnotatedNode sourceNode, Object visitor) { for (AnnotationNode an : sourceNode.getAnnotations()) { // skip built-in properties if (an.isBuiltIn()) continue; if (an.hasSourceRetention()) continue; AnnotationVisitor av = getAnnotationVisitor(targetNode, an, visitor); visitAnnotationAttributes(an, av); av.visitEnd(); } }
String signature = BytecodeHelper.getGenericsMethodSignature(node); int modifiers = node.getModifiers(); if (isVargs(node.getParameters())) modifiers |= Opcodes.ACC_VARARGS; MethodVisitor mv = cv.visitMethod(modifiers, node.getName(), methodType, signature, buildExceptions(node.getExceptions())); controller.setMethodVisitor(mv); visitAnnotations(node, mv); for (int i = 0; i < parameters.length; i++) { visitParameterAnnotations(parameters[i], i, mv); if (getCompileUnit().getConfig().getParameters()) { for (int i = 0; i < parameters.length; i++) { visitAnnotationDefault(node, mv); } else if (!node.isAbstract()) { Statement code = node.getCode(); ((BytecodeInstruction)((BytecodeSequence)code).getInstructions().get(0)).visit(mv); } else { visitStdMethod(node, isConstructor, parameters, code);
public void visitClosureExpression(ClosureExpression expression) { ClassNode innerClass = (ClassNode) closureClassMap.get(expression); if (innerClass==null) { innerClass = createClosureClass(expression); closureClassMap.put(expression,innerClass); addInnerClass(innerClass); innerClass.addInterface(ClassHelper.GENERATED_CLOSURE_Type); if ((isStaticMethod() || specialCallWithinConstructor) && !classNode.declaresInterface(ClassHelper.GENERATED_CLOSURE_Type)) { visitClassExpression(new ClassExpression(classNode)); visitClassExpression(new ClassExpression(getOutermostClass())); } else { mv.visitVarInsn(ALOAD, 0); loadThis(); visitFieldExpression(new FieldExpression(classNode.getDeclaredField(name))); } else { Variable v = compileStack.getVariable(name, classNode.getSuperClass() != ClassHelper.CLOSURE_TYPE);
public void visitMethodCallExpression(MethodCallExpression call) { onLineNumber(call, "visitMethodCallExpression: \"" + call.getMethod() + "\":"); if (isClosureCall(call)) { // let's invoke the closure method invokeClosure(call.getArguments(), call.getMethodAsString()); } else { boolean isSuperMethodCall = usesSuper(call); MethodCallerMultiAdapter adapter = invokeMethod; if (isThisExpression(call.getObjectExpression())) adapter = invokeMethodOnCurrent; if (isSuperMethodCall) adapter = invokeMethodOnSuper; if (isStaticInvocation(call)) adapter = invokeStaticMethod; makeInvokeMethodCall(call, isSuperMethodCall, adapter); } }
boolean containsSpreadExpression = AsmClassGenerator.containsSpreadExpression(arguments); int numberOfArguments = containsSpreadExpression ? -1 : AsmClassGenerator.argumentSize(arguments); int operandsToReplace = 1; if (numberOfArguments > MethodCallerMultiAdapter.MAX_ARGS || containsSpreadExpression) { if (containsSpreadExpression) { numberOfArguments = -1; controller.getAcg().despreadList(ae.getExpressions(), true); } else { numberOfArguments = ae.getExpressions().size(); argument.visit(controller.getAcg()); operandStack.box(); if (argument instanceof CastExpression) controller.getAcg().loadWrapper(argument);
private void makeCallSite(Expression receiver, String message, Expression arguments, boolean safe, boolean implicitThis, boolean callCurrent, boolean callStatic) { if (isNotClinit()) { mv.visitVarInsn(ALOAD, callSiteArrayVarIndex); mv.visitMethodInsn(INVOKESTATIC,getClassName(),"$getCallSiteArray","()[Lorg/codehaus/groovy/runtime/callsite/CallSite;"); final int index = allocateIndex(message); mv.visitLdcInsn(index); mv.visitInsn(AALOAD); visitAndAutoboxBoolean(receiver); this.implicitThis = oldVal; boolean containsSpreadExpression = containsSpreadExpression(arguments); int numberOfArguments = containsSpreadExpression ? -1 : argumentSize(arguments); if (numberOfArguments > MethodCallerMultiAdapter.MAX_ARGS || containsSpreadExpression) { ArgumentListExpression ae; despreadList(ae.getExpressions(), true); } else { numberOfArguments = ae.getExpressions().size(); for (int i = 0; i < numberOfArguments; i++) { Expression argument = ae.getExpression(i); visitAndAutoboxBoolean(argument); if (argument instanceof CastExpression) loadWrapper(argument); final String createArraySignature = getCreateArraySignature(numberOfArguments); mv.visitMethodInsn(INVOKESTATIC, "org/codehaus/groovy/runtime/ArrayUtil", "createArray", createArraySignature); final String desc = getDescForParamNum(numberOfArguments);
getBytecodeVersion(), adjustedModifiers(classNode.getModifiers()), internalClassName, BytecodeHelper.getGenericsSignature(classNode), ); cv.visitSource(sourceFile, null); visitAnnotations(classNode, cv); createInterfaceSyntheticStaticFields(); } else { super.visitClass(classNode); if (!classNode.declaresInterface(ClassHelper.GENERATED_CLOSURE_Type)) { createMopMethods(); createSyntheticStaticFields(); outerClassName, innerClassName, adjustedModifiers(innerClass.getModifiers())); generateCallSiteArray(); cv.visitEnd();
) { if ((adapter == invokeMethod || adapter == invokeMethodOnCurrent || adapter == invokeStaticMethod)&& !spreadSafe) { String methodName = getMethodName(message); makeCallSite(receiver, methodName, arguments, safe, implicitThis, adapter == invokeMethodOnCurrent, adapter == invokeStaticMethod); return; visitAndAutoboxBoolean(receiver); this.implicitThis = oldVal; boolean containsSpreadExpression = containsSpreadExpression(arguments); int numberOfArguments = containsSpreadExpression ? -1 : argumentSize(arguments); if (numberOfArguments > MethodCallerMultiAdapter.MAX_ARGS || containsSpreadExpression) { ArgumentListExpression ae; despreadList(ae.getExpressions(), true); } else { ae.visit(this); for (int i = 0; i < numberOfArguments; i++) { Expression argument = te.getExpression(i); visitAndAutoboxBoolean(argument); if (argument instanceof CastExpression) loadWrapper(argument);
getBytecodeVersion(), adjustedClassModifiers(classNode.getModifiers()), controller.getInternalClassName(), BytecodeHelper.getGenericsSignature(classNode), if (an.hasSourceRetention()) continue; AnnotationVisitor av = getAnnotationVisitor(classNode, an, cv); visitAnnotationAttributes(an, av); av.visitEnd(); return; } else { visitAnnotations(classNode, cv); controller.getCallSiteWriter().getCallSites())); super.visitClass(classNode); createInterfaceSyntheticStaticFields(); } else { super.visitClass(classNode); mopWriter.createMopMethods(); controller.getCallSiteWriter().generateCallSiteArray(); createSyntheticStaticFields(); makeInnerClassEntry(innerClass); makeInnerClassEntry(classNode);
public void visitListExpression(ListExpression expression) { onLineNumber(expression,"ListExpression" ); int size = expression.getExpressions().size(); boolean containsSpreadExpression = containsSpreadExpression(expression); if (!containsSpreadExpression) { helper.pushConstant(size); mv.visitTypeInsn(ANEWARRAY, "java/lang/Object"); for (int i = 0; i < size; i++) { mv.visitInsn(DUP); helper.pushConstant(i); visitAndAutoboxBoolean(expression.getExpression(i)); mv.visitInsn(AASTORE); } } else { despreadList(expression.getExpressions(), false); } createListMethod.call(mv); }
private void makeInvokeMethodCall(MethodCallExpression call, boolean useSuper, MethodCallerMultiAdapter adapter) { // receiver // we operate on GroovyObject if possible Expression objectExpression = call.getObjectExpression(); if (!isStaticMethod() && !isStaticContext() && isThisExpression(call.getObjectExpression())) { objectExpression = new CastExpression(classNode, objectExpression); } // message name Expression messageName = new CastExpression(ClassHelper.STRING_TYPE, call.getMethod()); if (useSuper) { makeCall(new ClassExpression(getOutermostClass().getSuperClass()), objectExpression, messageName, call.getArguments(), adapter, call.isSafe(), call.isSpreadSafe(), false ); } else { makeCall(objectExpression, messageName, call.getArguments(), adapter, call.isSafe(), call.isSpreadSafe(), call.isImplicitThis() ); } }
if (isThisOrSuper(objectExpression)) { FieldNode field = null; boolean privateSuperField = false; if (isSuperExpression(objectExpression)) { field = classNode.getSuperClass().getDeclaredField(name); if (field != null && ((field.getModifiers() & ACC_PRIVATE) != 0)) { && isThisExpression(objectExpression) && controller.isStaticContext()) { visitFieldExpression(new FieldExpression(field)); return; visitFieldExpression(new FieldExpression(field)); return; if (isSuperExpression(objectExpression)) { String prefix; if (controller.getCompileStack().isLHS()) { setPropertyOfSuperClass(classNode, expression, mv); visitMethodCallExpression(new MethodCallExpression(objectExpression, propName, MethodCallExpression.NO_ARGUMENTS)); return;
public void visitListExpression(ListExpression expression) { onLineNumber(expression,"ListExpression" ); boolean containsSpreadExpression = containsSpreadExpression(expression); boolean containsOnlyConstants = !containsSpreadExpression && containsOnlyConstants(expression); OperandStack operandStack = controller.getOperandStack(); if (!containsSpreadExpression) { despreadList(expression.getExpressions(), false);
adjustedClassModifiersForClassWriting(classNode), controller.getInternalClassName(), BytecodeHelper.getGenericsSignature(classNode), if (packageNode != null) { visitAnnotations(classNode, packageNode, cv); visitAnnotations(classNode, cv); controller.getCallSiteWriter().getCallSites())); super.visitClass(classNode); createInterfaceSyntheticStaticFields(); } else { super.visitClass(classNode); mopWriter.createMopMethods(); controller.getCallSiteWriter().generateCallSiteArray(); createSyntheticStaticFields(); makeInnerClassEntry(innerClass); makeInnerClassEntry(classNode);
boolean containsSpreadExpression = AsmClassGenerator.containsSpreadExpression(arguments); if (containsSpreadExpression) { controller.getAcg().despreadList(ae.getExpressions(), true); sig.append(getTypeDescription(Object[].class)); } else { if (arg instanceof CastExpression) { operandStack.box(); controller.getAcg().loadWrapper(arg); sig.append(getTypeDescription(Wrapper.class)); } else {