Examples with ParameterTypeVariable2 org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.ParameterTypeVariable2 used on opensource projects

Example 1 with ParameterTypeVariable2

use of org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.ParameterTypeVariable2 in project che by eclipse.

the class InferTypeArgumentsTCModel method makeDeclaredParameterTypeVariable.

/**
	 * Make a ParameterTypeVariable2 from a method declaration.
	 * The constraint variable is always stored if it passes the type filter.
	 * @param methodBinding
	 * @param parameterIndex
	 * @param cu
	 * @return the ParameterTypeVariable2, or <code>null</code>
	 */
public ParameterTypeVariable2 makeDeclaredParameterTypeVariable(IMethodBinding methodBinding, int parameterIndex, ICompilationUnit cu) {
    if (methodBinding == null)
        return null;
    ParameterTypeVariable2 cv = makeParameterTypeVariable(methodBinding, parameterIndex);
    if (cv == null)
        return null;
    cv.setCompilationUnit(cu);
    return cv;
}

Example 2 with ParameterTypeVariable2

use of org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.ParameterTypeVariable2 in project che by eclipse.

the class InferTypeArgumentsConstraintCreator method addConstraintsForOverriding.

private void addConstraintsForOverriding(IMethodBinding methodBinding, ConstraintVariable2 returnTypeCv, ConstraintVariable2[] parameterTypeCvs) {
    boolean hasParameterElementCvs = false;
    for (int i = 0; i < parameterTypeCvs.length; i++) if (parameterTypeCvs[i] != null)
        hasParameterElementCvs = true;
    if (returnTypeCv == null && !hasParameterElementCvs)
        return;
    ITypeBinding[] allSuperTypes = Bindings.getAllSuperTypes(methodBinding.getDeclaringClass());
    for (int i = 0; i < allSuperTypes.length; i++) {
        ITypeBinding superType = allSuperTypes[i];
        IMethodBinding superMethod = Bindings.findOverriddenMethodInType(superType, methodBinding);
        if (superMethod == null)
            continue;
        for (int p = 0; p < parameterTypeCvs.length; p++) {
            if (parameterTypeCvs[p] == null)
                continue;
            ParameterTypeVariable2 parameterTypeCv = fTCModel.makeParameterTypeVariable(superMethod, p);
            fTCModel.createElementEqualsConstraints(parameterTypeCv, parameterTypeCvs[p]);
        }
        if (returnTypeCv != null) {
            ReturnTypeVariable2 superMethodReturnTypeCv = fTCModel.makeReturnTypeVariable(superMethod);
            fTCModel.createElementEqualsConstraints(superMethodReturnTypeCv, returnTypeCv);
        }
    }
}

Example 3 with ParameterTypeVariable2

use of org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.ParameterTypeVariable2 in project che by eclipse.

the class InferTypeArgumentsTCModel method makeParameterTypeVariable.

public ParameterTypeVariable2 makeParameterTypeVariable(IMethodBinding methodBinding, int parameterIndex) {
    if (methodBinding == null)
        return null;
    TType type = getBoxedType(methodBinding.getParameterTypes()[parameterIndex], /*no boxing*/
    null);
    if (type == null)
        return null;
    ParameterTypeVariable2 cv = new ParameterTypeVariable2(type, parameterIndex, methodBinding);
    ParameterTypeVariable2 storedCv = (ParameterTypeVariable2) storedCv(cv);
    if (storedCv == cv) {
        if (methodBinding.getDeclaringClass().isLocal() || Modifier.isPrivate(methodBinding.getModifiers()))
            fCuScopedConstraintVariables.add(cv);
        makeElementVariables(storedCv, type);
        makeArrayElementVariable(storedCv);
        if (fStoreToString)
            //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
            storedCv.setData(ConstraintVariable2.TO_STRING, "[Parameter(" + parameterIndex + "," + Bindings.asString(methodBinding) + ")]");
    }
    return storedCv;
}

Example 4 with ParameterTypeVariable2

use of org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.ParameterTypeVariable2 in project che by eclipse.

the class InferTypeArgumentsConstraintCreator method doVisitMethodInvocationArguments.

