Example usage for org.eclipse.jdt.core Signature WILDCARD_TYPE

Introduction

In this page you can find the example usage for org.eclipse.jdt.core Signature WILDCARD_TYPE_SIGNATURE.

Prototype

int WILDCARD_TYPE_SIGNATURE

To view the source code for org.eclipse.jdt.core Signature WILDCARD_TYPE_SIGNATURE.

Click Source Link

Document

Kind constant for a wildcard type signature.

Usage

From source file:at.bestsolution.fxide.jdt.corext.util.MethodOverrideTester.java

License:Open Source License

private StringBuffer internalGetSubstitutedTypeName(String typeSig, IMember context, boolean erasure,
        StringBuffer buf) throws JavaModelException {
    int sigKind = Signature.getTypeSignatureKind(typeSig);
    switch (sigKind) {
    case Signature.BASE_TYPE_SIGNATURE:
        return buf.append(Signature.toString(typeSig));
    case Signature.ARRAY_TYPE_SIGNATURE:
        internalGetSubstitutedTypeName(Signature.getElementType(typeSig), context, erasure, buf);
        for (int i = Signature.getArrayCount(typeSig); i > 0; i--) {
            buf.append('[').append(']');
        }/*from   ww  w. j  a  v a 2 s  .c  om*/
        return buf;
    case Signature.CLASS_TYPE_SIGNATURE: {
        String erasureSig = Signature.getTypeErasure(typeSig);
        String erasureName = Signature.getSimpleName(Signature.toString(erasureSig));

        char ch = erasureSig.charAt(0);
        if (ch == Signature.C_RESOLVED) {
            buf.append(erasureName);
        } else if (ch == Signature.C_UNRESOLVED) { // could be a type variable
            if (erasure) {
                buf.append(getVariableErasure(context, erasureName));
            } else {
                buf.append(getVariableSubstitution(context, erasureName));
            }
        } else {
            Assert.isTrue(false, "Unknown class type signature"); //$NON-NLS-1$
        }
        if (!erasure) {
            String[] typeArguments = Signature.getTypeArguments(typeSig);
            if (typeArguments.length > 0) {
                buf.append('<');
                for (int i = 0; i < typeArguments.length; i++) {
                    if (i > 0) {
                        buf.append(',');
                    }
                    internalGetSubstitutedTypeName(typeArguments[i], context, erasure, buf);
                }
                buf.append('>');
            }
        }
        return buf;
    }
    case Signature.TYPE_VARIABLE_SIGNATURE:
        String varName = Signature.toString(typeSig);
        if (erasure) {
            return buf.append(getVariableErasure(context, varName));
        } else {
            return buf.append(getVariableSubstitution(context, varName));
        }
    case Signature.WILDCARD_TYPE_SIGNATURE: {
        buf.append('?');
        char ch = typeSig.charAt(0);
        if (ch == Signature.C_STAR) {
            return buf;
        } else if (ch == Signature.C_EXTENDS) {
            buf.append(" extends "); //$NON-NLS-1$
        } else {
            buf.append(" super "); //$NON-NLS-1$
        }
        return internalGetSubstitutedTypeName(typeSig.substring(1), context, erasure, buf);
    }
    case Signature.CAPTURE_TYPE_SIGNATURE:
        return internalGetSubstitutedTypeName(typeSig.substring(1), context, erasure, buf);
    default:
        Assert.isTrue(false, "Unhandled type signature kind"); //$NON-NLS-1$
        return buf;
    }
}

From source file:at.bestsolution.fxide.jdt.text.viewersupport.JavaElementLabelComposer.java

License:Open Source License

