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

Introduction

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

Prototype

char C_TYPE_VARIABLE

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

Click Source Link

Document

Character constant indicating the start of a resolved type variable in a signature.

Usage

From source file:com.codenvy.ide.ext.java.server.internal.core.SourceMapper.java

License:Open Source License

private int getUnqualifiedTypeSignature(String qualifiedTypeSig, int start, int length,
        StringBuffer unqualifiedTypeSig, boolean noDollar) {
    char firstChar = qualifiedTypeSig.charAt(start);
    int end = start + 1;
    boolean sigStart = false;
    firstPass: for (int i = start; i < length; i++) {
        char current = qualifiedTypeSig.charAt(i);
        switch (current) {
        case Signature.C_ARRAY:
        case Signature.C_SUPER:
        case Signature.C_EXTENDS:
            unqualifiedTypeSig.append(current);
            start = i + 1;// ww  w.  jav  a 2s  . c o  m
            end = start + 1;
            firstChar = qualifiedTypeSig.charAt(start);
            break;
        case Signature.C_RESOLVED:
        case Signature.C_UNRESOLVED:
        case Signature.C_TYPE_VARIABLE:
            if (!sigStart) {
                start = ++i;
                sigStart = true;
            }
            break;
        case Signature.C_NAME_END:
        case Signature.C_GENERIC_START:
            end = i;
            break firstPass;
        case Signature.C_STAR:
            unqualifiedTypeSig.append(current);
            start = i + 1;
            end = start + 1;
            firstChar = qualifiedTypeSig.charAt(start);
            break;
        case Signature.C_GENERIC_END:
            return i;
        case Signature.C_DOT:
            start = ++i;
            break;
        case Signature.C_BOOLEAN:
        case Signature.C_BYTE:
        case Signature.C_CHAR:
        case Signature.C_DOUBLE:
        case Signature.C_FLOAT:
        case Signature.C_INT:
        case Signature.C_LONG:
        case Signature.C_SHORT:
            if (!sigStart) {
                unqualifiedTypeSig.append(current);
                return i + 1;
            }
        }
    }
    switch (firstChar) {
    case Signature.C_RESOLVED:
    case Signature.C_UNRESOLVED:
    case Signature.C_TYPE_VARIABLE:
        unqualifiedTypeSig.append(Signature.C_UNRESOLVED);
        if (noDollar) {
            int lastDollar = qualifiedTypeSig.lastIndexOf('$', end);
            if (lastDollar > start)
                start = lastDollar + 1;
        }
        for (int i = start; i < length; i++) {
            char current = qualifiedTypeSig.charAt(i);
            switch (current) {
            case Signature.C_GENERIC_START:
                unqualifiedTypeSig.append(current);
                i++;
                do {
                    i = getUnqualifiedTypeSignature(qualifiedTypeSig, i, length, unqualifiedTypeSig, noDollar);
                } while (qualifiedTypeSig.charAt(i) != Signature.C_GENERIC_END);
                unqualifiedTypeSig.append(Signature.C_GENERIC_END);
                break;
            case Signature.C_NAME_END:
                unqualifiedTypeSig.append(current);
                return i + 1;
            default:
                unqualifiedTypeSig.append(current);
                break;
            }
        }
        return length;
    default:
        // primitive type or wildcard
        unqualifiedTypeSig.append(qualifiedTypeSig.substring(start, end));
        return end;
    }
}

---

From source file:com.codenvy.ide.ext.java.server.internal.core.util.Util.java

License:Open Source License

