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)))); }
private int extractVariableNumber(Expression expr){ if (!(expr instanceof MethodCallExpression)) return -1; MethodCallExpression methodExpr = (MethodCallExpression) expr; Expression targetExpr = methodExpr.getObjectExpression(); if (!(targetExpr instanceof VariableExpression)) return -1; VariableExpression var = (VariableExpression)targetExpr; if (!SpockNames.VALUE_RECORDER.equals(var.getName())) return -1; if(!ValueRecorder.RECORD.equals(methodExpr.getMethodAsString())) return -1; Expression startRecordingEpr = ((ArgumentListExpression) methodExpr.getArguments()).getExpression(0); if (!(startRecordingEpr instanceof MethodCallExpression)) return -1; MethodCallExpression startRecording = (MethodCallExpression) startRecordingEpr; if (!ValueRecorder.START_RECORDING_VALUE.equals(startRecording.getMethodAsString())) return -1; final Expression variableNumExpression = ((ArgumentListExpression) startRecording.getArguments()).getExpression(0); if (! (variableNumExpression instanceof ConstantExpression)) return -1; return (Integer)((ConstantExpression)variableNumExpression).getValue(); }
public void visitMethodCallExpression(MethodCallExpression call) { if (call.isImplicitThis() && call.getMethod() instanceof ConstantExpression) { ConstantExpression methodNameConstant = (ConstantExpression) call.getMethod(); Object value = methodNameConstant.getText(); if (!(value instanceof String)) { throw new GroovyBugError("tried to make a method call with a non-String constant method name."); } String methodName = (String) value; Variable v = checkVariableNameForDeclaration(methodName, call); if (v != null && !(v instanceof DynamicVariable)) { checkVariableContextAccess(v, call); } if (v instanceof VariableExpression || v instanceof Parameter) { VariableExpression object = new VariableExpression(v); object.setSourcePosition(methodNameConstant); call.setObjectExpression(object); ConstantExpression method = new ConstantExpression("call"); method.setSourcePosition(methodNameConstant); // important for GROOVY-4344 call.setImplicitThis(false); call.setMethod(method); } } super.visitMethodCallExpression(call); }
private static Character tryCharConstant(final Expression expr) { if (expr instanceof ConstantExpression) { ConstantExpression ce = (ConstantExpression) expr; if (ClassHelper.STRING_TYPE.equals(ce.getType())) { String val = (String) ce.getValue(); if (val!=null && val.length()==1) { return val.charAt(0); } } } return null; }
public Expression asConstantString() { StringBuilder buffer = new StringBuilder(); for (ConstantExpression expression : strings) { Object value = expression.getValue(); if (value != null) { buffer.append(value); } } return new ConstantExpression(buffer.toString()); } }
private Pattern determineClassNamePattern(Expression expr) { if (!(expr instanceof ConstantExpression)) { return null; } final ConstantExpression constExpr = (ConstantExpression) expr; final String text = constExpr.getText(); if (constExpr.getValue() == null || text.equals("")) { return null; } try { final Pattern pattern = Pattern.compile(text); return pattern; } catch (PatternSyntaxException e) { addError("Invalid class name pattern: " + e.getMessage(), expr); return null; } }
@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); if (methodNode!=null) { MethodCallExpression mce = new MethodCallExpression(receiver, methodNode.getName(), new ArgumentListExpression(field.isStatic()?new ConstantExpression(null):receiver)); mce.setMethodTarget(methodNode); mce.setSafe(safe);
if (var.getAccessedVariable() instanceof DynamicVariable) { MethodCallExpression callGetModel = new MethodCallExpression( new VariableExpression("this"), "getModel", ArgumentListExpression.EMPTY_ARGUMENTS ); callGetModel.setImplicitThis(true); callGetModel.setSourcePosition(exp); String varName = var.getName(); if ("model".equals(varName) || "unescaped".equals(varName)) { callGetModel, "get", new ArgumentListExpression(new ConstantExpression(varName)) ); mce.setSourcePosition(exp); new VariableExpression("this"), "tryEscape", new ArgumentListExpression(mce) ); yield.setImplicitThis(true);
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); } 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);
MethodCallExpression doCall1arg = new MethodCallExpression( new VariableExpression("this", closureClass), "doCall", new ArgumentListExpression(new VariableExpression(args)) ); doCall1arg.setImplicitThis(true); doCall1arg.setMethodTarget(doCallMethod); closureClass.addMethod( new MethodNode("call", Opcodes.ACC_PUBLIC, MethodCallExpression doCallNoArgs = new MethodCallExpression(new VariableExpression("this", closureClass), "doCall", new ArgumentListExpression(new ConstantExpression(null))); doCallNoArgs.setImplicitThis(true); doCallNoArgs.setMethodTarget(doCallMethod); closureClass.addMethod( new MethodNode("call", Opcodes.ACC_PUBLIC,
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 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); } }
ClassNode classNode = controller.getClassNode(); ClassNode receiverType = typeChooser.resolveType(receiver, classNode); if (receiver instanceof VariableExpression && ((VariableExpression) receiver).isThisExpression() && !controller.isInClosure()) { receiverType = classNode; if (controller.getInvocationWriter() instanceof StaticInvocationWriter) { MethodCallExpression currentCall = ((StaticInvocationWriter) controller.getInvocationWriter()).getCurrentCall(); if (currentCall != null && currentCall.getNodeMetaData(StaticTypesMarker.IMPLICIT_RECEIVER) != null) { property = currentCall.getNodeMetaData(StaticTypesMarker.IMPLICIT_RECEIVER); String[] props = property.split("\\."); BytecodeExpression thisLoader = new BytecodeExpression() { Expression pexp = new PropertyExpression(thisLoader, new ConstantExpression(props[0]), safe); for (int i = 1, propsLength = props.length; i < propsLength; i++) { final String prop = props[i]; if (makeGetField(receiver, receiverType, property, safe, implicitThis, samePackages(receiverType.getPackageName(), classNode.getPackageName()))) return; MethodCallExpression call = new MethodCallExpression( receiver, "getProperty", new ArgumentListExpression(new ConstantExpression(property)) ); call.setImplicitThis(implicitThis);
if ("this".equals(variable.getName())) { // NOI18N declaringClass = ContextHelper.getSurroundingClassNode(this); return declaringClass; if ("super".equals(variable.getName())) { // NOI18N ClassNode thisClass = ContextHelper.getSurroundingClassNode(this); declaringClass = thisClass.getSuperClass(); if (declaringClass == null) { return new ClassNode("java.lang.Object", ClassNode.ACC_PUBLIC, null); && "java.lang.Object".equals(expression.getType().getName())) { // NOI18N try { expression.setType( if (!constantExpression.isNullExpression()) { constantExpression.setType(new ClassNode(constantExpression.getValue().getClass()));
private Expression realizeNas(Expression expr) { return AstUtil.createDirectMethodCall( new VariableExpression(SpockNames.VALUE_RECORDER), resources.getAstNodeCache().ValueRecorder_RealizeNas, new ArgumentListExpression(new ConstantExpression(recordCount), expr)); }
public void testConstructor() throws Exception { ClassNode classNode = new ClassNode("Foo", ACC_PUBLIC, ClassHelper.OBJECT_TYPE); compositeStringExpr.addString(new ConstantExpression("Hello ")); compositeStringExpr.addValue(new VariableExpression("user")); compositeStringExpr.addString(new ConstantExpression("!")); BlockStatement block = new BlockStatement(); block.addStatement( new ExpressionStatement( new DeclarationExpression( new VariableExpression("user"), Token.newSymbol("=", -1, -1), new ConstantExpression("World")))); block.addStatement( new ExpressionStatement( block.addStatement( new ExpressionStatement( new MethodCallExpression(VariableExpression.THIS_EXPRESSION, "println", new VariableExpression("str")))); new VariableExpression("text"), Token.newSymbol("==", -1, -1), new ConstantExpression("Hello World!"))), new ConstantExpression("Assertion failed") // TODO FIX if empty, AssertionWriter fails because source text is null classNode.addMethod(new MethodNode("stringDemo", ACC_PUBLIC, ClassHelper.VOID_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, block));
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 static Statement createDelegatingForwarder(final MethodNode forwarderMethod, final ClassNode next) { // generates --> next$Trait$Helper.method(this, arg1, arg2) TraitHelpersTuple helpers = Traits.findHelpers(next); ArgumentListExpression args = new ArgumentListExpression(); args.addExpression(new VariableExpression("this")); Parameter[] forwarderMethodParameters = forwarderMethod.getParameters(); for (final Parameter forwarderMethodParameter : forwarderMethodParameters) { args.addExpression(new VariableExpression(forwarderMethodParameter)); } StaticMethodCallExpression delegateCall = new StaticMethodCallExpression( helpers.getHelper(), forwarderMethod.getName(), args ); Statement result; if (ClassHelper.VOID_TYPE.equals(forwarderMethod.getReturnType())) { BlockStatement stmt = new BlockStatement(); stmt.addStatement(new ExpressionStatement(delegateCall)); stmt.addStatement(new ReturnStatement(new ConstantExpression(null))); result = stmt; } else { result = new ReturnStatement(delegateCall); } return result; }
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; }