private static void extractParametersFromMethod(final List<ClassNode[]> signatures, final MethodNode method) { if (Traits.hasDefaultImplementation(method)) return; Parameter[] parameters = method.getParameters(); ClassNode[] typeParams = new ClassNode[parameters.length]; for (int i = 0; i < parameters.length; i++) { typeParams[i] = parameters[i].getOriginType(); } signatures.add(typeParams); } }
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; }
@Override public ClassNode[] getParameterTypes(final MethodNode node, final String[] options, final SourceUnit sourceUnit, final CompilationUnit unit, final ASTNode usage) { ClassNode type = node.getParameters()[parameterIndex].getOriginType(); if (genericTypeIndex>=0) { type = pickGenericType(type, genericTypeIndex); } return new ClassNode[]{type}; } }
/** * A helper method which will extract the n-th generic type from the n-th parameter of a method node. * @param node the method node from which the generic type should be picked * @param parameterIndex the index of the parameter in the method parameter list * @param gtIndex the index of the generic type to extract * @return the generic type, or {@link org.codehaus.groovy.ast.ClassHelper#OBJECT_TYPE} if it doesn't exist. */ public static ClassNode pickGenericType(MethodNode node, int parameterIndex, int gtIndex) { final Parameter[] parameters = node.getParameters(); final ClassNode type = parameters[parameterIndex].getOriginType(); return pickGenericType(type, gtIndex); }
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; } } }
protected void loadArguments(List<Expression> argumentList, Parameter[] para) { if (para.length==0) return; ClassNode lastParaType = para[para.length - 1].getOriginType(); AsmClassGenerator acg = controller.getAcg(); OperandStack operandStack = controller.getOperandStack();
for (int i = 0; i < length; i++) { Parameter closureParam = closureParams[i]; final ClassNode originType = closureParam.getOriginType(); ClassNode inferredType; if (i < inferred.length - 1 || inferred.length == closureParams.length) { for (int i = 0; i < length; i++) { Parameter closureParam = closureParams[i]; final ClassNode originType = closureParam.getOriginType(); ClassNode inferredType = OBJECT_TYPE; if (i < inferred.length - 1 || inferred.length == closureParams.length) {
int pindex = min(i, parameters.length - 1); ClassNode wrappedArgument = arguments[i]; ClassNode type = parameters[pindex].getOriginType();
/** * 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 void analyseParameters(Parameter[] parameters) { for (Parameter parameter : parameters) { visitType(parameter.getOriginType()); if (parameter.hasInitialExpression()) { parameter.getInitialExpression().visit(this); } } }
public List<ClassNode[]> getClosureSignatures(final MethodNode node, final SourceUnit sourceUnit, final CompilationUnit compilationUnit, final String[] options, final ASTNode usage) { Options opt; try { opt = Options.parse(node, usage, options); } catch (IncorrectTypeHintException e) { sourceUnit.addError(e); return Collections.emptyList(); } GenericsType[] genericsTypes = node.getParameters()[opt.parameterIndex].getOriginType().getGenericsTypes(); if (genericsTypes==null) { // would happen if you have a raw Map type for example genericsTypes = new GenericsType[] { new GenericsType(ClassHelper.OBJECT_TYPE), new GenericsType(ClassHelper.OBJECT_TYPE) }; } ClassNode[] firstSig; ClassNode[] secondSig; ClassNode mapEntry = MAPENTRY_TYPE.getPlainNodeReference(); mapEntry.setGenericsTypes(genericsTypes); if (opt.generateIndex) { firstSig = new ClassNode[] {genericsTypes[0].getType(), genericsTypes[1].getType(), ClassHelper.int_TYPE}; secondSig = new ClassNode[] {mapEntry, ClassHelper.int_TYPE}; } else { firstSig = new ClassNode[] {genericsTypes[0].getType(), genericsTypes[1].getType()}; secondSig = new ClassNode[] {mapEntry}; } return Arrays.asList(firstSig, secondSig); }
@Override public ClassNode resolveType(final Expression exp, final ClassNode current) { ASTNode target = exp instanceof VariableExpression ? getTarget((VariableExpression) exp) : exp; ClassNode inferredType = target.getNodeMetaData(StaticTypesMarker.DECLARATION_INFERRED_TYPE); if (inferredType == null) { inferredType = target.getNodeMetaData(StaticTypesMarker.INFERRED_TYPE); if (inferredType == null && target instanceof VariableExpression && ((VariableExpression) target).getAccessedVariable() instanceof Parameter) { target = (Parameter) ((VariableExpression) target).getAccessedVariable(); inferredType = ((Parameter) target).getOriginType(); } } if (inferredType != null) { if (ClassHelper.VOID_TYPE == inferredType) { // we are in a case of a type inference failure, probably because code was generated // it is better to avoid using this inferredType = super.resolveType(exp, current); } return inferredType; } if (target instanceof VariableExpression && ((VariableExpression) target).isThisExpression()) { // AsmClassGenerator may create "this" expressions that the type checker knows nothing about return current; } return super.resolveType(exp, current); }
if (para.isClosureSharedVariable()) { boolean useExistingReference = para.getNodeMetaData(ClosureWriter.UseExistingReference.class) != null; answer = defineVar(name, para.getOriginType(), true, useExistingReference); answer.setStartLabel(startLabel); if (!useExistingReference) { BytecodeVariable var = new BytecodeVariable(currentVariableIndex, para.getOriginType(), name, currentVariableIndex); var.setStartLabel(startLabel); var.setEndLabel(newStart);
ClassNode type = getWrapper(setter.getParameters()[0].getOriginType()); if (Boolean_TYPE.equals(type) || STRING_TYPE.equals(type) || CLASS_Type.equals(type)) { call = callX(ve, setterInfo.name, castX(type, newRightExpression)); ClassNode firstSetterType = setterInfo.setters.iterator().next().getParameters()[0].getOriginType(); addAssignmentError(firstSetterType, getType(newRightExpression), expression); return true;
private static Parameter[] selectAccessibleConstructorFromSuper(ConstructorNode node) { ClassNode type = node.getDeclaringClass(); ClassNode superType = type.getUnresolvedSuperClass(); Parameter[] bestMatch = null; for (ConstructorNode c : superType.getDeclaredConstructors()) { // Only look at things we can actually call if (!c.isPublic() && !c.isProtected()) continue; Parameter[] parameters = c.getParameters(); // workaround for GROOVY-5859: remove generic type info Parameter[] copy = new Parameter[parameters.length]; for (int i = 0; i < copy.length; i++) { Parameter orig = parameters[i]; copy[i] = new Parameter(orig.getOriginType().getPlainNodeReference(), orig.getName()); } if (noExceptionToAvoid(node,c)) return copy; if (bestMatch==null) bestMatch = copy; } if (bestMatch!=null) return bestMatch; // fall back for parameterless constructor if (superType.isPrimaryClassNode()) { return Parameter.EMPTY_ARRAY; } return null; }
for (int i = 0; i < parameters.length; i++) { final Parameter parameter = parameters[i]; if (parameter.getOriginType().isUsingGenerics() && closureParamTypes.length > i) { genericsToConnect.add(new ClassNode[]{closureParamTypes[i], parameter.getOriginType()});
Parameter orig = methodParameters[j-1]; newParams[j] = new Parameter( correctToGenericsSpecRecurse(genericsSpec, orig.getOriginType(), methodSpecificGenerics), orig.getName() );
for (int i = 0; i < parameters.length; i++) { Parameter parameter = parameters[i]; ClassNode originType = parameter.getOriginType(); superForwarderParams[i] = new Parameter(correctToGenericsSpecRecurse(genericsSpec, originType), parameter.getName());
boolean isHelperForStaticMethod = helperMethodParams[0].getOriginType().equals(ClassHelper.CLASS_Type); if (Modifier.isPrivate(access) && !isHelperForStaticMethod) {
@Override protected void writeForInLoop(final ForStatement loop) { controller.getAcg().onLineNumber(loop,"visitForLoop"); writeStatementLabel(loop); CompileStack compileStack = controller.getCompileStack(); MethodVisitor mv = controller.getMethodVisitor(); OperandStack operandStack = controller.getOperandStack(); compileStack.pushLoop(loop.getVariableScope(), loop.getStatementLabels()); // Identify type of collection TypeChooser typeChooser = controller.getTypeChooser(); Expression collectionExpression = loop.getCollectionExpression(); ClassNode collectionType = typeChooser.resolveType(collectionExpression, controller.getClassNode()); Parameter loopVariable = loop.getVariable(); int size = operandStack.getStackLength(); if (collectionType.isArray() && loopVariable.getOriginType().equals(collectionType.getComponentType())) { writeOptimizedForEachLoop(compileStack, operandStack, mv, loop, collectionExpression, collectionType, loopVariable); } else if (ENUMERATION_CLASSNODE.equals(collectionType)) { writeEnumerationBasedForEachLoop(compileStack, operandStack, mv, loop, collectionExpression, collectionType, loopVariable); } else { writeIteratorBasedForEachLoop(compileStack, operandStack, mv, loop, collectionExpression, collectionType, loopVariable); } operandStack.popDownTo(size); compileStack.pop(); }