Examples with Wildcard org.eclipse.jdt.internal.compiler.ast.Wildcard used on opensource projects

Example 1 with Wildcard

use of org.eclipse.jdt.internal.compiler.ast.Wildcard in project lombok by rzwitserloot.

the class HandleEqualsAndHashCode method wildcardify.

private TypeReference[] wildcardify(int pS, int pE, ASTNode source, int count) {
    if (count == 0)
        return null;
    TypeReference[] typeArgs = new TypeReference[count];
    for (int i = 0; i < count; i++) {
        typeArgs[i] = new Wildcard(Wildcard.UNBOUND);
        typeArgs[i].sourceStart = pS;
        typeArgs[i].sourceEnd = pE;
        setGeneratedBy(typeArgs[i], source);
    }
    return typeArgs;
}

Example 2 with Wildcard

use of org.eclipse.jdt.internal.compiler.ast.Wildcard in project lombok by rzwitserloot.

the class EclipseHandlerUtil method copyType.

/**
 * You can't share TypeReference objects or subtle errors start happening.
 * Unfortunately the TypeReference type hierarchy is complicated and there's no clone
 * method on TypeReference itself. This method can clone them.
 */
public static TypeReference copyType(TypeReference ref, ASTNode source) {
    if (ref instanceof ParameterizedQualifiedTypeReference) {
        ParameterizedQualifiedTypeReference iRef = (ParameterizedQualifiedTypeReference) ref;
        TypeReference[][] args = null;
        if (iRef.typeArguments != null) {
            args = new TypeReference[iRef.typeArguments.length][];
            int idx = 0;
            for (TypeReference[] inRefArray : iRef.typeArguments) {
                if (inRefArray == null)
                    args[idx++] = null;
                else {
                    TypeReference[] outRefArray = new TypeReference[inRefArray.length];
                    int idx2 = 0;
                    for (TypeReference inRef : inRefArray) {
                        outRefArray[idx2++] = copyType(inRef, source);
                    }
                    args[idx++] = outRefArray;
                }
            }
        }
        TypeReference typeRef = new ParameterizedQualifiedTypeReference(iRef.tokens, args, iRef.dimensions(), copy(iRef.sourcePositions));
        if (source != null)
            setGeneratedBy(typeRef, source);
        return typeRef;
    }
    if (ref instanceof ArrayQualifiedTypeReference) {
        ArrayQualifiedTypeReference iRef = (ArrayQualifiedTypeReference) ref;
        TypeReference typeRef = new ArrayQualifiedTypeReference(iRef.tokens, iRef.dimensions(), copy(iRef.sourcePositions));
        if (source != null)
            setGeneratedBy(typeRef, source);
        return typeRef;
    }
    if (ref instanceof QualifiedTypeReference) {
        QualifiedTypeReference iRef = (QualifiedTypeReference) ref;
        TypeReference typeRef = new QualifiedTypeReference(iRef.tokens, copy(iRef.sourcePositions));
        if (source != null)
            setGeneratedBy(typeRef, source);
        return typeRef;
    }
    if (ref instanceof ParameterizedSingleTypeReference) {
        ParameterizedSingleTypeReference iRef = (ParameterizedSingleTypeReference) ref;
        TypeReference[] args = null;
        if (iRef.typeArguments != null) {
            args = new TypeReference[iRef.typeArguments.length];
            int idx = 0;
            for (TypeReference inRef : iRef.typeArguments) {
                if (inRef == null)
                    args[idx++] = null;
                else
                    args[idx++] = copyType(inRef, source);
            }
        }
        TypeReference typeRef = new ParameterizedSingleTypeReference(iRef.token, args, iRef.dimensions(), (long) iRef.sourceStart << 32 | iRef.sourceEnd);
        if (source != null)
            setGeneratedBy(typeRef, source);
        return typeRef;
    }
    if (ref instanceof ArrayTypeReference) {
        ArrayTypeReference iRef = (ArrayTypeReference) ref;
        TypeReference typeRef = new ArrayTypeReference(iRef.token, iRef.dimensions(), (long) iRef.sourceStart << 32 | iRef.sourceEnd);
        if (source != null)
            setGeneratedBy(typeRef, source);
        return typeRef;
    }
    if (ref instanceof Wildcard) {
        Wildcard original = (Wildcard) ref;
        Wildcard wildcard = new Wildcard(original.kind);
        wildcard.sourceStart = original.sourceStart;
        wildcard.sourceEnd = original.sourceEnd;
        if (original.bound != null)
            wildcard.bound = copyType(original.bound, source);
        if (source != null)
            setGeneratedBy(wildcard, source);
        return wildcard;
    }
    if (ref instanceof SingleTypeReference) {
        SingleTypeReference iRef = (SingleTypeReference) ref;
        TypeReference typeRef = new SingleTypeReference(iRef.token, (long) iRef.sourceStart << 32 | iRef.sourceEnd);
        if (source != null)
            setGeneratedBy(typeRef, source);
        return typeRef;
    }
    return ref;
}