protected void appendTypeSignatureLabel(IJavaElement enclosingElement, String typeSig, long flags) {
    int sigKind = Signature.getTypeSignatureKind(typeSig);
    switch (sigKind) {
    case Signature.BASE_TYPE_SIGNATURE:
        fBuffer.append(Signature.toString(typeSig));
        break;//www  . j av  a2s.  c o  m
    case Signature.ARRAY_TYPE_SIGNATURE:
        appendTypeSignatureLabel(enclosingElement, Signature.getElementType(typeSig), flags);
        for (int dim = Signature.getArrayCount(typeSig); dim > 0; dim--) {
            fBuffer.append('[').append(']');
        }
        break;
    case Signature.CLASS_TYPE_SIGNATURE:
        String baseType = getSimpleTypeName(enclosingElement, typeSig);
        fBuffer.append(baseType);

        String[] typeArguments = Signature.getTypeArguments(typeSig);
        appendTypeArgumentSignaturesLabel(enclosingElement, typeArguments, flags);
        break;
    case Signature.TYPE_VARIABLE_SIGNATURE:
        fBuffer.append(getSimpleTypeName(enclosingElement, typeSig));
        break;
    case Signature.WILDCARD_TYPE_SIGNATURE:
        char ch = typeSig.charAt(0);
        if (ch == Signature.C_STAR) { //workaround for bug 85713
            fBuffer.append('?');
        } else {
            if (ch == Signature.C_EXTENDS) {
                fBuffer.append("? extends "); //$NON-NLS-1$
                appendTypeSignatureLabel(enclosingElement, typeSig.substring(1), flags);
            } else if (ch == Signature.C_SUPER) {
                fBuffer.append("? super "); //$NON-NLS-1$
                appendTypeSignatureLabel(enclosingElement, typeSig.substring(1), flags);
            }
        }
        break;
    case Signature.CAPTURE_TYPE_SIGNATURE:
        appendTypeSignatureLabel(enclosingElement, typeSig.substring(1), flags);
        break;
    case Signature.INTERSECTION_TYPE_SIGNATURE:
        String[] typeBounds = Signature.getIntersectionTypeBounds(typeSig);
        appendTypeBoundsSignaturesLabel(enclosingElement, typeBounds, flags);
        break;
    default:
        // unknown
    }
}

From source file:ca.uvic.chisel.javasketch.internal.JavaSearchUtils.java

License:Open Source License

public static boolean isSimilar(IMethod method1, IMethod method2) {
    String[] myParams = method1.getParameterTypes();
    String[] theirParams = method2.getParameterTypes();
    int myParamsLength = myParams.length;
    String[] simpleNames = new String[myParamsLength];
    for (int i = 0; i < myParamsLength; i++) {
        String erasure = Signature.getTypeErasure(myParams[i]);
        simpleNames[i] = Signature.getSimpleName(Signature.toString(erasure));
    }/*from   w w w.j a v a 2 s  . c o m*/
    String name = method1.getElementName();
    if (name.equals(method2.getElementName())) {

        if (myParamsLength == theirParams.length) {
            for (int i = 0; i < myParamsLength; i++) {

                String mySimpleName = simpleNames[i];
                String simpleName2 = Signature
                        .getSimpleName(Signature.toString(Signature.getTypeErasure(theirParams[i])));
                //first, check for generics. If my param is not generic,
                //but theirs is, it is a match.
                int myTypeKind = Signature.getTypeSignatureKind(myParams[i]);
                int theirTypeKind = Signature.getTypeSignatureKind(theirParams[i]);
                switch (theirTypeKind) {
                case Signature.TYPE_VARIABLE_SIGNATURE:
                case Signature.WILDCARD_TYPE_SIGNATURE:
                case Signature.CAPTURE_TYPE_SIGNATURE:
                    switch (myTypeKind) {
                    case Signature.CLASS_TYPE_SIGNATURE:
                    case Signature.ARRAY_TYPE_SIGNATURE:
                        continue;
                    }
                }
                //otherwise, try and match exactly
                if (!mySimpleName.equals(simpleName2)) {
                    return false;
                }
            }
            return true;
        }
    }
    return false;
}

From source file:com.codenvy.ide.ext.java.server.SourcesFromBytecodeGenerator.java

License:Open Source License

