public static MethodCallExpression createGetAtMethod(Expression expression, int index) { return new MethodCallExpression(expression, GET_AT_METHOD_NAME, new ConstantExpression(index)); }
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 useNamedArgs(boolean isMixed) { call(InteractionBuilder.SET_ARG_LIST_KIND, ConstantExpression.PRIM_FALSE, new ConstantExpression(isMixed,true)); }
public static Expression getVariableName(BinaryExpression assignment) { Expression left = assignment.getLeftExpression(); if (left instanceof Variable) return new ConstantExpression(((Variable) left).getName()); if (left instanceof FieldExpression) return new ConstantExpression(((FieldExpression) left).getFieldName()); return ConstantExpression.NULL; }
private Statement throwAssertionFailedError(AnnotationNode annotationNode) { ThrowStatement throwStatement = new ThrowStatement( new ConstructorCallExpression(ASSERTION_FAILED_ERROR_TYPE, new ArgumentListExpression( new ConstantExpression("Method is marked with @NotYetImplemented but passes unexpectedly")))); throwStatement.setSourcePosition(annotationNode); return throwStatement; } }
private BinaryExpression createVariableNotNullExpression(VariableExpression var) { return new BinaryExpression( new VariableExpression(var), Token.newSymbol(Types.COMPARE_NOT_EQUAL, -1, -1), new ConstantExpression(null)); }
private Expression realizeNas(Expression expr) { return AstUtil.createDirectMethodCall( new VariableExpression(SpockNames.VALUE_RECORDER), resources.getAstNodeCache().ValueRecorder_RealizeNas, new ArgumentListExpression(new ConstantExpression(recordCount), expr)); }
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") ) ) ); }
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; }
@Override public void expand() { List<Expression> args = new ArrayList<>(); args.add(inferredName); args.add(inferredType); args.addAll(AstUtil.getArgumentList(methodCallExpr)); ArgumentListExpression argsExpr = new ArgumentListExpression(args); AstUtil.copySourcePosition(methodCallExpr.getArguments(), argsExpr); methodCallExpr.setArguments(argsExpr); methodCallExpr.setMethod(new ConstantExpression(methodName + "Impl")); }
public void testIterateOverMap() throws Exception { MapExpression mapExpression = new MapExpression(); mapExpression.addMapEntryExpression(new ConstantExpression("a"), new ConstantExpression("x")); mapExpression.addMapEntryExpression(new ConstantExpression("b"), new ConstantExpression("y")); mapExpression.addMapEntryExpression(new ConstantExpression("c"), new ConstantExpression("z")); assertIterate("iterateOverMap", mapExpression); }
private void addFieldMetadata(Field field) { AnnotationNode ann = new AnnotationNode(nodeCache.FieldMetadata); ann.setMember(FieldMetadata.NAME, new ConstantExpression(field.getName())); ann.setMember(FieldMetadata.ORDINAL, new ConstantExpression(field.getOrdinal())); ann.setMember(FieldMetadata.LINE, new ConstantExpression(field.getAst().getLineNumber())); ann.setMember(FieldMetadata.INITIALIZER, new ConstantExpression(field.hasInitialExpression())); field.getAst().addAnnotation(ann); }
private void setConstructorCall() { setTarget(); call(InteractionBuilder.ADD_EQUAL_METHOD_NAME, new ConstantExpression("<init>")); addArgs(); }
private Expression record(Expression expr) { // replace expr with $spock_valueRecorder.record($spock_valueRecorder.startRecordingValue(recordCount++), <expr>) return AstUtil.createDirectMethodCall( new VariableExpression(SpockNames.VALUE_RECORDER), resources.getAstNodeCache().ValueRecorder_Record, new ArgumentListExpression( AstUtil.createDirectMethodCall( new VariableExpression(SpockNames.VALUE_RECORDER), resources.getAstNodeCache().ValueRecorder_StartRecordingValue, new ArgumentListExpression(new ConstantExpression(recordCount++)) ), expr)); }
public void testIterateOverList() throws Exception { ListExpression listExpression = new ListExpression(); listExpression.addExpression(new ConstantExpression("a")); listExpression.addExpression(new ConstantExpression("b")); listExpression.addExpression(new ConstantExpression("c")); listExpression.addExpression(new ConstantExpression("a")); listExpression.addExpression(new ConstantExpression("b")); listExpression.addExpression(new ConstantExpression("c")); assertIterate("iterateOverList", listExpression); }
private void addSpecMetadata(Spec spec) { AnnotationNode ann = new AnnotationNode(nodeCache.SpecMetadata); String pathname = spec.getAst().getModule().getContext().getName(); String filename = new File(pathname).getName(); ann.setMember(SpecMetadata.FILENAME, new ConstantExpression(filename)); ann.setMember(SpecMetadata.LINE, new ConstantExpression(spec.getAst().getLineNumber())); spec.getAst().addAnnotation(ann); }
private void addFeatureMetadata(FeatureMethod feature) { AnnotationNode ann = new AnnotationNode(nodeCache.FeatureMetadata); ann.setMember(FeatureMetadata.NAME, new ConstantExpression(feature.getName())); ann.setMember(FeatureMetadata.ORDINAL, new ConstantExpression(feature.getOrdinal())); ann.setMember(FeatureMetadata.LINE, new ConstantExpression(feature.getAst().getLineNumber())); ann.setMember(FeatureMetadata.BLOCKS, blockAnnElems = new ListExpression()); ListExpression paramNames = new ListExpression(); for (Parameter param : feature.getAst().getParameters()) paramNames.addExpression(new ConstantExpression(param.getName())); ann.setMember(FeatureMetadata.PARAMETER_NAMES, paramNames); feature.getAst().addAnnotation(ann); }
private void setCount() { if (count == null) return; if (count instanceof RangeExpression) { RangeExpression range = (RangeExpression)count; call(InteractionBuilder.SET_RANGE_COUNT, range.getFrom(), range.getTo(), new ConstantExpression(range.isInclusive())); return; } call(InteractionBuilder.SET_FIXED_COUNT, count); }
private boolean handleImplicitCallOnMethodParam(MethodCallExpression expr) { if (!expr.isImplicitThis()) return false; String methodName = expr.getMethodAsString(); List<Parameter> params = Arrays.asList(resources.getCurrentMethod().getAst().getParameters()); for (Parameter param : params) { if (param.getName().equals(methodName)) { expr.setMethod(new ConstantExpression("call")); expr.setObjectExpression(new VariableExpression(methodName)); return true; } } return false; }
private void addBlockMetadata(Block block, BlockKind kind) { AnnotationNode blockAnn = new AnnotationNode(nodeCache.BlockMetadata); blockAnn.setMember(BlockMetadata.KIND, new PropertyExpression( new ClassExpression(nodeCache.BlockKind), kind.name())); ListExpression textExprs = new ListExpression(); for (String text : block.getDescriptions()) textExprs.addExpression(new ConstantExpression(text)); blockAnn.setMember(BlockMetadata.TEXTS, textExprs); blockAnnElems.addExpression(new AnnotationConstantExpression(blockAnn)); }