Example 3 with Wildcard

use of org.eclipse.jdt.internal.compiler.ast.Wildcard in project spoon by INRIA.

the class ReferenceBuilder method buildTypeReferenceInternal.

private <T> CtTypeReference<T> buildTypeReferenceInternal(CtTypeReference<T> typeReference, TypeReference type, Scope scope) {
    if (type == null) {
        return null;
    }
    CtTypeReference<?> currentReference = typeReference;
    for (int position = type.getTypeName().length - 1; position >= 0; position--) {
        if (currentReference == null) {
            break;
        }
        this.jdtTreeBuilder.getContextBuilder().enter(currentReference, type);
        if (type.annotations != null && type.annotations.length - 1 <= position && type.annotations[position] != null && type.annotations[position].length > 0) {
            for (Annotation annotation : type.annotations[position]) {
                if (scope instanceof ClassScope) {
                    annotation.traverse(this.jdtTreeBuilder, (ClassScope) scope);
                } else if (scope instanceof BlockScope) {
                    annotation.traverse(this.jdtTreeBuilder, (BlockScope) scope);
                } else {
                    annotation.traverse(this.jdtTreeBuilder, (BlockScope) null);
                }
            }
        }
        if (type.getTypeArguments() != null && type.getTypeArguments().length - 1 <= position && type.getTypeArguments()[position] != null && type.getTypeArguments()[position].length > 0) {
            currentReference.getActualTypeArguments().clear();
            for (TypeReference typeArgument : type.getTypeArguments()[position]) {
                if (typeArgument instanceof Wildcard || typeArgument.resolvedType instanceof WildcardBinding || typeArgument.resolvedType instanceof TypeVariableBinding) {
                    currentReference.addActualTypeArgument(buildTypeParameterReference(typeArgument, scope));
                } else {
                    currentReference.addActualTypeArgument(buildTypeReference(typeArgument, scope));
                }
            }
        } else if ((type instanceof ParameterizedSingleTypeReference || type instanceof ParameterizedQualifiedTypeReference) && !isTypeArgumentExplicit(type.getTypeArguments())) {
            for (CtTypeReference<?> actualTypeArgument : currentReference.getActualTypeArguments()) {
                actualTypeArgument.setImplicit(true);
                if (actualTypeArgument instanceof CtArrayTypeReference) {
                    ((CtArrayTypeReference) actualTypeArgument).getComponentType().setImplicit(true);
                }
            }
        }
        if (type instanceof Wildcard && typeReference instanceof CtTypeParameterReference) {
            ((CtTypeParameterReference) typeReference).setBoundingType(buildTypeReference(((Wildcard) type).bound, scope));
        }
        this.jdtTreeBuilder.getContextBuilder().exit(type);
        currentReference = currentReference.getDeclaringType();
    }
    return typeReference;
}

Example 4 with Wildcard

use of org.eclipse.jdt.internal.compiler.ast.Wildcard in project lombok by rzwitserloot.

the class EclipseHandlerUtil method makeType.

