private Parameter createDataProcessorParameter() { Parameter p = new Parameter(ClassHelper.DYNAMIC_TYPE, "$spock_p" + dataProcessorParams.size()); dataProcessorParams.add(p); return p; }
private Parameter[] getPreviousParameters(int nextDataVariableIndex) { Parameter[] results = new Parameter[nextDataVariableIndex]; for (int i = 0; i < nextDataVariableIndex; i++) results[i] = new Parameter(ClassHelper.DYNAMIC_TYPE, dataProcessorVars.get(i).getName()); return results; }
public static Parameter param(ClassNode type, String name, Expression initialExpression) { Parameter param = new Parameter(type, name); if (initialExpression != null) { param.setInitialExpression(initialExpression); } return param; }
private void addFeatureParameters() { Parameter[] parameters = new Parameter[dataProcessorVars.size()]; for (int i = 0; i < dataProcessorVars.size(); i++) parameters[i] = new Parameter(ClassHelper.DYNAMIC_TYPE, dataProcessorVars.get(i).getName()); whereBlock.getParent().getAst().setParameters(parameters); }
private static Parameter createSelfParameter(final ClassNode traitClass, boolean isStatic) { final ClassNode rawType = traitClass.getPlainNodeReference(); ClassNode type = createReceiverType(isStatic, rawType); return new Parameter(type, isStatic?Traits.STATIC_THIS_OBJECT:Traits.THIS_OBJECT); }
private Parameter makeParameter(CompileUnit cu, Type type, Class cl, Annotation[] annotations, int idx) { ClassNode cn = makeClassNode(cu, type, cl); Parameter parameter = new Parameter(cn, "param" + idx); setAnnotationMetaData(annotations, parameter); return parameter; }
public static Parameter[] cloneParams(Parameter[] source) { Parameter[] result = new Parameter[source.length]; for (int i = 0; i < source.length; i++) { Parameter srcParam = source[i]; Parameter dstParam = new Parameter(srcParam.getOriginType(), srcParam.getName()); result[i] = dstParam; } return result; }
private TryCatchStatement tryCatchAssertionFailedError(AnnotationNode annotationNode, MethodNode methodNode, ArrayList<Statement> statements) { TryCatchStatement tryCatchStatement = new TryCatchStatement(new BlockStatement(statements, methodNode.getVariableScope()), EmptyStatement.INSTANCE); tryCatchStatement.addCatch(new CatchStatement(new Parameter(CATCHED_THROWABLE_TYPE, "ex"), ReturnStatement.RETURN_NULL_OR_VOID)); return tryCatchStatement; }
private static Parameter[] cleanParameters(Parameter[] parameters) { Parameter[] params = new Parameter[parameters.length]; for (int i = 0; i < params.length; i++) { params[i] = new Parameter(cleanType(parameters[i].getType()), parameters[i].getName()); } return params; }
public void testDetectsDuplicateMethodsForInterfaceOneParam() throws Exception { Parameter[] stringParam = {new Parameter(ClassHelper.STRING_TYPE, "x")}; checkDetectsDuplicateMethods(ACC_INTERFACE, EXPECTED_DUPLICATE_METHOD_ERROR_INTERFACE_MESSAGE, stringParam); }
private static Parameter[] getParams(List<FieldNode> fields, ClassNode cNode) { Parameter[] parameters = new Parameter[fields.size()]; for (int i = 0; i < parameters.length; i++) { FieldNode fNode = fields.get(i); Map<String,ClassNode> genericsSpec = createGenericsSpec(fNode.getDeclaringClass()); extractSuperClassGenerics(fNode.getType(), cNode, genericsSpec); ClassNode correctedType = correctToGenericsSpecRecurse(genericsSpec, fNode.getType()); parameters[i] = new Parameter(correctedType, fNode.getName()); } return parameters; }
private static void removeInitialValues(Parameter[] params) { for (int i = 0; i < params.length; i++) { if (params[i].hasInitialExpression()) { Parameter p = new Parameter(params[i].getType(), params[i].getName()); p.setOriginType(p.getOriginType()); params[i] = p; } } }
private static Parameter createParam(FieldNode fNode, String name, boolean defaults, AbstractASTTransformation xform, boolean makeImmutable) { Parameter param = new Parameter(fNode.getType(), name); if (defaults) { param.setInitialExpression(providedOrDefaultInitialValue(fNode)); } else if (!makeImmutable) { // TODO we could support some default vals provided they were listed last if (fNode.getInitialExpression() != null) { xform.addError("Error during " + MY_TYPE_NAME + " processing, default value processing disabled but default value found for '" + fNode.getName() + "'", fNode); } } return param; }
private static void addSetter(FieldNode fNode, ClassNode componentType) { ClassNode cNode = fNode.getDeclaringClass(); BlockStatement body = new BlockStatement(); Parameter[] theParams = params( new Parameter(ClassHelper.int_TYPE, "index"), new Parameter(componentType, "value")); body.addStatement(assignS(indexX(varX(fNode), varX(theParams[0])), varX(theParams[1]))); addGeneratedMethod(cNode, makeName(fNode, "set"), getModifiers(fNode), ClassHelper.VOID_TYPE, theParams, null, body); }
private static Parameter[] makeRawTypes(Parameter[] params, Map<GenericsType, GenericsType> genericsPlaceholderAndTypeMap) { Parameter[] newParam = new Parameter[params.length]; for (int i = 0; i < params.length; i++) { Parameter oldP = params[i]; ClassNode actualType = GenericsUtils.findActualTypeByGenericsPlaceholderName(oldP.getType().getUnresolvedName(), genericsPlaceholderAndTypeMap); Parameter newP = new Parameter(makeRawType(null == actualType ? oldP.getType() : actualType), oldP.getName()); newParam[i] = newP; } return newParam; }
public void testPrimitiveOriginTypeConstructorParameter() { Parameter boolParameter = new Parameter(ClassHelper.boolean_TYPE,"foo"); Parameter intParameter = new Parameter(ClassHelper.int_TYPE,"foo"); VariableExpression newBoolExpression = new VariableExpression(boolParameter); VariableExpression newIntExpression = new VariableExpression(intParameter); assertEquals(newBoolExpression.getOriginType().getName(),"boolean"); assertEquals(newIntExpression.getOriginType().getName(),"int"); }
private static void addGetter(FieldNode fNode, ClassNode componentType) { ClassNode cNode = fNode.getDeclaringClass(); BlockStatement body = new BlockStatement(); Parameter[] params = new Parameter[1]; params[0] = new Parameter(ClassHelper.int_TYPE, "index"); body.addStatement(stmt(indexX(varX(fNode), varX(params[0])))); addGeneratedMethod(cNode, makeName(fNode, "get"), getModifiers(fNode), componentType, params, null, body); }
public static MethodNode correctToGenericsSpec(Map<String, ClassNode> genericsSpec, MethodNode mn) { ClassNode correctedType = correctToGenericsSpecRecurse(genericsSpec, mn.getReturnType()); Parameter[] origParameters = mn.getParameters(); Parameter[] newParameters = new Parameter[origParameters.length]; for (int i = 0; i < origParameters.length; i++) { Parameter origParameter = origParameters[i]; newParameters[i] = new Parameter(correctToGenericsSpecRecurse(genericsSpec, origParameter.getType()), origParameter.getName(), origParameter.getInitialExpression()); } return new MethodNode(mn.getName(), mn.getModifiers(), correctedType, newParameters, mn.getExceptions(), mn.getCode()); }
private CatchStatement createHandleSuppressedThrowableStatement(VariableExpression featureThrowableVar) { Parameter catchParameter = new Parameter(nodeCache.Throwable, "$spock_tmp_throwable"); MethodCallExpression addSuppressedCall = new MethodCallExpression(featureThrowableVar, "addSuppressed", new ArgumentListExpression(new VariableExpression(catchParameter))); BinaryExpression featureThrowableNotNullExpr = createVariableNotNullExpression(featureThrowableVar); List<Statement> addSuppressedStats = Collections.<Statement>singletonList(new ExpressionStatement(addSuppressedCall)); List<Statement> throwFeatureStats = Collections.<Statement>singletonList(new ThrowStatement(new VariableExpression(catchParameter))); IfStatement ifFeatureNotNullStat = new IfStatement(new BooleanExpression(featureThrowableNotNullExpr), new BlockStatement(addSuppressedStats, new VariableScope()), new BlockStatement(throwFeatureStats, new VariableScope())); return new CatchStatement(catchParameter, new BlockStatement( Collections.<Statement>singletonList(ifFeatureNotNullStat), new VariableScope())); }
private CatchStatement createThrowableAssignmentAndRethrowCatchStatement(VariableExpression assignmentVar) { Parameter catchParameter = new Parameter(nodeCache.Throwable, "$spock_tmp_throwable"); BinaryExpression assignThrowableExpr = new BinaryExpression( new VariableExpression(assignmentVar), Token.newSymbol(Types.ASSIGN, -1, -1), new VariableExpression(catchParameter)); return new CatchStatement(catchParameter, new BlockStatement( Arrays.asList( new ExpressionStatement(assignThrowableExpr), new ThrowStatement(new VariableExpression(catchParameter))), new VariableScope())); }