static void appendTypeSignature(char[] string, int start, StringBuffer buffer, boolean compact) {
    char c = string[start];
    switch (c) {//from   ww  w  . ja v  a2  s. c o  m
    case Signature.C_ARRAY:
        appendArrayTypeSignature(string, start, buffer, compact);
        break;
    case Signature.C_RESOLVED:
        appendClassTypeSignature(string, start, buffer, compact);
        break;
    case Signature.C_TYPE_VARIABLE:
        int e = org.eclipse.jdt.internal.compiler.util.Util.scanTypeVariableSignature(string, start);
        buffer.append(string, start + 1, e - start - 1);
        break;
    case Signature.C_BOOLEAN:
        buffer.append(BOOLEAN);
        break;
    case Signature.C_BYTE:
        buffer.append(BYTE);
        break;
    case Signature.C_CHAR:
        buffer.append(CHAR);
        break;
    case Signature.C_DOUBLE:
        buffer.append(DOUBLE);
        break;
    case Signature.C_FLOAT:
        buffer.append(FLOAT);
        break;
    case Signature.C_INT:
        buffer.append(INT);
        break;
    case Signature.C_LONG:
        buffer.append(LONG);
        break;
    case Signature.C_SHORT:
        buffer.append(SHORT);
        break;
    case Signature.C_VOID:
        buffer.append(VOID);
        break;
    }
}

---

From source file:com.codenvy.ide.ext.java.server.internal.core.util.Util.java

License:Open Source License

private static int appendTypeSignatureForAnchor(char[] string, int start, StringBuffer buffer,
        boolean isVarArgs) {
    // need a minimum 1 char
    if (start >= string.length) {
        throw new IllegalArgumentException();
    }/*from ww  w  .  j  a  v a2 s . c  o m*/
    char c = string[start];
    if (isVarArgs) {
        switch (c) {
        case Signature.C_ARRAY:
            return appendArrayTypeSignatureForAnchor(string, start, buffer, true);
        case Signature.C_RESOLVED:
        case Signature.C_TYPE_VARIABLE:
        case Signature.C_BOOLEAN:
        case Signature.C_BYTE:
        case Signature.C_CHAR:
        case Signature.C_DOUBLE:
        case Signature.C_FLOAT:
        case Signature.C_INT:
        case Signature.C_LONG:
        case Signature.C_SHORT:
        case Signature.C_VOID:
        case Signature.C_STAR:
        case Signature.C_EXTENDS:
        case Signature.C_SUPER:
        case Signature.C_CAPTURE:
        default:
            throw new IllegalArgumentException(); // a var args is an array type
        }
    } else {
        switch (c) {
        case Signature.C_ARRAY:
            return appendArrayTypeSignatureForAnchor(string, start, buffer, false);
        case Signature.C_RESOLVED:
            return appendClassTypeSignatureForAnchor(string, start, buffer);
        case Signature.C_TYPE_VARIABLE:
            int e = org.eclipse.jdt.internal.compiler.util.Util.scanTypeVariableSignature(string, start);
            buffer.append(string, start + 1, e - start - 1);
            return e;
        case Signature.C_BOOLEAN:
            buffer.append(BOOLEAN);
            return start;
        case Signature.C_BYTE:
            buffer.append(BYTE);
            return start;
        case Signature.C_CHAR:
            buffer.append(CHAR);
            return start;
        case Signature.C_DOUBLE:
            buffer.append(DOUBLE);
            return start;
        case Signature.C_FLOAT:
            buffer.append(FLOAT);
            return start;
        case Signature.C_INT:
            buffer.append(INT);
            return start;
        case Signature.C_LONG:
            buffer.append(LONG);
            return start;
        case Signature.C_SHORT:
            buffer.append(SHORT);
            return start;
        case Signature.C_VOID:
            buffer.append(VOID);
            return start;
        case Signature.C_CAPTURE:
            return appendCaptureTypeSignatureForAnchor(string, start, buffer);
        case Signature.C_STAR:
        case Signature.C_EXTENDS:
        case Signature.C_SUPER:
            return appendTypeArgumentSignatureForAnchor(string, start, buffer);
        default:
            throw new IllegalArgumentException();
        }
    }
}

---

From source file:org.eclipse.recommenders.jdt.JavaElementsFinder.java

License:Open Source License

/**
 *
 * @param typeSignature/*  w w  w.  ja v  a 2  s  .  c  o m*/
 *            e.g., QList;
 * @param enclosing
 * @return
 */