public static TypeReference makeType(TypeBinding binding, ASTNode pos, boolean allowCompound) {
    int dims = binding.dimensions();
    binding = binding.leafComponentType();
    // Primitives
    char[] base = null;
    switch(binding.id) {
        case TypeIds.T_int:
            base = TypeConstants.INT;
            break;
        case TypeIds.T_long:
            base = TypeConstants.LONG;
            break;
        case TypeIds.T_short:
            base = TypeConstants.SHORT;
            break;
        case TypeIds.T_byte:
            base = TypeConstants.BYTE;
            break;
        case TypeIds.T_double:
            base = TypeConstants.DOUBLE;
            break;
        case TypeIds.T_float:
            base = TypeConstants.FLOAT;
            break;
        case TypeIds.T_boolean:
            base = TypeConstants.BOOLEAN;
            break;
        case TypeIds.T_char:
            base = TypeConstants.CHAR;
            break;
        case TypeIds.T_void:
            base = TypeConstants.VOID;
            break;
        case TypeIds.T_null:
            return null;
    }
    if (base != null) {
        if (dims > 0) {
            TypeReference result = new ArrayTypeReference(base, dims, pos(pos));
            setGeneratedBy(result, pos);
            return result;
        }
        TypeReference result = new SingleTypeReference(base, pos(pos));
        setGeneratedBy(result, pos);
        return result;
    }
    if (binding.isAnonymousType()) {
        ReferenceBinding ref = (ReferenceBinding) binding;
        ReferenceBinding[] supers = ref.superInterfaces();
        if (supers == null || supers.length == 0)
            supers = new ReferenceBinding[] { ref.superclass() };
        if (supers[0] == null) {
            TypeReference result = new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, poss(pos, 3));
            setGeneratedBy(result, pos);
            return result;
        }
        return makeType(supers[0], pos, false);
    }
    if (binding instanceof CaptureBinding) {
        return makeType(((CaptureBinding) binding).wildcard, pos, allowCompound);
    }
    if (binding.isUnboundWildcard()) {
        if (!allowCompound) {
            TypeReference result = new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, poss(pos, 3));
            setGeneratedBy(result, pos);
            return result;
        } else {
            Wildcard out = new Wildcard(Wildcard.UNBOUND);
            setGeneratedBy(out, pos);
            out.sourceStart = pos.sourceStart;
            out.sourceEnd = pos.sourceEnd;
            return out;
        }
    }
    if (binding.isWildcard()) {
        WildcardBinding wildcard = (WildcardBinding) binding;
        if (wildcard.boundKind == Wildcard.EXTENDS) {
            if (!allowCompound) {
                return makeType(wildcard.bound, pos, false);
            } else {
                Wildcard out = new Wildcard(Wildcard.EXTENDS);
                setGeneratedBy(out, pos);
                out.bound = makeType(wildcard.bound, pos, false);
                out.sourceStart = pos.sourceStart;
                out.sourceEnd = pos.sourceEnd;
                return out;
            }
        } else if (allowCompound && wildcard.boundKind == Wildcard.SUPER) {
            Wildcard out = new Wildcard(Wildcard.SUPER);
            setGeneratedBy(out, pos);
            out.bound = makeType(wildcard.bound, pos, false);
            out.sourceStart = pos.sourceStart;
            out.sourceEnd = pos.sourceEnd;
            return out;
        } else {
            TypeReference result = new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, poss(pos, 3));
            setGeneratedBy(result, pos);
            return result;
        }
    }
    // Keep moving up via 'binding.enclosingType()' and gather generics from each binding. We stop after a local type, or a static type, or a top-level type.
    // Finally, add however many nullTypeArgument[] arrays as that are missing, inverse the list, toArray it, and use that as PTR's typeArgument argument.
    List<TypeReference[]> params = new ArrayList<TypeReference[]>();
    /* Calculate generics */
    {
        TypeBinding b = binding;
        while (true) {
            boolean isFinalStop = b.isLocalType() || !b.isMemberType() || b.enclosingType() == null;
            TypeReference[] tyParams = null;
            if (b instanceof ParameterizedTypeBinding) {
                ParameterizedTypeBinding paramized = (ParameterizedTypeBinding) b;
                if (paramized.arguments != null) {
                    tyParams = new TypeReference[paramized.arguments.length];
                    for (int i = 0; i < tyParams.length; i++) {
                        tyParams[i] = makeType(paramized.arguments[i], pos, true);
                    }
                }
            }
            params.add(tyParams);
            if (isFinalStop)
                break;
            b = b.enclosingType();
        }
    }
    char[][] parts;
    if (binding.isTypeVariable()) {
        parts = new char[][] { binding.shortReadableName() };
    } else if (binding.isLocalType()) {
        parts = new char[][] { binding.sourceName() };
    } else {
        String[] pkg = new String(binding.qualifiedPackageName()).split("\\.");
        String[] name = new String(binding.qualifiedSourceName()).split("\\.");
        if (pkg.length == 1 && pkg[0].isEmpty())
            pkg = new String[0];
        parts = new char[pkg.length + name.length][];
        int ptr;
        for (ptr = 0; ptr < pkg.length; ptr++) parts[ptr] = pkg[ptr].toCharArray();
        for (; ptr < pkg.length + name.length; ptr++) parts[ptr] = name[ptr - pkg.length].toCharArray();
    }
    while (params.size() < parts.length) params.add(null);
    Collections.reverse(params);
    boolean isParamized = false;
    for (TypeReference[] tyParams : params) {
        if (tyParams != null) {
            isParamized = true;
            break;
        }
    }
    if (isParamized) {
        if (parts.length > 1) {
            TypeReference[][] typeArguments = params.toArray(new TypeReference[0][]);
            TypeReference result = new ParameterizedQualifiedTypeReference(parts, typeArguments, dims, poss(pos, parts.length));
            setGeneratedBy(result, pos);
            return result;
        }
        TypeReference result = new ParameterizedSingleTypeReference(parts[0], params.get(0), dims, pos(pos));
        setGeneratedBy(result, pos);
        return result;
    }
    if (dims > 0) {
        if (parts.length > 1) {
            TypeReference result = new ArrayQualifiedTypeReference(parts, dims, poss(pos, parts.length));
            setGeneratedBy(result, pos);
            return result;
        }
        TypeReference result = new ArrayTypeReference(parts[0], dims, pos(pos));
        setGeneratedBy(result, pos);
        return result;
    }
    if (parts.length > 1) {
        TypeReference result = new QualifiedTypeReference(parts, poss(pos, parts.length));
        setGeneratedBy(result, pos);
        return result;
    }
    TypeReference result = new SingleTypeReference(parts[0], pos(pos));
    setGeneratedBy(result, pos);
    return result;
}