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()); }
for (int i = size - 1; i >= 0; i--) { Parameter parameter = parameters[i]; if (parameter != null && parameter.hasInitialExpression()) { paramValues.add(i); paramValues.add( new CastExpression( parameter.getType(), parameter.getInitialExpression() ArgumentListExpression arguments = new ArgumentListExpression(); int index = 0; int k = 1; for (Parameter parameter : parameters) { if (parameter == null) { throw new GroovyBugError("Parameter should not be null for method " + methodNode.getName()); } else { if (k > counter - j && parameter.hasInitialExpression()) { arguments.addExpression( new CastExpression( parameter.getType(), parameter.getInitialExpression() } else if (parameter.hasInitialExpression()) { index = addExpression(newParams, arguments, index, parameter); k++; if (!parameter.hasInitialExpression()) continue; // GROOVY-8728 make idempotent parameter.putNodeMetaData(Verifier.INITIAL_EXPRESSION, parameter.getInitialExpression());
private List<Expression> buildParams(Parameter[] origParams, Parameter[] params, Map<String, ClassNode> genericsSpec, boolean copyParameterAnnotations) { List<Expression> theArgs = new ArrayList<Expression>(); for (int i = 0; i < origParams.length; i++) { Parameter p = origParams[i]; ClassNode newType = correctToGenericsSpecRecurse(genericsSpec, p.getType()); params[i] = p.hasInitialExpression() ? param(newType, p.getName(), p.getInitialExpression()) : param(newType, p.getName()); if (copyParameterAnnotations) { params[i].addAnnotations(copyAnnotatedNodeAnnotations(origParams[i], MY_TYPE_NAME)); } theArgs.add(varX(p.getName(), newType)); } return theArgs; }
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; } } }
public static Parameter param(ClassNode type, String name, Expression initialExpression) { Parameter param = new Parameter(type, name); if (initialExpression != null) { param.setInitialExpression(initialExpression); } return param; }
ClassNode enumRef = enumClass.getPlainNodeReference(); Parameter[] parameter = new Parameter[]{new Parameter(ClassHelper.OBJECT_TYPE.makeArray(), "para")}; MethodNode initMethod = new MethodNode("$INIT", PUBLIC_FS | Opcodes.ACC_SYNTHETIC, enumRef, parameter, ClassNode.EMPTY_ARRAY, null); initMethod.setSynthetic(true); ConstructorCallExpression cce = new ConstructorCallExpression( ClassNode.THIS, new ArgumentListExpression( new SpreadExpression(new VariableExpression("para")) initMethod.setCode(code); enumClass.addMethod(initMethod); ArgumentListExpression args = new ArgumentListExpression(); args.addExpression(new ConstantExpression(field.getName())); args.addExpression(new ConstantExpression(value)); if (field.getInitialExpression() == null) { if ((enumClass.getModifiers() & Opcodes.ACC_ABSTRACT) != 0) {
Set<ASTNode> accessedMethods = (Set<ASTNode>) node.getNodeMetaData(StaticTypesMarker.PV_METHODS_ACCESS); if (accessedMethods==null) return; List<MethodNode> methods = new ArrayList<MethodNode>(node.getAllDeclaredMethods()); methods.addAll(node.getDeclaredConstructors()); List<String> methodSpecificGenerics = methodSpecificGenerics(method); i++; ClassNode declaringClass = method.getDeclaringClass(); Map<String,ClassNode> genericsSpec = createGenericsSpec(node); genericsSpec = addMethodGenerics(method, genericsSpec); extractSuperClassGenerics(node, declaringClass, genericsSpec); Parameter[] methodParameters = method.getParameters(); Parameter[] newParams = new Parameter[methodParameters.length+1]; for (int j = 1; j < newParams.length; j++) { Parameter orig = methodParameters[j-1]; newParams[j] = new Parameter( correctToGenericsSpecRecurse(genericsSpec, orig.getOriginType(), methodSpecificGenerics), orig.getName() ); arguments = new ArgumentListExpression(args); newParams[0] = new Parameter(thatType.getPlainNodeReference(), "$that"); Expression cce = new ConstructorCallExpression(ClassNode.THIS, arguments); newParams[0] = new Parameter(node.getPlainNodeReference(), "$that"); Expression receiver = method.isStatic()?new ClassExpression(node):new VariableExpression(newParams[0]);
private void addDelegateMethod(DelegateDescription delegate, List<MethodNode> ownMethods, MethodNode candidate, boolean includeDeprecated, boolean allNames) { if (!candidate.isPublic() || candidate.isStatic() || 0 != (candidate.getModifiers () & ACC_SYNTHETIC)) return; boolean checkReturn = delegate.type.getMethods().contains(candidate); if (shouldSkipOnDescriptorUndefinedAware(checkReturn, genericsSpec, correctedMethodNode, delegate.excludeTypes, delegate.includeTypes)) return; for (MethodNode mn : GROOVYOBJECT_TYPE.getMethods()) { if (mn.getTypeDescriptor().equals(candidate.getTypeDescriptor())) { return; if (existingNode == null || existingNode.getCode() == null) { final ArgumentListExpression args = new ArgumentListExpression(); final Parameter[] params = candidate.getParameters(); final Parameter[] newParams = new Parameter[params.length]; List<String> currentMethodGenPlaceholders = genericPlaceholderNames(candidate); for (int i = 0; i < newParams.length; i++) { ClassNode newParamType = correctToGenericsSpecRecurse(genericsSpec, params[i].getType(), currentMethodGenPlaceholders); Parameter newParam = new Parameter(newParamType, getParamName(params, i, delegate.name)); newParam.setInitialExpression(params[i].getInitialExpression()); newParam.addAnnotations(copyAnnotatedNodeAnnotations(params[i], MY_TYPE_NAME)); args.addExpression(varX(newParam));
genericsSpec = GenericsUtils.createGenericsSpec(trait, genericsSpec); MethodNode originalMethod = trait.getMethod(name, params); ClassNode originType = parameter.getOriginType(); ClassNode fixedType = correctToGenericsSpecRecurse(methodGenericsSpec, originType); Parameter newParam = new Parameter(fixedType, "arg" + i); List<AnnotationNode> copied = new LinkedList<AnnotationNode>(); List<AnnotationNode> notCopied = new LinkedList<AnnotationNode>(); GeneralUtils.copyAnnotatedNodeAnnotations(parameter, copied, notCopied); newParam.addAnnotations(copied); params[i - 1] = newParam; origParams[i-1] = parameter; argList.addExpression(new VariableExpression(params[i - 1])); new Parameter[] {new Parameter(ClassHelper.CLASS_Type,"clazz")}, ClassNode.EMPTY_ARRAY, EmptyStatement.INSTANCE); cNode.addStaticInitializerStatements(Collections.<Statement>singletonList(new ExpressionStatement( staticInitCall )), false); newParams = Parameter.EMPTY_ARRAY; } else { ClassNode originType = methodNode.getParameters()[0].getOriginType(); ClassNode fixedType = originType.isGenericsPlaceHolder()?ClassHelper.OBJECT_TYPE:correctToGenericsSpecRecurse(genericsSpec, originType); newParams = new Parameter[]{new Parameter(fixedType, "val")};
private void applyDelegateAsyncTransform(ClassNode classNode, ClassNode targetApi, String fieldName) { List<MethodNode> methods = targetApi.getAllDeclaredMethods(); ClassNode promisesClass = ClassHelper.make(Promises.class).getPlainNodeReference(); MethodNode createPromiseMethodTargetWithDecorators = promisesClass.getDeclaredMethod("createPromise", new Parameter[]{new Parameter(new ClassNode(Closure.class), "c"), new Parameter(new ClassNode(List.class), "c")}); VariableScope variableScope = new VariableScope(); closureExpression.setVariableScope(variableScope); VariableExpression thisObject = new VariableExpression("this"); ClassNode delegateAsyncUtilsClassNode = new ClassNode(DelegateAsyncUtils.class); MethodNode getPromiseDecoratorsMethodNode = delegateAsyncUtilsClassNode.getDeclaredMethods("getPromiseDecorators").get(0); ListExpression promiseDecorators = new ListExpression(); ArgumentListExpression getPromiseDecoratorsArguments = new ArgumentListExpression(thisObject, promiseDecorators); delegateAsyncTransactionalMethodTransformer.transformTransactionalMethod(classNode, targetApi, m, promiseDecorators); getDecoratorsMethodCall.setMethodTarget(getPromiseDecoratorsMethodNode); MethodCallExpression createPromiseWithDecorators = new MethodCallExpression(new ClassExpression(promisesClass), "createPromise",new ArgumentListExpression( closureExpression, getDecoratorsMethodCall)); if(createPromiseMethodTargetWithDecorators != null) { createPromiseWithDecorators.setMethodTarget(createPromiseMethodTargetWithDecorators); p.setClosureSharedVariable(true); variableScope.putReferencedLocalVariable(p); VariableExpression ve = new VariableExpression(p); ve.setClosureSharedVariable(true); arguments.addExpression(ve);
public static void addDelegateMethods(@Nonnull ClassNode classNode, @Nonnull ClassNode delegateType, @Nonnull Expression delegate) { for (MethodNode method : delegateType.getMethods()) { List<Expression> variables = new ArrayList<>(); Parameter[] parameters = new Parameter[method.getParameters().length]; ClassNode[] exceptions = new ClassNode[method.getExceptions().length]; for (int i = 0; i < method.getParameters().length; i++) { Parameter p = method.getParameters()[i]; parameters[i] = new Parameter(makeClassSafe(p.getType()), p.getName()); parameters[i].getType().setGenericsTypes(p.getType().getGenericsTypes()); parameters[i].getType().setGenericsPlaceHolder(p.getType().isGenericsPlaceHolder()); parameters[i].getType().setUsingGenerics(p.getType().isUsingGenerics()); parameters[i].addAnnotations(p.getAnnotations()); variables.add(var(p.getName())); for (int i = 0; i < method.getExceptions().length; i++) {
boolean staticMethodOrInStaticClass = controller.isStaticMethod() || classNode.isStaticClass(); } else if (parameters.length == 0) { Parameter it = new Parameter(ClassHelper.OBJECT_TYPE, "it", ConstantExpression.NULL); parameters = new Parameter[]{it}; Variable ref = expression.getVariableScope().getDeclaredVariable("it"); if (ref!=null) it.setClosureSharedVariable(ref.isClosureSharedVariable()); && parameters[0].getType() != null && parameters[0].getType() != ClassHelper.OBJECT_TYPE && !ClassHelper.OBJECT_TYPE.equals(parameters[0].getType().getComponentType()))) String paramName = param.getName(); ClassNode type = param.getType(); ClassNode realType = type; type = ClassHelper.makeReference(); param.setType(ClassHelper.makeReference()); FieldNode paramField = answer.addField(paramName, ACC_PRIVATE | ACC_SYNTHETIC, type, initialValue); paramField.setOriginType(ClassHelper.getWrapper(param.getOriginType())); paramField.setHolder(true); String methodName = Verifier.capitalize(paramName); params[0] = new Parameter(ClassHelper.OBJECT_TYPE, "_outerInstance"); params[1] = new Parameter(ClassHelper.OBJECT_TYPE, "_thisObject"); System.arraycopy(localVariableParams, 0, params, 2, localVariableParams.length);
final Set<String> knownFields) { if (field.isProtected()) { unit.addError(new SyntaxException("Cannot have protected field in a trait (" + trait.getName() + "#" + field.getName() + ")", field.getLineNumber(), field.getColumnNumber())); return; returnS(initCode.getExpression()) ); helper.addMethod(fieldInitializer); } else { BlockStatement code = (BlockStatement) selectedMethod.getCode(); MethodCallExpression mce; if (field.isStatic()) { new ClassExpression(INVOKERHELPER_CLASSNODE), "invokeStaticMethod", new ArgumentListExpression( thisObject, new ConstantExpression(Traits.helperSetterName(field)), initCode.getExpression() target.addMethod( Traits.helperSetterName(field), ACC_PUBLIC | ACC_ABSTRACT, field.getOriginType(), new Parameter[]{new Parameter(field.getOriginType(), "val")}, ClassNode.EMPTY_ARRAY, null
protected ClassNode createStatementsClass() { ClassNode classNode = getScriptClassDummy(); if (classNode.getName().endsWith("package-info")) { return classNode; classNode.addMethod( new MethodNode( "main", ACC_PUBLIC | ACC_STATIC, ClassHelper.VOID_TYPE, new Parameter[] { new Parameter(ClassHelper.STRING_TYPE.makeArray(), "args")}, ClassNode.EMPTY_ARRAY, new ExpressionStatement( new ClassExpression(ClassHelper.make(InvokerHelper.class)), "runScript", new ArgumentListExpression( new ClassExpression(classNode), new VariableExpression("args")))))); MethodNode methodNode = new MethodNode("run", ACC_PUBLIC, ClassHelper.OBJECT_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, statementBlock); methodNode.setIsScriptBody(); classNode.addMethod(methodNode); classNode.addConstructor( ACC_PUBLIC, new Parameter[] { new Parameter(ClassHelper.make(Binding.class), "context")}, ClassNode.EMPTY_ARRAY, stmt);
Expression arguments, GenericsType[] explicitTypeHints) { ClassNode returnType = method.getReturnType(); if (method instanceof ExtensionMethodNode && (isUsingGenericsOrIsArrayUsingGenerics(returnType))) { Map<GenericsTypeName, GenericsType> resolvedPlaceholders = resolvePlaceHoldersFromDeclaration(receiver, getDeclaringClass(method, arguments), method, method.isStatic()); if (!receiver.isGenericsPlaceHolder()) { GenericsUtils.extractPlaceholders(receiver, resolvedPlaceholders); Parameter[] parameters = method.getParameters(); boolean isVargs = isVargs(parameters); ArgumentListExpression argList = InvocationWriter.makeArgumentList(arguments); for (int i = 0; i < paramLength; i++) { boolean lastArg = i == paramLength - 1; ClassNode type = parameters[i].getType(); ClassNode actualType = getType(expressions.get(i)); while (!type.isUsingGenerics() && type.isArray() && actualType.isArray()) { type = type.getComponentType(); actualType = actualType.getComponentType();
private void createSharedFieldSetter(Field field) { String setterName = "set" + MetaClassHelper.capitalize(field.getName()); Parameter[] params = new Parameter[] { new Parameter(field.getAst().getType(), "$spock_value") }; MethodNode setter = spec.getAst().getMethod(setterName, params); if (setter != null) { errorReporter.error(field.getAst(), "@Shared field '%s' conflicts with method '%s'; please rename either of them", field.getName(), setter.getName()); return; } BlockStatement setterBlock = new BlockStatement(); setter = new MethodNode(setterName, determineVisibilityForSharedFieldAccessor(field) | Opcodes.ACC_SYNTHETIC, ClassHelper.VOID_TYPE, params, ClassNode.EMPTY_ARRAY, setterBlock); setterBlock.addStatement( new ExpressionStatement( new BinaryExpression( new AttributeExpression( getSharedInstance(), // use internal name new ConstantExpression(field.getAst().getName())), Token.newSymbol(Types.ASSIGN, -1, -1), new VariableExpression("$spock_value")))); setter.setSourcePosition(field.getAst()); spec.getAst().addMethod(setter); }
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; }
protected void visitConstructorOrMethod(MethodNode node, boolean isConstructor) { VariableScope oldScope = currentScope; currentScope = node.getVariableScope(); Map<GenericsTypeName, GenericsType> oldPNames = genericParameterNames; genericParameterNames = node.isStatic() && !Traits.isTrait(node.getDeclaringClass()) ? new HashMap<GenericsTypeName, GenericsType>() : new HashMap<GenericsTypeName, GenericsType>(genericParameterNames); resolveGenericsHeader(node.getGenericsTypes()); Parameter[] paras = node.getParameters(); for (Parameter p : paras) { p.setInitialExpression(transform(p.getInitialExpression())); resolveOrFail(p.getType(), p.getType()); visitAnnotations(p); } ClassNode[] exceptions = node.getExceptions(); for (ClassNode t : exceptions) { resolveOrFail(t, node); } resolveOrFail(node.getReturnType(), node); MethodNode oldCurrentMethod = currentMethod; currentMethod = node; super.visitConstructorOrMethod(node, isConstructor); currentMethod = oldCurrentMethod; genericParameterNames = oldPNames; currentScope = oldScope; }
thisExpression.setType(targetClass); for (FieldNode field : parent.getFields()) { names.add(field.getName()); for (PropertyNode field : parent.getProperties()) { names.add(field.getName()); } else if (params.length == 0) { params = new Parameter[]{ new Parameter(ClassHelper.OBJECT_TYPE, "it") }; for (MethodNode method : parent.getMethods()) { if (!method.isStatic()) { method.setModifiers(method.getModifiers() | Opcodes.ACC_STATIC); final Parameter[] origParams = method.getParameters(); final Parameter[] newParams = new Parameter[origParams.length + 1]; Parameter p = new Parameter(targetClass, "$this"); p.setClosureSharedVariable(true); newParams[0] = p; parameter.set(p);