public static Optional<ITypeName> resolveType(char[] typeSignature, @Nullable IJavaElement enclosing) {
    typeSignature = CharOperation.replaceOnCopy(typeSignature, '.', '/');
    VmTypeName res = null;
    try {
        int dimensions = Signature.getArrayCount(typeSignature);
        outer: switch (typeSignature[dimensions]) {

        case Signature.C_BOOLEAN:
        case Signature.C_BYTE:
        case Signature.C_CHAR:
        case Signature.C_DOUBLE:
        case Signature.C_FLOAT:
        case Signature.C_INT:
        case Signature.C_LONG:
        case Signature.C_SHORT:
        case Signature.C_VOID:
            // take the whole string including any arrays
            res = VmTypeName.get(new String(typeSignature, 0, typeSignature.length));
            break;
        case Signature.C_RESOLVED:
            // take the whole string including any arrays but remove the trailing ';'
            res = VmTypeName.get(new String(typeSignature, 0, typeSignature.length - 1 /* ';' */));
            break;
        case Signature.C_UNRESOLVED:
            if (enclosing == null) {
                break;
            }
            // take the whole string (e.g. QList; or [QList;)
            String unresolved = new String(typeSignature, dimensions + 1,
                    typeSignature.length - (dimensions + 2 /* 'Q' + ';' */));
            IType ancestor = (IType) enclosing.getAncestor(IJavaElement.TYPE);
            if (ancestor == null) {
                break;
            }
            final String[][] resolvedNames = ancestor.resolveType(unresolved);
            if (isEmpty(resolvedNames)) {
                break;
            }
            String array = repeat('[', dimensions);
            final String pkg = resolvedNames[0][0].replace('.', '/');
            final String name = resolvedNames[0][1].replace('.', '$');
            res = VmTypeName.get(array + 'L' + pkg + '/' + name);
            break;
        case Signature.C_TYPE_VARIABLE:
            String varName = new String(typeSignature, dimensions + 1,
                    typeSignature.length - (dimensions + 2 /* 'Q' + ';' */));
            array = repeat('[', dimensions);

            for (IJavaElement cur = enclosing; cur instanceof IType
                    || cur instanceof IMethod; cur = cur.getParent()) {
                switch (cur.getElementType()) {
                case TYPE: {
                    IType type = (IType) cur;
                    ITypeParameter param = type.getTypeParameter(varName);
                    if (param.exists()) {
                        String[] signatures = getBoundSignatures(param);
                        if (isEmpty(signatures)) {
                            res = VmTypeName.OBJECT;
                            break outer;
                        }
                        // XXX we only consider the first type.
                        char[] append = array.concat(signatures[0]).toCharArray();
                        return resolveType(append, type);
                    }
                }
                case METHOD: {
                    IMethod method = (IMethod) cur;
                    ITypeParameter param = method.getTypeParameter(varName);
                    if (param.exists()) {
                        String[] signatures = getBoundSignatures(param);
                        if (isEmpty(signatures)) {
                            res = dimensions == 0 ? OBJECT
                                    : VmTypeName.get(repeat('[', dimensions) + OBJECT.getIdentifier());
                            break outer;
                        }
                        // XXX we only consider the first type.
                        char[] append = array.concat(signatures[0]).toCharArray();
                        return resolveType(append, method);
                    }
                }
                }
            }

            break;
        default:
            break;
        }
    } catch (Exception e) {
        Logs.log(LogMessages.ERROR_FAILED_TO_CREATE_TYPENAME, e,
                charToString(typeSignature) + (enclosing != null ? " in " + enclosing.getElementName() : ""));
    }
    return Optional.<ITypeName>fromNullable(res);
}

---

From source file:org.eclipse.recommenders.rcp.utils.JdtUtils.java

License:Open Source License

