@SuppressWarnings("unchecked") private boolean makeGetPrivateFieldWithBridgeMethod(final Expression receiver, final ClassNode receiverType, final String fieldName, final boolean safe, final boolean implicitThis) { FieldNode field = receiverType.getField(fieldName); ClassNode outerClass = receiverType.getOuterClass(); if (field==null && implicitThis && outerClass !=null && !receiverType.isStaticClass()) { Expression pexp; if (controller.isInClosure()) { MethodCallExpression mce = new MethodCallExpression( new VariableExpression("this"), "getThisObject", ArgumentListExpression.EMPTY_ARGUMENTS ); mce.putNodeMetaData(StaticTypesMarker.INFERRED_TYPE, controller.getOutermostClass()); mce.setImplicitThis(true); mce.setMethodTarget(CLOSURE_GETTHISOBJECT_METHOD); pexp = new CastExpression(controller.getOutermostClass(),mce); } else { pexp = new PropertyExpression( new ClassExpression(outerClass), "this" ); if (methodNode!=null) { MethodCallExpression mce = new MethodCallExpression(receiver, methodNode.getName(), new ArgumentListExpression(field.isStatic()?new ConstantExpression(null):receiver)); mce.setMethodTarget(methodNode); mce.setSafe(safe);
private void rewriteArgumentList(MethodCallExpression call, ClassExpression objectExpression) { if (SpockRuntime.class.getName().equals(objectExpression.getType().getName())) { String methodName = call.getMethod().getText(); if (REWRITE_METHOD_ARGS.contains(methodName)) { List<Expression> arguments = new ArrayList<>(((ArgumentListExpression)call.getArguments()).getExpressions()); Expression expression = arguments.get(0); if (expression instanceof VariableExpression && isErrorCollectorExpression(((VariableExpression)expression))) { arguments.set(0, errorCollectorExpression()); } expression = arguments.get(1); if (expression instanceof VariableExpression && isValueRecorderExpression(((VariableExpression)expression))) { arguments.set(1, valueRecorderExpression()); } call.setArguments(new ArgumentListExpression(arguments)); } } }
private static Expression correctClassClassChain(PropertyExpression pe) { LinkedList<Expression> stack = new LinkedList<Expression>(); ClassExpression found = null; for (Expression it = pe; it != null; it = ((PropertyExpression) it).getObjectExpression()) { if (it instanceof ClassExpression) { found = (ClassExpression) it; break; } else if (!(it.getClass() == PropertyExpression.class)) { return pe; } stack.addFirst(it); } if (found == null) return pe; if (stack.isEmpty()) return pe; Object stackElement = stack.removeFirst(); if (!(stackElement.getClass() == PropertyExpression.class)) return pe; PropertyExpression classPropertyExpression = (PropertyExpression) stackElement; String propertyNamePart = classPropertyExpression.getPropertyAsString(); if (propertyNamePart == null || !propertyNamePart.equals("class")) return pe; found.setSourcePosition(classPropertyExpression); if (stack.isEmpty()) return found; stackElement = stack.removeFirst(); if (!(stackElement.getClass() == PropertyExpression.class)) return pe; PropertyExpression classPropertyExpressionContainer = (PropertyExpression) stackElement; classPropertyExpressionContainer.setObjectExpression(found); return pe; }
public void coerce(ClassNode from, ClassNode target) { if (from.isDerivedFrom(target)) return; MethodVisitor mv = controller.getMethodVisitor(); OperandStack os = controller.getOperandStack(); os.box(); (new ClassExpression(target)).visit(controller.getAcg()); os.remove(1); asTypeMethod.call(mv); BytecodeHelper.doCast(mv,target); os.replace(target); } }
if (null == currentClass.tryFindPossibleMethod(mce.getMethodAsString(), args)) { String methodName = (String) ((ConstantExpression) method).getValue(); ret = findStaticFieldOrPropAccessorImportFromModule(methodName); if (ret != null) { MethodCallExpression ret = new MethodCallExpression(new ClassExpression(currentClass.getSuperClass()), method, args); setSourcePosition(ret, mce); return ret; Object value = ce.getValue(); if (value instanceof String) { boolean foundInstanceMethod = false; boolean inInnerClass = isInnerClass(currentClass); if (currentMethod != null && !currentMethod.isStatic()) { if (currentClass.hasPossibleMethod(methodName, args)) { foundInstanceMethod = true; object = new PropertyExpression(new ClassExpression(currentClass.getOuterClass()), new ConstantExpression("this"));
Set<ASTNode> accessedMethods = (Set<ASTNode>) node.getNodeMetaData(StaticTypesMarker.PV_METHODS_ACCESS); if (accessedMethods==null) return; List<MethodNode> methods = new ArrayList<MethodNode>(node.getAllDeclaredMethods()); methods.addAll(node.getDeclaredConstructors()); Map<MethodNode, MethodNode> privateBridgeMethods = (Map<MethodNode, MethodNode>) node.getNodeMetaData(PRIVATE_BRIDGE_METHODS); if (privateBridgeMethods!=null) { List<Expression> args = new LinkedList<Expression>(); for (Parameter parameter : methodParameters) { args.add(new VariableExpression(parameter)); arguments = new ArgumentListExpression(args); } else { newParams[0] = new Parameter(node.getPlainNodeReference(), "$that"); Expression receiver = method.isStatic()?new ClassExpression(node):new VariableExpression(newParams[0]); MethodCallExpression mce = new MethodCallExpression(receiver, method.getName(), arguments); mce.setMethodTarget(method);
private Expression transformMethodCallExpression(final MethodCallExpression exp) { if (isTraitSuperPropertyExpression(exp.getObjectExpression())) { Expression objectExpression = exp.getObjectExpression(); ClassNode traitReceiver = ((PropertyExpression) objectExpression).getObjectExpression().getType(); ClassExpression receiver = new ClassExpression( getHelper(traitReceiver) ); ArgumentListExpression newArgs = new ArgumentListExpression(); Expression arguments = exp.getArguments(); newArgs.addExpression(new VariableExpression("this")); if (arguments instanceof TupleExpression) { List<Expression> expressions = ((TupleExpression) arguments).getExpressions(); for (Expression expression : expressions) { newArgs.addExpression(transform(expression));
boolean isThisOrSuper = false; if (receiver instanceof VariableExpression) { isThisOrSuper = ((VariableExpression) receiver).isThisExpression() || ((VariableExpression) receiver).isSuperExpression(); ClassNode current = classNode.getOuterClass(); fixedReceiver = new VariableExpression("thisObject", current); while (current instanceof InnerClassNode && !classNode.equals(current)) { FieldNode thisField = current.getField("this$0"); current = current.getOuterClass(); if (thisField != null) { return super.writeDirectMethodCall(target, implicitThis, receiver, new ArgumentListExpression(arr)); MethodCallExpression mce = new MethodCallExpression( INVOKERHELER_RECEIVER, target.isStatic() ? "invokeStaticMethod" : "invokeMethodSafe", new ArgumentListExpression( target.isStatic() ? new ClassExpression(target.getDeclaringClass()) : receiver, new ConstantExpression(target.getName()), arr mce.setMethodTarget(target.isStatic() ? INVOKERHELPER_INVOKESTATICMETHOD : INVOKERHELPER_INVOKEMETHOD); mce.visit(controller.getAcg()); return true;
protected ClassNode createStatementsClass() { ClassNode classNode = getScriptClassDummy(); if (classNode.getName().endsWith("package-info")) { return classNode; classNode.addMethod( new MethodNode( "main", ACC_PUBLIC | ACC_STATIC, ClassHelper.VOID_TYPE, new Parameter[] { new Parameter(ClassHelper.STRING_TYPE.makeArray(), "args")}, ClassNode.EMPTY_ARRAY, new ExpressionStatement( new MethodCallExpression( new ClassExpression(ClassHelper.make(InvokerHelper.class)), "runScript", new ArgumentListExpression( new ClassExpression(classNode), new VariableExpression("args"))))));
final Set<String> knownFields) { if (field.isProtected()) { unit.addError(new SyntaxException("Cannot have protected field in a trait (" + trait.getName() + "#" + field.getName() + ")", field.getLineNumber(), field.getColumnNumber())); return; target = staticFieldHelper; mce = new MethodCallExpression( new ClassExpression(INVOKERHELPER_CLASSNODE), "invokeStaticMethod", new ArgumentListExpression( thisObject, new ConstantExpression(Traits.helperSetterName(field)), initCode.getExpression() mce = new MethodCallExpression( new CastExpression(createReceiverType(field.isStatic(), fieldHelper), thisObject), Traits.helperSetterName(field), ); mce.setImplicitThis(false); target.addMethod( Traits.helperSetterName(field), ACC_PUBLIC | ACC_ABSTRACT,
if (target.isProtected()) { lookupClassNode = controller.getClassNode(); while (lookupClassNode != null && !lookupClassNode.isDerivedFrom(target.getDeclaringClass())) { lookupClassNode = lookupClassNode.getOuterClass(); lookupClassNode = target.getDeclaringClass().redirect(); Map<MethodNode, MethodNode> bridges = lookupClassNode.getNodeMetaData(PRIVATE_BRIDGE_METHODS); if (implicitThis) { if (!controller.isInClosure()) { fixedReceiver = new PropertyExpression(new ClassExpression(lookupClassNode), "this"); } else if (thisClass != null) { ClassNode current = thisClass.getOuterClass(); fixedReceiver = new VariableExpression("thisObject", current); while (current instanceof InnerClassNode && !lookupClassNode.equals(current)) { ArgumentListExpression newArgs = new ArgumentListExpression(target.isStatic()?new ConstantExpression(null):fixedReceiver); for (Expression expression : args.getExpressions()) { newArgs.addExpression(expression);
public FieldNode addLoggerFieldToClass(ClassNode classNode, String logFieldName, String categoryName) { return classNode.addField(logFieldName, Opcodes.ACC_FINAL | Opcodes.ACC_TRANSIENT | Opcodes.ACC_STATIC | Opcodes.ACC_PRIVATE, LOGGER_CLASSNODE, new MethodCallExpression( new ClassExpression(LOGGER_CLASSNODE), "getLogger", new ConstantExpression(getCategoryName(classNode, categoryName)))); }
protected Expression transformVariableExpression(VariableExpression ve) { visitAnnotations(ve); Variable v = ve.getAccessedVariable(); String name = ve.getName(); ClassNode t = ClassHelper.make(name); boolean isClass = t.isResolved(); if (!isClass) { if (scope.removeReferencedClassVariable(ve.getName()) == null) break; ClassExpression ce = new ClassExpression(t); ce.setSourcePosition(ve); return ce;
private static Statement createSuperFallback(MethodNode forwarderMethod, ClassNode returnType) { ArgumentListExpression args = new ArgumentListExpression(); Parameter[] forwarderMethodParameters = forwarderMethod.getParameters(); for (final Parameter forwarderMethodParameter : forwarderMethodParameters) { args.addExpression(new VariableExpression(forwarderMethodParameter)); } BinaryExpression instanceOfExpr = new BinaryExpression(new VariableExpression("this"), Token.newSymbol(Types.KEYWORD_INSTANCEOF, -1, -1), new ClassExpression(Traits.GENERATED_PROXY_CLASSNODE)); MethodCallExpression superCall = new MethodCallExpression( new VariableExpression("super"), forwarderMethod.getName(), args ); superCall.setImplicitThis(false); CastExpression proxyReceiver = new CastExpression(Traits.GENERATED_PROXY_CLASSNODE, new VariableExpression("this")); MethodCallExpression getProxy = new MethodCallExpression(proxyReceiver, "getProxyTarget", ArgumentListExpression.EMPTY_ARGUMENTS); getProxy.setImplicitThis(true); StaticMethodCallExpression proxyCall = new StaticMethodCallExpression( ClassHelper.make(InvokerHelper.class), "invokeMethod", new ArgumentListExpression(getProxy, new ConstantExpression(forwarderMethod.getName()), new ArrayExpression(ClassHelper.OBJECT_TYPE, args.getExpressions())) ); IfStatement stmt = new IfStatement( new BooleanExpression(instanceOfExpr), new ExpressionStatement(new CastExpression(returnType,proxyCall)), new ExpressionStatement(superCall) ); return stmt; }
private void makeDynamicGetProperty(final Expression receiver, final String methodName, final boolean safe) { MethodNode target = safe?INVOKERHELPER_GETPROPERTYSAFE_METHOD:INVOKERHELPER_GETPROPERTY_METHOD; MethodCallExpression mce = new MethodCallExpression( new ClassExpression(INVOKERHELPER_TYPE), target.getName(), new ArgumentListExpression(receiver, new ConstantExpression(methodName)) ); mce.setSafe(false); mce.setImplicitThis(false); mce.setMethodTarget(target); mce.visit(controller.getAcg()); }
private TryCatchStatement surroundWithTryCatch(Expression condition, Expression message, Expression executeAndVerify) { final TryCatchStatement tryCatchStatement = new TryCatchStatement( new ExpressionStatement(executeAndVerify), EmptyStatement.INSTANCE ); tryCatchStatement.addCatch( new CatchStatement( new Parameter(new ClassNode(Throwable.class), "throwable"), new ExpressionStatement( AstUtil.createDirectMethodCall( new ClassExpression(resources.getAstNodeCache().SpockRuntime), resources.getAstNodeCache().SpockRuntime_ConditionFailedWithException, new ArgumentListExpression(Arrays.asList( new VariableExpression(SpockNames.ERROR_COLLECTOR), new VariableExpression(SpockNames.VALUE_RECORDER), // recorder new ConstantExpression(resources.getSourceText(condition)), // text new ConstantExpression(condition.getLineNumber()), // line new ConstantExpression(condition.getColumnNumber()), // column message == null ? ConstantExpression.NULL : message, // message new VariableExpression("throwable") // throwable )) ) ) ) ); return tryCatchStatement; }
ClassNode helper = helpers.getHelper(); String setterName = MetaProperty.getSetterName(leftPropertyExpression.getPropertyAsString()); List<MethodNode> methods = helper.getMethods(setterName); for (MethodNode method : methods) { Parameter[] parameters = method.getParameters(); if (parameters.length==2 && parameters[0].getType().equals(traitReceiver)) { ArgumentListExpression args = new ArgumentListExpression( new VariableExpression("this"), transform(exp.getRightExpression()) ); MethodCallExpression setterCall = new MethodCallExpression( new ClassExpression(helper), setterName, args ); setterCall.setMethodTarget(method); setterCall.setImplicitThis(false); return setterCall;
private MethodCallExpression referenceToCurrentClosure() { return new MethodCallExpression( new VariableExpression("this"), new ConstantExpression("each"), new ArgumentListExpression( new PropertyExpression( new ClassExpression(ClassHelper.makeWithoutCaching(Closure.class)), new ConstantExpression("IDENTITY") ) ) ); }
@Override public Expression wrapLoggingMethodCall(Expression logVariable, String methodName, Expression originalExpression) { AttributeExpression logLevelExpression = new AttributeExpression( new ClassExpression(LEVEL_CLASSNODE), new ConstantExpression(methodName.toUpperCase(Locale.ENGLISH))); ArgumentListExpression args = new ArgumentListExpression(); args.addExpression(logLevelExpression); MethodCallExpression condition = new MethodCallExpression(logVariable, "isLoggable", args); condition.setImplicitThis(false); return new TernaryExpression( new BooleanExpression(condition), originalExpression, ConstantExpression.NULL); } }
left instanceof ClassExpression) { ClassExpression ce = (ClassExpression) left; String error = "you tried to assign a value to the class '" + ce.getType().getName() + "'"; if (ce.getType().isScript()) { error += ". Do you have a script with this name?"; if (list.getExpressions().isEmpty()) { final ClassExpression ce = new ClassExpression(left.getType().makeArray()); ce.setSourcePosition(be); return ce;