protected void appendTypeSignatureLabel(IJavaElement enclosingElement, String typeSig, long flags,
        StringBuilder builder) {/*w  w  w.  ja v a2 s .c  om*/
    int sigKind = Signature.getTypeSignatureKind(typeSig);
    switch (sigKind) {
    case Signature.BASE_TYPE_SIGNATURE:
        builder.append(Signature.toString(typeSig));
        break;
    case Signature.ARRAY_TYPE_SIGNATURE:
        appendTypeSignatureLabel(enclosingElement, Signature.getElementType(typeSig), flags, builder);
        for (int dim = Signature.getArrayCount(typeSig); dim > 0; dim--) {
            builder.append('[').append(']');
        }
        break;
    case Signature.CLASS_TYPE_SIGNATURE:
        String baseType = getSimpleTypeName(enclosingElement, typeSig);
        builder.append(baseType);

        String[] typeArguments = Signature.getTypeArguments(typeSig);
        appendTypeArgumentSignaturesLabel(enclosingElement, typeArguments, flags, builder);
        break;
    case Signature.TYPE_VARIABLE_SIGNATURE:
        builder.append(getSimpleTypeName(enclosingElement, typeSig));
        break;
    case Signature.WILDCARD_TYPE_SIGNATURE:
        char ch = typeSig.charAt(0);
        if (ch == Signature.C_STAR) { //workaround for bug 85713
            builder.append('?');
        } else {
            if (ch == Signature.C_EXTENDS) {
                builder.append("? extends "); //$NON-NLS-1$
                appendTypeSignatureLabel(enclosingElement, typeSig.substring(1), flags, builder);
            } else if (ch == Signature.C_SUPER) {
                builder.append("? super "); //$NON-NLS-1$
                appendTypeSignatureLabel(enclosingElement, typeSig.substring(1), flags, builder);
            }
        }
        break;
    case Signature.CAPTURE_TYPE_SIGNATURE:
        appendTypeSignatureLabel(enclosingElement, typeSig.substring(1), flags, builder);
        break;
    case Signature.INTERSECTION_TYPE_SIGNATURE:
        String[] typeBounds = Signature.getIntersectionTypeBounds(typeSig);
        appendTypeBoundsSignaturesLabel(enclosingElement, typeBounds, flags, builder);
        break;
    default:
        // unknown
    }
}

From source file:com.google.inject.tools.ideplugin.eclipse.TypeUtil.java

License:Open Source License

/**
 * Resolve typeSignature in the context of owningType.  This method will return 
 * a type erased signture if eraseTypeParameters == true and will attempt to
 * resolve and include parameters if eraseTypeParamters == false
 * //from w w w.ja  v  a 2 s. com
 * NOTE: special rules apply to the way unresolved type parameters and wildcards
 * are resolved:
 * 
 * 1) If a fully unresolved type parameter is found, then it will be replaced with Ljava.lang.Object;
 * 
 * i.e.  List<T>  -> Ljava.util.List<Ljava.lang.Object;>;  for any unresolved T.
 * 
 * 2) Any bounded wildcard will be replaced by the bound:
 * 
 * i.e. List<? extends String> -> Ljava.util.List<Ljava.lang.String;>;
 * i.e. List<? super String> -> Ljava.util.List<Ljava.lang.String;>;
 * 
 * Note limitation here: bounds that use 'super' will take the "best case" scenario that the list
 * type is of that type.
 * 
 * 3) The unbounded wildcard will be replaced by Ljava.lang.Object;
 * 
 * i.e. List<?> -> Ljava.util.List<Ljava.lang.Object;>;
 * 
 * 
 * The reason for this substition is to return the most accurate reasonable approximation
 * of the type within what is known by owningType
 * 
 * @param owningType
 * @param typeSignature
 * @param eraseTypeParameters if set to false, type parameters are resolved included
 * in the signature
 * @return the resolved type signature for typeSignature in owningType or
 * typeSignature unchanged if cannot resolve.
 */