public static Optional<ITypeName> resolveUnqualifiedJDTType(String qName, final IJavaElement parent) {
    IType type = null;//from w ww. jav a 2 s.c  o m
    try {
        qName = Signature.getTypeErasure(qName);
        qName = StringUtils.removeEnd(qName, ";"); //$NON-NLS-1$
        final int dimensions = Signature.getArrayCount(qName);
        if (dimensions > 0) {
            qName = Signature.getElementType(qName);
        }

        if (isPrimitiveTypeSignature(qName)) {
            final ITypeName t = VmTypeName.get(StringUtils.repeat('[', dimensions) + qName);
            return of(t);
        }

        type = findClosestTypeOrThis(parent);
        if (type == null) {
            return absent();
        }

        if (qName.charAt(0) == Signature.C_TYPE_VARIABLE) {
            String literal = StringUtils.repeat('[', dimensions) + VmTypeName.OBJECT.getIdentifier();
            ITypeName name = VmTypeName.get(literal);
            return of(name);
        }
        if (qName.charAt(0) == Signature.C_UNRESOLVED) {

            final String[][] resolvedNames = type.resolveType(qName.substring(1));
            if (resolvedNames == null || resolvedNames.length == 0) {
                return of((ITypeName) VmTypeName.OBJECT);
            }
            final String pkg = resolvedNames[0][0];
            final String name = resolvedNames[0][1].replace('.', '$');
            qName = StringUtils.repeat('[', dimensions) + 'L' + pkg + '.' + name;
        }
        qName = qName.replace('.', '/');
        final ITypeName typeName = VmTypeName.get(qName);
        return of(typeName);
    } catch (JavaModelException e) {
        log(WARNING_FAILED_TO_RESOLVE_UNQUALIFIED_JDT_TYPE, e, type.getFullyQualifiedName());
        return absent();
    } catch (Exception e) {
        log(ERROR_FAILED_TO_RESOLVE_UNQUALIFIED_JDT_TYPE, e, parent.getElementName(), qName);
        return absent();
    }
}

---

From source file:org.eclipse.recommenders.utils.rcp.JdtUtils.java

License:Open Source License

public static Optional<ITypeName> resolveUnqualifiedJDTType(String qName, final IJavaElement parent) {
    try {/*from w  w  w  .java  2 s  .c  o  m*/
        qName = Signature.getTypeErasure(qName);
        qName = StringUtils.removeEnd(qName, ";");
        final int dimensions = Signature.getArrayCount(qName);
        if (dimensions > 0) {
            qName = Signature.getElementType(qName);
        }

        if (isPrimitiveTypeSignature(qName)) {
            final ITypeName t = VmTypeName.get(StringUtils.repeat('[', dimensions) + qName);
            return of(t);
        }

        final IType type = findClosestTypeOrThis(parent);
        if (type == null) {
            return absent();
        }

        if (qName.charAt(0) == Signature.C_TYPE_VARIABLE) {
            String literal = StringUtils.repeat('[', dimensions) + VmTypeName.OBJECT.getIdentifier();
            ITypeName name = VmTypeName.get(literal);
            return of(name);
        }
        if (qName.charAt(0) == Signature.C_UNRESOLVED) {

            final String[][] resolvedNames = type.resolveType(qName.substring(1));
            if (resolvedNames == null || resolvedNames.length == 0) {
                return of((ITypeName) VmTypeName.OBJECT);
            }
            final String pkg = new String(resolvedNames[0][0]);
            final String name = new String(resolvedNames[0][1]).replace('.', '$');
            qName = StringUtils.repeat('[', dimensions) + "L" + pkg + "." + name;
        }
        qName = qName.replace('.', '/');
        final ITypeName typeName = VmTypeName.get(qName);
        return of(typeName);
    } catch (final Exception e) {
        log(e);
        return absent();
    }
}

---

From source file:org.eclipse.wb.internal.core.utils.jdt.core.CodeUtils.java

License:Open Source License

/**
 * Resolves the given type name within the context of given {@link IType} (depending on the type
 * hierarchy and its imports)./*www  . j a v  a  2  s.c o m*/
 */
