private AnnotationNode createDataProviderAnnotation(Expression dataProviderExpr, int nextDataVariableIndex) { AnnotationNode ann = new AnnotationNode(resources.getAstNodeCache().DataProviderMetadata); ann.addMember(DataProviderMetadata.LINE, new ConstantExpression(dataProviderExpr.getLineNumber())); List<Expression> dataVariableNames = new ArrayList<>(); for (int i = nextDataVariableIndex; i < dataProcessorVars.size(); i++) dataVariableNames.add(new ConstantExpression(dataProcessorVars.get(i).getName())); ann.addMember(DataProviderMetadata.DATA_VARIABLES, new ListExpression(dataVariableNames)); return ann; }
public void record(Expression expression) { if (assertionTracker==null) return; record(assertionTracker.sourceText.getNormalizedColumn(expression.getLineNumber(), expression.getColumnNumber())); }
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; } }
private void assertStringConstant(Expression exp) { if (exp == null) return; if (!(exp instanceof ConstantExpression)) { source.getErrorCollector().addErrorAndContinue(new SyntaxErrorMessage(new SyntaxException( "Expected a String constant.", exp.getLineNumber(), exp.getColumnNumber()), source)); } ConstantExpression ce = (ConstantExpression) exp; if (!(ce.getValue() instanceof String)) { source.getErrorCollector().addErrorAndContinue(new SyntaxErrorMessage(new SyntaxException( "Expected a String constant.", exp.getLineNumber(), exp.getColumnNumber()), source)); } }
private void createBuilder() { // ExpressionStatements w/ label have wrong source position, // but source position of the contained expression is OK Expression expr = stat.getExpression(); builderExpr = new ConstructorCallExpression( resources.getAstNodeCache().InteractionBuilder, new ArgumentListExpression( Arrays.<Expression> asList( new ConstantExpression(expr.getLineNumber()), new ConstantExpression(expr.getColumnNumber()), new ConstantExpression(resources.getSourceText(expr))))); }
private void checkAndAddCannotCallPrivateMethodError(MethodNode target, Expression receiver, ClassNode classNode, ClassNode declaringClass) { if (declaringClass != classNode) { controller.getSourceUnit().addError(new SyntaxException("Cannot call private method " + (target.isStatic() ? "static " : "") + declaringClass.toString(false) + "#" + target.getName() + " from class " + classNode.toString(false), receiver.getLineNumber(), receiver.getColumnNumber(), receiver.getLastLineNumber(), receiver.getLastColumnNumber())); } }
BinaryExpression binaryExpression = new BinaryExpression( objectExpression, Token.newSymbol("[", indexExpr.getLineNumber(), indexExpr.getColumnNumber()), indexExpr ); BinaryExpression arrayGet = new BinaryExpression( objectExpression, Token.newSymbol("[", indexExpr.getLineNumber(), indexExpr.getColumnNumber()), indexExpr ); BinaryExpression assignment = new BinaryExpression( arrayGet, Token.newSymbol("=", objExpr.getLineNumber(), objExpr.getColumnNumber()), objExpr );
@Override public void makeSingleArgumentCall(final Expression receiver, final String message, final Expression arguments) { TypeChooser typeChooser = controller.getTypeChooser(); ClassNode classNode = controller.getClassNode(); ClassNode rType = typeChooser.resolveType(receiver, classNode); ClassNode aType = typeChooser.resolveType(arguments, classNode); if (trySubscript(receiver, message, arguments, rType, aType)) { return; } // now try with flow type instead of declaration type rType = receiver.getNodeMetaData(StaticTypesMarker.INFERRED_TYPE); if (receiver instanceof VariableExpression && rType == null) { // TODO: can STCV be made smarter to avoid this check? Variable accessedVariable = ((VariableExpression)receiver).getAccessedVariable(); VariableExpression ve = (VariableExpression) accessedVariable; rType = ve.getNodeMetaData(StaticTypesMarker.INFERRED_TYPE); } if (rType!=null && trySubscript(receiver, message, arguments, rType, aType)) { return; } // todo: more cases throw new GroovyBugError( "At line " + receiver.getLineNumber() + " column " + receiver.getColumnNumber() + "\n" + "On receiver: " + receiver.getText() + " with message: " + message + " and arguments: " + arguments.getText() + "\n" + "This method should not have been called. Please try to create a simple example reproducing\n" + "this error and file a bug report at https://issues.apache.org/jira/browse/GROOVY"); }
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; }
new SyntaxException("Access to "+ (receiver instanceof ClassExpression ?receiver.getType():receiverType).toString(false) +"#"+methodName+" is forbidden", receiver.getLineNumber(), receiver.getColumnNumber(), receiver.getLastLineNumber(), receiver.getLastColumnNumber()) ); controller.getMethodVisitor().visitInsn(ACONST_NULL);
public void record(Expression expression) { if (assertionTracker==null) return; record(assertionTracker.sourceText.getNormalizedColumn(expression.getLineNumber(), expression.getColumnNumber())); }
private void addCriteriaCallMethodExpression(BlockStatement newCode, String operator, Expression leftExpression, Expression rightExpression, String propertyName, List<String> propertyNames, boolean addAll, VariableScope variableScope) { String methodToCall = OPERATOR_TO_CRITERIA_METHOD_MAP.get(operator); if (methodToCall == null) { sourceUnit.getErrorCollector().addError(new LocatedMessage("Unsupported operator [" + operator + "] used in query", Token.newString(rightExpression.getText(), rightExpression.getLineNumber(), rightExpression.getColumnNumber()), sourceUnit)); } addCriteriaCall(newCode, operator, leftExpression, rightExpression, propertyName, propertyNames, addAll, methodToCall, variableScope); }
sourceUnit.getErrorCollector().addError(new LocatedMessage("Cannot query on property \"" + propertyName + "\" - no such property on class " + currentClassNode.getName() + " exists.", Token.newString(propertyName, leftExpression.getLineNumber(), leftExpression.getColumnNumber()), sourceUnit)); sourceUnit.getErrorCollector().addError(new LocatedMessage("Cannot query size of property \"" + propertyName + "\" - no such property on class " + currentClassNode.getName() + " exists.", Token.newString(propertyName, leftExpression.getLineNumber(), leftExpression.getColumnNumber()), sourceUnit));
private void handleFunctionCall(BlockStatement newCode, String operator, Expression rightExpression, String functionName, Expression propertyNameExpression) { ArgumentListExpression newArgs = new ArgumentListExpression(); ArgumentListExpression constructorArgs = new ArgumentListExpression(); constructorArgs.addExpression(new ConstantExpression(functionName)); ClassNode criterionClassNode = OPERATOR_TO_CRITERION_METHOD_MAP.get(operator); if (criterionClassNode != null) { ArgumentListExpression criterionConstructorArguments = new ArgumentListExpression(); if (!(propertyNameExpression instanceof ConstantExpression)) { propertyNameExpression = new ConstantExpression(propertyNameExpression.getText()); } criterionConstructorArguments.addExpression(propertyNameExpression); criterionConstructorArguments.addExpression(rightExpression); constructorArgs.addExpression(new ConstructorCallExpression(criterionClassNode, criterionConstructorArguments)); ConstructorCallExpression constructorCallExpression = new ConstructorCallExpression(FUNCTION_CALL_CRITERION, constructorArgs); newArgs.addExpression(constructorCallExpression); newCode.addStatement(new ExpressionStatement(new MethodCallExpression(new VariableExpression("this"), "add", newArgs))); } else { sourceUnit.getErrorCollector().addError(new LocatedMessage("Unsupported operator [" + operator + "] used with function call [" + functionName + "] in query", Token.newString(functionName, rightExpression.getLineNumber(), rightExpression.getColumnNumber()), sourceUnit)); } }
MethodCallExpression methodCall = (MethodCallExpression) node; Expression method = methodCall.getMethod(); lineNumber = method.getLineNumber(); columnNumber = method.getColumnNumber(); if (lineNumber < 1 || columnNumber < 1) {
var.setLastLineNumber(call.getMethod().getLineNumber()); var.setLastColumnNumber(call.getMethod().getColumnNumber()); call.setObjectExpression(var);
sourceUnit.getErrorCollector().addErrorAndContinue( new SyntaxErrorMessage( new SyntaxException(msg + '\n', exp.getLineNumber(), exp.getColumnNumber()), sourceUnit) ); continue;