public static String resolveTypeSignature(final IType owningType, final String typeSignature,
        boolean eraseTypeParameters) {
    final int sigKind = Signature.getTypeSignatureKind(typeSignature);

    switch (sigKind) {
    case Signature.BASE_TYPE_SIGNATURE:
        return typeSignature;

    case Signature.ARRAY_TYPE_SIGNATURE: {
        final String elementType = Signature.getElementType(typeSignature);

        if (Signature.getTypeSignatureKind(elementType) == Signature.BASE_TYPE_SIGNATURE) {
            return typeSignature;
        }

        final String resolvedElementType = resolveSignatureRelative(owningType, elementType,
                eraseTypeParameters);
        String resultType = ""; //$NON-NLS-1$
        for (int i = 0; i < Signature.getArrayCount(typeSignature); i++) {
            resultType += Signature.C_ARRAY;
        }

        return resultType + resolvedElementType;
    }

    case Signature.TYPE_VARIABLE_SIGNATURE:
        return resolveSignatureRelative(owningType, typeSignature, eraseTypeParameters);

    case Signature.CLASS_TYPE_SIGNATURE:
        return resolveSignatureRelative(owningType, typeSignature, eraseTypeParameters);

    case Signature.WILDCARD_TYPE_SIGNATURE:
        // strip the wildcard and try again.  Too bad Signature doesn't seem to have a method
        // for this
        if (typeSignature.charAt(0) == Signature.C_STAR) {
            return TypeConstants.TYPE_JAVAOBJECT;
        }
        return resolveTypeSignature(owningType, typeSignature.substring(1), eraseTypeParameters);

    case Signature.CAPTURE_TYPE_SIGNATURE:
        // strip the capture and try again
        return resolveTypeSignature(owningType, Signature.removeCapture(typeSignature), eraseTypeParameters);
    //      case Signature.TYPE_VARIABLE_SIGNATURE:
    //      resolveSignatureRelative(owningType, typeSignature, eraseTypeParameters);

    default:
        return typeSignature;
    }
}

From source file:com.google.inject.tools.ideplugin.eclipse.TypeUtil.java

License:Open Source License

/**
 * @param owningType -- type relative to which typeSignature will be resolved
 * @param typeSignature -- non-array type signature
 * @return the resolved type signature if possible or typeSignature if not
 *//*from w  w w .  jav  a  2 s . com*/
private static String resolveSignatureRelative(final IType owningType, final String typeSignature,
        final boolean eraseTypeParameters) {
    // if already fully resolved, return the input
    if (typeSignature.charAt(0) == Signature.C_RESOLVED) {
        return typeSignature;
    }

    List<String> typeParameters = new ArrayList<String>();

    IType resolvedType = resolveTypeRelative(owningType, typeSignature);

    if (resolvedType != null) {
        if (!eraseTypeParameters) {
            // ensure that type parameters are resolved recursively
            for (String typeParam : Signature.getTypeArguments(typeSignature)) {
                typeParam = Signature.removeCapture(typeParam);
                // check and remove bound wildcarding (extends/super/?)
                if (Signature.getTypeSignatureKind(typeParam) == Signature.WILDCARD_TYPE_SIGNATURE) {
                    // convert ? to Object, strip extends/super
                    if (typeParam.charAt(0) == Signature.C_STAR) {
                        typeParam = TypeConstants.TYPE_JAVAOBJECT;
                    } else {
                        typeParam = typeParam.substring(1);
                    }
                }
                final String resolvedParameter = resolveSignatureRelative(
                        // use the enclosing type, 
                        // *not* the resolved type because 
                        // we need to resolve in that context
                        owningType, typeParam, eraseTypeParameters);
                typeParameters.add(resolvedParameter);
            }
        }

        final String resolvedTypeSignature = Signature.createTypeSignature(resolvedType.getFullyQualifiedName(),
                true);

        if (typeParameters.size() > 0 && !eraseTypeParameters) {
            StringBuffer sb = new StringBuffer(resolvedTypeSignature);

            if (sb.charAt(sb.length() - 1) == ';') {
                sb = sb.delete(sb.length() - 1, sb.length());
            }

            sb.append("<"); //$NON-NLS-1$
            for (String param : typeParameters) {
                //System.out.println("type param: "+resolvedType.getTypeParameter(param));
                sb.append(param);
            }

            // replace the dangling ',' with the closing ">"
            sb.append(">;"); //$NON-NLS-1$
            return sb.toString();
        }

        return resolvedTypeSignature;
    }

    if (Signature.getTypeSignatureKind(typeSignature) == Signature.CLASS_TYPE_SIGNATURE
            || Signature.getTypeSignatureKind(typeSignature) == Signature.TYPE_VARIABLE_SIGNATURE) {
        // if we are unable to resolve, check to see if the owning type has
        // a parameter by this name
        ITypeParameter typeParam = owningType.getTypeParameter(Signature.getSignatureSimpleName(typeSignature));

        // if we have a type parameter and it hasn't been resolved to a type,
        // then assume it is a method template placeholder (i.e. T in ArrayList).
        // at runtime these unresolved parameter variables are effectively 
        // turned into Object's.  For example, think List.add(E o).  At runtime,
        // E will behave exactly like java.lang.Object in that signature
        if (typeParam.exists()) {
            return TypeConstants.TYPE_JAVAOBJECT;
        }
    }

    return typeSignature;
}