public static String getResolvedTypeName(IType context, String typeSignature) throws JavaModelException {
    // remove generic
    if (typeSignature.indexOf(Signature.C_GENERIC_START) != -1) {
        typeSignature = Signature.getTypeErasure(typeSignature);
    }
    //
    int arrayCount = Signature.getArrayCount(typeSignature);
    char type = typeSignature.charAt(arrayCount);
    if (type == Signature.C_UNRESOLVED || type == Signature.C_TYPE_VARIABLE) {
        int semi = typeSignature.indexOf(Signature.C_SEMICOLON, arrayCount + 1);
        String name = typeSignature.substring(arrayCount + 1, semi);
        name = getResolvedTypeName_resolveTypeVariable(context, name);
        // resolve type
        String[][] resolvedNames = context.resolveType(name);
        if (resolvedNames != null && resolvedNames.length > 0) {
            return concatenateName(resolvedNames[0][0], resolvedNames[0][1])
                    + StringUtils.repeat("[]", arrayCount);
        }
        // can not resolve
        return null;
    }
    // resolved
    {
        String name = Signature.toString(typeSignature);
        name = getResolvedTypeName_resolveTypeVariable(context, name);
        // done
        return name;
    }
}

---

From source file:org.jboss.tools.common.java.ParametedType.java

License:Open Source License

public String resolveParameters(String typeSignature) {
    if (typeSignature == null) {
        return typeSignature;
    }/*from   w w  w.  jav  a 2s  .c  o m*/
    int i = typeSignature.indexOf(Signature.C_GENERIC_START);
    if (i < 0) {
        char c = typeSignature.length() == 0 ? '\0' : typeSignature.charAt(0);
        char e = typeSignature.length() == 0 ? '\0' : typeSignature.charAt(typeSignature.length() - 1);
        if ((c == Signature.C_TYPE_VARIABLE || c == Signature.C_UNRESOLVED || c == Signature.C_RESOLVED)
                && e == Signature.C_SEMICOLON) {
            String param = typeSignature.substring(1, typeSignature.length() - 1);
            String s = findParameterSignature(param);
            return s == null ? typeSignature : s;
        }
        return typeSignature;
    }
    int j = typeSignature.lastIndexOf(Signature.C_GENERIC_END);
    if (j < i) {
        return typeSignature;
    }
    boolean replaced = false;
    StringBuffer newParams = new StringBuffer();
    String[] ps = Signature.getTypeArguments(typeSignature);
    for (String param : ps) {
        String newParam = resolveParameters(param);
        if (!param.equals(newParam))
            replaced = true;
        newParams.append(newParam);
    }
    if (replaced) {
        typeSignature = typeSignature.substring(0, i) + Signature.C_GENERIC_START + newParams.toString()
                + Signature.C_GENERIC_END + Signature.C_SEMICOLON;
    }
    return typeSignature;
}

---

From source file:org.jboss.tools.common.java.ParametedTypeFactory.java

License:Open Source License

