List<AnnotationNode> annotations = param.getAnnotations(NAMED_PARAMS_CLASSNODE); if (annotations != null && !annotations.isEmpty()) { AnnotationNode an = null;
private void visitParameterAnnotations(Parameter parameter, int paramNumber, MethodVisitor mv) { for (AnnotationNode an : parameter.getAnnotations()) { // skip built-in properties if (an.isBuiltIn()) continue; if (an.hasSourceRetention()) continue; final String annotationDescriptor = BytecodeHelper.getTypeDescription(an.getClassNode()); AnnotationVisitor av = mv.visitParameterAnnotation(paramNumber, annotationDescriptor, an.hasRuntimeRetention()); visitAnnotationAttributes(an, av); av.visitEnd(); } }
/** * This method is responsible for performing type inference on closure argument types whenever code like this is * found: <code>foo.collect { it.toUpperCase() }</code>. * In this case, the type checker tries to find if the <code>collect</code> method has its {@link Closure} argument * annotated with {@link groovy.transform.stc.ClosureParams}. If yes, then additional type inference can be performed * and the type of <code>it</code> may be inferred. * * @param receiver * @param arguments * @param expression a closure expression for which the argument types should be inferred * @param param the parameter where to look for a {@link groovy.transform.stc.ClosureParams} annotation. * @param selectedMethod the method accepting a closure */ protected void inferClosureParameterTypes(final ClassNode receiver, final Expression arguments, final ClosureExpression expression, final Parameter param, final MethodNode selectedMethod) { List<AnnotationNode> annotations = param.getAnnotations(CLOSUREPARAMS_CLASSNODE); if (annotations != null && !annotations.isEmpty()) { for (AnnotationNode annotation : annotations) { Expression hintClass = annotation.getMember("value"); Expression options = annotation.getMember("options"); Expression resolverClass = annotation.getMember("conflictResolutionStrategy"); if (hintClass instanceof ClassExpression) { doInferClosureParameterTypes(receiver, arguments, expression, selectedMethod, hintClass, resolverClass, options); } } } else if (isSAMType(param.getOriginType())) { // SAM coercion inferSAMType(param, receiver, selectedMethod, InvocationWriter.makeArgumentList(arguments), expression); } }
private boolean processExplicitNamedParam(MethodNode mNode, Parameter mapParam, BlockStatement inner, ArgumentListExpression args, List<String> propNames, Parameter fromParam) { AnnotationNode namedParam = fromParam.getAnnotations(NAMED_PARAM_TYPE).get(0); boolean required = memberHasValue(namedParam, "required", true); if (getMemberStringValue(namedParam, "value") == null) { namedParam.addMember("value", constX(fromParam.getName())); } String name = getMemberStringValue(namedParam, "value"); if (getMemberValue(namedParam, "type") == null) { namedParam.addMember("type", classX(fromParam.getType())); } if (hasDuplicates(mNode, propNames, name)) return false; // TODO check specified type is assignable from declared param type? // ClassNode type = getMemberClassValue(namedParam, "type"); if (required) { if (fromParam.hasInitialExpression()) { addError("Error during " + MY_TYPE_NAME + " processing. A required parameter can't have an initial value.", mNode); return false; } inner.addStatement(new AssertStatement(boolX(callX(varX(mapParam), "containsKey", args(constX(name)))), plusX(new ConstantExpression("Missing required named argument '" + name + "'. Keys found: "), callX(varX(mapParam), "keySet")))); } args.addExpression(propX(varX(mapParam), name)); mapParam.addAnnotation(namedParam); fromParam.getAnnotations().remove(namedParam); return true; }
final Expression expression, final Parameter param) { List<AnnotationNode> annotations = param.getAnnotations(DELEGATES_TO); if (annotations != null && !annotations.isEmpty()) { for (AnnotationNode annotation : annotations) { List<AnnotationNode> targets = methodParam.getAnnotations(DELEGATES_TO_TARGET); if (targets != null && targets.size() == 1) { AnnotationNode targetAnnotation = targets.get(0); // @DelegatesTo.Target Obj foo
private boolean hasInjectedParameterAnnotation(Parameter p) { for (AnnotationNode a : p.getAnnotations()) { if (hasAnnotation(a.getClassNode(), INJECTED_PARAMETER_ANN)) return true; } return false; }
private boolean hasInjectedParameterAnnotation(Parameter p) { for (AnnotationNode a : p.getAnnotations()) { if (hasAnnotation(a.getClassNode(), INJECTED_PARAMETER_ANN)) return true; } return false; }
private void visitParameterAnnotations(Parameter parameter, int paramNumber, MethodVisitor mv) { Map annotionMap = parameter.getAnnotations(); if (annotionMap.isEmpty()) return; Iterator it = annotionMap.values().iterator(); while (it.hasNext()) { AnnotationNode an = (AnnotationNode) it.next(); //skip builtin properties if (an.isBuiltIn()) continue; if (an.hasSourceRetention()) continue; final String annotationDescriptor = BytecodeHelper.getTypeDescription(an.getClassNode()); AnnotationVisitor av = mv.visitParameterAnnotation(paramNumber, annotationDescriptor, an.hasRuntimeRetention()); visitAnnotationAttributes(an, av); av.visitEnd(); } }
private void visitParameterAnnotations(Parameter parameter, int paramNumber, MethodVisitor mv) { List annotations = parameter.getAnnotations(); if (annotations.isEmpty()) return; Iterator it = annotations.iterator(); while (it.hasNext()) { AnnotationNode an = (AnnotationNode) it.next(); // skip built-in properties if (an.isBuiltIn()) continue; if (an.hasSourceRetention()) continue; final String annotationDescriptor = BytecodeHelper.getTypeDescription(an.getClassNode()); AnnotationVisitor av = mv.visitParameterAnnotation(paramNumber, annotationDescriptor, an.hasRuntimeRetention()); visitAnnotationAttributes(an, av); av.visitEnd(); } }
private void visitParameterAnnotations(Parameter parameter, int paramNumber, MethodVisitor mv) { List annotions = parameter.getAnnotations(); if (annotions.isEmpty()) return; Iterator it = annotions.iterator(); while (it.hasNext()) { AnnotationNode an = (AnnotationNode) it.next(); //skip builtin properties if (an.isBuiltIn()) continue; if (an.hasSourceRetention()) continue; final String annotationDescriptor = BytecodeHelper.getTypeDescription(an.getClassNode()); AnnotationVisitor av = mv.visitParameterAnnotation(paramNumber, annotationDescriptor, an.hasRuntimeRetention()); visitAnnotationAttributes(an, av); av.visitEnd(); } }
final String paramName = param.getName(); String requestParameterName = paramName; List<AnnotationNode> requestParameters = param.getAnnotations( new ClassNode(RequestParameter.class)); requestParameters = helperParam.getAnnotations(new ClassNode(RequestParameter.class));
private static Parameter[] copyParameters(Parameter[] parameterTypes) { Parameter[] newParameterTypes = new Parameter[parameterTypes.length]; for (int i = 0; i < parameterTypes.length; i++) { Parameter parameterType = parameterTypes[i]; Parameter newParameter = new Parameter(nonGeneric(parameterType.getType()), parameterType.getName(), parameterType.getInitialExpression()); newParameter.addAnnotations(parameterType.getAnnotations()); newParameterTypes[i] = newParameter; } return newParameterTypes; }
private void visitParameterAnnotations(Parameter parameter, int paramNumber, MethodVisitor mv) { for (AnnotationNode an : parameter.getAnnotations()) { // skip built-in properties if (an.isBuiltIn()) continue; if (an.hasSourceRetention()) continue; final String annotationDescriptor = BytecodeHelper.getTypeDescription(an.getClassNode()); AnnotationVisitor av = mv.visitParameterAnnotation(paramNumber, annotationDescriptor, an.hasRuntimeRetention()); visitAnnotationAttributes(an, av); av.visitEnd(); } }
private static Parameter[] copyParameters(Parameter[] parameterTypes) { Parameter[] newParameterTypes = new Parameter[parameterTypes.length]; for (int i = 0; i < parameterTypes.length; i++) { Parameter parameterType = parameterTypes[i]; ClassNode parameterTypeCN = parameterType.getType(); ClassNode newParameterTypeCN = parameterTypeCN.getPlainNodeReference(); if(parameterTypeCN.isUsingGenerics() && !parameterTypeCN.isGenericsPlaceHolder()) { newParameterTypeCN.setGenericsTypes(parameterTypeCN.getGenericsTypes()); } Parameter newParameter = new Parameter(newParameterTypeCN, parameterType.getName(), parameterType.getInitialExpression()); newParameter.addAnnotations(parameterType.getAnnotations()); newParameterTypes[i] = newParameter; } return newParameterTypes; }
public void visitMethod(MethodNode method){ super.visitMethod(method); Parameter[] parms = method.getParameters(); for(Parameter parm: parms){ AnnotationNode argNode = null; for (AnnotationNode annotation : parm.getAnnotations()) { if("Arg".equals(annotation.getClassNode().getName())){ argNode=annotation; break; } } if(argNode==null){ //dynamically add annotation so we can retain the parameter name AnnotationNode dynamicAnno = new AnnotationNode(new ClassNode(Arg.class)); dynamicAnno.addMember("name", new ConstantExpression(parm.getName())); parm.addAnnotation(dynamicAnno); } else{ //fill in name on existing annotation if it is missing if(argNode.getMember("name")==null){ argNode.addMember("name", new ConstantExpression(parm.getName())); } } } } }
public void visitMethod(MethodNode method){ super.visitMethod(method); Parameter[] parms = method.getParameters(); for(Parameter parm: parms){ AnnotationNode argNode = null; for (AnnotationNode annotation : parm.getAnnotations()) { if("Arg".equals(annotation.getClassNode().getName())){ argNode=annotation; break; } } if(argNode==null){ //dynamically add annotation so we can retain the parameter name AnnotationNode dynamicAnno = new AnnotationNode(new ClassNode(Arg.class)); dynamicAnno.addMember("name", new ConstantExpression(parm.getName())); parm.addAnnotation(dynamicAnno); } else{ //fill in name on existing annotation if it is missing if(argNode.getMember("name")==null){ argNode.addMember("name", new ConstantExpression(parm.getName())); } } } } }
parameters[i].getType().setGenericsPlaceHolder(p.getType().isGenericsPlaceHolder()); parameters[i].getType().setUsingGenerics(p.getType().isUsingGenerics()); parameters[i].addAnnotations(p.getAnnotations()); variables.add(var(p.getName()));