From source file:edu.uci.ics.sourcerer.extractor.ast.ClassFileExtractor.java

License:Open Source License

private static String typeSignatureToFqn(String signature) {
    try {//from www .j av a  2 s . co m
        switch (Signature.getTypeSignatureKind(signature)) {
        case Signature.ARRAY_TYPE_SIGNATURE:
            return typeSignatureToFqn(Signature.getElementType(signature))
                    + brackets.substring(0, 2 * Signature.getArrayCount(signature));
        case Signature.CLASS_TYPE_SIGNATURE:
            String args[] = Signature.getTypeArguments(signature);
            if (args.length == 0) {
                int firstDollar = signature.indexOf('$');
                if (firstDollar == -1) {
                    return Signature.getSignatureQualifier(signature) + "."
                            + Signature.getSignatureSimpleName(signature);
                } else {
                    String shortSig = signature.substring(0, firstDollar) + ";";
                    return Signature.getSignatureQualifier(shortSig) + "."
                            + Signature.getSignatureSimpleName(shortSig)
                            + signature.substring(firstDollar, signature.length() - 1);
                }
            } else {
                StringBuilder fqnBuilder = new StringBuilder(
                        typeSignatureToFqn(Signature.getTypeErasure(signature)));
                fqnBuilder.append('<');
                boolean first = true;
                for (String arg : args) {
                    if (first) {
                        first = false;
                    } else {
                        fqnBuilder.append(',');
                    }
                    fqnBuilder.append(typeSignatureToFqn(arg));
                }
                fqnBuilder.append('>');
                return fqnBuilder.toString();
            }
        case Signature.BASE_TYPE_SIGNATURE:
            return Signature.getSignatureSimpleName(signature);
        case Signature.TYPE_VARIABLE_SIGNATURE:
            return "<" + Signature.getSignatureSimpleName(signature) + ">";
        case Signature.WILDCARD_TYPE_SIGNATURE:
            if (signature.startsWith("+")) {
                return "<?+" + typeSignatureToFqn(signature.substring(1)) + ">";
            } else if (signature.startsWith("-")) {
                return "<?-" + typeSignatureToFqn(signature.substring(1)) + ">";
            } else {
                return "<?>";
            }
        case Signature.CAPTURE_TYPE_SIGNATURE:
            System.out.println("eek");
            return "";
        default:
            throw new IllegalArgumentException("Not a valid type signature");
        }
    } catch (Exception e) {
        e.printStackTrace();
        System.out.println("bad");
        return null;
    }
}