public ParametedType getParametedType(IMember context, IParametedType basetype, String typeSignature)
        throws JavaModelException {
    if (typeSignature == null)
        return null;
    if (basetype != null) {
        ParametedType param = ((ParametedType) basetype).findParameter(typeSignature);
        if (param != null)
            return param;
    }//from   w  ww.j a v a2 s  .  c  o  m

    IType contextType = context instanceof IType ? (IType) context : context.getDeclaringType();

    String key = context == null || context.isBinary() || OBJECT.equals(typeSignature) ? typeSignature
            : contextType.getFullyQualifiedName() + "+" + typeSignature;
    if (cache.containsKey(key))
        return cache.get(key);
    ParametedType result = new ParametedType();
    result.setFactory(this);
    result.setSignature(typeSignature);

    typeSignature = typeSignature.substring(result.getArrayIndex());

    char c = typeSignature.length() == 0 ? '\0' : typeSignature.charAt(0);
    if (primitives.containsKey(c) && typeSignature.length() == 1) {
        typeSignature = primitives.get(c);
        result.setSignature(result.getArrayPrefix() + typeSignature);
        result.setPrimitive(true);
    } else if (c == Signature.C_EXTENDS) {
        typeSignature = typeSignature.substring(1);
        result.setUpper(true);
    } else if (c == Signature.C_SUPER) {
        typeSignature = typeSignature.substring(1);
        result.setLower(true);
    } else if (c == Signature.C_STAR && typeSignature.length() == 1) {
        result.setUpper(true);
        return result;
    }

    int startToken = typeSignature.indexOf(Signature.C_GENERIC_START);
    if (startToken < 0) {
        String resovedTypeName = EclipseJavaUtil.resolveTypeAsString(contextType, typeSignature);
        if (resovedTypeName == null)
            return null;
        if (!context.isBinary() || typeSignature.charAt(0) == Signature.C_TYPE_VARIABLE) {
            StringBuffer ns = new StringBuffer();
            ns.append(result.getArrayPrefix());
            if (result.isLower())
                ns.append(Signature.C_SUPER);
            if (result.isUpper())
                ns.append(Signature.C_EXTENDS);
            ns.append(Signature.C_RESOLVED).append(resovedTypeName).append(Signature.C_SEMICOLON);
            result.setSignature(ns.toString());
        }
        IType type = EclipseJavaUtil.findType(context.getJavaProject(), resovedTypeName);
        if (type != null) {
            result.setType(type);
            cache.put(key, result);
            return result;
        }
        if (context instanceof IMethod) {
            String[] ps = ((IMethod) context).getTypeParameterSignatures();
            for (int i = 0; i < ps.length; i++) {
                ParametedType st = getParametedTypeForParameter(context, ps[i], result);
                if (st != null) {
                    if (st.getSignature().indexOf(Signature.C_COLON) >= 0) {
                        CommonCorePlugin.getDefault().logWarning("Wrong signature=" + st.getSignature());
                    }
                    return st;
                }
            }
        }
        String[] ps = contextType.getTypeParameterSignatures();
        for (int i = 0; i < ps.length; i++) {
            ParametedType st = getParametedTypeForParameter(contextType, ps[i], result);
            if (st != null)
                return st;
        }
    } else {
        int endToken = typeSignature.lastIndexOf(Signature.C_GENERIC_END);
        if (endToken < startToken)
            return null;
        String typeName = typeSignature.substring(0, startToken) + typeSignature.substring(endToken + 1);
        String resovedTypeName = EclipseJavaUtil.resolveTypeAsString(contextType, typeName);
        if (resovedTypeName == null)
            return null;
        IType type = EclipseJavaUtil.findType(context.getJavaProject(), resovedTypeName);
        if (type != null) {
            result.setType(type);
            cache.put(key, result);
            StringBuffer newParams = new StringBuffer();
            String[] paramSignatures = null;
            try {
                paramSignatures = Signature.getTypeArguments(typeSignature);
            } catch (IllegalArgumentException e) {
                CommonCorePlugin.getDefault().logError(e);
            }
            if (paramSignatures != null)
                for (String paramSignature : paramSignatures) {
                    ParametedType param = getParametedType(context, basetype, paramSignature);
                    if (param == null) {
                        param = new ParametedType();
                        param.setSignature(paramSignature);
                    }
                    result.addParameter(param);
                    newParams.append(param.getSignature());
                }
            if (!context.isBinary()) {
                StringBuffer ns = new StringBuffer();
                ns.append(result.getArrayPrefix());
                if (result.isLower())
                    ns.append(Signature.C_SUPER);
                if (result.isUpper())
                    ns.append(Signature.C_EXTENDS);
                ns.append(Signature.C_RESOLVED).append(resovedTypeName).append(Signature.C_GENERIC_START)
                        .append(newParams).append(Signature.C_GENERIC_END).append(Signature.C_SEMICOLON);
                result.setSignature(ns.toString());
            }
            return result;
        }
    }
    return null;
}

---

From source file:org.springframework.tooling.jdt.ls.commons.java.JavaData.java

License:Open Source License

