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

Example 11 with CollectionElementVariable2

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

the class InferTypeArgumentsConstraintCreator method endVisit.

@Override
public void endVisit(CastExpression node) {
    //		if (! (expressionCv instanceof CollectionElementVariable2))
    //			return; //TODO: returns too early when dealing with nested collections.
    Type type = node.getType();
    ITypeBinding typeBinding = type.resolveBinding();
    if (typeBinding.isPrimitive()) {
        ImmutableTypeVariable2 boxed = fTCModel.makeImmutableTypeVariable(typeBinding, node);
        setConstraintVariable(node, boxed);
        // avoid removing numeric conversions
        return;
    }
    ConstraintVariable2 typeCv = getConstraintVariable(type);
    if (typeCv == null)
        return;
    //TODO: can this be loosened when we remove casts?
    setConstraintVariable(node, typeCv);
    Expression expression = node.getExpression();
    ConstraintVariable2 expressionCv = getConstraintVariable(expression);
    //Avoid removing casts that have not been made obsolete by this refactoring:
    if (expressionCv == null)
        return;
    if (expressionCv instanceof ImmutableTypeVariable2)
        return;
    if (!(expressionCv instanceof TypeVariable2 || expressionCv instanceof IndependentTypeVariable2 || expressionCv instanceof CollectionElementVariable2) && fTCModel.getElementVariables(expressionCv).size() == 0 && fTCModel.getArrayElementVariable(expressionCv) == null)
        return;
    fTCModel.createAssignmentElementConstraints(typeCv, expressionCv);
    if (expression instanceof MethodInvocation) {
        MethodInvocation invoc = (MethodInvocation) expression;
        if (!isSpecialCloneInvocation(invoc.resolveMethodBinding(), invoc.getExpression())) {
            fTCModel.makeCastVariable(node, expressionCv);
        }
    } else {
        fTCModel.makeCastVariable(node, expressionCv);
    }
    boolean eitherIsIntf = typeBinding.isInterface() || expression.resolveTypeBinding().isInterface();
    if (eitherIsIntf)
        return;
//TODO: preserve up- and down-castedness!
}

Example 12 with CollectionElementVariable2

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

the class InferTypeArgumentsRefactoring method inferArguments.

public static ParameterizedType[] inferArguments(SimpleType[] types, InferTypeArgumentsUpdate update, InferTypeArgumentsTCModel model, CompilationUnitRewrite rewrite) {
    for (int i = 0; i < types.length; i++) {
        types[i].setProperty(REWRITTEN, null);
    }
    List<ParameterizedType> result = new ArrayList<ParameterizedType>();
    HashMap<ICompilationUnit, CuUpdate> updates = update.getUpdates();
    Set<Entry<ICompilationUnit, CuUpdate>> entrySet = updates.entrySet();
    for (Iterator<Entry<ICompilationUnit, CuUpdate>> iter = entrySet.iterator(); iter.hasNext(); ) {
        Entry<ICompilationUnit, CuUpdate> entry = iter.next();
        rewrite.setResolveBindings(false);
        CuUpdate cuUpdate = entry.getValue();
        for (Iterator<CollectionElementVariable2> cvIter = cuUpdate.getDeclarations().iterator(); cvIter.hasNext(); ) {
            ConstraintVariable2 cv = cvIter.next();
            ParameterizedType newNode = rewriteConstraintVariable(cv, rewrite, model, false, types);
            if (newNode != null)
                result.add(newNode);
        }
    }
    return result.toArray(new ParameterizedType[result.size()]);
}

Example 13 with CollectionElementVariable2

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

the class InferTypeArgumentsRefactoring method getTypeArgumentCvs.

private static ArrayList<CollectionElementVariable2> getTypeArgumentCvs(ConstraintVariable2 baseCv, InferTypeArgumentsTCModel tCModel) {
    Map<String, CollectionElementVariable2> elementCvs = tCModel.getElementVariables(baseCv);
    ArrayList<CollectionElementVariable2> typeArgumentCvs = new ArrayList<CollectionElementVariable2>();
    for (Iterator<CollectionElementVariable2> iter = elementCvs.values().iterator(); iter.hasNext(); ) {
        CollectionElementVariable2 elementCv = iter.next();
        int index = elementCv.getDeclarationTypeVariableIndex();
        if (index != CollectionElementVariable2.NOT_DECLARED_TYPE_VARIABLE_INDEX) {
            while (index >= typeArgumentCvs.size()) // fill with null until set(index, ..) is possible
            typeArgumentCvs.add(null);
            typeArgumentCvs.set(index, elementCv);
        }
    }
    return typeArgumentCvs;
}

Example 14 with CollectionElementVariable2

use of org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.CollectionElementVariable2 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);
        }
    }
}

Example 15 with CollectionElementVariable2

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

the class InferTypeArgumentsConstraintCreator method endVisit.

@Override
public void endVisit(VariableDeclarationFragment node) {
    VariableVariable2 cv = fTCModel.makeDeclaredVariableVariable(node.resolveBinding(), fCU);
    if (cv == null)
        return;
    setConstraintVariable(node, cv);
    //TODO: prune unused CV for local variables (but not fields)
    Expression initializer = node.getInitializer();
    if (initializer == null)
        return;
    ConstraintVariable2 initializerCv = getConstraintVariable(initializer);
    if (initializerCv == null)
        return;
    fTCModel.createElementEqualsConstraints(cv, initializerCv);
// name= initializer  -->  [initializer] <= [name]
//		if (initializerCv instanceof CollectionElementVariable2)
//			fTCModel.createSubtypeConstraint(initializerCv, cv);
}