From source file:edu.uci.ics.sourcerer.tools.java.extractor.eclipse.ClassFileExtractor.java

License:Open Source License

private static String typeSignatureToFqn(String signature) {
    try {/*from  ww  w .j a va  2s  . co  m*/
        switch (Signature.getTypeSignatureKind(signature)) {
        case Signature.ARRAY_TYPE_SIGNATURE:
            return typeSignatureToFqn(Signature.getElementType(signature))
                    + brackets.substring(0, 2 * Signature.getArrayCount(signature));
        case Signature.CLASS_TYPE_SIGNATURE:
            if (signature.indexOf('<') == -1) {
                int firstDollar = signature.indexOf('$');
                if (firstDollar == -1) {
                    return Signature.getSignatureQualifier(signature) + "."
                            + Signature.getSignatureSimpleName(signature);
                } else {
                    String shortSig = signature.substring(0, firstDollar) + ";";
                    return Signature.getSignatureQualifier(shortSig) + "."
                            + Signature.getSignatureSimpleName(shortSig)
                            + signature.substring(firstDollar, signature.length() - 1);
                }
            } else {
                StringBuilder fqnBuilder = new StringBuilder();
                StringBuilder current = new StringBuilder();
                int depth = 0;
                boolean dollar = false;
                for (char c : signature.toCharArray()) {
                    switch (c) {
                    case '<':
                        if (fqnBuilder.length() == 0) {
                            current.append(';');
                            fqnBuilder.append(typeSignatureToFqn(current.toString()));
                            current.setLength(current.length() - 1);
                        }
                        current.append(c);
                        depth++;
                        break;
                    case '>':
                        current.append(c);
                        if (--depth == 0) {
                            dollar = true;
                            fqnBuilder.append('<');
                            boolean first = true;
                            current.append(";");
                            for (String arg : Signature.getTypeArguments(current.toString())) {
                                if (first) {
                                    first = false;
                                } else {
                                    fqnBuilder.append(',');
                                }
                                fqnBuilder.append(typeSignatureToFqn(arg));
                            }
                            current.setLength(current.length() - 1);
                            fqnBuilder.append('>');
                        }
                        break;
                    case '.':
                        if (dollar && depth == 0) {
                            fqnBuilder.append('$');
                        }
                        current.append(c);
                        break;
                    default:
                        if (dollar && depth == 0) {
                            fqnBuilder.append(c);
                        }
                        current.append(c);
                        break;
                    }
                }
                fqnBuilder.setLength(fqnBuilder.length() - 1);
                return fqnBuilder.toString();
            }
        case Signature.BASE_TYPE_SIGNATURE:
            return Signature.getSignatureSimpleName(signature);
        case Signature.TYPE_VARIABLE_SIGNATURE:
            return "<" + Signature.getSignatureSimpleName(signature) + ">";
        case Signature.WILDCARD_TYPE_SIGNATURE:
            if (signature.startsWith("+")) {
                return "<?+" + typeSignatureToFqn(signature.substring(1)) + ">";
            } else if (signature.startsWith("-")) {
                return "<?-" + typeSignatureToFqn(signature.substring(1)) + ">";
            } else {
                return "<?>";
            }
        case Signature.CAPTURE_TYPE_SIGNATURE:
            System.out.println("eek");
            return "";
        default:
            throw new IllegalArgumentException("Not a valid type signature");
        }
    } catch (Exception e) {
        e.printStackTrace();
        System.out.println("bad");
        return null;
    }
}

From source file:org.eclipse.e4.demo.simpleide.jdt.internal.editor.viewer.JavaElementLabelComposer.java

License:Open Source License