private JavaTypeData createFromSignature(IType type, String signature) {
    JavaTypeData data = new JavaTypeData();
    data.setName(signature);/*from w w w  .  ja va  2s.  c o m*/

    char[] typeSignature = signature.toCharArray();

    String[] typeArguments = Signature.getTypeArguments(signature);
    if (typeArguments != null && typeArguments.length > 0) {
        JavaTypeData[] javaTypeArguments = new JavaTypeData[typeArguments.length];
        for (int i = 0; i < typeArguments.length; i++) {
            javaTypeArguments[i] = createFromSignature(type, typeArguments[i]);
            // In case binding key is unresolved replace each argument with resolved one.
            data.setName(data.getName().replace(typeArguments[i], javaTypeArguments[i].getName()));
        }
        data.setKind(JavaTypeKind.PARAMETERIZED);
        LinkedHashMap<String, Object> extras = new LinkedHashMap<>();
        String typeErasure = Signature.getTypeErasure(signature);
        JavaTypeData owner = createFromSignature(type, typeErasure);
        extras.put("owner", owner);
        extras.put("arguments", javaTypeArguments);
        data.setExtras(extras);
        // In case binding key is unresolved replace owner. Trim trailing ; from type erasure string and from the replacement
        data.setName(data.getName().replace(typeErasure.substring(0, typeErasure.length() - 1),
                owner.getName().substring(0, owner.getName().length() - 1)));

    } else {
        // need a minimum 1 char
        if (typeSignature.length < 1) {
            throw new IllegalArgumentException();
        }
        char c = typeSignature[0];
        if (c == Signature.C_GENERIC_START) {
            int count = 1;
            for (int i = 1, length = typeSignature.length; i < length; i++) {
                switch (typeSignature[i]) {
                case Signature.C_GENERIC_START:
                    count++;
                    break;
                case Signature.C_GENERIC_END:
                    count--;
                    break;
                }
                if (count == 0) {
                    if (i + 1 < length)
                        c = typeSignature[i + 1];
                    break;
                }
            }
        }
        switch (c) {
        case Signature.C_ARRAY:
            data.setKind(JavaTypeKind.ARRAY);
            LinkedHashMap<String, Object> extras = new LinkedHashMap<>();
            extras.put("component", createFromSignature(type, Signature.getElementType(signature)));
            extras.put("dimensions", Signature.getArrayCount(typeSignature));
            data.setExtras(extras);
            break;
        case Signature.C_RESOLVED:
            data.setKind(JavaTypeKind.CLASS);
            break;
        case Signature.C_TYPE_VARIABLE:
            data.setKind(JavaTypeKind.TYPE_VARIABLE);
            break;
        case Signature.C_BOOLEAN:
            data.setKind(JavaTypeKind.BOOLEAN);
            break;
        case Signature.C_BYTE:
            data.setKind(JavaTypeKind.BYTE);
            break;
        case Signature.C_CHAR:
            data.setKind(JavaTypeKind.CHAR);
            break;
        case Signature.C_DOUBLE:
            data.setKind(JavaTypeKind.DOUBLE);
            break;
        case Signature.C_FLOAT:
            data.setKind(JavaTypeKind.FLOAT);
            break;
        case Signature.C_INT:
            data.setKind(JavaTypeKind.INT);
            break;
        case Signature.C_LONG:
            data.setKind(JavaTypeKind.LONG);
            break;
        case Signature.C_SHORT:
            data.setKind(JavaTypeKind.SHORT);
            break;
        case Signature.C_VOID:
            data.setKind(JavaTypeKind.VOID);
            break;
        case Signature.C_STAR:
        case Signature.C_SUPER:
        case Signature.C_EXTENDS:
            data.setKind(JavaTypeKind.WILDCARD);
            break;
        case Signature.C_UNRESOLVED:
            if (type != null) {
                // Attempt to resolve type. For some reason JDT has them unresolved for type members
                try {
                    String signatureSimpleName = Signature.getSignatureSimpleName(signature);
                    String resolvedType = resolveFQName(type, signatureSimpleName);
                    if (resolvedType != null) {
                        data.setKind(JavaTypeKind.CLASS);
                        data.setName("L" + resolvedType.replace('.', '/') + ";");
                        break;
                    }
                } catch (JavaModelException e) {
                    data.setKind(JavaTypeKind.UNRESOLVED);
                }
            }
        case Signature.C_CAPTURE:
        case Signature.C_INTERSECTION:
        case Signature.C_UNION:
        default:
            data.setKind(JavaTypeKind.UNRESOLVED);
            break;
        }
    }

    return data;
}

---