public void visitMethodCallExpression(final MethodCallExpression call) { assertExpressionAuthorized(call); Expression receiver = call.getObjectExpression(); final String typeName = receiver.getType().getName(); if (receiversWhiteList != null && !receiversWhiteList.contains(typeName)) { throw new SecurityException("Method calls not allowed on [" + typeName + "]"); } else if (receiversBlackList != null && receiversBlackList.contains(typeName)) { throw new SecurityException("Method calls not allowed on [" + typeName + "]"); } receiver.visit(this); final Expression method = call.getMethod(); checkConstantTypeIfNotMethodNameOrProperty(method); call.getArguments().visit(this); }
public Expression transformExpression(ExpressionTransformer transformer) { Expression ret = new BinaryExpression(transformer.transform(leftExpression), operation, transformer.transform(rightExpression)); ret.setSourcePosition(this); ret.copyNodeMetaData(this); return ret; }
public Expression transformExpression(ExpressionTransformer transformer) { Expression ret = new SpreadExpression(transformer.transform(expression)); ret.setSourcePosition(this); ret.copyNodeMetaData(this); return ret; }
@Override public void makeGetPropertySite(Expression receiver, final String methodName, final boolean safe, final boolean implicitThis) { Object dynamic = receiver.getNodeMetaData(StaticCompilationMetadataKeys.RECEIVER_OF_DYNAMIC_PROPERTY); if (dynamic !=null) { makeDynamicGetProperty(receiver, methodName, safe); ClassNode receiverType = receiver.getNodeMetaData(StaticCompilationMetadataKeys.PROPERTY_OWNER); if (receiverType==null) { receiverType = typeChooser.resolveType(receiver, classNode); Object type = receiver.getNodeMetaData(StaticTypesMarker.INFERRED_TYPE); if (type==null && receiver instanceof VariableExpression) { Variable variable = ((VariableExpression) receiver).getAccessedVariable(); if (variable instanceof Expression) { type = ((Expression) variable).getNodeMetaData(StaticTypesMarker.INFERRED_TYPE); if (receiverType.isArray() && methodName.equals("length")) { receiver.visit(controller.getAcg()); ClassNode arrayGetReturnType = typeChooser.resolveType(receiver, classNode); controller.getOperandStack().doGroovyCast(arrayGetReturnType); && (receiverType.isDerivedFrom(receiver.getType()) || receiverType.implementsInterface(receiver.getType())); if (makeGetField(receiver, receiver.getType(), methodName, safe, implicitThis, samePackages(receiver.getType().getPackageName(), classNode.getPackageName()))) return; if (makeGetPropertyWithGetter(receiver, receiver.getType(), methodName, safe, implicitThis)) return; if (makeGetPrivateFieldWithBridgeMethod(receiver, receiver.getType(), methodName, safe, implicitThis)) return; (receiver instanceof ClassExpression ?receiver.getType():receiverType).toString(false) +"#"+methodName+" is forbidden", receiver.getLineNumber(), receiver.getColumnNumber(), receiver.getLastLineNumber(), receiver.getLastColumnNumber()) );
return trn; ClassNode superCallReceiver = expr.getNodeMetaData(StaticTypesMarker.SUPER_MOP_METHOD_REQUIRED); if (superCallReceiver!=null) { return transformMethodCallExpression(transformToMopSuperCall(superCallReceiver, expr)); BinaryExpression binaryExpression = new BinaryExpression( objectExpression, Token.newSymbol("[", indexExpr.getLineNumber(), indexExpr.getColumnNumber()), indexExpr ); binaryExpression.putNodeMetaData(StaticTypesMarker.INFERRED_TYPE, componentType); return staticCompilationTransformer.transform(binaryExpression); ClassNode argType = staticCompilationTransformer.getTypeChooser().resolveType(indexExpr, staticCompilationTransformer.getClassNode()); if (argType != null && ClassHelper.Integer_TYPE == ClassHelper.getWrapper(argType)) { BinaryExpression arrayGet = new BinaryExpression( objectExpression, Token.newSymbol("[", indexExpr.getLineNumber(), indexExpr.getColumnNumber()), indexExpr ); Token.newSymbol("=", objExpr.getLineNumber(), objExpr.getColumnNumber()), objExpr );
@Override public void visitMethodCallExpression(MethodCallExpression expr) { // at runtime, condition AST is only parsed up to phase conversion, // and hence looks differently in cases where groovyc inserts ".call" // in phase semantic analysis; we need to compensate for that // (in other cases, ".call" is only inserted after transform has // run, and hence we don't need to compensate) boolean objectExprSeenAsMethodNameAtRuntime = !expr.isImplicitThis() && expr.getObjectExpression() instanceof VariableExpression && "call".equals(expr.getMethodAsString()) && (!AstUtil.hasPlausibleSourcePosition(expr.getMethod()) // before GROOVY-4344 fix || (expr.getMethod().getColumnNumber() == expr.getObjectExpression().getColumnNumber())); // after GROOVY-4344 fix MethodCallExpression conversion = new MethodCallExpression( expr.isImplicitThis() ? expr.getObjectExpression() : convert(expr.getObjectExpression()), objectExprSeenAsMethodNameAtRuntime ? expr.getMethod() : convert(expr.getMethod()), convert(expr.getArguments())); conversion.setSafe(expr.isSafe()); conversion.setSpreadSafe(expr.isSpreadSafe()); conversion.setSourcePosition(expr); result = record(conversion); }
private static boolean checkIsConditionBlock(MethodCallExpression methodCallExpr) { ClassNode targetType = methodCallExpr.getObjectExpression().getType(); String methodName = methodCallExpr.getMethodAsString(); List<MethodNode> methods = targetType.getMethods(methodName); for (MethodNode method : methods) { for (AnnotationNode annotation : method.getAnnotations()) { if (annotation.getClassNode().getName().equals(ConditionBlock.class.getName())) return true; } } return false; } }
if (expr instanceof MethodCallExpression && candidate == null) { MethodCallExpression mce = (MethodCallExpression) expr; Expression args = transform(mce.getArguments()); if (isNewifyCandidate(mce)) { Expression transformed = transformMethodCall(mce, args); transformed.setSourcePosition(mce); return transformed; Expression method = transform(mce.getMethod()); Expression object = transform(mce.getObjectExpression()); MethodCallExpression transformed = callX(object, method, args); transformed.setImplicitThis(mce.isImplicitThis()); ConstructorCallExpression cce = (ConstructorCallExpression) expr; if (cce.isUsingAnonymousInnerClass()) { cce.getType().visitContents(this); return expr.transformExpression(this);
public void visitMethodCallExpression(MethodCallExpression call) { call.getObjectExpression().visit(this); call.getMethod().visit(this); call.getArguments().visit(this); }
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)); } } }
@Override public void visitBinaryExpression(BinaryExpression expr) { // order of convert calls is important or indexes and thus recorded values get confused Expression convertedLeftExpression = Types.ofType(expr.getOperation().getType(), Types.ASSIGNMENT_OPERATOR) ? // prevent lvalue from getting turned into record(lvalue), which can no longer be assigned to convertAndRecordNa(expr.getLeftExpression()) : convert(expr.getLeftExpression()); Expression convertedRightExpression = convert(expr.getRightExpression()); Expression conversion = Types.ofType(expr.getOperation().getType(), Types.KEYWORD_INSTANCEOF) ? // morph instanceof expression to isInstance method call to be able to record rvalue new MethodCallExpression(convertedRightExpression, "isInstance", convertedLeftExpression): new BinaryExpression(convertedLeftExpression, expr.getOperation(), convertedRightExpression); conversion.setSourcePosition(expr); result = record(conversion); }
private Expression transformMapEntryExpression(MapEntryExpression me, ClassNode constructorCallType) { Expression key = me.getKeyExpression(); Expression value = me.getValueExpression(); ModuleNode module = currentClass.getModule(); if (module != null && key instanceof ConstantExpression) { Map<String, ImportNode> importNodes = module.getStaticImports(); if (importNodes.containsKey(key.getText())) { ImportNode importNode = importNodes.get(key.getText()); if (importNode.getType().equals(constructorCallType)) { String newKey = importNode.getFieldName(); return new MapEntryExpression(new ConstantExpression(newKey), value.transformExpression(this)); } } } return me; }
public void visitBinaryExpression(BinaryExpression expression) { Expression left = expression.getLeftExpression(); Expression right = expression.getRightExpression(); boolean leaf = (right instanceof ConstantExpression || left instanceof ConstantExpression); if (!leaf) buffer.append("("); left.visit(this); buffer.append(" "); Token token = expression.getOperation(); buffer.append(tokenAsSql(token)); buffer.append(" "); right.visit(this); if (!leaf) buffer.append(")"); }
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; }
private Expression transformMethodCallOnThis(final MethodCallExpression call) { Expression method = call.getMethod(); Expression arguments = call.getArguments(); if (method instanceof ConstantExpression) { String methodName = method.getText(); List<MethodNode> methods = traitClass.getMethods(methodName); for (MethodNode methodNode : methods) { if (methodName.equals(methodNode.getName()) && methodNode.isPrivate()) { if (inClosure) { return transformPrivateMethodCallOnThisInClosure(call, arguments, methodName); } return transformPrivateMethodCallOnThis(call, arguments, methodName); } } } if (inClosure) { return transformMethodCallOnThisInClosure(call); } return transformMethodCallOnThisFallBack(call, method, arguments); }
protected void visitEnumExpression(String attrName, PropertyExpression propExpr, ClassNode attrType) { if (!propExpr.getObjectExpression().getType().isDerivedFrom(attrType)) { addError("Attribute '" + attrName + "' should have type '" + attrType.getName() + "' (Enum), but found " + propExpr.getObjectExpression().getType().getName(), propExpr); } }
private static BinaryExpression tryOptimizeCharComparison(final Expression left, final Expression right, final BinaryExpression bin) { int op = bin.getOperation().getType(); if (isCompareToBoolean(op) || op == COMPARE_EQUAL || op == COMPARE_NOT_EQUAL) { Character cLeft = tryCharConstant(left); Character cRight = tryCharConstant(right); if (cLeft != null || cRight != null) { Expression oLeft = cLeft == null ? left : new ConstantExpression(cLeft, true); oLeft.setSourcePosition(left); Expression oRight = cRight == null ? right : new ConstantExpression(cRight, true); oRight.setSourcePosition(right); bin.setLeftExpression(oLeft); bin.setRightExpression(oRight); return bin; } } return null; }
private Expression rewriteToSpockRuntimeCall(MethodNode method, Expression condition, Expression message, List<Expression> additionalArgs) { List<Expression> args = new ArrayList<>(); MethodCallExpression result = AstUtil.createDirectMethodCall( new ClassExpression(resources.getAstNodeCache().SpockRuntime), method, new ArgumentListExpression(args)); args.add(new VariableExpression(SpockNames.ERROR_COLLECTOR, resources.getAstNodeCache().ErrorCollector)); args.add(AstUtil.createDirectMethodCall( new VariableExpression(SpockNames.VALUE_RECORDER), resources.getAstNodeCache().ValueRecorder_Reset, ArgumentListExpression.EMPTY_ARGUMENTS)); args.add(new ConstantExpression(resources.getSourceText(condition))); args.add(new ConstantExpression(condition.getLineNumber())); args.add(new ConstantExpression(condition.getColumnNumber())); // the following means that "assert x, exprEvaluatingToNull" will be // treated the same as "assert x"; but probably it doesn't matter too much args.add(message == null ? ConstantExpression.NULL : message); args.addAll(additionalArgs); result.setSourcePosition(condition); return result; } }