protected void appendTypeSignatureLabel(IJavaElement enclosingElement, String typeSig, long flags) {
    int sigKind = Signature.getTypeSignatureKind(typeSig);
    switch (sigKind) {
    case Signature.BASE_TYPE_SIGNATURE:
        fBuffer.append(Signature.toString(typeSig));
        break;/*  ww  w . ja  v a2  s. c  om*/
    case Signature.ARRAY_TYPE_SIGNATURE:
        appendTypeSignatureLabel(enclosingElement, Signature.getElementType(typeSig), flags);
        for (int dim = Signature.getArrayCount(typeSig); dim > 0; dim--) {
            fBuffer.append('[').append(']');
        }
        break;
    case Signature.CLASS_TYPE_SIGNATURE:
        String baseType = getSimpleTypeName(enclosingElement, Signature.getTypeErasure(typeSig));
        fBuffer.append(baseType);

        String[] typeArguments = Signature.getTypeArguments(typeSig);
        appendTypeArgumentSignaturesLabel(enclosingElement, typeArguments, flags);
        break;
    case Signature.TYPE_VARIABLE_SIGNATURE:
        fBuffer.append(getSimpleTypeName(enclosingElement, typeSig));
        break;
    case Signature.WILDCARD_TYPE_SIGNATURE:
        char ch = typeSig.charAt(0);
        if (ch == Signature.C_STAR) { // workaround for bug 85713
            fBuffer.append('?');
        } else {
            if (ch == Signature.C_EXTENDS) {
                fBuffer.append("? extends "); //$NON-NLS-1$
                appendTypeSignatureLabel(enclosingElement, typeSig.substring(1), flags);
            } else if (ch == Signature.C_SUPER) {
                fBuffer.append("? super "); //$NON-NLS-1$
                appendTypeSignatureLabel(enclosingElement, typeSig.substring(1), flags);
            }
        }
        break;
    case Signature.CAPTURE_TYPE_SIGNATURE:
        appendTypeSignatureLabel(enclosingElement, typeSig.substring(1), flags);
        break;
    default:
        // unknown
    }
}

From source file:org.eclipse.jpt.common.core.internal.resource.java.binary.BinaryMember.java

License:Open Source License

/**
 * no null check//  w  w w  .  j a v  a2  s . com
 */
static String convertTypeSignatureToTypeName_(String typeSignature, Iterable<ITypeParameter> typeParameters) {
    String erasureSignature = Signature.getTypeErasure(typeSignature);
    if (Signature.getTypeSignatureKind(erasureSignature) == Signature.TYPE_VARIABLE_SIGNATURE) {
        try {
            String typeParameterName = Signature.toString(erasureSignature);
            for (ITypeParameter typeParameter : typeParameters) {
                if (typeParameterName.equals(typeParameter.getElementName())) {
                    String[] bounds = typeParameter.getBoundsSignatures();
                    if (bounds.length > 0) {
                        return convertTypeSignatureToTypeName_(bounds[0], typeParameters);
                    }
                }
            }
        } catch (JavaModelException jme) {
            JptCommonCorePlugin.instance().logError(jme);
        }
    } else if (Signature.getTypeSignatureKind(erasureSignature) == Signature.ARRAY_TYPE_SIGNATURE) {
        int dim = Signature.getArrayCount(erasureSignature);
        String arrayTypeName = convertTypeSignatureToTypeName(Signature.getElementType(erasureSignature),
                typeParameters);
        return Signature.toString(
                Signature.createArraySignature(Signature.createTypeSignature(arrayTypeName, true), dim));
    } else if (Signature.getTypeSignatureKind(erasureSignature) == Signature.WILDCARD_TYPE_SIGNATURE) {
        // if signature is ? (wildcard) or ? super X (bottom bounded), return top bound, which is Object
        if (String.valueOf(Signature.C_STAR).equals(erasureSignature)
                || erasureSignature.startsWith(String.valueOf(Signature.C_SUPER))) {
            return Object.class.getName();
        }
        // return top bound
        return Signature.toString(erasureSignature.substring(1));
    }
    return Signature.toString(erasureSignature);
}

Example usage for org.eclipse.jdt.core Signature WILDCARD_TYPE_SIGNATURE

Introduction

Prototype

Document

Usage