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

Introduction

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

Prototype

int TYPE_VARIABLE_SIGNATURE

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

Click Source Link

Document

Kind constant for a type variable 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 w  w w. ja v a 2  s  .  c o m*/
        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;//  w w w.j  a  v  a 2s .  co  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.mcgill.cs.swevo.jayfx.FastConverter.java

License:Open Source License

/**
 * Returns an IElement describing the argument Java element. Not designed to
 * be able to find initializer blocks or arrays.
 * /*from ww w . j  av  a 2s . c  om*/
 * @param pElement
 *            Never null.
 * @return Never null
 */
public IElement getElement(final IJavaElement pElement) throws ConversionException {
    // assert( pElement != null );
    IElement lReturn = null;

    if (pElement instanceof IType)
        lReturn = this.getClassElement((IType) pElement);
    else if (pElement instanceof IField) {
        final IElement lClass = this.getClassElement(((IField) pElement).getDeclaringType());
        lReturn = FlyweightElementFactory.getElement(Category.FIELD,
                lClass.getId() + "." + ((IField) pElement).getElementName());
    } else if (pElement instanceof IMethod) {
        final IElement lClass = this.getClassElement(((IMethod) pElement).getDeclaringType());
        String lName = ((IMethod) pElement).getElementName();
        try {
            if (((IMethod) pElement).isConstructor())
                lName = "<init>";
        } catch (final JavaModelException pException) {
            throw new ConversionException(pException);
        }
        String lSignature = "(";
        final String[] lParams = ((IMethod) pElement).getParameterTypes();
        for (int i = 0; i < lParams.length - 1; i++) {
            String param = null;
            if (Signature.getTypeSignatureKind(lParams[i]) == Signature.TYPE_VARIABLE_SIGNATURE) // its
                // a
                // type
                // variable,
                // erase
                // it.
                param = "Ljava.lang.Object;";
            else
                param = lParams[i];

            lSignature += this.resolveType(param, ((IMethod) pElement).getDeclaringType()) + ",";
        }
        if (lParams.length > 0) {
            String param = lParams[lParams.length - 1];
            if (Signature
                    .getTypeSignatureKind(Signature.getElementType(param)) == Signature.TYPE_VARIABLE_SIGNATURE) // its
                // a
                // type
                // variable,
                // erase
                // it.
                param = "Ljava.lang.Object;";
            else
                param = lParams[lParams.length - 1];

            if (param.charAt(0) == 'Q' && param.charAt(1) == 'T')
                param = "Ljava.lang.Object;";
            lSignature += this.resolveType(param, ((IMethod) pElement).getDeclaringType());
        }
        lSignature += ")";
        lReturn = FlyweightElementFactory.getElement(Category.METHOD,
                lClass.getId() + "." + lName + lSignature);
    }

    else if (pElement instanceof IAJCodeElement) {
        final String lName = ((IAJCodeElement) pElement).getElementName();
        System.out.println(lName);
    }

    if (lReturn == null) {
        System.err.println("Error with element: " + pElement);
        throw new IllegalStateException("In trouble.");
    }
    return lReturn;
}

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   ww w.ja  v  a2 s .com
    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) {//from  www  .  ja v  a 2  s.  c  o  m
    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
 * //  w w  w  .  jav  a  2  s . c o m
 * 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.j  a v  a 2s . co m*/
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:com.google.inject.tools.ideplugin.eclipse.TypeUtil.java

License:Open Source License

/**
 * @param type//from  w w w . j  a v a  2 s .c o  m
 * @param typeParamSignature -- must be a Type Variable Signature
 * @param typeArguments
 * @return the signature for the type argument in typeArguments that matches the
 * named typeParamSignature in type.
 * @throws IllegalArgumentException if typeParamSignature is not valid
 * 
 * For example, given type for java.util.Map, typeParamSignature == "V" and
 * typeArguments = {Ljava.util.String;, Lcom.test.Blah;}, the result would be
 * the typeArgument that matches "V", which is "Lcom.test.Blah;}
 * 
 * returns null if the match cannot be found.
 */
public static String matchTypeParameterToArgument(final IType type, final String typeParamSignature,
        final List<String> typeArguments) {
    if (Signature.getTypeSignatureKind(typeParamSignature) != Signature.TYPE_VARIABLE_SIGNATURE) {
        throw new IllegalArgumentException();
    }

    try {
        ITypeParameter[] typeParams = type.getTypeParameters();

        for (int pos = 0; pos < typeParams.length; pos++) {
            if (typeParams[pos].getElementName().equals(Signature.getSignatureSimpleName(typeParamSignature))) {
                if (pos < typeArguments.size()) {
                    return typeArguments.get(pos);
                }
            }
        }
    } catch (JavaModelException e) {

    }

    return null;
}

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

License:Open Source License

private static String typeSignatureToFqn(String signature) {
    try {/*from  w  w w  .ja v  a2  s .  c  o 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 {/* w w w.  j a va2s.c  om*/
        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;
    }
}

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

Introduction

Prototype

Document

Usage