private void doVisitMethodInvocationArguments(IMethodBinding methodBinding, List<Expression> arguments, Expression receiver, Map<String, IndependentTypeVariable2> methodTypeVariables, Type createdType) {
    //TODO: connect generic method type parameters, e.g. <T> void take(T t, List<T> ts)
    ITypeBinding[] declaredParameterTypes = methodBinding.getMethodDeclaration().getParameterTypes();
    int lastParamIdx = declaredParameterTypes.length - 1;
    for (int i = 0; i < arguments.size(); i++) {
        Expression arg = arguments.get(i);
        ConstraintVariable2 argCv = getConstraintVariable(arg);
        if (argCv == null)
            continue;
        TType declaredParameterType;
        int iParam;
        if (!methodBinding.isVarargs() || i < lastParamIdx) {
            iParam = i;
            declaredParameterType = fTCModel.createTType(declaredParameterTypes[iParam]);
        } else {
            // isVararg() && i >= lastParamIdx
            iParam = lastParamIdx;
            declaredParameterType = fTCModel.createTType(declaredParameterTypes[iParam]);
            if (i == lastParamIdx && canAssignToVararg(fTCModel.createTType(arg.resolveTypeBinding()), (org.eclipse.jdt.internal.corext.refactoring.typeconstraints.types.ArrayType) declaredParameterType)) {
            //OK: argument will not be packed into an array
            } else {
                declaredParameterType = ((org.eclipse.jdt.internal.corext.refactoring.typeconstraints.types.ArrayType) declaredParameterType).getComponentType();
            }
        }
        if (declaredParameterType.isTypeVariable()) {
            ConstraintVariable2 methodTypeVariableCv = methodTypeVariables.get(declaredParameterType.getBindingKey());
            if (methodTypeVariableCv != null) {
                // e.g. t in "<T> void take(T t, List<T> ts)"
                fTCModel.createSubtypeConstraint(argCv, methodTypeVariableCv);
            } else {
                if (createdType != null) {
                    //e.g. Tuple<T1, T2>: constructor Tuple(T1 t1, T2 t2)
                    ConstraintVariable2 createdTypeCv = getConstraintVariable(createdType);
                    ConstraintVariable2 elementCv = fTCModel.getElementVariable(createdTypeCv, (TypeVariable) declaredParameterType);
                    // [arg] <= Elem[createdType]:
                    fTCModel.createSubtypeConstraint(argCv, elementCv);
                }
                if (receiver != null) {
                    //e.g. "Collection<E>: boolean add(E o)"
                    ConstraintVariable2 expressionCv = getConstraintVariable(receiver);
                    ConstraintVariable2 elementCv = fTCModel.getElementVariable(expressionCv, (TypeVariable) declaredParameterType);
                    //	//TypeVariableConstraintVariable2 typeVariableCv= fTCModel.makeTypeVariableVariable(declaredParameterType);
                    //				ConstraintVariable2 elementCv= fTCModel.makeElementVariable(expressionCv, typeVariableCv);
                    //TODO: Somebody must connect typeVariableCv to corresponding typeVariableCVs of supertypes.
                    //- Do only once for binaries.
                    //- Do when passing for sources.
                    //- Keep a flag in CV whether done?
                    //- Do in one pass over all TypeVarCvs at the end?
                    // [arg] <= Elem[receiver]:
                    fTCModel.createSubtypeConstraint(argCv, elementCv);
                } else {
                //TODO: ???
                }
            }
        } else if (declaredParameterType.isParameterizedType()) {
            TType[] typeArguments = ((ParameterizedType) declaredParameterType).getTypeArguments();
            TypeVariable[] typeParameters = ((GenericType) declaredParameterType.getTypeDeclaration()).getTypeParameters();
            for (int ta = 0; ta < typeArguments.length; ta++) {
                TType typeArgument = typeArguments[ta];
                CollectionElementVariable2 argElementCv = fTCModel.getElementVariable(argCv, typeParameters[ta]);
                if (typeArgument.isWildcardType()) {
                    // Elem[arg] <= Elem[receiver]
                    WildcardType wildcardTypeArgument = (WildcardType) typeArgument;
                    TType bound = wildcardTypeArgument.getBound();
                    if (bound != null && bound.isTypeVariable()) {
                        ConstraintVariable2 methodTypeVariableCv = methodTypeVariables.get(bound.getBindingKey());
                        if (methodTypeVariableCv != null) {
                            //e.g. in Collections: <T ..> T min(Collection<? extends T> coll):
                            createWildcardConstraint(wildcardTypeArgument, argElementCv, methodTypeVariableCv);
                        } else {
                            if (createdType != null) {
                                ConstraintVariable2 createdTypeCv = getConstraintVariable(createdType);
                                CollectionElementVariable2 elementCv = fTCModel.getElementVariable(createdTypeCv, typeParameters[ta]);
                                createWildcardConstraint(wildcardTypeArgument, argElementCv, elementCv);
                            }
                            if (receiver != null) {
                                //e.g. Collection<E>: boolean addAll(Collection<? extends E> c)
                                ConstraintVariable2 expressionCv = getConstraintVariable(receiver);
                                CollectionElementVariable2 elementCv = fTCModel.getElementVariable(expressionCv, typeParameters[ta]);
                                createWildcardConstraint(wildcardTypeArgument, argElementCv, elementCv);
                            } else {
                            //TODO: ???
                            }
                        }
                    } else {
                    //TODO
                    }
                } else if (typeArgument.isTypeVariable()) {
                    ConstraintVariable2 methodTypeVariableCv = methodTypeVariables.get(typeArgument.getBindingKey());
                    if (methodTypeVariableCv != null) {
                        //e.g. in Collections: <T> List<T> synchronizedList(List<T> list)
                        fTCModel.createEqualsConstraint(argElementCv, methodTypeVariableCv);
                    } else {
                        if (createdType != null) {
                            ConstraintVariable2 createdTypeCv = getConstraintVariable(createdType);
                            ConstraintVariable2 elementCv = fTCModel.getElementVariable(createdTypeCv, (TypeVariable) typeArgument);
                            fTCModel.createEqualsConstraint(argElementCv, elementCv);
                        }
                        if (receiver != null) {
                            ConstraintVariable2 expressionCv = getConstraintVariable(receiver);
                            ConstraintVariable2 elementCv = fTCModel.getElementVariable(expressionCv, (TypeVariable) typeArgument);
                            fTCModel.createEqualsConstraint(argElementCv, elementCv);
                        } else {
                        //TODO: ???
                        }
                    }
                } else {
                    ImmutableTypeVariable2 typeArgumentCv = fTCModel.makeImmutableTypeVariable(typeArgument);
                    fTCModel.createEqualsConstraint(argElementCv, typeArgumentCv);
                }
            }
        } else if (declaredParameterType.isArrayType()) {
            //TODO: check methodBinding.isVarargs() !
            TType declaredElementType = ((org.eclipse.jdt.internal.corext.refactoring.typeconstraints.types.ArrayType) declaredParameterType).getElementType();
            if (declaredElementType.isTypeVariable()) {
                ConstraintVariable2 methodTypeVariableCv = methodTypeVariables.get(declaredElementType.getBindingKey());
                if (methodTypeVariableCv != null) {
                    ArrayElementVariable2 argElementCv = fTCModel.getArrayElementVariable(argCv);
                    //e.g. in Arrays: <T> List<T> asList(T... a): //<T> List<T> asList(T[] a)
                    fTCModel.createEqualsConstraint(argElementCv, methodTypeVariableCv);
                } else {
                //TODO: receiver, createdType
                }
            } else {
            //TODO
            }
        } else {
            //TODO: not else, but always? Other kinds of type references?
            if (!InferTypeArgumentsTCModel.isAGenericType(declaredParameterType))
                continue;
            ParameterTypeVariable2 parameterTypeCv = fTCModel.makeParameterTypeVariable(methodBinding, iParam);
            // Elem[param] =^= Elem[arg]
            fTCModel.createElementEqualsConstraints(parameterTypeCv, argCv);
        }
    }
}